@gitkraken/core-gitlens 0.6.0 → 0.7.0

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

@@ -1,1470 +1,1134 @@
-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 { BranchError } from '../../git/errors.js';
-import { GitBranch } from '../../git/models/branch.js';
-import { formatDetachedHeadName, getBranchId, getLocalBranchByUpstream, isDetachedHead, isRemoteHEAD, parseRefName, parseUpstream, } from '../../git/utils/branch.utils.js';
-import { createConflictDetectionError } from '../../git/utils/mergeConflicts.utils.js';
-import { createReference } from '../../git/utils/reference.utils.js';
-import { createRevisionRange, shortenRevision } from '../../git/utils/revision.utils.js';
-import { sortBranches, sortContributors } from '../../git/utils/sorting.js';
-import { ensureArray, filterMap } from '../../utils/array.js';
-import { CancellationError, isCancellationError } from '../../utils/cancellation.js';
-import { debounce } from '../../utils/decorators/debounce.js';
-import { debug } from '../../utils/decorators/log.js';
-import { Logger } from '../../utils/logger.js';
-import { getScopedLogger } from '../../utils/logger.scoped.js';
-import { emptyPagedResult, PageableResult } from '../../utils/paging.js';
-import { normalizePath } from '../../utils/path.js';
-import { getSettledValue } from '../../utils/promise.js';
-import { maybeStopWatch } from '../../utils/stopwatch.js';
-import { getGitCommandError, gitConfigsBranch, gitConfigsLog, GitError, GitErrors, GitWarnings } from '../exec/git.js';
-import { parseMergeTreeConflict } from '../parsers/mergeTreeParser.js';
+import { ensureArray, filterMap } from "../../utils/array.js";
+import { CancellationError, isCancellationError } from "../../utils/cancellation.js";
+import { Logger as _logger } from "../../utils/logger.js";
+import { getScopedLogger } from "../../utils/logger.scoped.js";
+import { getSettledValue } from "../../utils/promise.js";
+import { debug } from "../../utils/decorators/log.js";
+import { getBranchId } from "../../utils/gitRefs.js";
+import { normalizePath } from "../../utils/path.js";
+import { createRevisionRange, shortenRevision } from "../../git/utils/revision.utils.js";
+import { createReference } from "../../git/utils/reference.utils.js";
+import __decorate from "../../_virtual/@oxc-project+runtime/helpers/esm/decorate.js";
+import { BranchError, GitWarnings } from "../../git/errors.js";
+import { GitError, GitErrors, getGitCommandError, gitConfigsBranch, gitConfigsLog } from "../exec/git.js";
+import { maybeStopWatch } from "../../utils/stopwatch.js";
+import _usingCtx from "../../_virtual/@oxc-project+runtime/helpers/esm/usingCtx.js";
+import { formatDetachedHeadName, getLocalBranchByUpstream, isDetachedHead, isRemoteHEAD, parseRefName, parseUpstream } from "../../git/utils/branch.utils.js";
+import { GitBranch } from "../../git/models/branch.js";
+import { createConflictDetectionError } from "../../git/utils/mergeConflicts.utils.js";
+import { sortBranches, sortContributors } from "../../git/utils/sorting.js";
+import { debounce } from "../../utils/decorators/debounce.js";
+import { PageableResult, emptyPagedResult } from "../../utils/paging.js";
+import { parseMergeTreeConflict } from "../parsers/mergeTreeParser.js";
+//#region ../git-cli/src/providers/branches.ts
 /** Minimum time between writes to the config for last accessed/modified dates */
-const dateMetadataStaleThresholdMs = 5 * 60 * 1000; // 5 minutes
-export class BranchesGitSubProvider {
-    context;
-    git;
-    cache;
-    provider;
-    constructor(context, git, cache, provider) {
-        this.context = context;
-        this.git = git;
-        this.cache = cache;
-        this.provider = provider;
-    }
-    async getBranch(repoPath, name, cancellation) {
-        if (name != null) {
-            const { values: [branch], } = await this.getBranches(repoPath, { filter: b => b.name === name }, cancellation);
-            return branch;
-        }
-        const branchPromise = this.cache.branch.getOrCreate(repoPath, async (_cacheable, signal) => {
-            const { values: [branch], } = await this.getBranches(repoPath, { filter: b => b.current }, signal);
-            return branch ?? this.getCurrentBranch(repoPath, undefined, undefined, signal);
-        }, cancellation);
-        if (branchPromise == null) {
-            const { values: [branch], } = await this.getBranches(repoPath, { filter: b => b.current }, cancellation);
-            return branch ?? this.getCurrentBranch(repoPath, undefined, undefined, cancellation);
-        }
-        return branchPromise;
-    }
-    async getCurrentBranch(repoPath, metadataMap, ordering, cancellation) {
-        const ref = await this.getCurrentBranchReferenceCore(repoPath, ordering, cancellation);
-        if (ref == null)
-            return undefined;
-        const [pausedOpStatusResult, committerDateResult, defaultWorktreePathResult, metadataMapResult] = await Promise.allSettled([
-            isDetachedHead(ref.name)
-                ? this.provider.pausedOps?.getPausedOperationStatus(repoPath, undefined, cancellation)
-                : undefined,
-            this.git
-                .run({
-                cwd: repoPath,
-                cancellation: cancellation,
-                configs: gitConfigsLog,
-                errors: 'ignore',
-            }, 'log', '-n1', '--format=%ct', ordering ? `--${ordering}-order` : undefined, '--')
-                .then(result => (result.stdout ? result.stdout.trim() : undefined)),
-            this.provider.config.getDefaultWorktreePath?.(repoPath),
-            metadataMap != null ? Promise.resolve(metadataMap) : this.getBranchMetadataMap(repoPath),
-        ]);
-        const committerDate = getSettledValue(committerDateResult);
-        const pausedOpStatus = getSettledValue(pausedOpStatusResult);
-        const rebaseStatus = pausedOpStatus?.type === 'rebase' ? pausedOpStatus : undefined;
-        const defaultWorktreePath = getSettledValue(defaultWorktreePathResult);
-        metadataMap ??= getSettledValue(metadataMapResult);
-        const metadata = metadataMap?.get(ref.name);
-        if (cancellation?.aborted)
-            throw new CancellationError();
-        const branchRefName = rebaseStatus?.incoming.name ?? `refs/heads/${ref.name}`;
-        const branch = new GitBranch(repoPath, // Use worktree-specific path for consistent IDs within each worktree
-        branchRefName, true, committerDate != null ? new Date(Number(committerDate) * 1000) : undefined, metadata, ref.sha, ref.upstream ? { ...ref.upstream, state: { ahead: 0, behind: 0 } } : undefined, { path: repoPath, isDefault: repoPath === defaultWorktreePath }, undefined, rebaseStatus != null);
-        return branch;
-    }
-    async getBranches(repoPath, options, cancellation) {
-        if (repoPath == null)
-            return emptyPagedResult;
-        const scope = getScopedLogger();
-        const getCore = async (commonPath, cacheable, signal) => {
-            // Prefer the aggregate signal from the cache when present; fall back to the caller's
-            // own cancellation when bypassing the cache (e.g. paging-cursor path).
-            signal ??= cancellation;
-            try {
-                const env_1 = { stack: [], error: void 0, hasError: false };
-                try {
-                    const [recordsResult, supportedResult, defaultWorktreePathResult, metadataMapResult] = await Promise.allSettled([
-                        this.provider.refs.getRefs(commonPath, signal),
-                        this.git.supported('git:for-each-ref'),
-                        this.provider.config.getDefaultWorktreePath?.(commonPath),
-                        this.getBranchMetadataMap(commonPath),
-                    ]);
-                    const records = getSettledValue(recordsResult) ?? [];
-                    const supported = getSettledValue(supportedResult) ?? [];
-                    const metadataMap = getSettledValue(metadataMapResult) ?? new Map();
-                    const defaultWorktreePath = getSettledValue(defaultWorktreePathResult);
-                    const worktreePathSupported = supported.includes('git:for-each-ref:worktreePath');
-                    // If we don't get any data, assume the repo doesn't have any commits yet so check if we have a current branch
-                    if (!records.length) {
-                        // Never CACHE that conclusion. `getRefs` reports a failed enumeration the same way as a
-                        // genuinely ref-less repo — an empty array (it invalidates its own entry but doesn't
-                        // throw) — so a transient `for-each-ref` failure would otherwise pin this degraded
-                        // current-branch-only list in a map with no TTL, and every branch consumer would see a
-                        // one-branch repo for the session. A truly empty repo re-reads cheaply, so refusing the
-                        // entry costs nothing in the case this is actually meant to serve.
-                        cacheable?.invalidate();
-                        const current = await this.getCurrentBranch(commonPath, metadataMap, options?.ordering ?? this.context.config?.commits.ordering ?? undefined, signal);
-                        return current != null ? { values: [current] } : emptyPagedResult;
-                    }
-                    const sw = __addDisposableResource(env_1, maybeStopWatch(scope, { log: { onlyExit: true, level: 'debug' } }), false);
-                    const branches = [];
-                    for (const record of records) {
-                        const fullName = record.name;
-                        // Filter to branches and remote-tracking branches; skip tags from the unified records.
-                        if (!fullName.startsWith('refs/heads/') && !fullName.startsWith('refs/remotes/'))
-                            continue;
-                        // Skip HEAD refs in remote branches
-                        if (isRemoteHEAD(fullName))
-                            continue;
-                        const upstream = parseUpstream(record.upstream, record.upstreamTracking);
-                        const metadata = metadataMap.get(parseRefName(fullName).name);
-                        const worktreePath = record.worktreePath ? normalizePath(record.worktreePath) : undefined;
-                        branches.push(new GitBranch(commonPath, fullName, false, // Don't trust %(HEAD) for current as it's per-worktree -- we will set it later
-                        record.committerDate ? new Date(record.committerDate) : undefined, metadata, record.objectname, upstream, worktreePathSupported
-                            ? worktreePath
-                                ? { path: worktreePath, isDefault: worktreePath === defaultWorktreePath }
-                                : false
-                            : undefined));
-                    }
-                    sw?.stop({ suffix: ` parsed ${branches.length} branches` });
-                    // Pre-populate current branch cache for worktrees based on worktreePath info
-                    // This eliminates the need for rev-parse calls during branch reconstruction
-                    for (const branch of branches) {
-                        // oxlint-disable-next-line typescript/prefer-optional-chain
-                        if (branch.worktree && branch.worktree.path) {
-                            const { name } = parseRefName(branch.refName);
-                            const reference = createReference(name, branch.worktree.path, {
-                                refType: 'branch',
-                                name: name,
-                                id: getBranchId(branch.worktree.path, false, name),
-                                remote: false,
-                                upstream: branch.upstream?.name
-                                    ? { name: branch.upstream.name, missing: branch.upstream.missing }
-                                    : undefined,
-                                sha: branch.sha,
-                            });
-                            this.cache.setCurrentBranchReferenceIfAbsent(branch.worktree.path, reference);
-                        }
-                    }
-                    return branches.length ? { values: branches } : emptyPagedResult;
-                }
-                catch (e_1) {
-                    env_1.error = e_1;
-                    env_1.hasError = true;
-                }
-                finally {
-                    __disposeResources(env_1);
-                }
-            }
-            catch (ex) {
-                // Signal cache invalidation so the shared cache entry is cleaned up
-                cacheable?.invalidate();
-                if (isCancellationError(ex))
-                    throw ex;
-                return emptyPagedResult;
-            }
-        };
-        // Mapper function that adjusts branches for a specific worktree
-        const mapBranches = async (shared, targetRepoPath, commonPath, mapperSignal) => {
-            if (!shared.values.length)
-                return shared;
-            // Prefer the mapper's per-entry aggregate signal when present; fall back to the
-            // caller's own cancellation when bypassing the cache (paging-cursor path).
-            mapperSignal ??= cancellation;
-            // Get current branch info and default worktree path for the target worktree
-            const [currentRefResult, defaultWorktreePathResult] = await Promise.allSettled([
-                this.getCurrentBranchReferenceCore(targetRepoPath, undefined, mapperSignal),
-                this.provider.config.getDefaultWorktreePath?.(commonPath),
-            ]);
-            const currentRef = getSettledValue(currentRefResult);
-            const defaultWorktreePath = getSettledValue(defaultWorktreePathResult);
-            const isDetached = currentRef != null && isDetachedHead(currentRef.name);
-            // Clone branches with correct repoPath and current flag
-            const branches = shared.values.map(b => {
-                // Check if this branch is current in the target worktree
-                const isCurrent = !b.remote && b.name === currentRef?.name && !isDetached;
-                // Only create new object if something changed
-                if (!isCurrent && targetRepoPath === commonPath)
-                    return b;
-                return new GitBranch(targetRepoPath, // Use target worktree path
-                b.refName, isCurrent, b.date, b.metadata, b.sha, b.upstream, 
-                // For current branch, ensure worktree is set (fallback when git doesn't support worktreePath)
-                isCurrent
-                    ? (b.worktree ?? { path: targetRepoPath, isDefault: targetRepoPath === defaultWorktreePath })
-                    : b.worktree, false, // detached - only true for detached HEAD branch itself
-                false);
-            });
-            // Handle detached HEAD - need to create a special branch for it
-            if (isDetached || (currentRef != null && !branches.some(b => b.current))) {
-                const metadataMap = await this.getBranchMetadataMap(commonPath);
-                const current = await this.getCurrentBranch(targetRepoPath, metadataMap, options?.ordering ?? this.context.config?.commits.ordering ?? undefined, mapperSignal);
-                if (current != null) {
-                    // Replace if exists (by id), otherwise prepend
-                    const index = branches.findIndex(b => b.id === current.id);
-                    if (index !== -1) {
-                        branches[index] = current;
-                    }
-                    else {
-                        branches.unshift(current);
-                    }
-                }
-            }
-            return { ...shared, values: branches };
-        };
-        let result;
-        // Use paging cursor to bypass cache if paginating
-        if (options?.paging?.cursor != null) {
-            const commonPath = this.cache.getCommonPath(repoPath);
-            const shared = await getCore(commonPath);
-            // Still apply the mapper to ensure correct repoPath and current flag for the requesting worktree
-            result = await mapBranches(shared, repoPath, commonPath);
-        }
-        else {
-            result = await this.cache.getBranches(repoPath, getCore, mapBranches, cancellation);
-        }
-        if (options?.filter != null) {
-            result = {
-                ...result,
-                values: result.values.filter(options.filter),
-            };
-        }
-        if (options?.sort) {
-            sortBranches(result.values, typeof options.sort === 'boolean' ? undefined : options.sort);
-        }
-        return result;
-    }
-    async getBranchContributionsOverview(repoPath, ref, options, cancellation) {
-        const scope = getScopedLogger();
-        const priority = options?.priority;
-        const priorityOpts = priority != null ? { priority: priority } : undefined;
-        // Expensive body — runs only on cache miss. Closes over `mergeTarget` so the cache key
-        // (`${ref}|${mergeTarget}`) fully captures every input that affects the result.
-        const fetchBody = async (mergeTarget, signal) => {
-            const mergeBase = await this.provider.refs.getMergeBase(repoPath, ref, mergeTarget, priorityOpts, signal);
-            if (mergeBase == null)
-                return undefined;
-            // Fetch the merge-base commit's dates in parallel with contributors so consumers
-            // (e.g. the graph minimap scope window) don't pay a separate round-trip for them.
-            // `allSettled` so a transient failure in one side doesn't drop the overview entirely.
-            const [contributorsSettled, mergeBaseDatesSettled] = await Promise.allSettled([
-                this.provider.contributors.getContributors(repoPath, createRevisionRange(mergeBase, ref, '..'), { stats: true }, signal),
-                this.provider.commits.getCommitDates(repoPath, mergeBase, signal),
-            ]);
-            if (signal?.aborted)
-                throw new CancellationError();
-            const result = getSettledValue(contributorsSettled) ?? { contributors: [] };
-            const mergeBaseDates = getSettledValue(mergeBaseDatesSettled);
-            sortContributors(result.contributors, { orderBy: 'score:desc' });
-            let totalCommits = 0;
-            let totalFiles = 0;
-            let totalAdditions = 0;
-            let totalDeletions = 0;
-            let firstCommitTimestamp;
-            let latestCommitTimestamp;
-            for (const c of result.contributors) {
-                totalCommits += c.contributionCount;
-                totalFiles += c.stats?.files ?? 0;
-                totalAdditions += c.stats?.additions ?? 0;
-                totalDeletions += c.stats?.deletions ?? 0;
-                const firstTimestamp = c.firstCommitDate?.getTime();
-                const latestTimestamp = c.latestCommitDate?.getTime();
-                if (firstTimestamp != null || latestTimestamp != null) {
-                    firstCommitTimestamp =
-                        firstCommitTimestamp != null
-                            ? Math.min(firstCommitTimestamp, firstTimestamp ?? Infinity, latestTimestamp ?? Infinity)
-                            : (firstTimestamp ?? latestTimestamp);
-                    latestCommitTimestamp =
-                        latestCommitTimestamp != null
-                            ? Math.max(latestCommitTimestamp, firstTimestamp ?? -Infinity, latestTimestamp ?? -Infinity)
-                            : (latestTimestamp ?? firstTimestamp);
-                }
-            }
-            return {
-                repoPath: repoPath,
-                branch: ref,
-                mergeTarget: mergeTarget,
-                mergeBase: mergeBase,
-                mergeBaseDate: mergeBaseDates?.committerDate,
-                commits: totalCommits,
-                files: totalFiles,
-                additions: totalAdditions,
-                deletions: totalDeletions,
-                latestCommitDate: latestCommitTimestamp != null ? new Date(latestCommitTimestamp) : undefined,
-                firstCommitDate: firstCommitTimestamp != null ? new Date(firstCommitTimestamp) : undefined,
-                contributors: result.contributors,
-            };
-        };
-        try {
-            // Resolve `mergeTarget` through Tier 1 → Tier 2 → Tier 3. The pieces of each tier are
-            // already individually cached (`getStoredMergeTargetBranchName`, `getBaseBranchName`,
-            // `getDefaultBranchName`), so this resolution path is cheap on warm caches. Only the
-            // expensive body below (`getMergeBase` + `getContributors` w/ stats + `getCommitDates`)
-            // is wrapped by `cache.getBranchOverview`, keyed on the resolved `mergeTarget` so any
-            // caller that resolves to the same target shares; differing targets get independent
-            // slots, which is the correctness constraint that previously forced the Tier 2/3 paths
-            // to bypass the cache entirely.
-            let mergeTarget;
-            // Tier 1: Stored merge target (user-set or previously detected from PR).
-            const storedTarget = await this.getStoredMergeTargetBranchName(repoPath, ref);
-            if (storedTarget) {
-                const validated = await this.provider.refs.getSymbolicReferenceName(repoPath, storedTarget, priorityOpts, cancellation);
-                mergeTarget = validated || storedTarget;
-            }
-            // Tier 2: PR-based lookup. The branch object is only needed here (for `remoteName`),
-            // so lazy-load it on the cold path instead of paying for it on every call.
-            if (mergeTarget == null && options?.associatedPullRequest != null) {
-                const pr = await options.associatedPullRequest;
-                if (pr?.refs?.base != null) {
-                    const branch = await this.getBranch(repoPath, ref, cancellation);
-                    if (branch == null)
-                        return undefined;
-                    mergeTarget = `${branch.remoteName}/${pr.refs.base.branch}`;
-                    // A stacked PR's base is the layer below it, which is deleted when the stack merges.
-                    // Storing it would leave a stored target naming a branch that no longer exists — and
-                    // a stored target beats every other tier, so it would keep winning until cleared by
-                    // hand. Use it for this lookup, but don't persist it.
-                    if (pr.stack == null) {
-                        // Store for future reuse — turns the next call into a Tier 1 path. Skip the
-                        // `branchOverviews` invalidation that the write would otherwise trigger: we're
-                        // about to populate `${ref}|${mergeTarget}` with this exact target, so evicting
-                        // it would just force the next caller to redo the body. (gk-merge-target writes
-                        // do not affect `baseBranchName`, so no need to skip that target.)
-                        void this.storeMergeTargetBranchName(repoPath, ref, mergeTarget, {
-                            skipInvalidation: ['branchOverviews'],
-                        });
-                    }
-                }
-            }
-            // Tier 3: Base branch, then default branch.
-            mergeTarget ??= await this.getBaseBranchName(repoPath, ref, priorityOpts, cancellation);
-            mergeTarget ??= await this.getDefaultBranchName(repoPath, undefined, priorityOpts, cancellation);
-            if (mergeTarget == null)
-                return undefined;
-            const resolvedTarget = mergeTarget;
-            return await this.cache.getBranchOverview(repoPath, `${ref}|${resolvedTarget}`, (_commonPath, _cacheable, signal) => fetchBody(resolvedTarget, signal ?? cancellation), { cancellation: cancellation });
-        }
-        catch (ex) {
-            scope?.error(ex);
-            if (isCancellationError(ex))
-                throw ex;
-            return undefined;
-        }
-    }
-    async getBranchesWithCommits(repoPath, commits, branch, options, cancellation) {
-        if (branch != null) {
-            const result = await this.branchesContainingCore(repoPath, commits, { mode: 'contains', name: branch }, cancellation);
-            const data = result.stdout.trim();
-            return data ? [data] : [];
-        }
-        const result = await this.branchesContainingCore(repoPath, commits, options, cancellation);
-        if (!result.stdout)
-            return [];
-        return filterMap(result.stdout.split('\n'), b => b.trim() || undefined);
-    }
-    async branchesContainingCore(repoPath, refs, options, cancellation) {
-        const params = ['branch'];
-        if (options?.all) {
-            params.push('-a');
-        }
-        else if (options?.remotes) {
-            params.push('-r');
-        }
-        params.push('--format=%(refname:short)');
-        for (const ref of refs) {
-            params.push(options?.mode === 'pointsAt' ? `--points-at=${ref}` : `--contains=${ref}`);
-        }
-        if (options?.name != null) {
-            params.push(options.name);
-        }
-        return this.git.run({
-            cwd: repoPath,
-            cancellation: cancellation,
-            configs: gitConfigsBranch,
-            errors: 'ignore',
-        }, ...params);
-    }
-    async getCurrentBranchReference(repoPath, cancellation) {
-        let ref = await this.getCurrentBranchReferenceCore(repoPath, undefined, cancellation);
-        if (ref != null && isDetachedHead(ref.name)) {
-            ref = createReference(ref.sha, repoPath, {
-                refType: 'branch',
-                name: formatDetachedHeadName(ref.sha),
-                id: getBranchId(repoPath, ref.remote, ref.sha),
-                remote: ref.remote,
-                upstream: ref.upstream,
-                sha: ref.sha,
-            });
-        }
-        return ref;
-    }
-    getCurrentBranchReferenceCore(repoPath, ordering, cancellation) {
-        return this.cache.currentBranchReference.getOrCreate(repoPath, async (_cacheable, signal) => {
-            const commitOrdering = ordering;
-            let data;
-            let result;
-            try {
-                result = await this.git.run({ cwd: repoPath, cancellation: signal, errors: 'throw' }, 'rev-parse', '--abbrev-ref', '--symbolic-full-name', '@', '@{u}', '--');
-                data = [result.stdout, undefined];
-            }
-            catch (ex) {
-                if (isCancellationError(ex))
-                    throw ex;
-                const msg = ex?.toString() ?? '';
-                if (GitErrors.badRevision.test(msg) || GitWarnings.noUpstream.test(msg)) {
-                    if (ex.stdout != null && ex.stdout.length !== 0) {
-                        data = [ex.stdout, undefined];
-                    }
-                    else {
-                        try {
-                            result = await this.git.run({ cwd: repoPath, cancellation: signal }, 'symbolic-ref', '--short', 'HEAD');
-                            if (result.stdout) {
-                                data = [result.stdout.trim(), undefined];
-                            }
-                        }
-                        catch {
-                            if (isCancellationError(ex))
-                                throw ex;
-                        }
-                        if (data == null) {
-                            const symbolicRef = await this.getDefaultBranchName(repoPath, 'origin', undefined, signal);
-                            if (symbolicRef != null) {
-                                data = [
-                                    symbolicRef.startsWith('origin/')
-                                        ? symbolicRef.substring('origin/'.length)
-                                        : symbolicRef,
-                                    undefined,
-                                ];
-                            }
-                        }
-                        if (data == null) {
-                            const defaultBranch = (await this.provider.config.getConfig(repoPath, 'init.defaultBranch')) ?? 'main';
-                            const configMap = await this.provider.config.getConfigRegex(repoPath, `branch\\.${defaultBranch}\\.+`, { runGitLocally: true });
-                            const remote = configMap.get(`branch.${defaultBranch}.remote`);
-                            const merge = configMap.get(`branch.${defaultBranch}.merge`);
-                            const remoteBranch = merge?.startsWith('refs/heads/')
-                                ? merge.substring('refs/heads/'.length)
-                                : undefined;
-                            data = [
-                                `${defaultBranch}${remote && remoteBranch ? `\n${remote}/${remoteBranch}` : ''}`,
-                                undefined,
-                            ];
-                        }
-                    }
-                }
-                else if (GitWarnings.headNotABranch.test(msg)) {
-                    result = await this.git.run({
-                        cwd: repoPath,
-                        cancellation: signal,
-                        configs: gitConfigsLog,
-                        errors: 'ignore',
-                    }, 'log', '-n1', '--format=%H', commitOrdering ? `--${commitOrdering}-order` : undefined, '--');
-                    if (result.completion.status === 'cancelled' || signal?.aborted) {
-                        throw new CancellationError();
-                    }
-                    const sha = result.stdout.trim();
-                    if (sha) {
-                        data = [`(HEAD detached at ${shortenRevision(sha)})`, sha];
-                    }
-                }
-                else {
-                    Logger.warn(`[${repoPath}] Unable to get current branch: ${ex}`);
-                }
-            }
-            if (data == null)
-                return undefined;
-            const [name, upstream] = data[0].split('\n');
-            return createReference(name, repoPath, {
-                refType: 'branch',
-                name: name,
-                id: getBranchId(repoPath, false, name),
-                remote: false,
-                upstream: upstream ? { name: upstream, missing: false } : undefined,
-                sha: data[1],
-            });
-        }, { cancellation: cancellation });
-    }
-    async getDefaultBranchName(repoPath, remote, options, cancellation) {
-        if (repoPath == null)
-            return undefined;
-        remote ??= 'origin';
-        const priority = options?.priority;
-        const priorityOpts = priority != null ? { priority: priority } : undefined;
-        // Local-only: read just the existing local symref, never contacting the remote. Cached under a
-        // `${remote}:local` key — a colon can't appear in a refname component, so it can never collide
-        // with a real remote name used by the networked variant below. Invalidated by the same
-        // remotes/branches cache cascades as the networked lookup.
-        if (options?.local) {
-            return this.cache.getDefaultBranchName(repoPath, `${remote}:local`, async (commonPath, cacheable, signal) => {
-                try {
-                    // Bind 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: commonPath, cancellation: signal ?? cancellation, ...priorityOpts }, 'symbolic-ref', '--short', `refs/remotes/${remote}/HEAD`);
-                    return result.stdout.trim() || undefined;
-                }
-                catch (ex) {
-                    if (isCancellationError(ex))
-                        throw ex;
-                    // `symbolic-ref` on an absent `refs/remotes/<remote>/HEAD` exits fatal rather than
-                    // empty, and that message matches no `GitWarnings` entry, so it arrives here as a
-                    // throw. It is still an ANSWER — the ref genuinely isn't set — and the overwhelmingly
-                    // common one, so cache it. Invalidating instead means every caller re-probes and the
-                    // whole point of caching this lookup is lost.
-                    const stderr = ex.stderr ?? '';
-                    if (stderr.includes('is not a symbolic ref'))
-                        return undefined;
-                    // Anything else never produced an answer (spawn failure, queue rejection). This entry
-                    // has no TTL, so caching that would pin "no default branch" for the session.
-                    cacheable.invalidate();
-                    return undefined;
-                }
-            }, cancellation);
-        }
-        return this.cache.getDefaultBranchName(repoPath, remote, async (commonPath, cacheable, signal) => {
-            let retried = false;
-            while (true) {
-                try {
-                    const result = await this.git.run({ cwd: commonPath, cancellation: signal ?? cancellation, ...priorityOpts }, 'symbolic-ref', '--short', `refs/remotes/${remote}/HEAD`);
-                    return result.stdout.trim() || undefined;
-                }
-                catch (ex) {
-                    // Only "no HEAD ref configured" is an ANSWER here; every other throw means the lookup
-                    // never happened. This entry has no TTL, so caching a failure — an offline `ls-remote`
-                    // being the likely one — would pin "no default branch" for the session.
-                    let answered = false;
-                    if (/is not a symbolic ref/.test(ex.stderr)) {
-                        try {
-                            if (!retried) {
-                                retried = true;
-                                await this.git.run({ cwd: commonPath, cancellation: signal ?? cancellation, ...priorityOpts }, 'remote', 'set-head', '-a', remote);
-                                // This just created `refs/remotes/<remote>/HEAD`, which the `local` variant
-                                // may already have cached a miss for. The watcher would also catch the new
-                                // ref, but evict directly so consumers of this package that don't wire up a
-                                // watcher aren't stuck with that miss.
-                                this.cache.deleteDefaultBranchName(commonPath, `${remote}:local`);
-                                continue;
-                            }
-                            const result = await this.git.run({ cwd: commonPath, cancellation: signal ?? cancellation, ...priorityOpts }, 'ls-remote', '--symref', remote, 'HEAD');
-                            if (result.stdout) {
-                                const match = /ref:\s(\S+)\s+HEAD/m.exec(result.stdout);
-                                if (match != null) {
-                                    const [, branch] = match;
-                                    return `${remote}/${branch.substring('refs/heads/'.length).trim()}`;
-                                }
-                            }
-                            // `ls-remote` ran and the remote advertised no HEAD — a real "none".
-                            answered = true;
-                        }
-                        catch {
-                            if (isCancellationError(ex))
-                                throw ex;
-                        }
-                    }
-                    if (!answered) {
-                        cacheable.invalidate();
-                    }
-                    return undefined;
-                }
-            }
-        }, cancellation);
-    }
-    async createBranch(repoPath, name, ref, options) {
-        const args = ['branch', name, ref];
-        if (options?.noTracking) {
-            args.push('--no-track');
-        }
-        try {
-            await this.git.run({ cwd: repoPath }, ...args);
-            // Evict the cached base so the new branch re-derives its own. The PERSISTED `branch.<ref>.gk-*`
-            // keys are left alone: they're dropped when GitLens deletes a branch, never when one is created.
-            // Removing them here would mean treating a reused name as proof of a different branch, which
-            // nothing can establish — so the trade is that a branch reusing a name deleted outside GitLens
-            // inherits the orphaned section.
-            this.cache.deleteBaseBranchName(repoPath, name);
-            this.context.hooks?.cache?.onReset?.(repoPath, 'branches');
-            this.context.hooks?.repository?.onChanged?.(repoPath, ['heads']);
-        }
-        catch (ex) {
-            throw getGitCommandError('branch', ex, reason => new BranchError({
-                reason: reason ?? 'other',
-                action: 'create',
-                branch: name,
-                gitCommand: { repoPath: repoPath, args: args },
-            }, ex));
-        }
-    }
-    async deleteLocalBranch(repoPath, names, options) {
-        const branches = ensureArray(names);
-        const args = ['branch', options?.force ? '-D' : '-d', ...branches];
-        try {
-            await this.git.run({ cwd: repoPath }, ...args);
-            for (const branch of branches) {
-                this.cache.deleteBaseBranchName(repoPath, branch);
-                // Drop the persisted gk metadata too, not just the cached resolution. `getBaseBranchName`
-                // reads `branch.<ref>.gk-merge-base` before falling back to the reflog, so leaving it behind
-                // would hand a later branch reusing this name its predecessor's base — evicting the cache
-                // alone just forces a re-derivation that reads the same stale value back.
-                await this.provider.config.removeGkConfigBranchSection(repoPath, branch);
-            }
-            this.context.hooks?.cache?.onReset?.(repoPath, 'branches');
-            this.context.hooks?.repository?.onChanged?.(repoPath, ['heads']);
-        }
-        catch (ex) {
-            // A multi-name delete partially succeeds: `git branch -d a bad c` removes `a` and `c`, refuses
-            // `bad`, and still exits non-zero — so the loop above never ran for the branches that did go.
-            // Clean those up here rather than leave persisted gk metadata behind for a name a later branch
-            // can reuse.
-            const anyDeleted = await this.cleanupDeletedBranchMetadata(repoPath, branches);
-            // The success path's notifications never ran, but some branches DID go — without these the
-            // branch caches stay stale and consumers wait on the filesystem watcher (which never fires
-            // for a packed ref).
-            if (anyDeleted) {
-                this.context.hooks?.cache?.onReset?.(repoPath, 'branches');
-                this.context.hooks?.repository?.onChanged?.(repoPath, ['heads']);
-            }
-            if (ex instanceof BranchError) {
-                throw ex.update({
-                    action: options?.force ? 'force delete' : 'delete',
-                    branch: branches.join(', '),
-                    gitCommand: { repoPath: repoPath, args: args },
-                });
-            }
-            // Classify the failure (e.g. not fully merged) so consumers like the delete wizard can offer a
-            // force retry — without this the reason would be undefined and every failure reads as 'other'.
-            throw getGitCommandError('branch', ex, reason => new BranchError({
-                reason: reason ?? 'other',
-                action: options?.force ? 'force delete' : 'delete',
-                branch: branches.join(', '),
-                gitCommand: { repoPath: repoPath, args: args },
-            }, ex));
-        }
-    }
-    /**
-     * Drops the cached and persisted per-branch metadata for whichever of `names` no longer exists. Only
-     * for the partial-failure path — one extra `for-each-ref` is cheap while already handling an error,
-     * and keeps the success path free of it.
-     *
-     * Returns whether any of `names` is confirmed gone; `false` when the probe couldn't answer, so a
-     * spurious notification is never fired on an unrelated failure.
-     */
-    async cleanupDeletedBranchMetadata(repoPath, names) {
-        try {
-            const result = await this.git.run({ cwd: repoPath, errors: 'ignore' }, 'for-each-ref', 
-            // Full refname, stripped here rather than by git. NOT `%(refname:short)`: that yields the
-            // shortest UNAMBIGUOUS name, so a branch with a same-named tag comes back as `heads/<name>`,
-            // never matches the requested name, and would read as deleted — wiping a live branch's
-            // metadata. `%(refname:strip=2)` also solves that, but `%(refname)` is the oldest, plainest
-            // field and needs no assumption about which git version gained `strip`.
-            '--format=%(refname)', ...names.map(n => `refs/heads/${n}`));
-            // `errors: 'ignore'` means a failed probe RESOLVES empty, which is indistinguishable from "none
-            // of them survived" — and would delete every name's metadata, including user-owned keys like
-            // `gk-disposition` and `gk-associated-issues`. Only act on a genuine answer.
-            //
-            // BOTH conditions: `exitCode !== 0` catches a probe git ran and rejected, `status !== 'exited'`
-            // catches one that never produced an answer — a spawn failure or queue rejection (no exit code at
-            // all), or a swallowed warning (which carries git's real code, so the exit-code test alone can
-            // still read it as "none survived").
-            if (result.completion.status !== 'exited' || result.exitCode !== 0)
-                return false;
-            const prefix = 'refs/heads/';
-            const surviving = new Set(result.stdout
-                .split('\n')
-                .map(l => l.trim())
-                .filter(l => l.startsWith(prefix))
-                .map(l => l.substring(prefix.length)));
-            let anyDeleted = false;
-            for (const name of names) {
-                if (surviving.has(name))
-                    continue;
-                anyDeleted = true;
-                this.cache.deleteBaseBranchName(repoPath, name);
-                await this.provider.config.removeGkConfigBranchSection(repoPath, name);
-            }
-            return anyDeleted;
-        }
-        catch {
-            // Best-effort bookkeeping while already unwinding a failure — never mask the original error.
-            return false;
-        }
-    }
-    async deleteRemoteBranch(repoPath, names, remote) {
-        const branches = ensureArray(names);
-        const args = ['push', '-d', remote, ...branches];
-        try {
-            await this.git.run({ cwd: repoPath }, ...args);
-            this.context.hooks?.cache?.onReset?.(repoPath, 'branches');
-            this.context.hooks?.repository?.onChanged?.(repoPath, ['remotes']);
-        }
-        catch (ex) {
-            if (ex instanceof BranchError) {
-                throw ex.update({
-                    action: 'delete',
-                    branch: branches.join(', '),
-                    gitCommand: { repoPath: repoPath, args: args },
-                });
-            }
-            // Classify against the underlying `git push -d` failure modes; map the "remote ref does not
-            // exist" case onto BranchError's noRemoteReference so consumers get an actionable reason.
-            throw getGitCommandError('push', ex, reason => new BranchError({
-                reason: reason === 'rejectedRefDoesNotExist' ? 'noRemoteReference' : 'other',
-                action: 'delete',
-                branch: branches.join(', '),
-                gitCommand: { repoPath: repoPath, args: args },
-            }, ex));
-        }
-    }
-    async getBranchMergedStatus(repoPath, branch, into, cancellation) {
-        if (branch.name === into.name || branch.upstream?.name === into.name) {
-            return { merged: false };
-        }
-        // Hoisted so it can feed the cache key below (its tip is a 3rd key input) and the mapper
-        // below reuses it instead of resolving it a second time.
-        const localInto = into.remote
-            ? await this.getLocalBranchByUpstream(repoPath, into.name, cancellation)
-            : undefined;
-        // Cache key omits repoPath so worktrees of the same common repo share the cached answer.
-        // Content-keyed on the involved tip shas (the result is a pure function of them), so tip
-        // movement mints a new key instead of relying on eviction; falls back to the name-only
-        // identity when a sha is missing (defensive — the sole caller always supplies both tips).
-        const cacheKey = branch.sha != null && into.sha != null
-            ? `${branch.remote ? 'r' : 'l'}:${branch.name}@${branch.sha}|${into.remote ? 'r' : 'l'}:${into.name}@${into.sha}${localInto?.sha != null ? `|L:${localInto.name}@${localInto.sha}` : ''}`
-            : `${branch.remote ? 'r' : 'l'}:${branch.name}|${into.remote ? 'r' : 'l'}:${into.name}`;
-        return this.cache.getBranchMergedStatus(repoPath, cacheKey, async (commonPath, _cacheable, signal) => {
-            const result = await this.getBranchMergedStatusCore(commonPath, branch, into, signal);
-            if (result.merged)
-                return result;
-            // If there is a local branch and it is not the branch we are checking, check if it has been merged into it
-            if (localInto != null && localInto.name !== branch.name) {
-                // Skip the second full merge-check cycle when the local branch points at the same commit as the remote —
-                // the merge-base/cherry/diff/apply pipeline would produce the same answer we already got for `into` above
-                if (localInto.sha != null && localInto.sha === into.sha) {
-                    return { merged: false };
-                }
-                const result = await this.getBranchMergedStatusCore(commonPath, branch, localInto, signal);
-                if (result.merged) {
-                    // `localBranchOnly` is built against `commonPath` here; the cache mapper rewrites
-                    // `repoPath`/`id` to the requesting worktree on retrieval.
-                    return {
-                        ...result,
-                        localBranchOnly: createReference(localInto.ref, commonPath, {
-                            id: getBranchId(commonPath, localInto.remote, localInto.name),
-                            refType: 'branch',
-                            name: localInto.name,
-                            remote: localInto.remote,
-                            upstream: localInto.upstream,
-                            sha: localInto.sha,
-                        }),
-                    };
-                }
-            }
-            return { merged: false };
-        }, cancellation);
-    }
-    async getBranchMergedStatusCore(repoPath, branch, into, cancellation) {
-        const scope = getScopedLogger();
-        try {
-            // Check if branch is direct ancestor (handles FF merges)
-            try {
-                await this.git.run({ cwd: repoPath, cancellation: cancellation, errors: 'throw' }, 'merge-base', '--is-ancestor', branch.name, into.name);
-                return { merged: true, confidence: 'highest' };
-            }
-            catch (ex) {
-                if (isCancellationError(ex))
-                    throw ex;
-            }
-            // Cherry-pick detection (handles cherry-picks, rebases, etc)
-            let result = await this.git.run({ cwd: repoPath, cancellation: cancellation }, 'cherry', '--abbrev', '-v', into.name, branch.name);
-            // Check if there are no lines or all lines startwith a `-` (i.e. likely merged)
-            if (!result.stdout ||
-                result.stdout
-                    .trim()
-                    .split('\n')
-                    .every(l => l.startsWith('-'))) {
-                return { merged: true, confidence: 'high' };
-            }
-            // Attempt to detect squash merges by checking if the diff of the branch can be cleanly removed from the target
-            const mergeBase = await this.provider.refs.getMergeBase(repoPath, into.name, branch.name, undefined, cancellation);
-            result = await this.git.run({ cwd: repoPath, cancellation: cancellation }, 'diff', mergeBase, branch.name);
-            if (result.stdout) {
-                const env_2 = { stack: [], error: void 0, hasError: false };
-                try {
-                    // Create a temporary index file
-                    const disposableIndex = __addDisposableResource(env_2, await this.provider.staging.createTemporaryIndex(repoPath, 'ref', into.name), true);
-                    const { env } = disposableIndex;
-                    result = await this.git.run({
-                        cwd: repoPath,
-                        cancellation: cancellation,
-                        env: env,
-                        errors: 'ignore',
-                        stdin: result.stdout,
-                    }, 'apply', '--cached', '--reverse', '--check', '-');
-                    if (result.exitCode === 0 && !result.stdout.trim() && !result.stderr?.trim()) {
-                        return { merged: true, confidence: 'medium' };
-                    }
-                }
-                catch (e_2) {
-                    env_2.error = e_2;
-                    env_2.hasError = true;
-                }
-                finally {
-                    const result_1 = __disposeResources(env_2);
-                    if (result_1)
-                        await result_1;
-                }
-            }
-            return { merged: false };
-        }
-        catch (ex) {
-            if (Logger.enabled('trace')) {
-                scope?.error(ex);
-            }
-            if (isCancellationError(ex))
-                throw ex;
-            return { merged: false };
-        }
-    }
-    async getLocalBranchByUpstream(repoPath, remoteBranchName, cancellation) {
-        const branches = new PageableResult(p => this.getBranches(repoPath, p != null ? { paging: p } : undefined, cancellation));
-        return getLocalBranchByUpstream(remoteBranchName, branches);
-    }
-    /** Detects potential conflicts when applying commits onto a target branch (git rebase and cherry-pick) */
-    async getPotentialApplyConflicts(repoPath, targetBranch, shas, options, cancellation) {
-        if (!shas.length)
-            return { status: 'clean' };
-        const cacheKey = `apply:${targetBranch}:${shas.join(',')}:${options?.stopOnFirstConflict ?? false}`;
-        return this.cache.conflictDetection.getOrCreate(repoPath, cacheKey, async (_cacheable, signal) => {
-            // Resolve all parent refs in a single call - fails if any commit is a root commit (no parent)
-            const parentRefs = shas.map(c => `${c}^`);
-            let parentShas;
-            try {
-                const result = await this.git.run({ cwd: repoPath, cancellation: signal, errors: 'throw' }, 'rev-parse', ...parentRefs);
-                parentShas = result.stdout.trim().split('\n');
-            }
-            catch (ex) {
-                if (isCancellationError(ex))
-                    throw ex;
-                // If any commit doesn't have a parent (root commit), we can't do conflict detection
-                return createConflictDetectionError('noParent');
-            }
-            if (parentShas.length !== shas.length) {
-                return createConflictDetectionError('refNotFound');
-            }
-            const commitsWithParents = shas.map((c, i) => ({ sha: c, parent: parentShas[i] }));
-            return this.checkForPotentialConflicts(repoPath, commitsWithParents, targetBranch, signal, options);
-        }, { cancellation: cancellation });
-    }
-    /** Detects potential conflict when merge a branch into a target branch (git merge) */
-    async getPotentialMergeConflicts(repoPath, branch, targetBranch, cancellation) {
-        const scope = getScopedLogger();
-        const cacheKey = `merge:${branch}:${targetBranch}`;
-        return this.cache.conflictDetection.getOrCreate(repoPath, cacheKey, async (_cacheable, signal) => {
-            // Requires Git v2.33+
-            if (!(await this.git.supports('git:merge-tree'))) {
-                return createConflictDetectionError('unsupported');
-            }
-            let data;
-            try {
-                const result = await this.git.run({ cwd: repoPath, cancellation: signal, errors: 'throw' }, 'merge-tree', '-z', '--name-only', '--no-messages', branch, targetBranch);
-                data = result.stdout;
-            }
-            catch (ex) {
-                if (isCancellationError(ex))
-                    throw ex;
-                const msg = ex?.toString() ?? '';
-                if (GitErrors.notAValidObjectName.test(msg)) {
-                    scope?.error(ex, `'${targetBranch}' or '${branch}' not found - ensure the branches exist and are fully qualified (e.g. 'refs/heads/main')`);
-                    return createConflictDetectionError('refNotFound');
-                }
-                else if (GitErrors.badRevision.test(msg)) {
-                    scope?.error(ex, `Invalid branch name: ${msg.slice(msg.indexOf("'"))}`);
-                    return createConflictDetectionError('refNotFound');
-                }
-                else if (GitErrors.noMergeBase.test(msg)) {
-                    scope?.error(ex, `Unable to merge '${branch}' and '${targetBranch}' as they have no common ancestor`);
-                    return createConflictDetectionError('noMergeBase');
-                }
-                else if (ex instanceof GitError) {
-                    data = ex.stdout;
-                }
-                else {
-                    scope?.error(ex);
-                    return createConflictDetectionError('other');
-                }
-            }
-            if (!data)
-                return { status: 'clean' };
-            const mergeConflict = parseMergeTreeConflict(data);
-            if (!mergeConflict.conflicts.length)
-                return { status: 'clean', treeOid: mergeConflict.treeOid };
-            return {
-                status: 'conflicts',
-                conflict: {
-                    repoPath: repoPath,
-                    branch: branch,
-                    target: targetBranch,
-                    files: mergeConflict.conflicts,
-                    shas: undefined, // Merge conflicts don't have a specific commit SHA
-                },
-                treeOid: mergeConflict.treeOid,
-            };
-        }, { cancellation: cancellation });
-    }
-    /** Detects conflicts when an autostash is reapplied onto the tree an integration produced */
-    async getPotentialStashReapplyConflicts(repoPath, ontoTreeOid, cancellation) {
-        // Requires Git v2.38+ for --write-tree with 3-arg form
-        if (!(await this.git.supports('git:merge-tree:write-tree'))) {
-            return createConflictDetectionError('unsupported');
-        }
-        // git stash create writes commit objects but touches neither the working tree nor the stash ref, and
-        // captures tracked changes only — which is exactly what autostash does
-        let stashSha;
-        try {
-            const result = await this.git.run({ cwd: repoPath, cancellation: cancellation, errors: 'throw' }, 'stash', 'create');
-            stashSha = result.stdout.trim();
-        }
-        catch (ex) {
-            if (isCancellationError(ex))
-                throw ex;
-            return createConflictDetectionError('other');
-        }
-        if (!stashSha)
-            return { status: 'clean' };
-        // Key on what the simulation actually consumes — the stash's tree and its first parent (the HEAD it was
-        // taken against, and so the merge base). The stash SHA itself embeds a commit timestamp, so two runs over
-        // an identical tree produce different SHAs and a SHA-keyed entry could never be hit.
-        let stashTree;
-        let stashParent;
-        try {
-            const result = await this.git.run({ cwd: repoPath, cancellation: cancellation, errors: 'throw' }, 'rev-parse', `${stashSha}^{tree}`, `${stashSha}^`);
-            [stashTree, stashParent] = result.stdout.trim().split('\n');
-        }
-        catch (ex) {
-            if (isCancellationError(ex))
-                throw ex;
-            return createConflictDetectionError('other');
-        }
-        const cacheKey = `reapply:${ontoTreeOid}:${stashTree}.${stashParent}`;
-        return this.cache.conflictDetection.getOrCreate(repoPath, cacheKey, async (_cacheable, signal) => {
-            // The stash commit's first parent is the HEAD it was taken against, which is the correct merge
-            // base for a reapply — ours is the post-integration tree, theirs is the stash
-            const step = await this.runMergeTreeStep(repoPath, `${stashSha}^`, ontoTreeOid, stashSha, signal);
-            if (!step.ok)
-                return createConflictDetectionError(step.reason);
-            if (!step.result.conflicts.length)
-                return { status: 'clean', treeOid: step.result.treeOid };
-            return {
-                status: 'conflicts',
-                conflict: {
-                    repoPath: repoPath,
-                    branch: stashSha,
-                    target: ontoTreeOid,
-                    files: step.result.conflicts,
-                    shas: undefined,
-                },
-                treeOid: step.result.treeOid,
-            };
-        }, { cancellation: cancellation });
-    }
-    async runMergeTreeStep(repoPath, base, ours, theirs, cancellation) {
-        const scope = getScopedLogger();
-        let data;
-        try {
-            const result = await this.git.run({ cwd: repoPath, cancellation: cancellation, errors: 'throw' }, 'merge-tree', '--write-tree', '-z', '--name-only', '--no-messages', `--merge-base=${base}`, ours, theirs);
-            data = result.stdout;
-        }
-        catch (ex) {
-            if (isCancellationError(ex))
-                throw ex;
-            const msg = ex?.toString() ?? '';
-            if (GitErrors.notAValidObjectName.test(msg)) {
-                scope?.error(ex, `'${ours}' or '${theirs}' not found - ensure the branches/commits exist`);
-                return { ok: false, reason: 'refNotFound' };
-            }
-            else if (GitErrors.badRevision.test(msg)) {
-                scope?.error(ex, `Invalid revision: ${msg.slice(msg.indexOf("'"))}`);
-                return { ok: false, reason: 'refNotFound' };
-            }
-            else if (GitErrors.noMergeBase.test(msg)) {
-                scope?.error(ex, `Unable to merge '${ours}' and '${theirs}' as they have no common ancestor`);
-                return { ok: false, reason: 'noMergeBase' };
-            }
-            else if (ex instanceof GitError) {
-                data = ex.stdout;
-            }
-            else {
-                scope?.error(ex, 'Failed to execute merge-tree for conflict check');
-                return { ok: false, reason: 'other' };
-            }
-        }
-        return { ok: true, result: parseMergeTreeConflict(data ?? '') };
-    }
-    async checkForPotentialConflicts(repoPath, commits, targetBranch, cancellation, options) {
-        const scope = getScopedLogger();
-        // Requires Git v2.38+ for --write-tree with 3-arg form
-        if (!(await this.git.supports('git:merge-tree:write-tree'))) {
-            return createConflictDetectionError('unsupported');
-        }
-        let currentTreeOid;
-        try {
-            // Get the initial target branch tree OID
-            const treeResult = await this.git.run({ cwd: repoPath, cancellation: cancellation, errors: 'throw' }, 'rev-parse', `${targetBranch}^{tree}`);
-            currentTreeOid = treeResult.stdout.trim();
-        }
-        catch (ex) {
-            if (isCancellationError(ex))
-                throw ex;
-            scope?.error(ex, `Failed to resolve target branch '${targetBranch}'`);
-            return createConflictDetectionError('refNotFound');
-        }
-        const conflictingShas = [];
-        const conflictingFilePaths = new Set();
-        for (const commit of commits) {
-            if (cancellation?.aborted)
-                throw new CancellationError();
-            // Use merge-tree --write-tree with --merge-base to simulate cherry-pick:
-            // merge-tree --write-tree --merge-base=<commit-parent> <current-tree> <commit>
-            // This performs a 3-way merge where:
-            //   - base = commit.parent (where the commit started)
-            //   - ours = currentTreeOid (current state of the target)
-            //   - theirs = commit.sha (what we're cherry-picking)
-            const step = await this.runMergeTreeStep(repoPath, commit.parent, currentTreeOid, commit.sha, cancellation);
-            if (!step.ok)
-                return createConflictDetectionError(step.reason);
-            const mergeConflict = step.result;
-            if (mergeConflict.conflicts.length) {
-                conflictingShas.push(commit.sha);
-                for (const file of mergeConflict.conflicts) {
-                    conflictingFilePaths.add(file.path);
-                }
-                if (options?.stopOnFirstConflict) {
-                    return {
-                        status: 'conflicts',
-                        conflict: {
-                            repoPath: repoPath,
-                            branch: commit.sha,
-                            target: targetBranch,
-                            files: mergeConflict.conflicts,
-                            shas: [commit.sha],
-                        },
-                        stoppedOnFirstConflict: true,
-                        treeOid: mergeConflict.treeOid || undefined,
-                    };
-                }
-            }
-            // Update currentTreeOid to the result tree OID for the next iteration
-            // This works even when there are conflicts - the tree contains conflict markers
-            if (mergeConflict.treeOid) {
-                currentTreeOid = mergeConflict.treeOid;
-            }
-        }
-        if (conflictingShas.length) {
-            return {
-                status: 'conflicts',
-                conflict: {
-                    repoPath: repoPath,
-                    branch: conflictingShas[0],
-                    target: targetBranch,
-                    files: Array.from(conflictingFilePaths, path => ({ path: path })),
-                    shas: conflictingShas,
-                },
-                stoppedOnFirstConflict: false,
-                treeOid: currentTreeOid,
-            };
-        }
-        return { status: 'clean', treeOid: currentTreeOid };
-    }
-    getBaseBranchName(repoPath, ref, options, cancellation) {
-        const priority = options?.priority;
-        const priorityOpts = priority != null ? { priority: priority } : undefined;
-        return this.cache.getBaseBranchName(repoPath, ref, async (commonPath, cacheable, signal) => {
-            try {
-                // getGkConfig has built-in fallback to regular config for backward compatibility
-                let mergeBase = await this.provider.config.getGkConfig(commonPath, `branch.${ref}.gk-merge-base`);
-                let update = false;
-                // Also check vscode-merge-base in regular config (VS Code compatibility)
-                if (mergeBase == null) {
-                    mergeBase = await this.provider.config.getConfig(commonPath, `branch.${ref}.vscode-merge-base`);
-                    update = mergeBase != null;
-                }
-                if (mergeBase != null) {
-                    const branch = await this.provider.refs.getSymbolicReferenceName(commonPath, mergeBase, priorityOpts);
-                    if (branch != null) {
-                        if (update) {
-                            // Self-write: the value we're storing is exactly what this factory is
-                            // returning, so any in-flight `branchOverviews` or `baseBranchName` entry
-                            // being populated against this resolution should NOT be evicted.
-                            void this.storeBaseBranchName(commonPath, ref, branch, {
-                                skipInvalidation: ['branchOverviews', 'baseBranchName'],
-                            });
-                        }
-                        return branch;
-                    }
-                }
-            }
-            catch { }
-            const reflog = await this.getBaseBranchFromReflog(commonPath, ref, { upstream: true, priority: priority }, signal);
-            if (reflog.branch != null) {
-                // Self-write: see comment on the migration path above.
-                void this.storeBaseBranchName(commonPath, ref, reflog.branch, {
-                    skipInvalidation: ['branchOverviews', 'baseBranchName'],
-                });
-                return reflog.branch;
-            }
-            // This entry has no TTL and the `'branches'` cascade no longer clears it (a tip move can't
-            // change a base), so a failed read cached as `undefined` would read as "no base branch" for
-            // the rest of the session. Only a reflog that actually RAN and found nothing is an answer.
-            if (reflog.failed) {
-                cacheable.invalidate();
-            }
-            return undefined;
-        }, cancellation);
-    }
-    /**
-     * `failed` separates "the reflog ran and had no answer" from "the read never happened" — the caller
-     * caches the former forever and must not cache the latter.
-     */
-    async getBaseBranchFromReflog(repoPath, ref, options, cancellation) {
-        const priority = options?.priority;
-        const priorityOpts = priority != null ? { priority: priority } : undefined;
-        try {
-            let result = await this.git.run({ cwd: repoPath, cancellation: cancellation, ...priorityOpts }, 'reflog', ref, '--grep-reflog=branch: Created from *.');
-            let entries = result.stdout.split('\n').filter(entry => Boolean(entry));
-            if (entries.length !== 1)
-                return { branch: undefined, failed: false };
-            // Check if branch created from an explicit branch
-            let match = entries[0].match(/branch: Created from (.*)$/);
-            if (match?.length === 2) {
-                let name = match[1];
-                if (name !== 'HEAD') {
-                    if (options?.upstream) {
-                        const upstream = await this.provider.refs.getSymbolicReferenceName(repoPath, `${name}@{u}`, priorityOpts);
-                        if (upstream)
-                            return { branch: upstream, failed: false };
-                    }
-                    name = await this.provider.refs.getSymbolicReferenceName(repoPath, name, priorityOpts);
-                    if (name)
-                        return { branch: name, failed: false };
-                }
-            }
-            // Check if branch was created from HEAD
-            result = await this.git.run({ cwd: repoPath, cancellation: cancellation, ...priorityOpts }, 'reflog', 'HEAD', `--grep-reflog=checkout: moving from .* to ${ref.replace('refs/heads/', '')}`);
-            entries = result.stdout.split('\n').filter(entry => Boolean(entry));
-            if (!entries.length)
-                return { branch: undefined, failed: false };
-            match = entries.at(-1).match(/checkout: moving from ([^\s]+)\s/);
-            if (match?.length === 2) {
-                let name = match[1];
-                if (options?.upstream) {
-                    const upstream = await this.provider.refs.getSymbolicReferenceName(repoPath, `${name}@{u}`, priorityOpts);
-                    if (upstream)
-                        return { branch: upstream, failed: false };
-                }
-                name = await this.provider.refs.getSymbolicReferenceName(repoPath, name, priorityOpts);
-                if (name)
-                    return { branch: name, failed: false };
-            }
-        }
-        catch (ex) {
-            if (isCancellationError(ex))
-                throw ex;
-            // The reads use default error handling, so a spawn failure, queue rejection or swallowed
-            // `GitWarnings` match lands here rather than producing an empty answer.
-            return { branch: undefined, failed: true };
-        }
-        return { branch: undefined, failed: false };
-    }
-    async getStoredMergeTargetBranchName(repoPath, ref) {
-        const target = (await this.getStoredUserMergeTargetBranchName?.(repoPath, ref)) ??
-            (await this.getStoredDetectedMergeTargetBranchName?.(repoPath, ref));
-        return target?.trim() || undefined;
-    }
-    async getStoredDetectedMergeTargetBranchName(repoPath, ref) {
-        const target = (await this.provider.config.getGkConfig(repoPath, `branch.${ref}.gk-merge-target`)) ??
-            (await this.provider.config.getGkConfig(repoPath, `branch.${ref}.gk-target-base`)); // legacy key
-        return target?.trim() || undefined;
-    }
-    async getStoredUserMergeTargetBranchName(repoPath, ref) {
-        const target = await this.provider.config.getGkConfig(repoPath, `branch.${ref}.gk-merge-target-user`);
-        return target?.trim() || undefined;
-    }
-    /** Updates the last accessed timestamp for the current branch */
-    async onCurrentBranchAccessed(repoPath) {
-        const branch = await this.getBranch(repoPath);
-        if (branch == null || branch.remote || branch.detached)
-            return;
-        await this.storeBranchMetadata(repoPath, 'gk-last-accessed', branch.name, new Date());
-    }
-    /** Updates the last accessed and modified timestamp for the current branch */
-    async onCurrentBranchModified(repoPath) {
-        const branch = await this.getBranch(repoPath);
-        if (branch == null || branch.remote || branch.detached)
-            return;
-        const now = new Date();
-        await this.storeBranchMetadata(repoPath, 'gk-last-accessed', branch.name, now);
-        await this.storeBranchMetadata(repoPath, 'gk-last-modified', branch.name, now);
-    }
-    /** Updates the agent last activity timestamp for the current branch */
-    async onCurrentBranchAgentActivity(repoPath) {
-        const branch = await this.getBranch(repoPath);
-        if (branch == null || branch.remote || branch.detached)
-            return;
-        await this.storeBranchMetadata(repoPath, 'gk-agent-last-activity', branch.name, new Date());
-    }
-    async renameBranch(repoPath, oldName, newName) {
-        const args = ['branch', '-m', oldName, newName];
-        try {
-            await this.git.run({ cwd: repoPath }, ...args);
-            // The branch keeps its identity across a rename, so move its stored gk metadata with it —
-            // otherwise the new name re-derives a base it already had, and the old name is left holding
-            // metadata for a branch that no longer exists under it.
-            await this.provider.config.renameGkConfigBranchSection(repoPath, oldName, newName);
-            // Old name's entry is now orphaned; the new name must not inherit a predecessor's base
-            this.cache.deleteBaseBranchName(repoPath, oldName);
-            this.cache.deleteBaseBranchName(repoPath, newName);
-            this.context.hooks?.cache?.onReset?.(repoPath, 'branches');
-            this.context.hooks?.repository?.onChanged?.(repoPath, ['heads']);
-        }
-        catch (ex) {
-            throw getGitCommandError('branch', ex, reason => new BranchError({
-                reason: reason ?? 'other',
-                action: 'rename',
-                branch: oldName,
-                gitCommand: { repoPath: repoPath, args: args },
-            }, ex));
-        }
-    }
-    async setUpstreamBranch(repoPath, name, upstream) {
-        const args = upstream == null ? ['branch', '--unset-upstream', name] : ['branch', '--set-upstream-to', upstream, name];
-        try {
-            await this.git.run({ cwd: repoPath }, ...args);
-            this.context.hooks?.cache?.onReset?.(repoPath, 'branches');
-            this.context.hooks?.repository?.onChanged?.(repoPath, ['heads']);
-        }
-        catch (ex) {
-            throw getGitCommandError('branch', ex, reason => new BranchError({
-                reason: reason ?? 'other',
-                action: upstream == null ? 'unset upstream of' : `set upstream to '${upstream}' for`,
-                branch: name,
-                gitCommand: { repoPath: repoPath, args: args },
-            }, ex));
-        }
-    }
-    async storeBaseBranchName(repoPath, ref, base, options) {
-        await this.provider.config.setGkConfig(repoPath, `branch.${ref}.gk-merge-base`, base, options);
-    }
-    async storeMergeTargetBranchName(repoPath, ref, target, options) {
-        await this.provider.config.setGkConfig(repoPath, `branch.${ref}.gk-merge-target`, target, options);
-    }
-    async storeUserMergeTargetBranchName(repoPath, ref, target) {
-        await this.provider.config.setGkConfig(repoPath, `branch.${ref}.gk-merge-target-user`, target);
-    }
-    /**
-     * Gets all branch metadata (dates and disposition) from git config in a single batch operation.
-     * @returns A map of branch name to metadata.
-     */
-    getBranchMetadataMap(repoPath) {
-        return this.cache.getBranchMetadataMap(repoPath, async (commonPath) => {
-            const scope = getScopedLogger();
-            const metadataMap = new Map();
-            try {
-                // Use git config --get-regexp to load all gk-* branch metadata in one call
-                const configMap = await this.provider.config.getGkConfigRegex(commonPath, '^branch\\..*\\.gk-(last-(accessed|modified)|disposition|agent-last-activity)$');
-                if (!configMap.size)
-                    return metadataMap;
-                for (const [key, value] of configMap) {
-                    // Extract branch name and metadata key from "branch.{name}.gk-{key}"
-                    if (!key.startsWith('branch.'))
-                        continue;
-                    const keyParts = key.split('.');
-                    if (keyParts.length < 3)
-                        continue;
-                    // Branch name is everything between "branch." and the last ".gk-*"
-                    const metaKey = keyParts.at(-1);
-                    const branchName = keyParts.slice(1, -1).join('.');
-                    let metadata = metadataMap.get(branchName);
-                    if (metadata == null) {
-                        metadata = {};
-                        metadataMap.set(branchName, metadata);
-                    }
-                    if (metaKey === 'gk-last-accessed') {
-                        metadata.lastAccessedAt = value;
-                    }
-                    else if (metaKey === 'gk-last-modified') {
-                        metadata.lastModifiedAt = value;
-                    }
-                    else if (metaKey === 'gk-agent-last-activity') {
-                        metadata.agentLastActivityAt = value;
-                    }
-                    else if (metaKey === 'gk-disposition') {
-                        if (value === 'starred' || value === 'archived') {
-                            metadata.disposition = value;
-                        }
-                    }
-                }
-            }
-            catch (ex) {
-                debugger;
-                scope?.error(ex);
-            }
-            return metadataMap;
-        });
-    }
-    async storeBranchMetadata(repoPath, key, ref, date) {
-        const value = await this.provider.config.getGkConfig(repoPath, `branch.${ref}.${key}`);
-        // Skip if incoming date is not at least 5 minutes newer than stored date
-        if (value != null && date.getTime() - new Date(value).getTime() < dateMetadataStaleThresholdMs) {
-            return;
-        }
-        return this.provider.config.setGkConfig(repoPath, `branch.${ref}.${key}`, date.toISOString());
-    }
-    async setBranchDisposition(repoPath, branchName, disposition) {
-        await this.provider.config.setGkConfig(repoPath, `branch.${branchName}.gk-disposition`, disposition);
-        this.context.hooks?.cache?.onReset?.(repoPath, 'branches');
-        this.context.hooks?.repository?.onChanged?.(repoPath, ['starred']);
-    }
-}
-__decorate([
-    debug()
-], BranchesGitSubProvider.prototype, "getBranch", null);
-__decorate([
-    debug({ args: repoPath => ({ repoPath: repoPath }) })
-], BranchesGitSubProvider.prototype, "getBranches", null);
-__decorate([
-    debug()
-], BranchesGitSubProvider.prototype, "getBranchContributionsOverview", null);
-__decorate([
-    debug()
-], BranchesGitSubProvider.prototype, "getBranchesWithCommits", null);
-__decorate([
-    debug()
-], BranchesGitSubProvider.prototype, "getCurrentBranchReference", null);
-__decorate([
-    debug({ exit: true })
-], BranchesGitSubProvider.prototype, "getDefaultBranchName", null);
-__decorate([
-    debug()
-], BranchesGitSubProvider.prototype, "createBranch", null);
-__decorate([
-    debug()
-], BranchesGitSubProvider.prototype, "deleteLocalBranch", null);
-__decorate([
-    debug()
-], BranchesGitSubProvider.prototype, "deleteRemoteBranch", null);
-__decorate([
-    debug()
-], BranchesGitSubProvider.prototype, "getBranchMergedStatus", null);
-__decorate([
-    debug()
-], BranchesGitSubProvider.prototype, "getLocalBranchByUpstream", null);
-__decorate([
-    debug()
-], BranchesGitSubProvider.prototype, "getPotentialApplyConflicts", null);
-__decorate([
-    debug()
-], BranchesGitSubProvider.prototype, "getPotentialMergeConflicts", null);
-__decorate([
-    debug()
-], BranchesGitSubProvider.prototype, "getPotentialStashReapplyConflicts", null);
-__decorate([
-    debug({ exit: true })
-], BranchesGitSubProvider.prototype, "getBaseBranchName", null);
-__decorate([
-    debug({ exit: true })
-], BranchesGitSubProvider.prototype, "getStoredMergeTargetBranchName", null);
-__decorate([
-    debug({ exit: true })
-], BranchesGitSubProvider.prototype, "getStoredDetectedMergeTargetBranchName", null);
-__decorate([
-    debug()
-], BranchesGitSubProvider.prototype, "getStoredUserMergeTargetBranchName", null);
-__decorate([
-    debounce(2.5 * 60 * 1000),
-    debug()
-], BranchesGitSubProvider.prototype, "onCurrentBranchAccessed", null);
-__decorate([
-    debounce(2.5 * 60 * 1000),
-    debug()
-], BranchesGitSubProvider.prototype, "onCurrentBranchModified", null);
-__decorate([
-    debounce(2.5 * 60 * 1000),
-    debug()
-], BranchesGitSubProvider.prototype, "onCurrentBranchAgentActivity", null);
-__decorate([
-    debug()
-], BranchesGitSubProvider.prototype, "renameBranch", null);
-__decorate([
-    debug()
-], BranchesGitSubProvider.prototype, "setUpstreamBranch", null);
-__decorate([
-    debug()
-], BranchesGitSubProvider.prototype, "storeBaseBranchName", null);
-__decorate([
-    debug()
-], BranchesGitSubProvider.prototype, "storeMergeTargetBranchName", null);
-__decorate([
-    debug()
-], BranchesGitSubProvider.prototype, "storeUserMergeTargetBranchName", null);
+const dateMetadataStaleThresholdMs = 3e5;
+var BranchesGitSubProvider = class {
+	context;
+	git;
+	cache;
+	provider;
+	constructor(context, git, cache, provider) {
+		this.context = context;
+		this.git = git;
+		this.cache = cache;
+		this.provider = provider;
+	}
+	async getBranch(repoPath, name, cancellation) {
+		if (name != null) {
+			const { values: [branch] } = await this.getBranches(repoPath, { filter: (b) => b.name === name }, cancellation);
+			return branch;
+		}
+		const branchPromise = this.cache.branch.getOrCreate(repoPath, async (_cacheable, signal) => {
+			const { values: [branch] } = await this.getBranches(repoPath, { filter: (b) => b.current }, signal);
+			return branch ?? this.getCurrentBranch(repoPath, void 0, void 0, signal);
+		}, cancellation);
+		if (branchPromise == null) {
+			const { values: [branch] } = await this.getBranches(repoPath, { filter: (b) => b.current }, cancellation);
+			return branch ?? this.getCurrentBranch(repoPath, void 0, void 0, cancellation);
+		}
+		return branchPromise;
+	}
+	async getCurrentBranch(repoPath, metadataMap, ordering, cancellation) {
+		const ref = await this.getCurrentBranchReferenceCore(repoPath, ordering, cancellation);
+		if (ref == null) return void 0;
+		const [pausedOpStatusResult, committerDateResult, defaultWorktreePathResult, metadataMapResult] = await Promise.allSettled([
+			isDetachedHead(ref.name) ? this.provider.pausedOps?.getPausedOperationStatus(repoPath, void 0, cancellation) : void 0,
+			this.git.run({
+				cwd: repoPath,
+				cancellation,
+				configs: gitConfigsLog,
+				errors: "ignore"
+			}, "log", "-n1", "--format=%ct", ordering ? `--${ordering}-order` : void 0, "--").then((result) => result.stdout ? result.stdout.trim() : void 0),
+			this.provider.config.getDefaultWorktreePath?.(repoPath),
+			metadataMap != null ? Promise.resolve(metadataMap) : this.getBranchMetadataMap(repoPath)
+		]);
+		const committerDate = getSettledValue(committerDateResult);
+		const pausedOpStatus = getSettledValue(pausedOpStatusResult);
+		const rebaseStatus = pausedOpStatus?.type === "rebase" ? pausedOpStatus : void 0;
+		const defaultWorktreePath = getSettledValue(defaultWorktreePathResult);
+		metadataMap ??= getSettledValue(metadataMapResult);
+		const metadata = metadataMap?.get(ref.name);
+		if (cancellation?.aborted) throw new CancellationError();
+		const branchRefName = rebaseStatus?.incoming.name ?? `refs/heads/${ref.name}`;
+		return new GitBranch(repoPath, branchRefName, true, committerDate != null ? /* @__PURE__ */ new Date(Number(committerDate) * 1e3) : void 0, metadata, ref.sha, ref.upstream ? {
+			...ref.upstream,
+			state: {
+				ahead: 0,
+				behind: 0
+			}
+		} : void 0, {
+			path: repoPath,
+			isDefault: repoPath === defaultWorktreePath
+		}, void 0, rebaseStatus != null);
+	}
+	async getBranches(repoPath, options, cancellation) {
+		if (repoPath == null) return emptyPagedResult;
+		const scope = getScopedLogger();
+		const getCore = async (commonPath, cacheable, signal) => {
+			signal ??= cancellation;
+			try {
+				try {
+					var _usingCtx$1 = _usingCtx();
+					const [recordsResult, supportedResult, defaultWorktreePathResult, metadataMapResult] = await Promise.allSettled([
+						this.provider.refs.getRefs(commonPath, signal),
+						this.git.supported("git:for-each-ref"),
+						this.provider.config.getDefaultWorktreePath?.(commonPath),
+						this.getBranchMetadataMap(commonPath)
+					]);
+					const records = getSettledValue(recordsResult) ?? [];
+					const supported = getSettledValue(supportedResult) ?? [];
+					const metadataMap = getSettledValue(metadataMapResult) ?? /* @__PURE__ */ new Map();
+					const defaultWorktreePath = getSettledValue(defaultWorktreePathResult);
+					const worktreePathSupported = supported.includes("git:for-each-ref:worktreePath");
+					if (!records.length) {
+						cacheable?.invalidate();
+						const current = await this.getCurrentBranch(commonPath, metadataMap, options?.ordering ?? this.context.config?.commits.ordering ?? void 0, signal);
+						return current != null ? { values: [current] } : emptyPagedResult;
+					}
+					const sw = _usingCtx$1.u(maybeStopWatch(scope, { log: {
+						onlyExit: true,
+						level: "debug"
+					} }));
+					const branches = [];
+					for (const record of records) {
+						const fullName = record.name;
+						if (!fullName.startsWith("refs/heads/") && !fullName.startsWith("refs/remotes/")) continue;
+						if (isRemoteHEAD(fullName)) continue;
+						const upstream = parseUpstream(record.upstream, record.upstreamTracking);
+						const metadata = metadataMap.get(parseRefName(fullName).name);
+						const worktreePath = record.worktreePath ? normalizePath(record.worktreePath) : void 0;
+						branches.push(new GitBranch(commonPath, fullName, false, record.committerDate ? new Date(record.committerDate) : void 0, metadata, record.objectname, upstream, worktreePathSupported ? worktreePath ? {
+							path: worktreePath,
+							isDefault: worktreePath === defaultWorktreePath
+						} : false : void 0));
+					}
+					sw?.stop({ suffix: ` parsed ${branches.length} branches` });
+					for (const branch of branches) if (branch.worktree && branch.worktree.path) {
+						const { name } = parseRefName(branch.refName);
+						const reference = createReference(name, branch.worktree.path, {
+							refType: "branch",
+							name,
+							id: getBranchId(branch.worktree.path, false, name),
+							remote: false,
+							upstream: branch.upstream?.name ? {
+								name: branch.upstream.name,
+								missing: branch.upstream.missing
+							} : void 0,
+							sha: branch.sha
+						});
+						this.cache.setCurrentBranchReferenceIfAbsent(branch.worktree.path, reference);
+					}
+					return branches.length ? { values: branches } : emptyPagedResult;
+				} catch (_) {
+					_usingCtx$1.e = _;
+				} finally {
+					_usingCtx$1.d();
+				}
+			} catch (ex) {
+				cacheable?.invalidate();
+				if (isCancellationError(ex)) throw ex;
+				return emptyPagedResult;
+			}
+		};
+		const mapBranches = async (shared, targetRepoPath, commonPath, mapperSignal) => {
+			if (!shared.values.length) return shared;
+			mapperSignal ??= cancellation;
+			const [currentRefResult, defaultWorktreePathResult] = await Promise.allSettled([this.getCurrentBranchReferenceCore(targetRepoPath, void 0, mapperSignal), this.provider.config.getDefaultWorktreePath?.(commonPath)]);
+			const currentRef = getSettledValue(currentRefResult);
+			const defaultWorktreePath = getSettledValue(defaultWorktreePathResult);
+			const isDetached = currentRef != null && isDetachedHead(currentRef.name);
+			const branches = shared.values.map((b) => {
+				const isCurrent = !b.remote && b.name === currentRef?.name && !isDetached;
+				if (!isCurrent && targetRepoPath === commonPath) return b;
+				return new GitBranch(targetRepoPath, b.refName, isCurrent, b.date, b.metadata, b.sha, b.upstream, isCurrent ? b.worktree ?? {
+					path: targetRepoPath,
+					isDefault: targetRepoPath === defaultWorktreePath
+				} : b.worktree, false, false);
+			});
+			if (isDetached || currentRef != null && !branches.some((b) => b.current)) {
+				const metadataMap = await this.getBranchMetadataMap(commonPath);
+				const current = await this.getCurrentBranch(targetRepoPath, metadataMap, options?.ordering ?? this.context.config?.commits.ordering ?? void 0, mapperSignal);
+				if (current != null) {
+					const index = branches.findIndex((b) => b.id === current.id);
+					if (index !== -1) branches[index] = current;
+					else branches.unshift(current);
+				}
+			}
+			return {
+				...shared,
+				values: branches
+			};
+		};
+		let result;
+		if (options?.paging?.cursor != null) {
+			const commonPath = this.cache.getCommonPath(repoPath);
+			result = await mapBranches(await getCore(commonPath), repoPath, commonPath);
+		} else result = await this.cache.getBranches(repoPath, getCore, mapBranches, cancellation);
+		if (options?.filter != null) result = {
+			...result,
+			values: result.values.filter(options.filter)
+		};
+		if (options?.sort) sortBranches(result.values, typeof options.sort === "boolean" ? void 0 : options.sort);
+		return result;
+	}
+	async getBranchContributionsOverview(repoPath, ref, options, cancellation) {
+		const scope = getScopedLogger();
+		const priority = options?.priority;
+		const priorityOpts = priority != null ? { priority } : void 0;
+		const fetchBody = async (mergeTarget, signal) => {
+			const mergeBase = await this.provider.refs.getMergeBase(repoPath, ref, mergeTarget, priorityOpts, signal);
+			if (mergeBase == null) return void 0;
+			const [contributorsSettled, mergeBaseDatesSettled] = await Promise.allSettled([this.provider.contributors.getContributors(repoPath, createRevisionRange(mergeBase, ref, ".."), { stats: true }, signal), this.provider.commits.getCommitDates(repoPath, mergeBase, signal)]);
+			if (signal?.aborted) throw new CancellationError();
+			const result = getSettledValue(contributorsSettled) ?? { contributors: [] };
+			const mergeBaseDates = getSettledValue(mergeBaseDatesSettled);
+			sortContributors(result.contributors, { orderBy: "score:desc" });
+			let totalCommits = 0;
+			let totalFiles = 0;
+			let totalAdditions = 0;
+			let totalDeletions = 0;
+			let firstCommitTimestamp;
+			let latestCommitTimestamp;
+			for (const c of result.contributors) {
+				totalCommits += c.contributionCount;
+				totalFiles += c.stats?.files ?? 0;
+				totalAdditions += c.stats?.additions ?? 0;
+				totalDeletions += c.stats?.deletions ?? 0;
+				const firstTimestamp = c.firstCommitDate?.getTime();
+				const latestTimestamp = c.latestCommitDate?.getTime();
+				if (firstTimestamp != null || latestTimestamp != null) {
+					firstCommitTimestamp = firstCommitTimestamp != null ? Math.min(firstCommitTimestamp, firstTimestamp ?? Infinity, latestTimestamp ?? Infinity) : firstTimestamp ?? latestTimestamp;
+					latestCommitTimestamp = latestCommitTimestamp != null ? Math.max(latestCommitTimestamp, firstTimestamp ?? -Infinity, latestTimestamp ?? -Infinity) : latestTimestamp ?? firstTimestamp;
+				}
+			}
+			return {
+				repoPath,
+				branch: ref,
+				mergeTarget,
+				mergeBase,
+				mergeBaseDate: mergeBaseDates?.committerDate,
+				commits: totalCommits,
+				files: totalFiles,
+				additions: totalAdditions,
+				deletions: totalDeletions,
+				latestCommitDate: latestCommitTimestamp != null ? new Date(latestCommitTimestamp) : void 0,
+				firstCommitDate: firstCommitTimestamp != null ? new Date(firstCommitTimestamp) : void 0,
+				contributors: result.contributors
+			};
+		};
+		try {
+			let mergeTarget;
+			const storedTarget = await this.getStoredMergeTargetBranchName(repoPath, ref);
+			if (storedTarget) mergeTarget = await this.provider.refs.getSymbolicReferenceName(repoPath, storedTarget, priorityOpts, cancellation) || storedTarget;
+			if (mergeTarget == null && options?.associatedPullRequest != null) {
+				const pr = await options.associatedPullRequest;
+				if (pr?.refs?.base != null) {
+					const branch = await this.getBranch(repoPath, ref, cancellation);
+					if (branch == null) return void 0;
+					mergeTarget = `${branch.remoteName}/${pr.refs.base.branch}`;
+					if (pr.stack == null) this.storeMergeTargetBranchName(repoPath, ref, mergeTarget, { skipInvalidation: ["branchOverviews"] });
+				}
+			}
+			mergeTarget ??= await this.getBaseBranchName(repoPath, ref, priorityOpts, cancellation);
+			mergeTarget ??= await this.getDefaultBranchName(repoPath, void 0, priorityOpts, cancellation);
+			if (mergeTarget == null) return void 0;
+			const resolvedTarget = mergeTarget;
+			return await this.cache.getBranchOverview(repoPath, `${ref}|${resolvedTarget}`, (_commonPath, _cacheable, signal) => fetchBody(resolvedTarget, signal ?? cancellation), { cancellation });
+		} catch (ex) {
+			scope?.error(ex);
+			if (isCancellationError(ex)) throw ex;
+			return;
+		}
+	}
+	async getBranchesWithCommits(repoPath, commits, branch, options, cancellation) {
+		if (branch != null) {
+			const data = (await this.branchesContainingCore(repoPath, commits, {
+				mode: "contains",
+				name: branch
+			}, cancellation)).stdout.trim();
+			return data ? [data] : [];
+		}
+		const result = await this.branchesContainingCore(repoPath, commits, options, cancellation);
+		if (!result.stdout) return [];
+		return filterMap(result.stdout.split("\n"), (b) => b.trim() || void 0);
+	}
+	async branchesContainingCore(repoPath, refs, options, cancellation) {
+		const params = ["branch"];
+		if (options?.all) params.push("-a");
+		else if (options?.remotes) params.push("-r");
+		params.push("--format=%(refname:short)");
+		for (const ref of refs) params.push(options?.mode === "pointsAt" ? `--points-at=${ref}` : `--contains=${ref}`);
+		if (options?.name != null) params.push(options.name);
+		return this.git.run({
+			cwd: repoPath,
+			cancellation,
+			configs: gitConfigsBranch,
+			errors: "ignore"
+		}, ...params);
+	}
+	async getCurrentBranchReference(repoPath, cancellation) {
+		let ref = await this.getCurrentBranchReferenceCore(repoPath, void 0, cancellation);
+		if (ref != null && isDetachedHead(ref.name)) ref = createReference(ref.sha, repoPath, {
+			refType: "branch",
+			name: formatDetachedHeadName(ref.sha),
+			id: getBranchId(repoPath, ref.remote, ref.sha),
+			remote: ref.remote,
+			upstream: ref.upstream,
+			sha: ref.sha
+		});
+		return ref;
+	}
+	getCurrentBranchReferenceCore(repoPath, ordering, cancellation) {
+		return this.cache.currentBranchReference.getOrCreate(repoPath, async (_cacheable, signal) => {
+			const commitOrdering = ordering;
+			let data;
+			let result;
+			try {
+				result = await this.git.run({
+					cwd: repoPath,
+					cancellation: signal,
+					errors: "throw"
+				}, "rev-parse", "--abbrev-ref", "--symbolic-full-name", "@", "@{u}", "--");
+				data = [result.stdout, void 0];
+			} catch (ex) {
+				if (isCancellationError(ex)) throw ex;
+				const msg = ex?.toString() ?? "";
+				if (GitErrors.badRevision.test(msg) || GitWarnings.noUpstream.test(msg)) {
+					if (ex.stdout != null && ex.stdout.length !== 0) data = [ex.stdout, void 0];
+					else {
+						try {
+							result = await this.git.run({
+								cwd: repoPath,
+								cancellation: signal
+							}, "symbolic-ref", "--short", "HEAD");
+							if (result.stdout) data = [result.stdout.trim(), void 0];
+						} catch {
+							if (isCancellationError(ex)) throw ex;
+						}
+						if (data == null) {
+							const symbolicRef = await this.getDefaultBranchName(repoPath, "origin", void 0, signal);
+							if (symbolicRef != null) data = [symbolicRef.startsWith("origin/") ? symbolicRef.substring(7) : symbolicRef, void 0];
+						}
+						if (data == null) {
+							const defaultBranch = await this.provider.config.getConfig(repoPath, "init.defaultBranch") ?? "main";
+							const configMap = await this.provider.config.getConfigRegex(repoPath, `branch\\.${defaultBranch}\\.+`, { runGitLocally: true });
+							const remote = configMap.get(`branch.${defaultBranch}.remote`);
+							const merge = configMap.get(`branch.${defaultBranch}.merge`);
+							const remoteBranch = merge?.startsWith("refs/heads/") ? merge.substring(11) : void 0;
+							data = [`${defaultBranch}${remote && remoteBranch ? `\n${remote}/${remoteBranch}` : ""}`, void 0];
+						}
+					}
+				} else if (GitWarnings.headNotABranch.test(msg)) {
+					result = await this.git.run({
+						cwd: repoPath,
+						cancellation: signal,
+						configs: gitConfigsLog,
+						errors: "ignore"
+					}, "log", "-n1", "--format=%H", commitOrdering ? `--${commitOrdering}-order` : void 0, "--");
+					if (result.completion.status === "cancelled" || signal?.aborted) throw new CancellationError();
+					const sha = result.stdout.trim();
+					if (sha) data = [`(HEAD detached at ${shortenRevision(sha)})`, sha];
+				} else _logger.warn(`[${repoPath}] Unable to get current branch: ${ex}`);
+			}
+			if (data == null) return void 0;
+			const [name, upstream] = data[0].split("\n");
+			return createReference(name, repoPath, {
+				refType: "branch",
+				name,
+				id: getBranchId(repoPath, false, name),
+				remote: false,
+				upstream: upstream ? {
+					name: upstream,
+					missing: false
+				} : void 0,
+				sha: data[1]
+			});
+		}, { cancellation });
+	}
+	async getDefaultBranchName(repoPath, remote, options, cancellation) {
+		if (repoPath == null) return void 0;
+		remote ??= "origin";
+		const priority = options?.priority;
+		const priorityOpts = priority != null ? { priority } : void 0;
+		if (options?.local) return this.cache.getDefaultBranchName(repoPath, `${remote}:local`, async (commonPath, cacheable, signal) => {
+			try {
+				return (await this.git.run({
+					cwd: commonPath,
+					cancellation: signal ?? cancellation,
+					...priorityOpts
+				}, "symbolic-ref", "--short", `refs/remotes/${remote}/HEAD`)).stdout.trim() || void 0;
+			} catch (ex) {
+				if (isCancellationError(ex)) throw ex;
+				if ((ex.stderr ?? "").includes("is not a symbolic ref")) return void 0;
+				cacheable.invalidate();
+				return;
+			}
+		}, cancellation);
+		return this.cache.getDefaultBranchName(repoPath, remote, async (commonPath, cacheable, signal) => {
+			let retried = false;
+			while (true) try {
+				return (await this.git.run({
+					cwd: commonPath,
+					cancellation: signal ?? cancellation,
+					...priorityOpts
+				}, "symbolic-ref", "--short", `refs/remotes/${remote}/HEAD`)).stdout.trim() || void 0;
+			} catch (ex) {
+				let answered = false;
+				if (/is not a symbolic ref/.test(ex.stderr)) try {
+					if (!retried) {
+						retried = true;
+						await this.git.run({
+							cwd: commonPath,
+							cancellation: signal ?? cancellation,
+							...priorityOpts
+						}, "remote", "set-head", "-a", remote);
+						this.cache.deleteDefaultBranchName(commonPath, `${remote}:local`);
+						continue;
+					}
+					const result = await this.git.run({
+						cwd: commonPath,
+						cancellation: signal ?? cancellation,
+						...priorityOpts
+					}, "ls-remote", "--symref", remote, "HEAD");
+					if (result.stdout) {
+						const match = /ref:\s(\S+)\s+HEAD/m.exec(result.stdout);
+						if (match != null) {
+							const [, branch] = match;
+							return `${remote}/${branch.substring(11).trim()}`;
+						}
+					}
+					answered = true;
+				} catch {
+					if (isCancellationError(ex)) throw ex;
+				}
+				if (!answered) cacheable.invalidate();
+				return;
+			}
+		}, cancellation);
+	}
+	async createBranch(repoPath, name, ref, options) {
+		const args = [
+			"branch",
+			name,
+			ref
+		];
+		if (options?.noTracking) args.push("--no-track");
+		try {
+			await this.git.run({ cwd: repoPath }, ...args);
+			this.cache.deleteBaseBranchName(repoPath, name);
+			this.context.hooks?.cache?.onReset?.(repoPath, "branches");
+			this.context.hooks?.repository?.onChanged?.(repoPath, ["heads"]);
+		} catch (ex) {
+			throw getGitCommandError("branch", ex, (reason) => new BranchError({
+				reason: reason ?? "other",
+				action: "create",
+				branch: name,
+				gitCommand: {
+					repoPath,
+					args
+				}
+			}, ex));
+		}
+	}
+	async deleteLocalBranch(repoPath, names, options) {
+		const branches = ensureArray(names);
+		const args = [
+			"branch",
+			options?.force ? "-D" : "-d",
+			...branches
+		];
+		try {
+			await this.git.run({ cwd: repoPath }, ...args);
+			for (const branch of branches) {
+				this.cache.deleteBaseBranchName(repoPath, branch);
+				await this.provider.config.removeGkConfigBranchSection(repoPath, branch);
+			}
+			this.context.hooks?.cache?.onReset?.(repoPath, "branches");
+			this.context.hooks?.repository?.onChanged?.(repoPath, ["heads"]);
+		} catch (ex) {
+			if (await this.cleanupDeletedBranchMetadata(repoPath, branches)) {
+				this.context.hooks?.cache?.onReset?.(repoPath, "branches");
+				this.context.hooks?.repository?.onChanged?.(repoPath, ["heads"]);
+			}
+			if (ex instanceof BranchError) throw ex.update({
+				action: options?.force ? "force delete" : "delete",
+				branch: branches.join(", "),
+				gitCommand: {
+					repoPath,
+					args
+				}
+			});
+			throw getGitCommandError("branch", ex, (reason) => new BranchError({
+				reason: reason ?? "other",
+				action: options?.force ? "force delete" : "delete",
+				branch: branches.join(", "),
+				gitCommand: {
+					repoPath,
+					args
+				}
+			}, ex));
+		}
+	}
+	/**
+	* Drops the cached and persisted per-branch metadata for whichever of `names` no longer exists. Only
+	* for the partial-failure path — one extra `for-each-ref` is cheap while already handling an error,
+	* and keeps the success path free of it.
+	*
+	* Returns whether any of `names` is confirmed gone; `false` when the probe couldn't answer, so a
+	* spurious notification is never fired on an unrelated failure.
+	*/
+	async cleanupDeletedBranchMetadata(repoPath, names) {
+		try {
+			const result = await this.git.run({
+				cwd: repoPath,
+				errors: "ignore"
+			}, "for-each-ref", "--format=%(refname)", ...names.map((n) => `refs/heads/${n}`));
+			if (result.completion.status !== "exited" || result.exitCode !== 0) return false;
+			const prefix = "refs/heads/";
+			const surviving = new Set(result.stdout.split("\n").map((l) => l.trim()).filter((l) => l.startsWith(prefix)).map((l) => l.substring(11)));
+			let anyDeleted = false;
+			for (const name of names) {
+				if (surviving.has(name)) continue;
+				anyDeleted = true;
+				this.cache.deleteBaseBranchName(repoPath, name);
+				await this.provider.config.removeGkConfigBranchSection(repoPath, name);
+			}
+			return anyDeleted;
+		} catch {
+			return false;
+		}
+	}
+	async deleteRemoteBranch(repoPath, names, remote) {
+		const branches = ensureArray(names);
+		const args = [
+			"push",
+			"-d",
+			remote,
+			...branches
+		];
+		try {
+			await this.git.run({ cwd: repoPath }, ...args);
+			this.context.hooks?.cache?.onReset?.(repoPath, "branches");
+			this.context.hooks?.repository?.onChanged?.(repoPath, ["remotes"]);
+		} catch (ex) {
+			if (ex instanceof BranchError) throw ex.update({
+				action: "delete",
+				branch: branches.join(", "),
+				gitCommand: {
+					repoPath,
+					args
+				}
+			});
+			throw getGitCommandError("push", ex, (reason) => new BranchError({
+				reason: reason === "rejectedRefDoesNotExist" ? "noRemoteReference" : "other",
+				action: "delete",
+				branch: branches.join(", "),
+				gitCommand: {
+					repoPath,
+					args
+				}
+			}, ex));
+		}
+	}
+	async getBranchMergedStatus(repoPath, branch, into, cancellation) {
+		if (branch.name === into.name || branch.upstream?.name === into.name) return { merged: false };
+		const localInto = into.remote ? await this.getLocalBranchByUpstream(repoPath, into.name, cancellation) : void 0;
+		const cacheKey = branch.sha != null && into.sha != null ? `${branch.remote ? "r" : "l"}:${branch.name}@${branch.sha}|${into.remote ? "r" : "l"}:${into.name}@${into.sha}${localInto?.sha != null ? `|L:${localInto.name}@${localInto.sha}` : ""}` : `${branch.remote ? "r" : "l"}:${branch.name}|${into.remote ? "r" : "l"}:${into.name}`;
+		return this.cache.getBranchMergedStatus(repoPath, cacheKey, async (commonPath, _cacheable, signal) => {
+			const result = await this.getBranchMergedStatusCore(commonPath, branch, into, signal);
+			if (result.merged) return result;
+			if (localInto != null && localInto.name !== branch.name) {
+				if (localInto.sha != null && localInto.sha === into.sha) return { merged: false };
+				const result = await this.getBranchMergedStatusCore(commonPath, branch, localInto, signal);
+				if (result.merged) return {
+					...result,
+					localBranchOnly: createReference(localInto.ref, commonPath, {
+						id: getBranchId(commonPath, localInto.remote, localInto.name),
+						refType: "branch",
+						name: localInto.name,
+						remote: localInto.remote,
+						upstream: localInto.upstream,
+						sha: localInto.sha
+					})
+				};
+			}
+			return { merged: false };
+		}, cancellation);
+	}
+	async getBranchMergedStatusCore(repoPath, branch, into, cancellation) {
+		const scope = getScopedLogger();
+		try {
+			try {
+				await this.git.run({
+					cwd: repoPath,
+					cancellation,
+					errors: "throw"
+				}, "merge-base", "--is-ancestor", branch.name, into.name);
+				return {
+					merged: true,
+					confidence: "highest"
+				};
+			} catch (ex) {
+				if (isCancellationError(ex)) throw ex;
+			}
+			let result = await this.git.run({
+				cwd: repoPath,
+				cancellation
+			}, "cherry", "--abbrev", "-v", into.name, branch.name);
+			if (!result.stdout || result.stdout.trim().split("\n").every((l) => l.startsWith("-"))) return {
+				merged: true,
+				confidence: "high"
+			};
+			const mergeBase = await this.provider.refs.getMergeBase(repoPath, into.name, branch.name, void 0, cancellation);
+			result = await this.git.run({
+				cwd: repoPath,
+				cancellation
+			}, "diff", mergeBase, branch.name);
+			if (result.stdout) try {
+				var _usingCtx3 = _usingCtx();
+				const { env } = _usingCtx3.a(await this.provider.staging.createTemporaryIndex(repoPath, "ref", into.name));
+				result = await this.git.run({
+					cwd: repoPath,
+					cancellation,
+					env,
+					errors: "ignore",
+					stdin: result.stdout
+				}, "apply", "--cached", "--reverse", "--check", "-");
+				if (result.exitCode === 0 && !result.stdout.trim() && !result.stderr?.trim()) return {
+					merged: true,
+					confidence: "medium"
+				};
+			} catch (_) {
+				_usingCtx3.e = _;
+			} finally {
+				await _usingCtx3.d();
+			}
+			return { merged: false };
+		} catch (ex) {
+			if (_logger.enabled("trace")) scope?.error(ex);
+			if (isCancellationError(ex)) throw ex;
+			return { merged: false };
+		}
+	}
+	async getLocalBranchByUpstream(repoPath, remoteBranchName, cancellation) {
+		const branches = new PageableResult((p) => this.getBranches(repoPath, p != null ? { paging: p } : void 0, cancellation));
+		return getLocalBranchByUpstream(remoteBranchName, branches);
+	}
+	/** Detects potential conflicts when applying commits onto a target branch (git rebase and cherry-pick) */
+	async getPotentialApplyConflicts(repoPath, targetBranch, shas, options, cancellation) {
+		if (!shas.length) return { status: "clean" };
+		const cacheKey = `apply:${targetBranch}:${shas.join(",")}:${options?.stopOnFirstConflict ?? false}`;
+		return this.cache.conflictDetection.getOrCreate(repoPath, cacheKey, async (_cacheable, signal) => {
+			const parentRefs = shas.map((c) => `${c}^`);
+			let parentShas;
+			try {
+				parentShas = (await this.git.run({
+					cwd: repoPath,
+					cancellation: signal,
+					errors: "throw"
+				}, "rev-parse", ...parentRefs)).stdout.trim().split("\n");
+			} catch (ex) {
+				if (isCancellationError(ex)) throw ex;
+				return createConflictDetectionError("noParent");
+			}
+			if (parentShas.length !== shas.length) return createConflictDetectionError("refNotFound");
+			const commitsWithParents = shas.map((c, i) => ({
+				sha: c,
+				parent: parentShas[i]
+			}));
+			return this.checkForPotentialConflicts(repoPath, commitsWithParents, targetBranch, signal, options);
+		}, { cancellation });
+	}
+	/** Detects potential conflict when merge a branch into a target branch (git merge) */
+	async getPotentialMergeConflicts(repoPath, branch, targetBranch, cancellation) {
+		const scope = getScopedLogger();
+		const cacheKey = `merge:${branch}:${targetBranch}`;
+		return this.cache.conflictDetection.getOrCreate(repoPath, cacheKey, async (_cacheable, signal) => {
+			if (!await this.git.supports("git:merge-tree:write-tree")) return createConflictDetectionError("unsupported");
+			let data;
+			try {
+				data = (await this.git.run({
+					cwd: repoPath,
+					cancellation: signal,
+					errors: "throw"
+				}, "merge-tree", "-z", "--name-only", "--no-messages", branch, targetBranch)).stdout;
+			} catch (ex) {
+				if (isCancellationError(ex)) throw ex;
+				const msg = ex?.toString() ?? "";
+				if (GitErrors.notAValidObjectName.test(msg)) {
+					scope?.error(ex, `'${targetBranch}' or '${branch}' not found - ensure the branches exist and are fully qualified (e.g. 'refs/heads/main')`);
+					return createConflictDetectionError("refNotFound");
+				} else if (GitErrors.badRevision.test(msg)) {
+					scope?.error(ex, `Invalid branch name: ${msg.slice(msg.indexOf("'"))}`);
+					return createConflictDetectionError("refNotFound");
+				} else if (GitErrors.noMergeBase.test(msg)) {
+					scope?.error(ex, `Unable to merge '${branch}' and '${targetBranch}' as they have no common ancestor`);
+					return createConflictDetectionError("noMergeBase");
+				} else if (ex instanceof GitError) data = ex.stdout;
+				else {
+					scope?.error(ex);
+					return createConflictDetectionError("other");
+				}
+			}
+			if (!data) return { status: "clean" };
+			const mergeConflict = parseMergeTreeConflict(data);
+			if (!mergeConflict.conflicts.length) return {
+				status: "clean",
+				treeOid: mergeConflict.treeOid
+			};
+			return {
+				status: "conflicts",
+				conflict: {
+					repoPath,
+					branch,
+					target: targetBranch,
+					files: mergeConflict.conflicts,
+					shas: void 0
+				},
+				treeOid: mergeConflict.treeOid
+			};
+		}, { cancellation });
+	}
+	/** Detects conflicts when an autostash is reapplied onto the tree an integration produced */
+	async getPotentialStashReapplyConflicts(repoPath, ontoTreeOid, cancellation) {
+		if (!await this.git.supports("git:merge-tree:merge-base")) return createConflictDetectionError("unsupported");
+		let stashSha;
+		try {
+			stashSha = (await this.git.run({
+				cwd: repoPath,
+				cancellation,
+				errors: "throw"
+			}, "stash", "create")).stdout.trim();
+		} catch (ex) {
+			if (isCancellationError(ex)) throw ex;
+			return createConflictDetectionError("other");
+		}
+		if (!stashSha) return { status: "clean" };
+		let stashTree;
+		let stashParent;
+		try {
+			const result = await this.git.run({
+				cwd: repoPath,
+				cancellation,
+				errors: "throw"
+			}, "rev-parse", `${stashSha}^{tree}`, `${stashSha}^`);
+			[stashTree, stashParent] = result.stdout.trim().split("\n");
+		} catch (ex) {
+			if (isCancellationError(ex)) throw ex;
+			return createConflictDetectionError("other");
+		}
+		const cacheKey = `reapply:${ontoTreeOid}:${stashTree}.${stashParent}`;
+		return this.cache.conflictDetection.getOrCreate(repoPath, cacheKey, async (_cacheable, signal) => {
+			const step = await this.runMergeTreeStep(repoPath, `${stashSha}^`, ontoTreeOid, stashSha, signal);
+			if (!step.ok) return createConflictDetectionError(step.reason);
+			if (!step.result.conflicts.length) return {
+				status: "clean",
+				treeOid: step.result.treeOid
+			};
+			return {
+				status: "conflicts",
+				conflict: {
+					repoPath,
+					branch: stashSha,
+					target: ontoTreeOid,
+					files: step.result.conflicts,
+					shas: void 0
+				},
+				treeOid: step.result.treeOid
+			};
+		}, { cancellation });
+	}
+	async runMergeTreeStep(repoPath, base, ours, theirs, cancellation) {
+		const scope = getScopedLogger();
+		let data;
+		try {
+			data = (await this.git.run({
+				cwd: repoPath,
+				cancellation,
+				errors: "throw"
+			}, "merge-tree", "--write-tree", "-z", "--name-only", "--no-messages", `--merge-base=${base}`, ours, theirs)).stdout;
+		} catch (ex) {
+			if (isCancellationError(ex)) throw ex;
+			const msg = ex?.toString() ?? "";
+			if (GitErrors.notAValidObjectName.test(msg)) {
+				scope?.error(ex, `'${ours}' or '${theirs}' not found - ensure the branches/commits exist`);
+				return {
+					ok: false,
+					reason: "refNotFound"
+				};
+			} else if (GitErrors.badRevision.test(msg)) {
+				scope?.error(ex, `Invalid revision: ${msg.slice(msg.indexOf("'"))}`);
+				return {
+					ok: false,
+					reason: "refNotFound"
+				};
+			} else if (GitErrors.noMergeBase.test(msg)) {
+				scope?.error(ex, `Unable to merge '${ours}' and '${theirs}' as they have no common ancestor`);
+				return {
+					ok: false,
+					reason: "noMergeBase"
+				};
+			} else if (ex instanceof GitError) data = ex.stdout;
+			else {
+				scope?.error(ex, "Failed to execute merge-tree for conflict check");
+				return {
+					ok: false,
+					reason: "other"
+				};
+			}
+		}
+		return {
+			ok: true,
+			result: parseMergeTreeConflict(data ?? "")
+		};
+	}
+	async checkForPotentialConflicts(repoPath, commits, targetBranch, cancellation, options) {
+		const scope = getScopedLogger();
+		if (!await this.git.supports("git:merge-tree:merge-base")) return createConflictDetectionError("unsupported");
+		let currentTreeOid;
+		try {
+			currentTreeOid = (await this.git.run({
+				cwd: repoPath,
+				cancellation,
+				errors: "throw"
+			}, "rev-parse", `${targetBranch}^{tree}`)).stdout.trim();
+		} catch (ex) {
+			if (isCancellationError(ex)) throw ex;
+			scope?.error(ex, `Failed to resolve target branch '${targetBranch}'`);
+			return createConflictDetectionError("refNotFound");
+		}
+		const conflictingShas = [];
+		const conflictingFilePaths = /* @__PURE__ */ new Set();
+		for (const commit of commits) {
+			if (cancellation?.aborted) throw new CancellationError();
+			const step = await this.runMergeTreeStep(repoPath, commit.parent, currentTreeOid, commit.sha, cancellation);
+			if (!step.ok) return createConflictDetectionError(step.reason);
+			const mergeConflict = step.result;
+			if (mergeConflict.conflicts.length) {
+				conflictingShas.push(commit.sha);
+				for (const file of mergeConflict.conflicts) conflictingFilePaths.add(file.path);
+				if (options?.stopOnFirstConflict) return {
+					status: "conflicts",
+					conflict: {
+						repoPath,
+						branch: commit.sha,
+						target: targetBranch,
+						files: mergeConflict.conflicts,
+						shas: [commit.sha]
+					},
+					stoppedOnFirstConflict: true,
+					treeOid: mergeConflict.treeOid || void 0
+				};
+			}
+			if (mergeConflict.treeOid) currentTreeOid = mergeConflict.treeOid;
+		}
+		if (conflictingShas.length) return {
+			status: "conflicts",
+			conflict: {
+				repoPath,
+				branch: conflictingShas[0],
+				target: targetBranch,
+				files: Array.from(conflictingFilePaths, (path) => ({ path })),
+				shas: conflictingShas
+			},
+			stoppedOnFirstConflict: false,
+			treeOid: currentTreeOid
+		};
+		return {
+			status: "clean",
+			treeOid: currentTreeOid
+		};
+	}
+	getBaseBranchName(repoPath, ref, options, cancellation) {
+		const priority = options?.priority;
+		const priorityOpts = priority != null ? { priority } : void 0;
+		return this.cache.getBaseBranchName(repoPath, ref, async (commonPath, cacheable, signal) => {
+			try {
+				let mergeBase = await this.provider.config.getGkConfig(commonPath, `branch.${ref}.gk-merge-base`);
+				let update = false;
+				if (mergeBase == null) {
+					mergeBase = await this.provider.config.getConfig(commonPath, `branch.${ref}.vscode-merge-base`);
+					update = mergeBase != null;
+				}
+				if (mergeBase != null) {
+					const branch = await this.provider.refs.getSymbolicReferenceName(commonPath, mergeBase, priorityOpts);
+					if (branch != null) {
+						if (update) this.storeBaseBranchName(commonPath, ref, branch, { skipInvalidation: ["branchOverviews", "baseBranchName"] });
+						return branch;
+					}
+				}
+			} catch {}
+			const reflog = await this.getBaseBranchFromReflog(commonPath, ref, {
+				upstream: true,
+				priority
+			}, signal);
+			if (reflog.branch != null) {
+				this.storeBaseBranchName(commonPath, ref, reflog.branch, { skipInvalidation: ["branchOverviews", "baseBranchName"] });
+				return reflog.branch;
+			}
+			if (reflog.failed) cacheable.invalidate();
+		}, cancellation);
+	}
+	/**
+	* `failed` separates "the reflog ran and had no answer" from "the read never happened" — the caller
+	* caches the former forever and must not cache the latter.
+	*/
+	async getBaseBranchFromReflog(repoPath, ref, options, cancellation) {
+		const priority = options?.priority;
+		const priorityOpts = priority != null ? { priority } : void 0;
+		try {
+			let result = await this.git.run({
+				cwd: repoPath,
+				cancellation,
+				...priorityOpts
+			}, "reflog", ref, "--grep-reflog=branch: Created from *.");
+			let entries = result.stdout.split("\n").filter((entry) => Boolean(entry));
+			if (entries.length !== 1) return {
+				branch: void 0,
+				failed: false
+			};
+			let match = entries[0].match(/branch: Created from (.*)$/);
+			if (match?.length === 2) {
+				let name = match[1];
+				if (name !== "HEAD") {
+					if (options?.upstream) {
+						const upstream = await this.provider.refs.getSymbolicReferenceName(repoPath, `${name}@{u}`, priorityOpts);
+						if (upstream) return {
+							branch: upstream,
+							failed: false
+						};
+					}
+					name = await this.provider.refs.getSymbolicReferenceName(repoPath, name, priorityOpts);
+					if (name) return {
+						branch: name,
+						failed: false
+					};
+				}
+			}
+			result = await this.git.run({
+				cwd: repoPath,
+				cancellation,
+				...priorityOpts
+			}, "reflog", "HEAD", `--grep-reflog=checkout: moving from .* to ${ref.replace("refs/heads/", "")}`);
+			entries = result.stdout.split("\n").filter((entry) => Boolean(entry));
+			if (!entries.length) return {
+				branch: void 0,
+				failed: false
+			};
+			match = entries.at(-1).match(/checkout: moving from ([^\s]+)\s/);
+			if (match?.length === 2) {
+				let name = match[1];
+				if (options?.upstream) {
+					const upstream = await this.provider.refs.getSymbolicReferenceName(repoPath, `${name}@{u}`, priorityOpts);
+					if (upstream) return {
+						branch: upstream,
+						failed: false
+					};
+				}
+				name = await this.provider.refs.getSymbolicReferenceName(repoPath, name, priorityOpts);
+				if (name) return {
+					branch: name,
+					failed: false
+				};
+			}
+		} catch (ex) {
+			if (isCancellationError(ex)) throw ex;
+			return {
+				branch: void 0,
+				failed: true
+			};
+		}
+		return {
+			branch: void 0,
+			failed: false
+		};
+	}
+	async getStoredMergeTargetBranchName(repoPath, ref) {
+		return (await this.getStoredUserMergeTargetBranchName?.(repoPath, ref) ?? await this.getStoredDetectedMergeTargetBranchName?.(repoPath, ref))?.trim() || void 0;
+	}
+	async getStoredDetectedMergeTargetBranchName(repoPath, ref) {
+		return (await this.provider.config.getGkConfig(repoPath, `branch.${ref}.gk-merge-target`) ?? await this.provider.config.getGkConfig(repoPath, `branch.${ref}.gk-target-base`))?.trim() || void 0;
+	}
+	async getStoredUserMergeTargetBranchName(repoPath, ref) {
+		return (await this.provider.config.getGkConfig(repoPath, `branch.${ref}.gk-merge-target-user`))?.trim() || void 0;
+	}
+	/** Updates the last accessed timestamp for the current branch */
+	async onCurrentBranchAccessed(repoPath) {
+		const branch = await this.getBranch(repoPath);
+		if (branch == null || branch.remote || branch.detached) return;
+		await this.storeBranchMetadata(repoPath, "gk-last-accessed", branch.name, /* @__PURE__ */ new Date());
+	}
+	/** Updates the last accessed and modified timestamp for the current branch */
+	async onCurrentBranchModified(repoPath) {
+		const branch = await this.getBranch(repoPath);
+		if (branch == null || branch.remote || branch.detached) return;
+		const now = /* @__PURE__ */ new Date();
+		await this.storeBranchMetadata(repoPath, "gk-last-accessed", branch.name, now);
+		await this.storeBranchMetadata(repoPath, "gk-last-modified", branch.name, now);
+	}
+	/** Updates the agent last activity timestamp for the current branch */
+	async onCurrentBranchAgentActivity(repoPath) {
+		const branch = await this.getBranch(repoPath);
+		if (branch == null || branch.remote || branch.detached) return;
+		await this.storeBranchMetadata(repoPath, "gk-agent-last-activity", branch.name, /* @__PURE__ */ new Date());
+	}
+	async renameBranch(repoPath, oldName, newName) {
+		const args = [
+			"branch",
+			"-m",
+			oldName,
+			newName
+		];
+		try {
+			await this.git.run({ cwd: repoPath }, ...args);
+			await this.provider.config.renameGkConfigBranchSection(repoPath, oldName, newName);
+			this.cache.deleteBaseBranchName(repoPath, oldName);
+			this.cache.deleteBaseBranchName(repoPath, newName);
+			this.context.hooks?.cache?.onReset?.(repoPath, "branches");
+			this.context.hooks?.repository?.onChanged?.(repoPath, ["heads"]);
+		} catch (ex) {
+			throw getGitCommandError("branch", ex, (reason) => new BranchError({
+				reason: reason ?? "other",
+				action: "rename",
+				branch: oldName,
+				gitCommand: {
+					repoPath,
+					args
+				}
+			}, ex));
+		}
+	}
+	async setUpstreamBranch(repoPath, name, upstream) {
+		const args = upstream == null ? [
+			"branch",
+			"--unset-upstream",
+			name
+		] : [
+			"branch",
+			"--set-upstream-to",
+			upstream,
+			name
+		];
+		try {
+			await this.git.run({ cwd: repoPath }, ...args);
+			this.context.hooks?.cache?.onReset?.(repoPath, "branches");
+			this.context.hooks?.repository?.onChanged?.(repoPath, ["heads"]);
+		} catch (ex) {
+			throw getGitCommandError("branch", ex, (reason) => new BranchError({
+				reason: reason ?? "other",
+				action: upstream == null ? "unset upstream of" : `set upstream to '${upstream}' for`,
+				branch: name,
+				gitCommand: {
+					repoPath,
+					args
+				}
+			}, ex));
+		}
+	}
+	async storeBaseBranchName(repoPath, ref, base, options) {
+		await this.provider.config.setGkConfig(repoPath, `branch.${ref}.gk-merge-base`, base, options);
+	}
+	async storeMergeTargetBranchName(repoPath, ref, target, options) {
+		await this.provider.config.setGkConfig(repoPath, `branch.${ref}.gk-merge-target`, target, options);
+	}
+	async storeUserMergeTargetBranchName(repoPath, ref, target) {
+		await this.provider.config.setGkConfig(repoPath, `branch.${ref}.gk-merge-target-user`, target);
+	}
+	/**
+	* Gets all branch metadata (dates and disposition) from git config in a single batch operation.
+	* @returns A map of branch name to metadata.
+	*/
+	getBranchMetadataMap(repoPath) {
+		return this.cache.getBranchMetadataMap(repoPath, async (commonPath) => {
+			const scope = getScopedLogger();
+			const metadataMap = /* @__PURE__ */ new Map();
+			try {
+				const configMap = await this.provider.config.getGkConfigRegex(commonPath, "^branch\\..*\\.gk-(last-(accessed|modified)|disposition|agent-last-activity)$");
+				if (!configMap.size) return metadataMap;
+				for (const [key, value] of configMap) {
+					if (!key.startsWith("branch.")) continue;
+					const keyParts = key.split(".");
+					if (keyParts.length < 3) continue;
+					const metaKey = keyParts.at(-1);
+					const branchName = keyParts.slice(1, -1).join(".");
+					let metadata = metadataMap.get(branchName);
+					if (metadata == null) {
+						metadata = {};
+						metadataMap.set(branchName, metadata);
+					}
+					if (metaKey === "gk-last-accessed") metadata.lastAccessedAt = value;
+					else if (metaKey === "gk-last-modified") metadata.lastModifiedAt = value;
+					else if (metaKey === "gk-agent-last-activity") metadata.agentLastActivityAt = value;
+					else if (metaKey === "gk-disposition") {
+						if (value === "starred" || value === "archived") metadata.disposition = value;
+					}
+				}
+			} catch (ex) {
+				debugger;
+				scope?.error(ex);
+			}
+			return metadataMap;
+		});
+	}
+	async storeBranchMetadata(repoPath, key, ref, date) {
+		const value = await this.provider.config.getGkConfig(repoPath, `branch.${ref}.${key}`);
+		if (value != null && date.getTime() - new Date(value).getTime() < dateMetadataStaleThresholdMs) return;
+		return this.provider.config.setGkConfig(repoPath, `branch.${ref}.${key}`, date.toISOString());
+	}
+	async setBranchDisposition(repoPath, branchName, disposition) {
+		await this.provider.config.setGkConfig(repoPath, `branch.${branchName}.gk-disposition`, disposition);
+		this.context.hooks?.cache?.onReset?.(repoPath, "branches");
+		this.context.hooks?.repository?.onChanged?.(repoPath, ["starred"]);
+	}
+};
+__decorate([debug()], BranchesGitSubProvider.prototype, "getBranch", null);
+__decorate([debug({ args: (repoPath) => ({ repoPath }) })], BranchesGitSubProvider.prototype, "getBranches", null);
+__decorate([debug()], BranchesGitSubProvider.prototype, "getBranchContributionsOverview", null);
+__decorate([debug()], BranchesGitSubProvider.prototype, "getBranchesWithCommits", null);
+__decorate([debug()], BranchesGitSubProvider.prototype, "getCurrentBranchReference", null);
+__decorate([debug({ exit: true })], BranchesGitSubProvider.prototype, "getDefaultBranchName", null);
+__decorate([debug()], BranchesGitSubProvider.prototype, "createBranch", null);
+__decorate([debug()], BranchesGitSubProvider.prototype, "deleteLocalBranch", null);
+__decorate([debug()], BranchesGitSubProvider.prototype, "deleteRemoteBranch", null);
+__decorate([debug()], BranchesGitSubProvider.prototype, "getBranchMergedStatus", null);
+__decorate([debug()], BranchesGitSubProvider.prototype, "getLocalBranchByUpstream", null);
+__decorate([debug()], BranchesGitSubProvider.prototype, "getPotentialApplyConflicts", null);
+__decorate([debug()], BranchesGitSubProvider.prototype, "getPotentialMergeConflicts", null);
+__decorate([debug()], BranchesGitSubProvider.prototype, "getPotentialStashReapplyConflicts", null);
+__decorate([debug({ exit: true })], BranchesGitSubProvider.prototype, "getBaseBranchName", null);
+__decorate([debug({ exit: true })], BranchesGitSubProvider.prototype, "getStoredMergeTargetBranchName", null);
+__decorate([debug({ exit: true })], BranchesGitSubProvider.prototype, "getStoredDetectedMergeTargetBranchName", null);
+__decorate([debug()], BranchesGitSubProvider.prototype, "getStoredUserMergeTargetBranchName", null);
+__decorate([debounce(15e4), debug()], BranchesGitSubProvider.prototype, "onCurrentBranchAccessed", null);
+__decorate([debounce(15e4), debug()], BranchesGitSubProvider.prototype, "onCurrentBranchModified", null);
+__decorate([debounce(15e4), debug()], BranchesGitSubProvider.prototype, "onCurrentBranchAgentActivity", null);
+__decorate([debug()], BranchesGitSubProvider.prototype, "renameBranch", null);
+__decorate([debug()], BranchesGitSubProvider.prototype, "setUpstreamBranch", null);
+__decorate([debug()], BranchesGitSubProvider.prototype, "storeBaseBranchName", null);
+__decorate([debug()], BranchesGitSubProvider.prototype, "storeMergeTargetBranchName", null);
+__decorate([debug()], BranchesGitSubProvider.prototype, "storeUserMergeTargetBranchName", null);
+//#endregion
+export { BranchesGitSubProvider };
+
 //# sourceMappingURL=branches.js.map