@gitkraken/core-gitlens 0.5.116 → 0.7.0

package/dist/git-cli/exec/git.js

@@ -1,1061 +1,853 @@
-import { spawn } from 'child_process';
-import * as process from 'process';
-import { GitWarnings, WorkspaceUntrustedError } from '../../git/errors.js';
-import { CancellationError, getAbortSignalId, isCancellationError } from '../../utils/cancellation.js';
-import { getScopedCounter } from '../../utils/counter.js';
-import { getDurationMilliseconds, hrtime } from '../../utils/hrtime.js';
-import { Logger } from '../../utils/logger.js';
-import { formatLoggableScopeBlock } from '../../utils/logger.scoped.js';
-import { dirname, isAbsolute, joinPaths, normalizePath } from '../../utils/path.js';
-import { defer } from '../../utils/promise.js';
-import { compare, fromString } from '../../utils/version.js';
-import { CancelledRunError, RunError } from './exec.errors.js';
-import { fsExists, runSpawn } from './exec.js';
-import { gitFeaturesByVersion } from './features.js';
-import { getPrimaryGitCommand, GitQueue, inferGitCommandPriority } from './gitQueue.js';
-const slowCallWarningThreshold = 2000;
-export const maxGitCliLength = 30000;
-export const gitConfigsBranch = ['-c', 'color.branch=false'];
-export const gitConfigsDiff = ['-c', 'color.diff=false', '-c', 'diff.mnemonicPrefix=false'];
-export const gitConfigsLog = ['-c', 'log.showSignature=false'];
-export const gitConfigsLogWithFiles = ['-c', 'log.showSignature=false', '-c', 'diff.renameLimit=0'];
-export const gitConfigsLogWithSignatures = ['-c', 'log.showSignature=true'];
-export const gitConfigsPull = ['-c', 'merge.autoStash=true', '-c', 'rebase.autoStash=true'];
-export const gitConfigsStatus = ['-c', 'color.status=false'];
-export const GitErrors = {
-    alreadyCheckedOut: /already checked out/i,
-    alreadyExists: /already exists/i,
-    ambiguousArgument: /fatal:\s*ambiguous argument ['"](.+?)['"]: unknown revision or path not in the working tree/i,
-    badObject: /fatal:\s*bad object (.*?)/i,
-    badRevision: /bad revision '(.*?)'/i,
-    branchAlreadyExists: /fatal:\s*A branch named '.+?' already exists/i,
-    notFullyMerged: /error:\s*The branch '.+?' is not fully merged/i,
-    cantLockRef: /cannot lock ref|unable to update local ref/i,
-    changesWouldBeOverwritten: /Your local changes to the following files would be overwritten|Your local changes would be overwritten|overwritten by checkout/i,
-    cherryPickAborted: /cherry-pick.*aborted/i,
-    cherryPickInProgress: /cherry-pick is already in progress|You have not concluded your cherry-pick/i,
-    commitChangesFirst: /Please, commit your changes before you can/i,
-    conflict: /^CONFLICT \([^)]+\): \b/m,
-    detachedHead: /You are in 'detached HEAD' state/i,
-    entryNotUpToDate: /error:\s*Entry ['"].+['"] not uptodate\. Cannot merge\./i,
-    failedToDeleteDirectoryNotEmpty: /failed to delete '(.*?)': Directory not empty/i,
-    gpgNotFound: /gpg:?\s*(?:command\s+)?not found|'gpg' is not recognized as|cannot run gpg:/i,
-    gpgSignFailed: /^error:\s*gpg failed to sign the data/im,
-    invalidName: /fatal:\s*'.+?' is not a valid branch name/i,
-    invalidLineCount: /file .+? has only (\d+) lines/i,
-    invalidObjectName: /invalid object name: (.*)\s/i,
-    invalidObjectNameList: /could not open object name list: (.*)\s/i,
-    // Regcomp failure reasons from `-G`/pathspec regex compilation (search); matched without a known
-    // prefix as a fallback when the reason appears in an unrecognized stderr shape
-    invalidSearchPattern: /Unmatched \( or \\\(|Unmatched \[|Unmatched \) or \\\)|Invalid content of \\\{\\\}|Invalid preceding regular expression|Invalid regular expression|Trailing backslash|invalid regex/i,
-    invalidTagName: /invalid tag name/i,
-    mainWorkingTree: /is a main working tree/i,
-    mergeAborted: /merge.*aborted/i,
-    mergeInProgress: /^fatal:\s*You have not concluded your merge/i,
-    noFastForward: /\(non-fast-forward\)/i,
-    noMergeBase: /no merge base/i,
-    noRemoteReference: /unable to delete '.+?': remote ref does not exist/i,
-    noRemoteRepositorySpecified: /No remote repository specified\./i,
-    noUpstream: /^fatal:\s*The current branch .* has no upstream branch/i,
-    notAValidObjectName: /Not a valid object name/i,
-    notAWorkingTree: /'(.*?)' is not a working tree/i,
-    noUserNameConfigured: /Please tell me who you are\./i,
-    nothingToCommit: /nothing(?: added)? to commit|no changes added to commit/i,
-    noPausedOperation: /no merge (?:in progress|to abort)|no cherry-pick(?: or revert)? in progress|no rebase in progress/i,
-    permissionDenied: /Permission.*denied/i,
-    previousOperationEmpty: /The previous (?:cherry-pick|revert) is now empty/i,
-    problemWithEditor: /there was a problem with the editor/i,
-    pushRejected: /^error:\s*failed to push some refs to\b/m,
-    pushRejectedRefDoesNotExists: /error:\s*unable to delete '(.*?)': remote ref does not exist/m,
-    rebaseAborted: /Nothing to do|rebase.*aborted/i,
-    rebaseInProgress: /It seems that there is already a rebase-(?:merge|apply) directory/i,
-    rebaseMissingTodo: /error:\s*could not read file .*\/git-rebase-todo': No such file or directory/,
-    rebaseMultipleBranches: /cannot rebase onto multiple branches/i,
-    revertAborted: /revert.*aborted/i,
-    revertInProgress: /^(error: )?(revert|cherry-pick) is already in progress/i,
-    refLocked: /fatal:\s*cannot lock ref ['"].+['"]: unable to create file/i,
-    remoteAhead: /rejected because the remote contains work/i,
-    remoteConnectionFailed: /Could not read from remote repository/i,
-    remoteRejected: /rejected because the remote contains work/i,
-    signingKeyNotAvailable: /secret key not available|no secret key|no signing key/i,
-    sshNotFound: /ssh-keygen[^\n]*(?:not found|No such file or directory|is not recognized)/i,
-    stashConflictingStagedAndUnstagedLines: /Cannot remove worktree changes/i,
-    stashNothingToSave: /No local changes to save/i,
-    stashSavedWorkingDirAndIndexState: /Saved working directory and index state/i,
-    tagAlreadyExists: /tag .* already exists/i,
-    tagConflict: /! \[rejected\].*\(would clobber existing tag\)/m,
-    tagNotFound: /tag .* not found/i,
-    uncommittedChanges: /contains modified or untracked files/i,
-    unmergedChanges: /error:\s*you need to resolve your current index first/i,
-    unmergedFiles: /is not possible because you have unmerged files|You have unmerged files/i,
-    unresolvedConflicts: /You must edit all merge conflicts|Resolve all conflicts|^CONFLICT \(|^Automatic merge failed|could not apply .*/im,
-    unsafeRepository: /(?:^fatal:\s*detected dubious ownership in repository at '([^']+)'|unsafe repository \('([^']+)' is owned by someone else\))[\s\S]*(git config --global --add safe\.directory [^\n•]+)/m,
-    unstagedChanges: /You have unstaged changes/i,
-    // Matches both variants: with a lock reason (`..., lock reason: <reason>`) and without (`...;`)
-    worktreeLocked: /fatal:\s*cannot remove a locked working tree/i,
-    // Only matches the variant where Git reports a lock reason; the reason is free text, so capture the whole line
-    worktreeLockedReason: /cannot remove a locked working tree,[ \t]*lock reason:[ \t]*(.*)/i,
+import { getScopedCounter } from "../../utils/counter.js";
+import { CancellationError, getAbortSignalId, isCancellationError } from "../../utils/cancellation.js";
+import { getDurationMilliseconds, hrtime } from "../../utils/hrtime.js";
+import { Logger as _logger } from "../../utils/logger.js";
+import { formatLoggableScopeBlock } from "../../utils/logger.scoped.js";
+import { defer } from "../../utils/promise.js";
+import { dirname, isAbsolute, joinPaths, normalizePath } from "../../utils/path.js";
+import { GitWarnings, WorkspaceUntrustedError } from "../../git/errors.js";
+import { gitFeaturesByVersion } from "../../git/features.js";
+import { CancelledRunError, RunError, fsExists, runSpawn } from "../../utils/env/node/exec.js";
+import { compare, fromString } from "../../utils/version.js";
+import { EventLoopMonitor } from "./eventLoopMonitor.js";
+import { GitQueue, getPrimaryGitCommand, inferGitCommandPriority } from "./gitQueue.js";
+import { spawn } from "child_process";
+import * as process from "process";
+//#region ../git-cli/src/exec/git.ts
+const slowCallWarningThreshold = 2e3;
+/** Below this, a queue-wait annotation isn't worth adding to the log line. */
+const queueWaitAnnotationThreshold = 100;
+/** Below this, a measured event-loop stall isn't worth annotating — see {@link EventLoopMonitor}. */
+const eventLoopDelayAnnotationThreshold = 500;
+const maxGitCliLength = 3e4;
+const gitConfigsBranch = ["-c", "color.branch=false"];
+const gitConfigsDiff = [
+	"-c",
+	"color.diff=false",
+	"-c",
+	"diff.mnemonicPrefix=false"
+];
+const gitConfigsLog = ["-c", "log.showSignature=false"];
+const gitConfigsLogWithFiles = [
+	"-c",
+	"log.showSignature=false",
+	"-c",
+	"diff.renameLimit=0"
+];
+const gitConfigsLogWithSignatures = ["-c", "log.showSignature=true"];
+const gitConfigsPull = [
+	"-c",
+	"merge.autoStash=true",
+	"-c",
+	"rebase.autoStash=true"
+];
+const gitConfigsStatus = ["-c", "color.status=false"];
+const GitErrors = {
+	alreadyCheckedOut: /already checked out/i,
+	alreadyExists: /already exists/i,
+	ambiguousArgument: /fatal:\s*ambiguous argument ['"](.+?)['"]: unknown revision or path not in the working tree/i,
+	badObject: /fatal:\s*bad object (.*?)/i,
+	badRevision: /bad revision '(.*?)'/i,
+	branchAlreadyExists: /fatal:\s*A branch named '.+?' already exists/i,
+	notFullyMerged: /error:\s*The branch '.+?' is not fully merged/i,
+	cantLockRef: /cannot lock ref|unable to update local ref/i,
+	changesWouldBeOverwritten: /Your local changes to the following files would be overwritten|Your local changes would be overwritten|overwritten by checkout/i,
+	cherryPickAborted: /cherry-pick.*aborted/i,
+	cherryPickInProgress: /cherry-pick is already in progress|You have not concluded your cherry-pick/i,
+	commitChangesFirst: /Please, commit your changes before you can/i,
+	conflict: /^CONFLICT \([^)]+\): \b/m,
+	detachedHead: /You are in 'detached HEAD' state/i,
+	entryNotUpToDate: /error:\s*Entry ['"].+['"] not uptodate\. Cannot merge\./i,
+	failedToDeleteDirectoryNotEmpty: /failed to delete '(.*?)': Directory not empty/i,
+	gpgNotFound: /gpg:?\s*(?:command\s+)?not found|'gpg' is not recognized as|cannot run gpg:/i,
+	gpgSignFailed: /^error:\s*gpg failed to sign the data/im,
+	invalidName: /fatal:\s*'.+?' is not a valid branch name/i,
+	invalidLineCount: /file .+? has only (\d+) lines/i,
+	invalidObjectName: /invalid object name: (.*)\s/i,
+	invalidObjectNameList: /could not open object name list: (.*)\s/i,
+	invalidSearchPattern: /Unmatched \( or \\\(|Unmatched \[|Unmatched \) or \\\)|Invalid content of \\\{\\\}|Invalid preceding regular expression|Invalid regular expression|Trailing backslash|invalid regex/i,
+	invalidTagName: /invalid tag name/i,
+	mainWorkingTree: /is a main working tree/i,
+	mergeAborted: /merge.*aborted/i,
+	mergeInProgress: /^fatal:\s*You have not concluded your merge/i,
+	noFastForward: /\(non-fast-forward\)/i,
+	noMergeBase: /no merge base/i,
+	noRemoteReference: /unable to delete '.+?': remote ref does not exist/i,
+	noRemoteRepositorySpecified: /No remote repository specified\./i,
+	noUpstream: /^fatal:\s*The current branch .* has no upstream branch/i,
+	notAValidObjectName: /Not a valid object name/i,
+	notAWorkingTree: /'(.*?)' is not a working tree/i,
+	noUserNameConfigured: /Please tell me who you are\./i,
+	nothingToCommit: /nothing(?: added)? to commit|no changes added to commit/i,
+	noPausedOperation: /no merge (?:in progress|to abort)|no cherry-pick(?: or revert)? in progress|no rebase in progress/i,
+	permissionDenied: /Permission.*denied/i,
+	previousOperationEmpty: /The previous (?:cherry-pick|revert) is now empty/i,
+	problemWithEditor: /there was a problem with the editor/i,
+	pushRejected: /^error:\s*failed to push some refs to\b/m,
+	pushRejectedRefDoesNotExists: /error:\s*unable to delete '(.*?)': remote ref does not exist/m,
+	rebaseAborted: /Nothing to do|rebase.*aborted/i,
+	rebaseInProgress: /It seems that there is already a rebase-(?:merge|apply) directory/i,
+	rebaseMissingTodo: /error:\s*could not read file .*\/git-rebase-todo': No such file or directory/,
+	rebaseMultipleBranches: /cannot rebase onto multiple branches/i,
+	revertAborted: /revert.*aborted/i,
+	revertInProgress: /^(error: )?(revert|cherry-pick) is already in progress/i,
+	refLocked: /fatal:\s*cannot lock ref ['"].+['"]: unable to create file/i,
+	remoteAhead: /rejected because the remote contains work/i,
+	remoteConnectionFailed: /Could not read from remote repository/i,
+	remoteRejected: /rejected because the remote contains work/i,
+	signingKeyNotAvailable: /secret key not available|no secret key|no signing key/i,
+	sshNotFound: /ssh-keygen[^\n]*(?:not found|No such file or directory|is not recognized)/i,
+	stashConflictingStagedAndUnstagedLines: /Cannot remove worktree changes/i,
+	stashNothingToSave: /No local changes to save/i,
+	stashSavedWorkingDirAndIndexState: /Saved working directory and index state/i,
+	tagAlreadyExists: /tag .* already exists/i,
+	tagConflict: /! \[rejected\].*\(would clobber existing tag\)/m,
+	tagNotFound: /tag .* not found/i,
+	uncommittedChanges: /contains modified or untracked files/i,
+	unmergedChanges: /error:\s*you need to resolve your current index first/i,
+	unmergedFiles: /is not possible because you have unmerged files|You have unmerged files/i,
+	unresolvedConflicts: /You must edit all merge conflicts|Resolve all conflicts|^CONFLICT \(|^Automatic merge failed|could not apply .*/im,
+	unsafeRepository: /(?:^fatal:\s*detected dubious ownership in repository at '([^']+)'|unsafe repository \('([^']+)' is owned by someone else\))[\s\S]*(git config --global --add safe\.directory [^\n•]+)/m,
+	unstagedChanges: /You have unstaged changes/i,
+	worktreeLocked: /fatal:\s*cannot remove a locked working tree/i,
+	worktreeLockedReason: /cannot remove a locked working tree,[ \t]*lock reason:[ \t]*(.*)/i
 };
-// `GitWarnings` moved to `@gitlens/git/errors.js` so the shared run contract can name its keys; re-exported
-// here because it's long-established as part of this module's surface.
-export { GitWarnings };
-export class GitError extends Error {
-    original;
-    cmd;
-    exitCode;
-    stdout;
-    stderr;
-    constructor(original) {
-        let message;
-        let stdout;
-        let stderr;
-        let cmd;
-        let exitCode;
-        if (original instanceof RunError) {
-            stdout = original.stdout;
-            stderr = original.stderr;
-            message = stderr || stdout || original.message;
-            cmd = original.cmd;
-            exitCode = original.code;
-        }
-        else {
-            message = original.message;
-        }
-        super(message);
-        this.original = original;
-        this.stdout = stdout;
-        this.stderr = stderr;
-        this.cmd = cmd;
-        this.exitCode = exitCode;
-        Error.captureStackTrace?.(this, new.target);
-    }
-}
-const errorToReasonMap = new Map([
-    [
-        'branch',
-        [
-            [GitErrors.branchAlreadyExists, 'alreadyExists'],
-            [GitErrors.invalidName, 'invalidName'],
-            [GitErrors.notFullyMerged, 'notFullyMerged'],
-            [GitErrors.noRemoteReference, 'noRemoteReference'],
-        ],
-    ],
-    [
-        'checkout',
-        [
-            [GitErrors.changesWouldBeOverwritten, 'wouldOverwriteChanges'],
-            [GitErrors.ambiguousArgument, 'pathspecNotFound'],
-            [GitErrors.notAValidObjectName, 'invalidRef'],
-        ],
-    ],
-    [
-        'cherry-pick',
-        [
-            [GitErrors.cherryPickAborted, 'aborted'],
-            [GitErrors.cherryPickInProgress, 'alreadyInProgress'],
-            [GitErrors.conflict, 'conflicts'],
-            [GitErrors.previousOperationEmpty, 'emptyCommit'],
-            [GitErrors.changesWouldBeOverwritten, 'wouldOverwriteChanges'],
-        ],
-    ],
-    [
-        'commit',
-        [
-            [GitErrors.nothingToCommit, 'nothingToCommit'],
-            [GitErrors.unmergedFiles, 'conflicts'],
-            [GitErrors.unresolvedConflicts, 'conflicts'],
-            [GitErrors.noUserNameConfigured, 'noUserNameConfigured'],
-        ],
-    ],
-    [
-        'fetch',
-        [
-            [GitErrors.noFastForward, 'noFastForward'],
-            [GitErrors.noRemoteRepositorySpecified, 'noRemote'],
-            [GitErrors.remoteConnectionFailed, 'remoteConnectionFailed'],
-        ],
-    ],
-    [
-        'merge',
-        [
-            [GitErrors.mergeAborted, 'aborted'],
-            [GitErrors.mergeInProgress, 'alreadyInProgress'],
-            [GitErrors.unresolvedConflicts, 'conflicts'],
-            [GitErrors.uncommittedChanges, 'uncommittedChanges'],
-            [GitErrors.changesWouldBeOverwritten, 'wouldOverwriteChanges'],
-        ],
-    ],
-    ['paused-operation-abort', [[GitErrors.noPausedOperation, 'nothingToAbort']]],
-    [
-        'paused-operation-continue',
-        [
-            // Kept FIRST: an editor failure's stderr can also carry broader messages ("could not
-            // commit staged changes", …) that later patterns would otherwise claim
-            [GitErrors.problemWithEditor, 'messageEditFailed'],
-            [GitErrors.previousOperationEmpty, 'emptyCommit'],
-            [GitErrors.noPausedOperation, 'nothingToContinue'],
-            [GitErrors.uncommittedChanges, 'uncommittedChanges'],
-            [GitErrors.unmergedFiles, 'unmergedFiles'],
-            [GitErrors.unresolvedConflicts, 'conflicts'],
-            [GitErrors.unstagedChanges, 'unstagedChanges'],
-            [GitErrors.changesWouldBeOverwritten, 'wouldOverwriteChanges'],
-            // A single (non-sequencer) revert resolved to a no-op never gets git's "previous revert is now
-            // empty" message — its `--continue` falls through to the commit, which reports having nothing to
-            // commit. Mid-paused-op that means the step became empty, so it earns the same choice.
-            //
-            // Kept LAST because the pattern is deliberately broad: it also matches "no changes added to
-            // commit" and "nothing added to commit", which appear alongside the more specific unmerged /
-            // conflict / unstaged messages. Matching first would shadow those. It isn't narrowed to the
-            // "working tree clean" variant because an empty step with untracked files present instead reports
-            // "nothing added to commit but untracked files present".
-            [GitErrors.nothingToCommit, 'emptyCommit'],
-        ],
-    ],
-    [
-        'pull',
-        [
-            [GitErrors.conflict, 'conflict'],
-            [GitErrors.noUserNameConfigured, 'gitIdentity'],
-            [GitErrors.remoteConnectionFailed, 'remoteConnectionFailed'],
-            [GitErrors.unstagedChanges, 'unstagedChanges'],
-            [GitErrors.unmergedFiles, 'unmergedFiles'],
-            [GitErrors.commitChangesFirst, 'uncommittedChanges'],
-            [GitErrors.changesWouldBeOverwritten, 'wouldOverwriteChanges'],
-            [GitErrors.cantLockRef, 'refLocked'],
-            [GitErrors.rebaseMultipleBranches, 'rebaseMultipleBranches'],
-            [GitErrors.tagConflict, 'tagConflict'],
-        ],
-    ],
-    [
-        'push',
-        [
-            [GitErrors.remoteAhead, 'remoteAhead'],
-            [GitWarnings.tipBehind, 'tipBehind'],
-            // Kept BEFORE the generic push rejection: a failed `push -d` of a missing ref reports both
-            // "unable to delete '<ref>': remote ref does not exist" and "failed to push some refs to ...",
-            // and the specific reason is the actionable one.
-            [GitErrors.pushRejectedRefDoesNotExists, 'rejectedRefDoesNotExist'],
-            [GitErrors.pushRejected, 'rejected'],
-            [GitErrors.permissionDenied, 'permissionDenied'],
-            [GitErrors.remoteConnectionFailed, 'remoteConnectionFailed'],
-            [GitErrors.noUpstream, 'noUpstream'],
-        ],
-    ],
-    [
-        'rebase',
-        [
-            [GitErrors.rebaseAborted, 'aborted'],
-            [GitErrors.rebaseMissingTodo, 'aborted'],
-            [GitErrors.rebaseInProgress, 'alreadyInProgress'],
-            [GitErrors.unresolvedConflicts, 'conflicts'],
-            [GitErrors.uncommittedChanges, 'uncommittedChanges'],
-            [GitErrors.changesWouldBeOverwritten, 'wouldOverwriteChanges'],
-        ],
-    ],
-    [
-        'reset',
-        [
-            [GitErrors.ambiguousArgument, 'ambiguousArgument'],
-            [GitErrors.detachedHead, 'detachedHead'],
-            [GitErrors.refLocked, 'refLocked'],
-            [GitErrors.entryNotUpToDate, 'notUpToDate'],
-            [GitErrors.permissionDenied, 'permissionDenied'],
-            [GitErrors.unmergedChanges, 'unmergedChanges'],
-            [GitErrors.changesWouldBeOverwritten, 'wouldOverwriteChanges'],
-        ],
-    ],
-    [
-        'revert',
-        [
-            [GitErrors.revertAborted, 'aborted'],
-            [GitErrors.revertInProgress, 'alreadyInProgress'],
-            [GitErrors.unresolvedConflicts, 'conflicts'],
-            [GitErrors.uncommittedChanges, 'uncommittedChanges'],
-            [GitErrors.changesWouldBeOverwritten, 'wouldOverwriteChanges'],
-        ],
-    ],
-    [
-        'show',
-        [
-            [GitErrors.badObject, 'invalidObject'],
-            [GitErrors.badRevision, 'invalidRevision'],
-            [GitErrors.notAValidObjectName, 'invalidRevision'],
-            [GitWarnings.notFound, 'notFound'],
-            [GitWarnings.foundButNotInRevision, 'notInRevision'],
-        ],
-    ],
-    ['stash-apply', [[GitErrors.changesWouldBeOverwritten, 'uncommittedChanges']]],
-    [
-        'stash-push',
-        [
-            [GitErrors.stashConflictingStagedAndUnstagedLines, 'conflictingStagedAndUnstagedLines'],
-            [GitErrors.stashNothingToSave, 'nothingToSave'],
-            [GitErrors.stashSavedWorkingDirAndIndexState, 'conflictingStagedAndUnstagedLines'],
-        ],
-    ],
-    [
-        'tag',
-        [
-            [GitErrors.tagAlreadyExists, 'alreadyExists'],
-            [GitErrors.invalidTagName, 'invalidName'],
-            [GitErrors.tagNotFound, 'notFound'],
-            [GitErrors.permissionDenied, 'permissionDenied'],
-            [GitErrors.remoteRejected, 'remoteRejected'],
-            [GitErrors.tagConflict, 'tagConflict'],
-        ],
-    ],
-    [
-        'worktree-create',
-        [
-            [GitErrors.alreadyCheckedOut, 'alreadyCheckedOut'],
-            [GitErrors.alreadyExists, 'alreadyExists'],
-        ],
-    ],
-    [
-        'worktree-delete',
-        [
-            // Must come first -- a locked worktree's lock reason is free text that can otherwise match the errors below
-            [GitErrors.worktreeLocked, 'locked'],
-            [GitErrors.mainWorkingTree, 'defaultWorkingTree'],
-            [GitErrors.uncommittedChanges, 'uncommittedChanges'],
-            [GitErrors.failedToDeleteDirectoryNotEmpty, 'directoryNotEmpty'],
-        ],
-    ],
+var GitError = class extends Error {
+	original;
+	cmd;
+	exitCode;
+	stdout;
+	stderr;
+	constructor(original) {
+		let message;
+		let stdout;
+		let stderr;
+		let cmd;
+		let exitCode;
+		if (original instanceof RunError) {
+			stdout = original.stdout;
+			stderr = original.stderr;
+			message = stderr || stdout || original.message;
+			cmd = original.cmd;
+			exitCode = original.code;
+		} else message = original.message;
+		super(message);
+		this.original = original;
+		this.stdout = stdout;
+		this.stderr = stderr;
+		this.cmd = cmd;
+		this.exitCode = exitCode;
+		Error.captureStackTrace?.(this, new.target);
+	}
+};
+const errorToReasonMap = /* @__PURE__ */ new Map([
+	["branch", [
+		[GitErrors.branchAlreadyExists, "alreadyExists"],
+		[GitErrors.invalidName, "invalidName"],
+		[GitErrors.notFullyMerged, "notFullyMerged"],
+		[GitErrors.noRemoteReference, "noRemoteReference"]
+	]],
+	["checkout", [
+		[GitErrors.changesWouldBeOverwritten, "wouldOverwriteChanges"],
+		[GitErrors.ambiguousArgument, "pathspecNotFound"],
+		[GitErrors.notAValidObjectName, "invalidRef"]
+	]],
+	["cherry-pick", [
+		[GitErrors.cherryPickAborted, "aborted"],
+		[GitErrors.cherryPickInProgress, "alreadyInProgress"],
+		[GitErrors.conflict, "conflicts"],
+		[GitErrors.previousOperationEmpty, "emptyCommit"],
+		[GitErrors.changesWouldBeOverwritten, "wouldOverwriteChanges"]
+	]],
+	["commit", [
+		[GitErrors.nothingToCommit, "nothingToCommit"],
+		[GitErrors.unmergedFiles, "conflicts"],
+		[GitErrors.unresolvedConflicts, "conflicts"],
+		[GitErrors.noUserNameConfigured, "noUserNameConfigured"]
+	]],
+	["fetch", [
+		[GitErrors.noFastForward, "noFastForward"],
+		[GitErrors.noRemoteRepositorySpecified, "noRemote"],
+		[GitErrors.remoteConnectionFailed, "remoteConnectionFailed"]
+	]],
+	["merge", [
+		[GitErrors.mergeAborted, "aborted"],
+		[GitErrors.mergeInProgress, "alreadyInProgress"],
+		[GitErrors.unresolvedConflicts, "conflicts"],
+		[GitErrors.uncommittedChanges, "uncommittedChanges"],
+		[GitErrors.changesWouldBeOverwritten, "wouldOverwriteChanges"]
+	]],
+	["paused-operation-abort", [[GitErrors.noPausedOperation, "nothingToAbort"]]],
+	["paused-operation-continue", [
+		[GitErrors.problemWithEditor, "messageEditFailed"],
+		[GitErrors.previousOperationEmpty, "emptyCommit"],
+		[GitErrors.noPausedOperation, "nothingToContinue"],
+		[GitErrors.uncommittedChanges, "uncommittedChanges"],
+		[GitErrors.unmergedFiles, "unmergedFiles"],
+		[GitErrors.unresolvedConflicts, "conflicts"],
+		[GitErrors.unstagedChanges, "unstagedChanges"],
+		[GitErrors.changesWouldBeOverwritten, "wouldOverwriteChanges"],
+		[GitErrors.nothingToCommit, "emptyCommit"]
+	]],
+	["pull", [
+		[GitErrors.conflict, "conflict"],
+		[GitErrors.noUserNameConfigured, "gitIdentity"],
+		[GitErrors.remoteConnectionFailed, "remoteConnectionFailed"],
+		[GitErrors.unstagedChanges, "unstagedChanges"],
+		[GitErrors.unmergedFiles, "unmergedFiles"],
+		[GitErrors.commitChangesFirst, "uncommittedChanges"],
+		[GitErrors.changesWouldBeOverwritten, "wouldOverwriteChanges"],
+		[GitErrors.cantLockRef, "refLocked"],
+		[GitErrors.rebaseMultipleBranches, "rebaseMultipleBranches"],
+		[GitErrors.tagConflict, "tagConflict"]
+	]],
+	["push", [
+		[GitErrors.remoteAhead, "remoteAhead"],
+		[GitWarnings.tipBehind, "tipBehind"],
+		[GitErrors.pushRejectedRefDoesNotExists, "rejectedRefDoesNotExist"],
+		[GitErrors.pushRejected, "rejected"],
+		[GitErrors.permissionDenied, "permissionDenied"],
+		[GitErrors.remoteConnectionFailed, "remoteConnectionFailed"],
+		[GitErrors.noUpstream, "noUpstream"]
+	]],
+	["rebase", [
+		[GitErrors.rebaseAborted, "aborted"],
+		[GitErrors.rebaseMissingTodo, "aborted"],
+		[GitErrors.rebaseInProgress, "alreadyInProgress"],
+		[GitErrors.unresolvedConflicts, "conflicts"],
+		[GitErrors.uncommittedChanges, "uncommittedChanges"],
+		[GitErrors.changesWouldBeOverwritten, "wouldOverwriteChanges"]
+	]],
+	["reset", [
+		[GitErrors.ambiguousArgument, "ambiguousArgument"],
+		[GitErrors.detachedHead, "detachedHead"],
+		[GitErrors.refLocked, "refLocked"],
+		[GitErrors.entryNotUpToDate, "notUpToDate"],
+		[GitErrors.permissionDenied, "permissionDenied"],
+		[GitErrors.unmergedChanges, "unmergedChanges"],
+		[GitErrors.changesWouldBeOverwritten, "wouldOverwriteChanges"]
+	]],
+	["revert", [
+		[GitErrors.revertAborted, "aborted"],
+		[GitErrors.revertInProgress, "alreadyInProgress"],
+		[GitErrors.unresolvedConflicts, "conflicts"],
+		[GitErrors.uncommittedChanges, "uncommittedChanges"],
+		[GitErrors.changesWouldBeOverwritten, "wouldOverwriteChanges"]
+	]],
+	["show", [
+		[GitErrors.badObject, "invalidObject"],
+		[GitErrors.badRevision, "invalidRevision"],
+		[GitErrors.notAValidObjectName, "invalidRevision"],
+		[GitWarnings.notFound, "notFound"],
+		[GitWarnings.foundButNotInRevision, "notInRevision"]
+	]],
+	["stash-apply", [[GitErrors.changesWouldBeOverwritten, "uncommittedChanges"]]],
+	["stash-push", [
+		[GitErrors.stashConflictingStagedAndUnstagedLines, "conflictingStagedAndUnstagedLines"],
+		[GitErrors.stashNothingToSave, "nothingToSave"],
+		[GitErrors.stashSavedWorkingDirAndIndexState, "conflictingStagedAndUnstagedLines"]
+	]],
+	["tag", [
+		[GitErrors.tagAlreadyExists, "alreadyExists"],
+		[GitErrors.invalidTagName, "invalidName"],
+		[GitErrors.tagNotFound, "notFound"],
+		[GitErrors.permissionDenied, "permissionDenied"],
+		[GitErrors.remoteRejected, "remoteRejected"],
+		[GitErrors.tagConflict, "tagConflict"]
+	]],
+	["worktree-create", [[GitErrors.alreadyCheckedOut, "alreadyCheckedOut"], [GitErrors.alreadyExists, "alreadyExists"]]],
+	["worktree-delete", [
+		[GitErrors.worktreeLocked, "locked"],
+		[GitErrors.mainWorkingTree, "defaultWorkingTree"],
+		[GitErrors.uncommittedChanges, "uncommittedChanges"],
+		[GitErrors.failedToDeleteDirectoryNotEmpty, "directoryNotEmpty"]
+	]]
 ]);
-export function getGitCommandError(command, ex, creator) {
-    const msg = ex?.toString() ?? '';
-    const errorsToReasons = errorToReasonMap.get(command);
-    if (errorsToReasons != null) {
-        for (const [error, reason] of errorsToReasons) {
-            if (error.test(msg) || (ex.stderr && error.test(ex.stderr)) || (ex.stdout && error.test(ex.stdout))) {
-                return creator(reason);
-            }
-        }
-    }
-    return creator(undefined);
+function getGitCommandError(command, ex, creator) {
+	const msg = ex?.toString() ?? "";
+	const errorsToReasons = errorToReasonMap.get(command);
+	if (errorsToReasons != null) {
+		for (const [error, reason] of errorsToReasons) if (error.test(msg) || ex.stderr && error.test(ex.stderr) || ex.stdout && error.test(ex.stdout)) return creator(reason);
+	}
+	return creator(void 0);
 }
 function extractSigningErrorText(ex) {
-    if (ex == null)
-        return '';
-    if (ex instanceof GitError)
-        return ex.stderr || ex.stdout || ex.message || '';
-    if (ex instanceof Error)
-        return ex.message || '';
-    if (typeof ex === 'string')
-        return ex;
-    if (typeof ex === 'number' || typeof ex === 'boolean' || typeof ex === 'bigint')
-        return String(ex);
-    if (typeof ex === 'object' && 'message' in ex && typeof ex.message === 'string')
-        return ex.message;
-    return '';
+	if (ex == null) return "";
+	if (ex instanceof GitError) return ex.stderr || ex.stdout || ex.message || "";
+	if (ex instanceof Error) return ex.message || "";
+	if (typeof ex === "string") return ex;
+	if (typeof ex === "number" || typeof ex === "boolean" || typeof ex === "bigint") return String(ex);
+	if (typeof ex === "object" && "message" in ex && typeof ex.message === "string") return ex.message;
+	return "";
 }
 /**
- * Classifies a Git error as a signing-related failure using the {@link GitErrors}
- * signing regexes. Returns the matched {@link SigningErrorReason}, or `undefined`
- * when the error is not a recognized signing failure.
- *
- * Precedence is significant: `passphraseFailed` (gpg sign failure) is checked
- * before `noKey`, matching the ordering used historically in patch.ts — a
- * combined stderr like "error: gpg failed to sign … gpg: No secret key"
- * resolves to `passphraseFailed`, the outer cause.
- */
-export function classifySigningError(ex) {
-    const text = extractSigningErrorText(ex);
-    if (!text)
-        return undefined;
-    if (GitErrors.gpgSignFailed.test(text))
-        return 'passphraseFailed';
-    if (GitErrors.signingKeyNotAvailable.test(text))
-        return 'noKey';
-    if (GitErrors.gpgNotFound.test(text))
-        return 'gpgNotFound';
-    if (GitErrors.sshNotFound.test(text))
-        return 'sshNotFound';
-    return undefined;
+* Classifies a Git error as a signing-related failure using the {@link GitErrors}
+* signing regexes. Returns the matched {@link SigningErrorReason}, or `undefined`
+* when the error is not a recognized signing failure.
+*
+* Precedence is significant: `passphraseFailed` (gpg sign failure) is checked
+* before `noKey`, matching the ordering used historically in patch.ts — a
+* combined stderr like "error: gpg failed to sign … gpg: No secret key"
+* resolves to `passphraseFailed`, the outer cause.
+*/
+function classifySigningError(ex) {
+	const text = extractSigningErrorText(ex);
+	if (!text) return void 0;
+	if (GitErrors.gpgSignFailed.test(text)) return "passphraseFailed";
+	if (GitErrors.signingKeyNotAvailable.test(text)) return "noKey";
+	if (GitErrors.gpgNotFound.test(text)) return "gpgNotFound";
+	if (GitErrors.sshNotFound.test(text)) return "sshNotFound";
 }
 /**
- * Infers the {@link SigningFormat} from stderr hints (e.g., mentions of
- * `ssh-keygen` or `gpg.ssh.*` config keys). Returns `undefined` when no hints
- * are present so callers can supply their own default (typically `'gpg'`).
- *
- * Used as a fallback when `config.getSigningConfig` is unavailable or rejects
- * on the error path.
- */
-export function inferSigningFormatFromError(ex) {
-    const text = extractSigningErrorText(ex);
-    if (!text)
-        return undefined;
-    if (/\bssh-keygen\b|gpg\.ssh\.(?:program|allowedsignersfile)/i.test(text))
-        return 'ssh';
-    if (/\bgpg\b/i.test(text))
-        return 'gpg';
-    return undefined;
+* Infers the {@link SigningFormat} from stderr hints (e.g., mentions of
+* `ssh-keygen` or `gpg.ssh.*` config keys). Returns `undefined` when no hints
+* are present so callers can supply their own default (typically `'gpg'`).
+*
+* Used as a fallback when `config.getSigningConfig` is unavailable or rejects
+* on the error path.
+*/
+function inferSigningFormatFromError(ex) {
+	const text = extractSigningErrorText(ex);
+	if (!text) return void 0;
+	if (/\bssh-keygen\b|gpg\.ssh\.(?:program|allowedsignersfile)/i.test(text)) return "ssh";
+	if (/\bgpg\b/i.test(text)) return "gpg";
 }
 /**
- * Classifies a graph search failure from its stderr into an {@link GitSearchErrorReason}, with the
- * offending pattern/ref text (when git reports one) as `detail`. Returns `undefined` when the error
- * isn't a `GitError` with stderr, or the stderr doesn't match a recognized shape.
- */
-export function classifySearchError(ex) {
-    if (!(ex instanceof GitError) || !ex.stderr)
-        return undefined;
-    const stderr = ex.stderr;
-    // `-G<pattern>`/pathspec regex compile failures report one of two shapes:
-    //   fatal: command line, '<pattern>': <regcomp reason>
-    //   fatal: invalid regex: <regcomp reason>
-    // The pattern itself may contain "': ", so anchor on the known prefixes and let the greedy `.*`
-    // resolve to the LAST matching delimiter rather than splitting on the first occurrence.
-    const patternDetail = /^fatal:\s*command line,\s*'.*':\s*(.+)$/im.exec(stderr)?.[1] ??
-        /^fatal:\s*invalid regex:\s*(.+)$/im.exec(stderr)?.[1];
-    if (patternDetail != null)
-        return { reason: 'invalidPattern', detail: patternDetail.trim() };
-    if (GitErrors.invalidSearchPattern.test(stderr))
-        return { reason: 'invalidPattern' };
-    const ambiguous = GitErrors.ambiguousArgument.exec(stderr);
-    if (ambiguous != null)
-        return { reason: 'invalidRef', detail: ambiguous[1] };
-    const badRevision = GitErrors.badRevision.exec(stderr);
-    if (badRevision != null)
-        return { reason: 'invalidRef', detail: badRevision[1] };
-    if (/unknown revision/i.test(stderr))
-        return { reason: 'invalidRef' };
-    return undefined;
+* Classifies a graph search failure from its stderr into an {@link GitSearchErrorReason}, with the
+* offending pattern/ref text (when git reports one) as `detail`. Returns `undefined` when the error
+* isn't a `GitError` with stderr, or the stderr doesn't match a recognized shape.
+*/
+function classifySearchError(ex) {
+	if (!(ex instanceof GitError) || !ex.stderr) return void 0;
+	const stderr = ex.stderr;
+	const patternDetail = /^fatal:\s*command line,\s*'.*':\s*(.+)$/im.exec(stderr)?.[1] ?? /^fatal:\s*invalid regex:\s*(.+)$/im.exec(stderr)?.[1];
+	if (patternDetail != null) return {
+		reason: "invalidPattern",
+		detail: patternDetail.trim()
+	};
+	if (GitErrors.invalidSearchPattern.test(stderr)) return { reason: "invalidPattern" };
+	const ambiguous = GitErrors.ambiguousArgument.exec(stderr);
+	if (ambiguous != null) return {
+		reason: "invalidRef",
+		detail: ambiguous[1]
+	};
+	const badRevision = GitErrors.badRevision.exec(stderr);
+	if (badRevision != null) return {
+		reason: "invalidRef",
+		detail: badRevision[1]
+	};
+	if (/unknown revision/i.test(stderr)) return { reason: "invalidRef" };
 }
 const emptyArray = Object.freeze([]);
 const emptyObj = Object.freeze({});
 const trailingNewlineRegex = /[\r|\n]+$/;
 const uniqueCounterForStdin = getScopedCounter();
 const uniqueCounterForStream = getScopedCounter();
-export class Git {
-    _locator;
-    options;
-    /** Map of running git commands — avoids running duplicate overlapping commands */
-    pendingCommands = new Map();
-    /** Queue for throttling background git operations */
-    _queue;
-    /** Cached base environment: process.env + static options.env + GCM/LC_ALL vars */
-    _baseEnv;
-    /** Cached full environment: base + dynamic getEnvironment() result */
-    _fullEnv;
-    /** Last dynamic env reference, used to detect when getEnvironment() returns a new object */
-    _lastDynamicEnv;
-    constructor(_locator, options = {}) {
-        this._locator = _locator;
-        this.options = options;
-        this._queue = new GitQueue(options.queue, { onSlowQueue: options.hooks?.onSlowQueue });
-    }
-    /**
-     * Returns the base environment for git commands. Cached to avoid spreading
-     * process.env (30-100+ keys) on every call. Includes static options.env and
-     * GCM/LC_ALL vars but NOT dynamic getEnvironment() or per-call env overrides.
-     */
-    getBaseEnv() {
-        return (this._baseEnv ??= {
-            ...process.env,
-            ...(this.options.env ?? emptyObj),
-            GCM_INTERACTIVE: 'NEVER',
-            GCM_PRESERVE_CREDS: 'TRUE',
-            LC_ALL: 'C',
-        });
-    }
-    /**
-     * Returns the full environment (base + dynamic). Cached and invalidated
-     * when getEnvironment() returns a different object reference.
-     */
-    getFullEnv() {
-        const dynamicEnv = this.options.getEnvironment?.() ?? undefined;
-        if (this._fullEnv != null && dynamicEnv === this._lastDynamicEnv)
-            return this._fullEnv;
-        this._lastDynamicEnv = dynamicEnv;
-        this._fullEnv = dynamicEnv != null ? { ...this.getBaseEnv(), ...dynamicEnv } : this.getBaseEnv();
-        return this._fullEnv;
-    }
-    /**
-     * Builds the environment for a git command. Returns the cached full env
-     * directly when there are no per-call overrides (the common case).
-     * Only allocates a new object when per-call env overrides are provided.
-     */
-    buildEnv(perCallEnv) {
-        if (perCallEnv == null)
-            return this.getFullEnv();
-        return { ...this.getFullEnv(), ...perCallEnv };
-    }
-    dispose() {
-        this._queue.dispose();
-    }
-    /** Clear pending commands (e.g. on cache reset) */
-    clearPendingCommands() {
-        this.pendingCommands.clear();
-    }
-    _gitLocation;
-    _gitLocationPromise;
-    async getLocation() {
-        if (this._gitLocation == null) {
-            this._gitLocationPromise ??= this._locator();
-            this._gitLocation = await this._gitLocationPromise;
-        }
-        return this._gitLocation;
-    }
-    async path() {
-        return (await this.getLocation()).path;
-    }
-    async version() {
-        return (await this.getLocation()).version;
-    }
-    supports(feature) {
-        const version = gitFeaturesByVersion.get(feature);
-        if (version == null)
-            return true;
-        return this._gitLocation != null
-            ? compare(fromString(this._gitLocation.version), fromString(version)) !== -1
-            : this.version().then(v => compare(fromString(v), fromString(version)) !== -1);
-    }
-    supported(feature) {
-        function supportedCore(gitVersion) {
-            return [...gitFeaturesByVersion]
-                .filter(([f, v]) => f.startsWith(feature) && compare(fromString(gitVersion), v) !== -1)
-                .map(([f]) => f);
-        }
-        if (this._gitLocation == null) {
-            return this.version().then(v => supportedCore(v));
-        }
-        return supportedCore(this._gitLocation.version);
-    }
-    async ensureSupports(feature, prefix, suffix) {
-        const version = gitFeaturesByVersion.get(feature);
-        if (version == null)
-            return;
-        const gitVersion = await this.version();
-        if (compare(fromString(gitVersion), fromString(version)) !== -1)
-            return;
-        throw new Error(`${prefix} requires a newer version of Git (>= ${version}) than is currently installed (${gitVersion}).${suffix}`);
-    }
-    async run(options, ...args) {
-        if (this.options.isTrusted?.() === false)
-            throw new WorkspaceUntrustedError();
-        const runArgs = args.filter(a => a != null);
-        const gitCommand = `git ${runArgs.join(' ')}`;
-        // If cache is provided, use it to cache the full result
-        if (options.caching != null) {
-            return options.caching.cache.getOrCreate(options.caching.commonPath ?? options.cwd, gitCommand, async (cacheable, signal) => {
-                // Bind the shared spawn to the aggregate `signal` (fires only when ALL current callers
-                // abort), not this-caller's `options.cancellation` — otherwise a superseded caller's
-                // abort would kill the shared command and reject concurrent riders that never cancelled.
-                const result = await this.runCore({ ...options, caching: undefined, cancellation: signal ?? options.cancellation }, runArgs, gitCommand);
-                // Never cache a result that isn't a genuine command outcome. Under `errors: 'ignore'` a
-                // cancelled/aborted run RESOLVES an empty result, which — left cached — would be served as a
-                // real empty result for the full TTL (e.g. a valid merge-base read back as "none").
-                // Invalidate on anything that isn't a clean exit, or whenever the aggregate signal aborted,
-                // so the entry self-evicts instead of poisoning later callers.
-                //
-                // `status !== 'exited'` is what catches the case a bare `exitCode` check cannot. A swallowed
-                // `GitWarnings` match used to report `exitCode: 0` UNCONDITIONALLY — the old code read it off
-                // a `result` that is only ever assigned on the non-throwing path, so it was always the `?? 0`
-                // fallback — which meant `exitCode !== 0` could never fire and every swallowed failure was
-                // cached. A `warned` result now carries git's real code, so it's the status, not the code,
-                // that has to do the work here. The `exitCode !== 0` half is kept as-is — a non-zero exit is
-                // a real answer and arguably cacheable, but it isn't cached today and this isn't the change
-                // to start.
-                if (result.completion.status !== 'exited' || result.exitCode !== 0 || signal?.aborted) {
-                    cacheable.invalidate();
-                }
-                return result;
-            }, 
-            // Forward this caller's cancellation so `getOrCreate` races each caller's own wait — an
-            // aborting caller rejects only itself, leaving the shared work (and its riders) intact.
-            { ...options.caching.options, cancellation: options.cancellation });
-        }
-        return this.runCore(options, runArgs, gitCommand);
-    }
-    async runCore(options, args, gitCommand) {
-        const start = hrtime();
-        gitCommand = `[${options.cwd}] ${gitCommand}`;
-        const { cancellation, configs, correlationKey, errors: errorHandling, encoding, runLocally: _, selfMaintenance, ...opts } = options;
-        const defaultTimeout = this.options.gitTimeout ?? 60000;
-        const runOpts = {
-            ...opts,
-            timeout: opts.timeout === 0 || defaultTimeout === 0 ? undefined : (opts.timeout ?? defaultTimeout),
-            encoding: (encoding ?? 'utf8') === 'utf8' ? 'utf8' : 'buffer',
-            decode: this.options.decode,
-            env: this.buildEnv(options.env),
-            quiet: errorHandling === 'ignore',
-        };
-        const cacheKey = `${correlationKey !== undefined ? `${correlationKey}:` : ''}${options?.stdin != null ? `${uniqueCounterForStdin.next()}:` : ''}${cancellation != null ? `${getAbortSignalId(cancellation)}:` : ''}${gitCommand}`;
-        // When the subprocess actually started — `start` includes GitQueue wait, which is congestion rather
-        // than anything the repository did. Stays undefined for a dedup rider or a command aborted while queued.
-        let execStart;
-        let waiting;
-        let promise = this.pendingCommands.get(cacheKey);
-        if (promise == null) {
-            waiting = false;
-            // Create a deferred promise and store it immediately to prevent duplicate commands
-            // Note: cancellation tokens are not part of the dedup key — calls with different AbortSignals will not be deduplicated
-            const deferred = defer();
-            promise = deferred.promise;
-            this.pendingCommands.set(cacheKey, promise);
-            // Fixes https://github.com/gitkraken/vscode-gitlens/issues/73 & https://github.com/gitkraken/vscode-gitlens/issues/161
-            // See https://stackoverflow.com/questions/4144417/how-to-handle-asian-characters-in-file-names-in-git-on-os-x
-            args.unshift('-c', 'core.quotepath=false', '-c', 'color.ui=false', ...(configs ?? emptyArray));
-            if (process.platform === 'win32') {
-                args.unshift('-c', 'core.longpaths=true');
-            }
-            if (cancellation != null) {
-                runOpts.cancellation = cancellation;
-            }
-            // Determine command priority:
-            // Priority resolution:
-            // 1. Explicit priority from options (highest precedence)
-            // 2. Inferred from command type (only downgrades expensive commands to Background)
-            const priority = options.priority ?? inferGitCommandPriority(args);
-            // Execute through the queue (interactive/normal run immediately, background is throttled)
-            const gitPath = await this.path();
-            void this._queue
-                .run(priority, () => {
-                execStart = hrtime();
-                return runSpawn(gitPath, args, encoding ?? 'utf8', runOpts);
-            }, cancellation)
-                .then(deferred.fulfill, (e) => deferred.cancel(e instanceof Error ? e : new Error(String(e))))
-                .finally(() => {
-                this.pendingCommands.delete(cacheKey);
-            })
-                .catch(() => { });
-        }
-        else {
-            waiting = true;
-            Logger.trace(`${formatLoggableScopeBlock('GIT')} ${gitCommand} \u00b7 awaiting existing call...`);
-        }
-        let exception;
-        let result;
-        try {
-            result = await promise;
-            // A normal `runSpawn` only resolves on a clean exit — `code !== 0 || signal` rejects — but the
-            // `exitCodeOnly` overload resolves unconditionally, INCLUDING for a signalled run (no code, partial
-            // or absent stdout). Coercing that to `0` would report a killed command as a clean success, so
-            // classify it as the failure it is.
-            if (result.exitCode == null) {
-                // SIGTERM is how BOTH a timeout kill and a caller abort terminate, so it has to group with
-                // cancellations here exactly as it does on the reject path — `failed`/`signal` is for every
-                // OTHER signal. Only `exitCodeOnly` reaches this: a native spawn `timeout` fires
-                // `close(null, 'SIGTERM')` with no `error` event, so it resolves instead of rejecting.
-                // Throwing hands it to the catch below, which owns the timeout-vs-abort heuristic, the ABORTED
-                // log, and the `onAborted` hook — none of which a branch here would fire.
-                if (result.signal === 'SIGTERM') {
-                    throw new CancelledRunError(gitCommand, true, undefined, result.signal);
-                }
-                return {
-                    stdout: result.stdout,
-                    stderr: result.stderr,
-                    completion: {
-                        status: 'failed',
-                        reason: result.signal != null ? 'signal' : 'unstarted',
-                        error: new Error(`Command terminated without an exit code${result.signal != null ? ` (${result.signal})` : ''}`),
-                    },
-                };
-            }
-            return {
-                stdout: result.stdout,
-                stderr: result.stderr,
-                exitCode: result.exitCode,
-                completion: { status: 'exited', code: result.exitCode },
-            };
-        }
-        catch (ex) {
-            let cancellationReason = 'unknown';
-            if (ex instanceof CancelledRunError) {
-                const duration = getDurationMilliseconds(start);
-                const timeout = runOpts.timeout ?? 0;
-                const reason = timeout > 0 && duration >= timeout - 100
-                    ? 'timeout'
-                    : cancellation?.aborted
-                        ? 'cancellation'
-                        : 'unknown';
-                // Also surfaced on the result, but DIAGNOSTIC ONLY — a timeout kill and a caller abort are both
-                // SIGTERM, so this duration heuristic can be wrong near the boundary. Never gate behavior on it.
-                cancellationReason = reason === 'cancellation' ? 'aborted' : reason;
-                Logger.warn(`${formatLoggableScopeBlock('GIT')} ${gitCommand} \u00b7 ABORTED after ${duration}ms (${reason})`);
-                this.options.hooks?.onAborted?.({
-                    operation: gitCommand,
-                    reason: reason,
-                    duration: duration,
-                    timeout: timeout,
-                });
-            }
-            if (errorHandling === 'ignore') {
-                if (ex instanceof RunError) {
-                    // `code` is `string | number | undefined`: a numeric string is a real exit code, but an errno
-                    // (`'ENOENT'`) means the spawn itself failed, and `undefined` means the process never exited
-                    // normally. Only the numeric case is an exit; the rest previously became `0` or `NaN`.
-                    const code = typeof ex.code === 'number' ? ex.code : ex.code != null ? parseInt(ex.code, 10) : NaN;
-                    const exited = Number.isInteger(code);
-                    return {
-                        stdout: ex.stdout,
-                        stderr: ex.stderr,
-                        ...(exited ? { exitCode: code } : {}),
-                        completion: ex instanceof CancelledRunError
-                            ? { status: 'cancelled', reason: cancellationReason, error: ex }
-                            : exited
-                                ? { status: 'exited', code: code }
-                                : {
-                                    status: 'failed',
-                                    // A signal means it ran and was killed (partial `stdout` may exist);
-                                    // no signal and no numeric code means it never got that far.
-                                    reason: ex.signal != null ? 'signal' : 'unstarted',
-                                    error: ex,
-                                },
-                    };
-                }
-                // No cancellation branch here: `CancelledRunError extends RunError`, so reaching this at all
-                // proves `ex` is neither.
-                return {
-                    stdout: '',
-                    stderr: undefined,
-                    completion: {
-                        status: 'failed',
-                        // No `RunError` means no process was ever spawned — a queue rejection or a
-                        // failure before `spawn` returned. (Not an untrusted workspace: `run` refuses
-                        // those up front, so they never reach this catch.)
-                        reason: 'unstarted',
-                        error: ex instanceof Error ? ex : new Error(String(ex)),
-                    },
-                };
-            }
-            if (ex instanceof CancelledRunError) {
-                exception = new CancellationError(ex);
-            }
-            else {
-                exception = new GitError(ex);
-            }
-            if (errorHandling === 'throw')
-                throw exception;
-            // Rethrows unless the message matches a `GitWarnings` pattern, in which case it logs and returns the
-            // key that matched. Capture the error first — `exception` is cleared to keep it out of the `finally`
-            // log, but the result still needs to carry it.
-            const swallowed = exception;
-            const warning = defaultExceptionHandler(exception, options.cwd, start);
-            exception = undefined;
-            // The command did NOT produce this empty stdout — a warning was swallowed. Say so, or the caller
-            // can't tell a genuinely empty answer (`noCommits`) from a read that never happened
-            // (`notARepository`).
-            //
-            // The process DID exit though (a warning is only ever swallowed for a non-zero exit), so report the
-            // code. `GitError.exitCode` is `number | string | undefined` — same normalization as the
-            // `errors: 'ignore'` path above, since only the numeric case is a real exit.
-            const rawCode = swallowed instanceof GitError ? swallowed.exitCode : undefined;
-            const code = typeof rawCode === 'number' ? rawCode : rawCode != null ? parseInt(rawCode, 10) : NaN;
-            // No `stderr`: it belongs to the error here. The top-level field is the channel for runs that
-            // completed WITHOUT one (`exited` carries no error, so a successful command's stderr has nowhere
-            // else to go) — a swallowed warning always has a `GitError`, and it carries the stderr. Reading
-            // `result?.stderr` would be dead anyway: `result` is only assigned on the non-throwing path.
-            return {
-                stdout: '',
-                ...(Number.isInteger(code) ? { exitCode: code } : {}),
-                completion: { status: 'warned', warning: warning, error: swallowed },
-            };
-        }
-        finally {
-            this.logGitCommandComplete(gitCommand, exception, getDurationMilliseconds(start), 
-            // 0 when the subprocess never started — there is no execution time to attribute. Also 0 for
-            // GitLens's own maintenance work, which is slow by design and must not read as repo slowness.
-            execStart == null || selfMaintenance ? 0 : getDurationMilliseconds(execStart), waiting, options.cwd, args);
-        }
-    }
-    async *stream(options, ...args) {
-        if (this.options.isTrusted?.() === false)
-            throw new WorkspaceUntrustedError();
-        const start = hrtime();
-        const streamId = uniqueCounterForStream.next();
-        const { configs, stdin, stdinEncoding, cancellation, encoding, ...opts } = options;
-        const runArgs = args.filter(a => a != null);
-        const spawnOpts = {
-            // Unless provided, ignore stdin and leave default streams for stdout and stderr
-            stdio: [stdin ? 'pipe' : 'ignore', null, null],
-            ...opts,
-            signal: cancellation,
-            env: this.buildEnv(options.env),
-        };
-        const gitCommand = `(spawn) [${spawnOpts.cwd}] git ${runArgs.join(' ')}`;
-        // Fixes https://github.com/gitkraken/vscode-gitlens/issues/73 & https://github.com/gitkraken/vscode-gitlens/issues/161
-        // See https://stackoverflow.com/questions/4144417/how-to-handle-asian-characters-in-file-names-in-git-on-os-x
-        runArgs.unshift('-c', 'core.quotepath=false', '-c', 'color.ui=false', ...(configs ?? emptyArray));
-        if (process.platform === 'win32') {
-            runArgs.unshift('-c', 'core.longpaths=true');
-        }
-        const command = await this.path();
-        const proc = spawn(command, runArgs, spawnOpts);
-        if (stdin) {
-            proc.stdin?.end(stdin, (stdinEncoding ?? 'utf8'));
-        }
-        let exception;
-        const promise = new Promise((resolve, reject) => {
-            const stderrChunks = [];
-            if (proc.stderr) {
-                proc.stderr?.setEncoding('utf8');
-                proc.stderr.on('data', chunk => stderrChunks.push(chunk));
-            }
-            proc.once('error', ex => {
-                if (ex?.name === 'AbortError')
-                    return;
-                exception = new GitError(ex);
-            });
-            proc.once('close', (code, signal) => {
-                if (code === 0) {
-                    resolve();
-                    return;
-                }
-                if (signal === 'SIGTERM') {
-                    // If the caller aborted, just resolve
-                    if (cancellation?.aborted) {
-                        resolve();
-                    }
-                    else {
-                        reject(new CancelledRunError(proc.spawnargs.join(' '), true, code ?? undefined, signal));
-                    }
-                    return;
-                }
-                // If the caller didn't read the complete stream, just resolve
-                if (signal === 'SIGPIPE' ||
-                    code === 141 /* SIGPIPE */ ||
-                    (code === 128 && stderrChunks.some(c => c.includes('Connection reset by peer')))) {
-                    resolve();
-                    return;
-                }
-                const stderr = stderrChunks.join('').trim();
-                reject(new GitError(new RunError({
-                    message: `Error (${code}): ${stderr || 'Unknown'}`,
-                    cmd: proc.spawnargs.join(' '),
-                    killed: proc.killed,
-                    code: proc.exitCode,
-                }, '', stderr)));
-            });
-        });
-        let cleanedUp = false;
-        const cleanup = () => {
-            if (cleanedUp)
-                return;
-            cleanedUp = true;
-            try {
-                proc.removeAllListeners();
-            }
-            catch { }
-            // Streaming spawns directly, with no GitQueue wait to exclude. It isn't pure subprocess time
-            // either — the generator applies backpressure, so a slow consumer stalls the pipe and inflates
-            // this — but there's no separate signal to measure here.
-            const duration = getDurationMilliseconds(start);
-            this.logGitCommandComplete(gitCommand, exception, duration, duration, false, spawnOpts.cwd, runArgs, streamId);
-        };
-        try {
-            this.logGitCommandStart(gitCommand, streamId);
-            try {
-                if (proc.stdout) {
-                    const enc = encoding ?? 'utf8';
-                    if (enc === 'utf8' || enc === 'binary' || enc === 'buffer') {
-                        proc.stdout.setEncoding(enc === 'buffer' ? 'utf8' : enc);
-                        for await (const chunk of proc.stdout) {
-                            yield chunk;
-                        }
-                    }
-                    else {
-                        // Non-UTF-8 encoding: collect raw buffers and decode at the end.
-                        // Streaming decode is unsafe because chunk boundaries can split
-                        // multi-byte sequences in the source encoding.
-                        const decode = this.options.decode;
-                        if (decode == null) {
-                            throw new Error(`Non-UTF-8 encoding '${enc}' requested for stream but no decode function configured`);
-                        }
-                        const buffers = [];
-                        for await (const chunk of proc.stdout) {
-                            buffers.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
-                        }
-                        yield await decode(Buffer.concat(buffers), { encoding: enc });
-                    }
-                }
-            }
-            finally {
-                // This await MUST be in this inner finally block to ensure the child process close event completes
-                // before we call removeAllListeners() in the outer finally. When consumers break early from the
-                // async generator (e.g., reading only the first chunk), the git process receives SIGPIPE and triggers
-                // the close handler asynchronously. Without awaiting here, removeAllListeners() would execute before
-                // the close handler finishes, causing a race condition and potential resource leaks.
-                await promise;
-            }
-        }
-        catch (ex) {
-            exception = ex;
-            throw ex;
-        }
-        finally {
-            cleanup();
-        }
-        // Ensure cleanup happens immediately when the generator is explicitly closed (e.g., via break or return)
-        // This is called by JavaScript when the generator is abandoned, ensuring logGitCommand is called
-        // synchronously rather than waiting for garbage collection.
-        // oxlint-disable-next-line typescript/no-meaningless-void-operator
-        return void cleanup();
-    }
-    async rev_parse__git_dir(cwd) {
-        const result = await this.run({ cwd: cwd, errors: 'ignore' }, 'rev-parse', '--git-dir', '--git-common-dir');
-        if (!result.stdout)
-            return undefined;
-        // Keep trailing spaces which are part of the directory name
-        let [dotGitPath, commonDotGitPath] = result.stdout.split('\n').map(r => r.trimStart());
-        // Make sure to normalize: https://github.com/git-for-windows/git/issues/2478
-        if (!isAbsolute(dotGitPath)) {
-            dotGitPath = joinPaths(cwd, dotGitPath);
-        }
-        dotGitPath = normalizePath(dotGitPath);
-        if (commonDotGitPath) {
-            if (!isAbsolute(commonDotGitPath)) {
-                commonDotGitPath = joinPaths(cwd, commonDotGitPath);
-            }
-            commonDotGitPath = normalizePath(commonDotGitPath);
-            return { path: dotGitPath, commonPath: commonDotGitPath !== dotGitPath ? commonDotGitPath : undefined };
-        }
-        return { path: dotGitPath };
-    }
-    async rev_parse__show_toplevel(cwd) {
-        let result;
-        if (this.options.isTrusted?.() === false) {
-            // Check if the folder is a bare clone: if it has a file named HEAD && `rev-parse --show-cdup` is empty
-            if (await fsExists(joinPaths(cwd, 'HEAD'))) {
-                try {
-                    result = await this.run({ cwd: cwd, errors: 'throw', configs: ['-C', cwd] }, 'rev-parse', '--show-cdup');
-                    if (!result.stdout.trim()) {
-                        Logger.warn(`Skipping (untrusted workspace); bare clone repository detected in '${cwd}'`);
-                        return emptyArray;
-                    }
-                }
-                catch {
-                    // If this throws, we should be good to open the repo (e.g. HEAD doesn't exist)
-                }
-            }
-        }
-        try {
-            result = await this.run({ cwd: cwd, errors: 'throw' }, 'rev-parse', '--show-toplevel');
-            // Make sure to normalize: https://github.com/git-for-windows/git/issues/2478
-            // Keep trailing spaces which are part of the directory name
-            return !result.stdout
-                ? emptyArray
-                : [true, normalizePath(result.stdout.trimStart().replace(trailingNewlineRegex, ''))];
-        }
-        catch (ex) {
-            if (ex instanceof WorkspaceUntrustedError)
-                return emptyArray;
-            if (!(ex instanceof GitError))
-                throw ex;
-            const unsafeMatch = GitErrors.unsafeRepository.exec(ex.stderr ?? '');
-            if (unsafeMatch != null) {
-                Logger.warn(`Skipping; unsafe repository detected in '${unsafeMatch[1] || unsafeMatch[2]}'; run '${unsafeMatch[3]}' to allow it`);
-                return [false];
-            }
-            const inDotGit = GitWarnings.mustRunInWorkTree.test(ex.stderr ?? '');
-            // Check if we are in a bare clone
-            if (inDotGit && this.options.isTrusted?.() !== false) {
-                result = await this.run({ cwd: cwd, errors: 'ignore' }, 'rev-parse', '--is-bare-repository');
-                if (result.stdout.trim() === 'true') {
-                    const result = await this.rev_parse__git_dir(cwd);
-                    const repoPath = result?.commonPath ?? result?.path;
-                    if (repoPath?.length)
-                        return [true, repoPath];
-                }
-            }
-            if (inDotGit || ex.original?.code === 'ENOENT') {
-                // If the `cwd` doesn't exist, walk backward to see if any parent folder exists
-                let exists = inDotGit ? false : await fsExists(cwd);
-                if (!exists) {
-                    do {
-                        const parent = dirname(cwd);
-                        if (parent === cwd || parent.length === 0)
-                            return emptyArray;
-                        cwd = parent;
-                        exists = await fsExists(cwd);
-                    } while (!exists);
-                    return this.rev_parse__show_toplevel(cwd);
-                }
-            }
-            return emptyArray;
-        }
-    }
-    logGitCommandStart(command, id) {
-        Logger.info(`${formatLoggableScopeBlock(`GIT:\u2192${id}`)} ${command} \u00b7 starting...`);
-        this.options.logger?.info(`${formatLoggableScopeBlock(`\u2192${id}`, '')} ${command} \u2022 starting...`);
-    }
-    logGitCommandComplete(command, ex, duration, 
-    /** Subprocess-only duration (excludes GitQueue wait); 0 when it never ran. */
-    execDuration, waiting, cwd, args, id) {
-        const slow = duration > slowCallWarningThreshold;
-        const status = slow && waiting ? ' (slow, waiting)' : waiting ? ' (waiting)' : slow ? ' (slow)' : '';
-        // The health signal is gated on the SUBPROCESS time, not the total: time spent queued behind other
-        // git work is congestion, not repository slowness, and counting it would let a busy queue (including
-        // our own background maintenance holding slots) manufacture the evidence that recommends more
-        // maintenance. Logging keeps the total — the wait is exactly what you want to see when diagnosing.
-        //
-        // A deduplicated rider (`waiting`) shares the executed command's duration, so counting it too
-        // would double-count a single slow subprocess — fire only for the command that actually ran.
-        // Guarded: this runs inside the command's `finally`, so a hook throw would otherwise replace
-        // the command's real result/error for the caller.
-        if (execDuration > slowCallWarningThreshold && !waiting) {
-            try {
-                this.options.hooks?.onSlowCommand?.({
-                    operation: args != null ? getPrimaryGitCommand(args) : undefined,
-                    cwd: cwd,
-                    duration: execDuration,
-                });
-            }
-            catch { }
-        }
-        if (ex != null) {
-            Logger.error(undefined, `${formatLoggableScopeBlock(id ? `GIT:\u2190${id}` : 'GIT')} ${command} \u00b7 ${isCancellationError(ex)
-                ? 'cancelled'
-                : (ex.message || String(ex) || '')
-                    .trim()
-                    .replace(/fatal:\s*/g, '')
-                    .replace(/\r?\n|\r/g, ' \u00b7 ')} [${duration}ms]${status}`);
-        }
-        else if (slow) {
-            Logger.warn(`${formatLoggableScopeBlock(id ? `GIT:\u2190${id}` : 'GIT', `*${duration}ms`)} ${command} [*${duration}ms]${status}`);
-        }
-        else {
-            Logger.info(`${formatLoggableScopeBlock(id ? `GIT:\u2190${id}` : 'GIT', `${duration}ms`)} ${command} [${duration}ms]${status}`);
-        }
-        const logMessage = `${formatLoggableScopeBlock(`${id ? `\u2190${id}` : ''}${slow ? '*' : ''}`, `${duration}ms`)} ${command}${status}`;
-        if (ex != null) {
-            this.options.logger?.error(`${logMessage} \u2022 FAILED\n${String(ex)}`);
-        }
-        else {
-            this.options.logger?.info(`${logMessage} \u2022 completed`);
-        }
-    }
-}
+var Git = class {
+	_locator;
+	options;
+	/** Map of running git commands — avoids running duplicate overlapping commands */
+	pendingCommands = /* @__PURE__ */ new Map();
+	/** Queue for throttling background git operations */
+	_queue;
+	/** Detects event-loop stalls while at least one git command is in flight */
+	_eventLoopMonitor = new EventLoopMonitor();
+	/** Count of git commands currently in flight, across both the exec and streaming paths */
+	_activeCommandCount = 0;
+	/** Cached base environment: process.env + static options.env + GCM/LC_ALL vars */
+	_baseEnv;
+	/** Cached full environment: base + dynamic getEnvironment() result */
+	_fullEnv;
+	/** Last dynamic env reference, used to detect when getEnvironment() returns a new object */
+	_lastDynamicEnv;
+	constructor(_locator, options = {}) {
+		this._locator = _locator;
+		this.options = options;
+		this._queue = new GitQueue(options.queue, { onSlowQueue: options.hooks?.onSlowQueue });
+	}
+	/**
+	* Returns the base environment for git commands. Cached to avoid spreading
+	* process.env (30-100+ keys) on every call. Includes static options.env and
+	* GCM/LC_ALL vars but NOT dynamic getEnvironment() or per-call env overrides.
+	*/
+	getBaseEnv() {
+		return this._baseEnv ??= {
+			...process.env,
+			...this.options.env ?? emptyObj,
+			GCM_INTERACTIVE: "NEVER",
+			GCM_PRESERVE_CREDS: "TRUE",
+			LC_ALL: "C"
+		};
+	}
+	/**
+	* Returns the full environment (base + dynamic). Cached and invalidated
+	* when getEnvironment() returns a different object reference.
+	*/
+	getFullEnv() {
+		const dynamicEnv = this.options.getEnvironment?.() ?? void 0;
+		if (this._fullEnv != null && dynamicEnv === this._lastDynamicEnv) return this._fullEnv;
+		this._lastDynamicEnv = dynamicEnv;
+		this._fullEnv = dynamicEnv != null ? {
+			...this.getBaseEnv(),
+			...dynamicEnv
+		} : this.getBaseEnv();
+		return this._fullEnv;
+	}
+	/**
+	* Builds the environment for a git command. Returns the cached full env
+	* directly when there are no per-call overrides (the common case).
+	* Only allocates a new object when per-call env overrides are provided.
+	*/
+	buildEnv(perCallEnv) {
+		if (perCallEnv == null) return this.getFullEnv();
+		return {
+			...this.getFullEnv(),
+			...perCallEnv
+		};
+	}
+	dispose() {
+		this._queue.dispose();
+		this._eventLoopMonitor.dispose();
+	}
+	/** Clear pending commands (e.g. on cache reset) */
+	clearPendingCommands() {
+		this.pendingCommands.clear();
+	}
+	/** Marks one more git command as in flight; starts the event-loop monitor on the first. */
+	beginActiveCommand() {
+		this._activeCommandCount++;
+		if (this._activeCommandCount === 1) this._eventLoopMonitor.start();
+	}
+	/** Marks a git command as finished; stops the event-loop monitor once none remain. */
+	endActiveCommand() {
+		this._activeCommandCount--;
+		if (this._activeCommandCount === 0) this._eventLoopMonitor.stop();
+	}
+	/** Formats the shared "event loop blocked" log annotation; undefined below {@link eventLoopDelayAnnotationThreshold}. */
+	formatEventLoopDelayAnnotation(sinceEpochMs) {
+		const delay = this._eventLoopMonitor.maxDelaySince(sinceEpochMs);
+		return delay >= eventLoopDelayAnnotationThreshold ? `event loop blocked ~${delay}ms` : void 0;
+	}
+	_gitLocation;
+	_gitLocationPromise;
+	async getLocation() {
+		if (this._gitLocation == null) {
+			this._gitLocationPromise ??= this._locator();
+			this._gitLocation = await this._gitLocationPromise;
+		}
+		return this._gitLocation;
+	}
+	async path() {
+		return (await this.getLocation()).path;
+	}
+	async version() {
+		return (await this.getLocation()).version;
+	}
+	supports(feature) {
+		const version = gitFeaturesByVersion.get(feature);
+		if (version == null) return true;
+		return this._gitLocation != null ? compare(fromString(this._gitLocation.version), fromString(version)) !== -1 : this.version().then((v) => compare(fromString(v), fromString(version)) !== -1);
+	}
+	supported(feature) {
+		function supportedCore(gitVersion) {
+			return [...gitFeaturesByVersion].filter(([f, v]) => f.startsWith(feature) && compare(fromString(gitVersion), v) !== -1).map(([f]) => f);
+		}
+		if (this._gitLocation == null) return this.version().then((v) => supportedCore(v));
+		return supportedCore(this._gitLocation.version);
+	}
+	async ensureSupports(feature, prefixOrMessage, suffix) {
+		const version = gitFeaturesByVersion.get(feature);
+		if (version == null) return;
+		const gitVersion = await this.version();
+		if (compare(fromString(gitVersion), fromString(version)) !== -1) return;
+		const message = typeof prefixOrMessage === "function" ? prefixOrMessage(version, gitVersion) : `${prefixOrMessage} requires a newer version of Git (>= ${version}) than is currently installed (${gitVersion}).${suffix}`;
+		throw new Error(message);
+	}
+	async run(options, ...args) {
+		if (this.options.isTrusted?.() === false) throw new WorkspaceUntrustedError();
+		const runArgs = args.filter((a) => a != null);
+		const gitCommand = `git ${runArgs.join(" ")}`;
+		if (options.caching != null) return options.caching.cache.getOrCreate(options.caching.commonPath ?? options.cwd, gitCommand, async (cacheable, signal) => {
+			const result = await this.runCore({
+				...options,
+				caching: void 0,
+				cancellation: signal ?? options.cancellation
+			}, runArgs, gitCommand);
+			if (result.completion.status !== "exited" || result.exitCode !== 0 || signal?.aborted) cacheable.invalidate();
+			return result;
+		}, {
+			...options.caching.options,
+			cancellation: options.cancellation
+		});
+		return this.runCore(options, runArgs, gitCommand);
+	}
+	async runCore(options, args, gitCommand) {
+		const start = hrtime();
+		const startEpochMs = Date.now();
+		gitCommand = `[${options.cwd}] ${gitCommand}`;
+		const { cancellation, configs, correlationKey, errors: errorHandling, encoding, runLocally: _, selfMaintenance, slownessCategory, ...opts } = options;
+		const defaultTimeout = this.options.gitTimeout ?? 6e4;
+		const runOpts = {
+			...opts,
+			timeout: opts.timeout === 0 || defaultTimeout === 0 ? void 0 : opts.timeout ?? defaultTimeout,
+			encoding: (encoding ?? "utf8") === "utf8" ? "utf8" : "buffer",
+			decode: this.options.decode,
+			env: this.buildEnv(options.env),
+			quiet: errorHandling === "ignore"
+		};
+		const cacheKey = `${correlationKey !== void 0 ? `${correlationKey}:` : ""}${options?.stdin != null ? `${uniqueCounterForStdin.next()}:` : ""}${cancellation != null ? `${getAbortSignalId(cancellation)}:` : ""}${gitCommand}`;
+		let execStart;
+		let waiting;
+		let promise = this.pendingCommands.get(cacheKey);
+		if (promise == null) {
+			waiting = false;
+			const deferred = defer();
+			promise = deferred.promise;
+			this.pendingCommands.set(cacheKey, promise);
+			args.unshift("-c", "core.quotepath=false", "-c", "color.ui=false", ...configs ?? emptyArray);
+			if (process.platform === "win32") args.unshift("-c", "core.longpaths=true");
+			if (cancellation != null) runOpts.cancellation = cancellation;
+			const priority = options.priority ?? inferGitCommandPriority(args);
+			const gitPath = await this.path();
+			this._queue.run(priority, () => {
+				execStart = hrtime();
+				return runSpawn(gitPath, args, encoding ?? "utf8", runOpts);
+			}, cancellation).then(deferred.fulfill, (e) => deferred.cancel(e instanceof Error ? e : new Error(String(e)))).finally(() => {
+				this.pendingCommands.delete(cacheKey);
+			}).catch(() => {});
+		} else {
+			waiting = true;
+			_logger.trace(`${formatLoggableScopeBlock("GIT")} ${gitCommand} \u00b7 awaiting existing call...`);
+		}
+		this.beginActiveCommand();
+		let exception;
+		let result;
+		try {
+			result = await promise;
+			if (result.exitCode == null) {
+				if (result.signal === "SIGTERM") throw new CancelledRunError(gitCommand, true, void 0, result.signal);
+				return {
+					stdout: result.stdout,
+					stderr: result.stderr,
+					completion: {
+						status: "failed",
+						reason: result.signal != null ? "signal" : "unstarted",
+						error: /* @__PURE__ */ new Error(`Command terminated without an exit code${result.signal != null ? ` (${result.signal})` : ""}`)
+					}
+				};
+			}
+			return {
+				stdout: result.stdout,
+				stderr: result.stderr,
+				exitCode: result.exitCode,
+				completion: {
+					status: "exited",
+					code: result.exitCode
+				}
+			};
+		} catch (ex) {
+			let cancellationReason = "unknown";
+			if (ex instanceof CancelledRunError) {
+				const duration = getDurationMilliseconds(start);
+				const timeout = runOpts.timeout ?? 0;
+				const reason = timeout > 0 && duration >= timeout - 100 ? "timeout" : cancellation?.aborted ? "cancellation" : "unknown";
+				cancellationReason = reason === "cancellation" ? "aborted" : reason;
+				const loopDelayAnnotation = this.formatEventLoopDelayAnnotation(startEpochMs);
+				const loopDelayText = loopDelayAnnotation != null ? ` \u00b7 ${loopDelayAnnotation}` : "";
+				_logger.warn(`${formatLoggableScopeBlock("GIT")} ${gitCommand} \u00b7 ABORTED after ${duration}ms (${reason})${loopDelayText}`);
+				this.options.hooks?.onAborted?.({
+					operation: gitCommand,
+					reason,
+					duration,
+					timeout
+				});
+			}
+			if (errorHandling === "ignore") {
+				if (ex instanceof RunError) {
+					const code = typeof ex.code === "number" ? ex.code : ex.code != null ? parseInt(ex.code, 10) : NaN;
+					const exited = Number.isInteger(code);
+					return {
+						stdout: ex.stdout,
+						stderr: ex.stderr,
+						...exited ? { exitCode: code } : {},
+						completion: ex instanceof CancelledRunError ? {
+							status: "cancelled",
+							reason: cancellationReason,
+							error: ex
+						} : exited ? {
+							status: "exited",
+							code
+						} : {
+							status: "failed",
+							reason: ex.signal != null ? "signal" : "unstarted",
+							error: ex
+						}
+					};
+				}
+				return {
+					stdout: "",
+					stderr: void 0,
+					completion: {
+						status: "failed",
+						reason: "unstarted",
+						error: ex instanceof Error ? ex : new Error(String(ex))
+					}
+				};
+			}
+			if (ex instanceof CancelledRunError) exception = new CancellationError(ex);
+			else exception = new GitError(ex);
+			if (errorHandling === "throw") throw exception;
+			const swallowed = exception;
+			const warning = defaultExceptionHandler(exception, options.cwd, start);
+			exception = void 0;
+			const rawCode = swallowed instanceof GitError ? swallowed.exitCode : void 0;
+			const code = typeof rawCode === "number" ? rawCode : rawCode != null ? parseInt(rawCode, 10) : NaN;
+			return {
+				stdout: "",
+				...Number.isInteger(code) ? { exitCode: code } : {},
+				completion: {
+					status: "warned",
+					warning,
+					error: swallowed
+				}
+			};
+		} finally {
+			this.logGitCommandComplete(gitCommand, exception, getDurationMilliseconds(start), execStart == null || selfMaintenance ? 0 : getDurationMilliseconds(execStart), waiting, options.cwd, args, slownessCategory, startEpochMs);
+			this.endActiveCommand();
+		}
+	}
+	async *stream(options, ...args) {
+		if (this.options.isTrusted?.() === false) throw new WorkspaceUntrustedError();
+		const start = hrtime();
+		const startEpochMs = Date.now();
+		const streamId = uniqueCounterForStream.next();
+		const { configs, stdin, stdinEncoding, cancellation, encoding, slownessCategory, ...opts } = options;
+		const runArgs = args.filter((a) => a != null);
+		const spawnOpts = {
+			stdio: [
+				stdin ? "pipe" : "ignore",
+				null,
+				null
+			],
+			...opts,
+			signal: cancellation,
+			env: this.buildEnv(options.env)
+		};
+		const gitCommand = `(spawn) [${spawnOpts.cwd}] git ${runArgs.join(" ")}`;
+		runArgs.unshift("-c", "core.quotepath=false", "-c", "color.ui=false", ...configs ?? emptyArray);
+		if (process.platform === "win32") runArgs.unshift("-c", "core.longpaths=true");
+		const command = await this.path();
+		const proc = spawn(command, runArgs, spawnOpts);
+		if (stdin) proc.stdin?.end(stdin, stdinEncoding ?? "utf8");
+		let exception;
+		const promise = new Promise((resolve, reject) => {
+			const stderrChunks = [];
+			if (proc.stderr) {
+				proc.stderr?.setEncoding("utf8");
+				proc.stderr.on("data", (chunk) => stderrChunks.push(chunk));
+			}
+			proc.once("error", (ex) => {
+				if (ex?.name === "AbortError") return;
+				exception = new GitError(ex);
+			});
+			proc.once("close", (code, signal) => {
+				if (code === 0) {
+					resolve();
+					return;
+				}
+				if (signal === "SIGTERM") {
+					if (cancellation?.aborted) resolve();
+					else reject(new CancelledRunError(proc.spawnargs.join(" "), true, code ?? void 0, signal));
+					return;
+				}
+				if (signal === "SIGPIPE" || code === 141 || code === 128 && stderrChunks.some((c) => c.includes("Connection reset by peer"))) {
+					resolve();
+					return;
+				}
+				const stderr = stderrChunks.join("").trim();
+				reject(new GitError(new RunError({
+					message: `Error (${code}): ${stderr || "Unknown"}`,
+					cmd: proc.spawnargs.join(" "),
+					killed: proc.killed,
+					code: proc.exitCode
+				}, "", stderr)));
+			});
+		});
+		let cleanedUp = false;
+		const cleanup = () => {
+			if (cleanedUp) return;
+			cleanedUp = true;
+			try {
+				proc.removeAllListeners();
+			} catch {}
+			const duration = getDurationMilliseconds(start);
+			this.logGitCommandComplete(gitCommand, exception, duration, duration, false, spawnOpts.cwd, runArgs, slownessCategory, startEpochMs, streamId);
+			this.endActiveCommand();
+		};
+		this.beginActiveCommand();
+		try {
+			this.logGitCommandStart(gitCommand, streamId);
+			try {
+				if (proc.stdout) {
+					const enc = encoding ?? "utf8";
+					if (enc === "utf8" || enc === "binary" || enc === "buffer") {
+						proc.stdout.setEncoding(enc === "buffer" ? "utf8" : enc);
+						for await (const chunk of proc.stdout) yield chunk;
+					} else {
+						const decode = this.options.decode;
+						if (decode == null) throw new Error(`Non-UTF-8 encoding '${enc}' requested for stream but no decode function configured`);
+						const buffers = [];
+						for await (const chunk of proc.stdout) buffers.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+						yield await decode(Buffer.concat(buffers), { encoding: enc });
+					}
+				}
+			} finally {
+				await promise;
+			}
+		} catch (ex) {
+			exception = ex;
+			throw ex;
+		} finally {
+			cleanup();
+		}
+		return void cleanup();
+	}
+	async rev_parse__git_dir(cwd) {
+		const result = await this.run({
+			cwd,
+			errors: "ignore"
+		}, "rev-parse", "--git-dir", "--git-common-dir");
+		if (!result.stdout) return void 0;
+		let [dotGitPath, commonDotGitPath] = result.stdout.split("\n").map((r) => r.trimStart());
+		if (!isAbsolute(dotGitPath)) dotGitPath = joinPaths(cwd, dotGitPath);
+		dotGitPath = normalizePath(dotGitPath);
+		if (commonDotGitPath) {
+			if (!isAbsolute(commonDotGitPath)) commonDotGitPath = joinPaths(cwd, commonDotGitPath);
+			commonDotGitPath = normalizePath(commonDotGitPath);
+			return {
+				path: dotGitPath,
+				commonPath: commonDotGitPath !== dotGitPath ? commonDotGitPath : void 0
+			};
+		}
+		return { path: dotGitPath };
+	}
+	async rev_parse__show_toplevel(cwd) {
+		let result;
+		if (this.options.isTrusted?.() === false) {
+			if (await fsExists(joinPaths(cwd, "HEAD"))) try {
+				result = await this.run({
+					cwd,
+					errors: "throw",
+					configs: ["-C", cwd]
+				}, "rev-parse", "--show-cdup");
+				if (!result.stdout.trim()) {
+					_logger.warn(`Skipping (untrusted workspace); bare clone repository detected in '${cwd}'`);
+					return emptyArray;
+				}
+			} catch {}
+		}
+		try {
+			result = await this.run({
+				cwd,
+				errors: "throw"
+			}, "rev-parse", "--show-toplevel");
+			return !result.stdout ? emptyArray : [true, normalizePath(result.stdout.trimStart().replace(trailingNewlineRegex, ""))];
+		} catch (ex) {
+			if (ex instanceof WorkspaceUntrustedError) return emptyArray;
+			if (!(ex instanceof GitError)) throw ex;
+			const unsafeMatch = GitErrors.unsafeRepository.exec(ex.stderr ?? "");
+			if (unsafeMatch != null) {
+				_logger.warn(`Skipping; unsafe repository detected in '${unsafeMatch[1] || unsafeMatch[2]}'; run '${unsafeMatch[3]}' to allow it`);
+				return [false];
+			}
+			const inDotGit = GitWarnings.mustRunInWorkTree.test(ex.stderr ?? "");
+			if (inDotGit && this.options.isTrusted?.() !== false) {
+				result = await this.run({
+					cwd,
+					errors: "ignore"
+				}, "rev-parse", "--is-bare-repository");
+				if (result.stdout.trim() === "true") {
+					const result = await this.rev_parse__git_dir(cwd);
+					const repoPath = result?.commonPath ?? result?.path;
+					if (repoPath?.length) return [true, repoPath];
+				}
+			}
+			if (inDotGit || ex.original?.code === "ENOENT") {
+				let exists = inDotGit ? false : await fsExists(cwd);
+				if (!exists) {
+					do {
+						const parent = dirname(cwd);
+						if (parent === cwd || parent.length === 0) return emptyArray;
+						cwd = parent;
+						exists = await fsExists(cwd);
+					} while (!exists);
+					return this.rev_parse__show_toplevel(cwd);
+				}
+			}
+			return emptyArray;
+		}
+	}
+	logGitCommandStart(command, id) {
+		_logger.info(`${formatLoggableScopeBlock(`GIT:\u2192${id}`)} ${command} \u00b7 starting...`);
+		this.options.logger?.info(`${formatLoggableScopeBlock(`\u2192${id}`, "")} ${command} \u2022 starting...`);
+	}
+	logGitCommandComplete(command, ex, duration, execDuration, waiting, cwd, args, slownessCategory, startEpochMs, id) {
+		const slow = duration > slowCallWarningThreshold;
+		const annotations = [];
+		if (slow) annotations.push("slow");
+		if (waiting) annotations.push("waiting");
+		else if (execDuration > 0) {
+			const queued = duration - execDuration;
+			if (queued >= queueWaitAnnotationThreshold) annotations.push(`queued ${queued}ms`);
+		}
+		if (slow) {
+			const loopDelayAnnotation = this.formatEventLoopDelayAnnotation(startEpochMs);
+			if (loopDelayAnnotation != null) annotations.push(loopDelayAnnotation);
+		}
+		const status = annotations.length > 0 ? ` (${annotations.join(", ")})` : "";
+		if (execDuration > 2e3 && !waiting) {
+			const execEventLoopDelay = this._eventLoopMonitor.maxDelaySince(startEpochMs + (duration - execDuration));
+			try {
+				this.options.hooks?.onSlowCommand?.({
+					operation: args != null ? getPrimaryGitCommand(args) : void 0,
+					cwd,
+					duration: execDuration,
+					eventLoopDelay: execEventLoopDelay,
+					slownessCategory
+				});
+			} catch {}
+		}
+		if (ex != null) _logger.error(void 0, `${formatLoggableScopeBlock(id ? `GIT:\u2190${id}` : "GIT")} ${command} \u00b7 ${isCancellationError(ex) ? "cancelled" : (ex.message || String(ex) || "").trim().replace(/fatal:\s*/g, "").replace(/\r?\n|\r/g, " · ")} [${duration}ms]${status}`);
+		else if (slow) _logger.warn(`${formatLoggableScopeBlock(id ? `GIT:\u2190${id}` : "GIT", `*${duration}ms`)} ${command} [*${duration}ms]${status}`);
+		else _logger.info(`${formatLoggableScopeBlock(id ? `GIT:\u2190${id}` : "GIT", `${duration}ms`)} ${command} [${duration}ms]${status}`);
+		const logMessage = `${formatLoggableScopeBlock(`${id ? `\u2190${id}` : ""}${slow ? "*" : ""}`, `${duration}ms`)} ${command}${status}`;
+		if (ex != null) this.options.logger?.error(`${logMessage} \u2022 FAILED\n${String(ex)}`);
+		else this.options.logger?.info(`${logMessage} \u2022 completed`);
+	}
+};
 /**
- * Swallows an error whose message matches a known-benign {@link GitWarnings} pattern, returning WHICH one
- * matched so the caller can record it — the distinction matters, since `noCommits` is a real answer while
- * `notARepository` is a failed read. Rethrows anything else.
- */
-export function defaultExceptionHandler(ex, cwd, start) {
-    if (isCancellationError(ex))
-        throw ex;
-    const msg = ex.message || ex.toString();
-    if (msg) {
-        for (const [key, warning] of Object.entries(GitWarnings)) {
-            if (warning.test(msg)) {
-                const duration = start !== undefined ? ` [${getDurationMilliseconds(start)}ms]` : '';
-                Logger.warn(`[${cwd}] Git ${msg
-                    .trim()
-                    .replace(/fatal:\s*/g, '')
-                    .replace(/\r?\n|\r/g, ' \u00b7 ')}${duration}`);
-                return key;
-            }
-        }
-        const match = GitErrors.badRevision.exec(msg);
-        if (match != null) {
-            const [, ref] = match;
-            // Since looking up a ref with ^3 (e.g. looking for untracked files in a stash) can error on some versions of git just ignore it
-            // Swallowed, but it matched no `GitWarnings` entry — `undefined` records "unclassified", which
-            // callers must treat as "not a real answer" exactly like any warning they don't whitelist.
-            if (ref?.endsWith('^3'))
-                return undefined;
-        }
-    }
-    throw ex;
+* Swallows an error whose message matches a known-benign {@link GitWarnings} pattern, returning WHICH one
+* matched so the caller can record it — the distinction matters, since `noCommits` is a real answer while
+* `notARepository` is a failed read. Rethrows anything else.
+*/
+function defaultExceptionHandler(ex, cwd, start) {
+	if (isCancellationError(ex)) throw ex;
+	const msg = ex.message || ex.toString();
+	if (msg) {
+		for (const [key, warning] of Object.entries(GitWarnings)) if (warning.test(msg)) {
+			const duration = start !== void 0 ? ` [${getDurationMilliseconds(start)}ms]` : "";
+			_logger.warn(`[${cwd}] Git ${msg.trim().replace(/fatal:\s*/g, "").replace(/\r?\n|\r/g, " · ")}${duration}`);
+			return key;
+		}
+		const match = GitErrors.badRevision.exec(msg);
+		if (match != null) {
+			const [, ref] = match;
+			if (ref?.endsWith("^3")) return void 0;
+		}
+	}
+	throw ex;
 }
+//#endregion
+export { Git, GitError, GitErrors, GitWarnings, classifySearchError, classifySigningError, defaultExceptionHandler, getGitCommandError, gitConfigsBranch, gitConfigsDiff, gitConfigsLog, gitConfigsLogWithFiles, gitConfigsLogWithSignatures, gitConfigsPull, gitConfigsStatus, inferSigningFormatFromError, maxGitCliLength, slowCallWarningThreshold };
+
 //# sourceMappingURL=git.js.map