@gitkraken/core-gitlens 0.6.0 → 0.7.1

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

@@ -1,457 +1,336 @@
-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 { GitFileWorkingTreeStatus } from '../../git/models/fileStatus.js';
-import { GitStatus } from '../../git/models/status.js';
-import { isCancellationError, raceWithTimeout } from '../../utils/cancellation.js';
-import { debug } from '../../utils/decorators/log.js';
-import { createDisposable } from '../../utils/disposable.js';
-import { getScopedLogger } from '../../utils/logger.scoped.js';
-import { normalizePath, splitPath, stripFolderGlob } from '../../utils/path.js';
-import { getSettledValue } from '../../utils/promise.js';
-import { PromiseMap } from '../../utils/promiseCache.js';
-import { iterateByDelimiter } from '../../utils/string.js';
-import { fileUri, joinUriPath, toFsPath } from '../../utils/uri.js';
-import { gitConfigsStatus } from '../exec/git.js';
-import { parseGitConflictFiles } from '../parsers/indexParser.js';
-import { parseGitStatus } from '../parsers/statusParser.js';
+import { isCancellationError, raceWithTimeout } from "../../utils/cancellation.js";
+import { iterateByDelimiter } from "../../utils/string.js";
+import { getScopedLogger } from "../../utils/logger.scoped.js";
+import { getSettledValue } from "../../utils/promise.js";
+import { debug } from "../../utils/decorators/log.js";
+import { fileUri, joinUriPath, toFsPath } from "../../utils/uri.js";
+import { normalizePath, splitPath, stripFolderGlob } from "../../utils/path.js";
+import { PromiseMap } from "../../utils/promiseCache.js";
+import __decorate from "../../_virtual/@oxc-project+runtime/helpers/esm/decorate.js";
+import { createDisposable } from "../../utils/disposable.js";
+import { gitConfigsStatus } from "../exec/git.js";
+import { GitFileWorkingTreeStatus } from "../../git/models/fileStatus.js";
+import _usingCtx from "../../_virtual/@oxc-project+runtime/helpers/esm/usingCtx.js";
+import { parseGitConflictFiles } from "../parsers/indexParser.js";
+import { GitStatus } from "../../git/models/status.js";
+import { parseGitStatus } from "../parsers/statusParser.js";
+//#region ../git-cli/src/providers/status.ts
 /** Backstop when `advanced.git.timeout` is disabled (0). Independent of the command timeout so disabling it can't
- *  also disable deadlock recovery — mirrors `@gate`'s always-on 5-min force-clear. */
-const disabledTimeoutBackstopMs = 1000 * 60 * 5;
+*  also disable deadlock recovery — mirrors `@gate`'s always-on 5-min force-clear. */
+const disabledTimeoutBackstopMs = 3e5;
 /**
- * Deadlock-backstop duration for a status read (see `dedupeByStatusGeneration`), exported for testing.
- * Always returns a value so a wedged read recovers even with `advanced.git.timeout` disabled (which bounds git
- * *commands*, not deadlock recovery). With a timeout set, `gitTimeout * 2` sits above the per-command timeout so
- * `git.run` reads reject at their own timeout first; the backstop's real job is bounding the timeout-less
- * `git.stream` reads (`hasUntrackedFiles`/`hasConflictingFiles`).
- */
-export function computeDeadlockBackstopMs(gitTimeout) {
-    const timeout = gitTimeout ?? 60000;
-    return timeout > 0 ? timeout * 2 : disabledTimeoutBackstopMs;
+* Deadlock-backstop duration for a status read (see `dedupeByStatusGeneration`), exported for testing.
+* Always returns a value so a wedged read recovers even with `advanced.git.timeout` disabled (which bounds git
+* *commands*, not deadlock recovery). With a timeout set, `gitTimeout * 2` sits above the per-command timeout so
+* `git.run` reads reject at their own timeout first; the backstop's real job is bounding the timeout-less
+* `git.stream` reads (`hasUntrackedFiles`/`hasConflictingFiles`).
+*/
+function computeDeadlockBackstopMs(gitTimeout) {
+	const timeout = gitTimeout ?? 6e4;
+	return timeout > 0 ? timeout * 2 : disabledTimeoutBackstopMs;
 }
-export class StatusGitSubProvider {
-    context;
-    git;
-    cache;
-    provider;
-    constructor(context, git, cache, provider) {
-        this.context = context;
-        this.git = git;
-        this.cache = cache;
-        this.provider = provider;
-    }
-    /** In-flight reads, keyed by `<read>\0<repoPath>\0<generation>`. `PromiseMap` (not a bare Map) so joiners
-     *  get per-caller cancellation: the shared run aborts only when ALL current callers do. */
-    _pendingReads = new PromiseMap();
-    /**
-     * Single-flight for point-in-time reads of mutable working-tree state — replaces `@gate`, which dedups on
-     * repoPath with no notion of *when* a run started and so joins a pre-change read to a post-change caller
-     * (see {@link Cache.getStatusGeneration}). Same-generation callers share one run (via a `PromiseMap`, so a
-     * joiner cancelling can't reject the others); a caller in a newer generation gets a different key and a
-     * fresh run; a `force` read advances the clock first, so it fences every later reader too, not just itself.
-     * The exec-layer command dedup (`Git.pendingCommands`) is fenced automatically: each run carries this entry's
-     * aggregate signal, whose id is part of the exec cache key, so a newer-generation run never joins an older
-     * one's process; the generation-derived `correlationKey` is a readable second guard on that key. A `raceWithTimeout` backstop (scaled to `advanced.git.timeout`, see
-     * {@link computeDeadlockBackstopMs}) replaces `@gate`'s 5-min force-clear so a never-settling read (a hung
-     * `git.stream`, which has no per-command timeout) can't wedge same-generation callers — including blocking
-     * awaiters like the commit flow — indefinitely.
-     */
-    dedupeByStatusGeneration(repoPath, read, run, cancellation, force) {
-        // A `force` (user refresh) read is the user asserting the working tree may have changed without the watcher
-        // observing it — the same class of event as a watcher tick, so it ADVANCES the clock rather than carving out
-        // a private key for itself. A one-shot nonce would fence only this caller: the pre-assertion run stays
-        // joinable, so the very next ordinary reader still picks up pre-change content — and, stamped with a newer
-        // `Wip.revision` (assigned at producer start, not read start), applies it right back over the refreshed
-        // result. Advancing is also CHEAPER than a nonce: concurrent readers join the one fresh read instead of each
-        // spawning a private one.
-        if (force) {
-            this.cache.incrementStatusGeneration(repoPath);
-        }
-        const generation = this.cache.getStatusGeneration(repoPath);
-        // `\0` separators: `read`/`repoPath` are free-form (paths can contain `:`), so a printable delimiter could
-        // collide (`getStatusForPath:/a:x` vs `getStatusForPath:/a` + `:x`).
-        const key = `${read}\0${repoPath}\0${generation}`;
-        const correlationKey = `status:${generation}`;
-        const backstopMs = computeDeadlockBackstopMs(this.git.options.gitTimeout);
-        return this._pendingReads.getOrCreate(key, (cacheable, signal) => {
-            // Point-in-time read: never memoize a settled value. `invalidate()` at the start makes the entry
-            // self-evict on settle, so a later caller in this same generation re-reads (a newer generation
-            // already gets a different key). `signal` is the aggregate — the run aborts only if every caller
-            // cancels, so one caller's abort can't reject the others. The backstop rejects a wedged read so
-            // waiters unblock and the entry self-evicts; it ALSO aborts the underlying git op (via `backstop`
-            // linked into the run's signal) so a wedged read releases its GitQueue slot/process rather than
-            // running orphaned — best-effort, since a truly-stuck process may ignore the abort.
-            cacheable.invalidate();
-            const backstop = new AbortController();
-            const runSignal = signal != null ? AbortSignal.any([signal, backstop.signal]) : backstop.signal;
-            return raceWithTimeout(run(correlationKey, runSignal), backstopMs, backstop);
-        }, cancellation);
-    }
-    getStatus(repoPath, options, cancellation) {
-        if (repoPath == null)
-            return Promise.resolve(undefined);
-        return this.dedupeByStatusGeneration(repoPath, 'getStatus', (correlationKey, signal) => this.getStatusCore(repoPath, { ...options, correlationKey: correlationKey }, signal), cancellation, options?.force);
-    }
-    async getStatusCore(repoPath, options, cancellation) {
-        const porcelainVersion = (await this.git.supports('git:status:porcelain-v2')) ? 2 : 1;
-        const result = await this.statusCore(repoPath, porcelainVersion, {
-            similarityThreshold: this.context.config?.commits.similarityThreshold,
-            priority: options?.priority,
-            correlationKey: options?.correlationKey,
-        }, cancellation);
-        const repoUri = fileUri(normalizePath(repoPath));
-        const status = parseGitStatus(result.stdout, repoPath, porcelainVersion, p => joinUriPath(repoUri, normalizePath(p)));
-        if (status?.detached) {
-            const pausedOpStatus = await this.provider.pausedOps?.getPausedOperationStatus?.(repoPath, undefined, cancellation);
-            if (pausedOpStatus?.type === 'rebase') {
-                return new GitStatus(repoPath, pausedOpStatus.incoming.name, status.sha, status.files, status.upstream, true);
-            }
-        }
-        return status;
-    }
-    async getStatusForFile(repoPath, pathOrUri, options, cancellation) {
-        const files = await this.getStatusForPathCore(repoPath, toFsPath(pathOrUri), { ...options, exact: true }, cancellation);
-        return files?.[0];
-    }
-    async getStatusForPath(repoPath, pathOrUri, options, cancellation) {
-        return this.getStatusForPathCore(repoPath, toFsPath(pathOrUri), { ...options, exact: false }, cancellation);
-    }
-    async getStatusForPathCore(repoPath, pathOrUri, options, cancellation) {
-        const relativePath = stripFolderGlob(splitPath(pathOrUri, repoPath)[0]);
-        // Rename-aware queries can't scope by pathspec (that disables Git's rename detection), so they run the
-        // SAME full `git status` as `getStatus`. Delegate to it — sharing one process/dedup entry — and filter,
-        // rather than spawning a second identical `git status`.
-        if (options.renames !== false) {
-            const status = await this.getStatus(repoPath, undefined, cancellation);
-            if (status == null)
-                return undefined;
-            if (options.exact) {
-                const file = status.files.find(f => f.path === relativePath);
-                return file ? [file] : undefined;
-            }
-            return status.files.filter(f => f.path.startsWith(relativePath));
-        }
-        // Non-rename query: pathspec-scoped `git status` (a distinct command), deduped on its own key. `exact`
-        // is NOT in the key — the pathspec-scoped command is identical for exact/non-exact, so both share one run.
-        return this.dedupeByStatusGeneration(repoPath, 
-        // Free-form `relativePath` (may contain `:`) goes LAST so the prefix can't be shifted into it.
-        `getStatusForPath:${relativePath}`, (correlationKey, signal) => this.getStatusForPathScoped(repoPath, relativePath, correlationKey, signal), cancellation);
-    }
-    async getStatusForPathScoped(repoPath, relativePath, correlationKey, cancellation) {
-        const porcelainVersion = (await this.git.supports('git:status:porcelain-v2')) ? 2 : 1;
-        const result = await this.statusCore(repoPath, porcelainVersion, { similarityThreshold: this.context.config?.commits.similarityThreshold, correlationKey: correlationKey }, cancellation, relativePath);
-        const repoUri = fileUri(normalizePath(repoPath));
-        const status = parseGitStatus(result.stdout, repoPath, porcelainVersion, p => joinUriPath(repoUri, normalizePath(p)));
-        return status?.files;
-    }
-    async statusCore(repoPath, porcelainVersion = 1, options, cancellation, ...pathspecs) {
-        const params = [
-            'status',
-            porcelainVersion >= 2 ? `--porcelain=v${porcelainVersion}` : '--porcelain',
-            '--branch',
-            '-u',
-        ];
-        if (await this.git.supports('git:status:find-renames')) {
-            params.push(`--find-renames${options?.similarityThreshold == null ? '' : `=${options.similarityThreshold}%`}`);
-        }
-        return this.git.run({
-            cwd: repoPath,
-            cancellation: cancellation,
-            configs: gitConfigsStatus,
-            env: { GIT_OPTIONAL_LOCKS: '0' },
-            correlationKey: options?.correlationKey,
-            ...(options?.priority != null ? { priority: options.priority } : undefined),
-        }, ...params, '--', ...pathspecs);
-    }
-    hasWorkingChanges(repoPath, options, cancellation) {
-        const scope = getScopedLogger();
-        const staged = options?.staged ?? true;
-        const unstaged = options?.unstaged ?? true;
-        const untracked = options?.untracked ?? true;
-        // `throwOnError` is in the key because it changes the RESULT on git failure (throw vs `false`) — a
-        // throwing caller must not join, and be silently satisfied by, a non-throwing caller's graceful run.
-        // `priority` is in the key for a different reason: it doesn't change the answer, but a joiner INHERITS
-        // the in-flight run's scheduling. `GitQueue` refuses to start background work while anything is
-        // waiting at normal/interactive, so letting a foreground caller (the overview's dirty pill, the
-        // Worktrees view) join a `background` probe would strand it for the whole graph load. Splitting the
-        // two lanes costs at most one extra spawn; joining costs unbounded foreground latency.
-        const throwOnError = options?.throwOnError ?? false;
-        const priority = options?.priority ?? 'default';
-        return this.dedupeByStatusGeneration(repoPath, `hasWorkingChanges:${staged}:${unstaged}:${untracked}:${throwOnError}:${priority}`, async (correlationKey, signal) => {
-            try {
-                if (staged || unstaged) {
-                    const result = await this.git.run({
-                        cwd: repoPath,
-                        cancellation: signal,
-                        errors: 'ignore',
-                        correlationKey: correlationKey,
-                        ...(options?.priority != null ? { priority: options.priority } : undefined),
-                    }, 'diff', '--quiet', staged && unstaged ? 'HEAD' : staged ? '--staged' : undefined);
-                    if (result.exitCode === 1) {
-                        if (staged && unstaged) {
-                            scope?.addExitInfo('has staged and unstaged changes');
-                        }
-                        else if (staged) {
-                            scope?.addExitInfo('has staged changes');
-                        }
-                        else {
-                            scope?.addExitInfo('has unstaged changes');
-                        }
-                        return true;
-                    }
-                }
-                // Check for untracked files. NOTE: this runs through `git.stream`, which spawns directly
-                // and never enters the queue — so `priority` above doesn't reach it. Only clean worktrees
-                // get this far (a dirty one already returned above), and callers fanning out across many
-                // worktrees are expected to bound their own concurrency.
-                if (untracked) {
-                    const hasUntracked = await this.hasUntrackedFiles(repoPath, signal);
-                    if (hasUntracked) {
-                        scope?.addExitInfo('has untracked files');
-                        return true;
-                    }
-                }
-                scope?.addExitInfo('no working changes');
-                return false;
-            }
-            catch (ex) {
-                // Re-throw cancellation errors
-                if (isCancellationError(ex))
-                    throw ex;
-                // Log other errors and return false for graceful degradation
-                scope?.error(ex);
-                scope?.addExitInfo('error checking for changes');
-                if (throwOnError)
-                    throw ex;
-                return false;
-            }
-        }, cancellation);
-    }
-    getWorkingChangesState(repoPath, cancellation) {
-        const scope = getScopedLogger();
-        return this.dedupeByStatusGeneration(repoPath, 'getWorkingChangesState', async (correlationKey, signal) => {
-            try {
-                const [stagedResult, unstagedResult, untrackedResult] = await Promise.allSettled([
-                    // Check for staged changes
-                    this.git.run({ cwd: repoPath, cancellation: signal, errors: 'ignore', correlationKey: correlationKey }, 'diff', '--quiet', '--staged'),
-                    // Check for unstaged changes
-                    this.git.run({ cwd: repoPath, cancellation: signal, errors: 'ignore', correlationKey: correlationKey }, 'diff', '--quiet'),
-                    // Check for untracked files
-                    this.hasUntrackedFiles(repoPath, signal),
-                ]);
-                const result = {
-                    staged: getSettledValue(stagedResult)?.exitCode === 1,
-                    unstaged: getSettledValue(unstagedResult)?.exitCode === 1,
-                    untracked: getSettledValue(untrackedResult) === true,
-                };
-                scope?.addExitInfo(result.staged || result.unstaged || result.untracked
-                    ? `has ${result.staged ? 'staged' : ''}${result.unstaged ? (result.staged ? ', unstaged' : 'unstaged ') : ''}${result.untracked
-                        ? result.staged || result.unstaged
-                            ? ', untracked'
-                            : 'untracked'
-                        : ''} changes`
-                    : 'no working changes');
-                return result;
-            }
-            catch (ex) {
-                if (isCancellationError(ex))
-                    throw ex;
-                scope?.error(ex);
-                scope?.addExitInfo('error checking for changes');
-                // Return all false on error for graceful degradation
-                return { staged: false, unstaged: false, untracked: false };
-            }
-        }, cancellation);
-    }
-    hasConflictingFiles(repoPath, cancellation) {
-        // Route through `dedupeByStatusGeneration` (like every other point-in-time read here) for the join-fence
-        // and the `raceWithTimeout` backstop — a bare `git.stream` has no per-command timeout and could wedge.
-        return this.dedupeByStatusGeneration(repoPath, 'hasConflictingFiles', async (_correlationKey, signal) => {
-            try {
-                const env_1 = { stack: [], error: void 0, hasError: false };
-                try {
-                    const stream = this.git.stream({ cwd: repoPath, cancellation: signal }, 'ls-files', '--unmerged');
-                    const _streamDisposer = __addDisposableResource(env_1, createDisposable(() => void stream.return?.(undefined)), false);
-                    // Early exit on first chunk - breaking causes SIGPIPE, killing git process
-                    for await (const _chunk of stream) {
-                        return true;
-                    }
-                    return false;
-                }
-                catch (e_1) {
-                    env_1.error = e_1;
-                    env_1.hasError = true;
-                }
-                finally {
-                    __disposeResources(env_1);
-                }
-            }
-            catch (ex) {
-                // Re-throw cancellation errors
-                if (isCancellationError(ex))
-                    throw ex;
-                return false;
-            }
-        }, cancellation);
-    }
-    getConflictingFiles(repoPath, cancellation) {
-        const scope = getScopedLogger();
-        return this.dedupeByStatusGeneration(repoPath, 'getConflictingFiles', async (correlationKey, signal) => {
-            try {
-                const result = await this.git.run({ cwd: repoPath, cancellation: signal, errors: 'ignore', correlationKey: correlationKey }, 'ls-files', '-z', '--unmerged');
-                if (!result.stdout) {
-                    scope?.addExitInfo('no conflicting files');
-                    return [];
-                }
-                const files = parseGitConflictFiles(result.stdout, repoPath);
-                scope?.addExitInfo(`${String(files.length)} conflicting file(s)`);
-                return files;
-            }
-            catch (ex) {
-                // Re-throw cancellation errors
-                if (isCancellationError(ex))
-                    throw ex;
-                // Log other errors and return empty array for graceful degradation
-                scope?.error(ex);
-                scope?.addExitInfo('error getting conflicting files');
-                return [];
-            }
-        }, cancellation);
-    }
-    async hasUntrackedFiles(repoPath, cancellation) {
-        try {
-            const env_2 = { stack: [], error: void 0, hasError: false };
-            try {
-                const stream = this.git.stream({ cwd: repoPath, cancellation: cancellation }, 'ls-files', 
-                // '-z', // Unneeded since we are only looking for presence
-                '--others', '--exclude-standard');
-                const _streamDisposer = __addDisposableResource(env_2, createDisposable(() => void stream.return?.(undefined)), false);
-                // Early exit on first chunk - breaking causes SIGPIPE, killing git process
-                for await (const _chunk of stream) {
-                    return true;
-                }
-                return false;
-            }
-            catch (e_2) {
-                env_2.error = e_2;
-                env_2.hasError = true;
-            }
-            finally {
-                __disposeResources(env_2);
-            }
-        }
-        catch (ex) {
-            // Re-throw cancellation errors
-            if (isCancellationError(ex))
-                throw ex;
-            // Treat other errors as "no untracked files" for graceful degradation
-            return false;
-        }
-    }
-    getUntrackedFiles(repoPath, cancellation) {
-        const scope = getScopedLogger();
-        return this.dedupeByStatusGeneration(repoPath, 'getUntrackedFiles', async (correlationKey, signal) => {
-            try {
-                const result = await this.git.run({ cwd: repoPath, cancellation: signal, errors: 'ignore', correlationKey: correlationKey }, 'ls-files', '-z', '--others', '--exclude-standard');
-                if (!result.stdout) {
-                    scope?.addExitInfo('no untracked files');
-                    return [];
-                }
-                const files = [];
-                for (const line of iterateByDelimiter(result.stdout, '\0')) {
-                    if (!line.length)
-                        continue;
-                    files.push({ path: line, repoPath: repoPath, status: GitFileWorkingTreeStatus.Untracked });
-                }
-                scope?.addExitInfo(`${String(files.length)} untracked file(s)`);
-                return files;
-            }
-            catch (ex) {
-                // Re-throw cancellation errors
-                if (isCancellationError(ex))
-                    throw ex;
-                // Log other errors and return empty array for graceful degradation
-                scope?.error(ex);
-                scope?.addExitInfo('error getting untracked files');
-                return [];
-            }
-        }, cancellation);
-    }
-}
-__decorate([
-    debug()
-], StatusGitSubProvider.prototype, "getStatus", null);
-__decorate([
-    debug()
-], StatusGitSubProvider.prototype, "getStatusForFile", null);
-__decorate([
-    debug()
-], StatusGitSubProvider.prototype, "getStatusForPath", null);
-__decorate([
-    debug()
-], StatusGitSubProvider.prototype, "hasWorkingChanges", null);
-__decorate([
-    debug()
-], StatusGitSubProvider.prototype, "getWorkingChangesState", null);
-__decorate([
-    debug()
-], StatusGitSubProvider.prototype, "getConflictingFiles", null);
-__decorate([
-    debug()
-], StatusGitSubProvider.prototype, "getUntrackedFiles", null);
+var StatusGitSubProvider = class {
+	context;
+	git;
+	cache;
+	provider;
+	constructor(context, git, cache, provider) {
+		this.context = context;
+		this.git = git;
+		this.cache = cache;
+		this.provider = provider;
+	}
+	/** In-flight reads, keyed by `<read>\0<repoPath>\0<generation>`. `PromiseMap` (not a bare Map) so joiners
+	*  get per-caller cancellation: the shared run aborts only when ALL current callers do. */
+	_pendingReads = new PromiseMap();
+	/**
+	* Single-flight for point-in-time reads of mutable working-tree state — replaces `@gate`, which dedups on
+	* repoPath with no notion of *when* a run started and so joins a pre-change read to a post-change caller
+	* (see {@link Cache.getStatusGeneration}). Same-generation callers share one run (via a `PromiseMap`, so a
+	* joiner cancelling can't reject the others); a caller in a newer generation gets a different key and a
+	* fresh run; a `force` read advances the clock first, so it fences every later reader too, not just itself.
+	* The exec-layer command dedup (`Git.pendingCommands`) is fenced automatically: each run carries this entry's
+	* aggregate signal, whose id is part of the exec cache key, so a newer-generation run never joins an older
+	* one's process; the generation-derived `correlationKey` is a readable second guard on that key. A `raceWithTimeout` backstop (scaled to `advanced.git.timeout`, see
+	* {@link computeDeadlockBackstopMs}) replaces `@gate`'s 5-min force-clear so a never-settling read (a hung
+	* `git.stream`, which has no per-command timeout) can't wedge same-generation callers — including blocking
+	* awaiters like the commit flow — indefinitely.
+	*/
+	dedupeByStatusGeneration(repoPath, read, run, cancellation, force) {
+		if (force) this.cache.incrementStatusGeneration(repoPath);
+		const generation = this.cache.getStatusGeneration(repoPath);
+		const key = `${read}\0${repoPath}\0${generation}`;
+		const correlationKey = `status:${generation}`;
+		const backstopMs = computeDeadlockBackstopMs(this.git.options.gitTimeout);
+		return this._pendingReads.getOrCreate(key, (cacheable, signal) => {
+			cacheable.invalidate();
+			const backstop = new AbortController();
+			const runSignal = signal != null ? AbortSignal.any([signal, backstop.signal]) : backstop.signal;
+			return raceWithTimeout(run(correlationKey, runSignal), backstopMs, backstop);
+		}, cancellation);
+	}
+	getStatus(repoPath, options, cancellation) {
+		if (repoPath == null) return Promise.resolve(void 0);
+		return this.dedupeByStatusGeneration(repoPath, "getStatus", (correlationKey, signal) => this.getStatusCore(repoPath, {
+			...options,
+			correlationKey
+		}, signal), cancellation, options?.force);
+	}
+	async getStatusCore(repoPath, options, cancellation) {
+		const porcelainVersion = await this.git.supports("git:status:porcelain-v2") ? 2 : 1;
+		const result = await this.statusCore(repoPath, porcelainVersion, {
+			similarityThreshold: this.context.config?.commits.similarityThreshold,
+			priority: options?.priority,
+			correlationKey: options?.correlationKey
+		}, cancellation);
+		const repoUri = fileUri(normalizePath(repoPath));
+		const status = parseGitStatus(result.stdout, repoPath, porcelainVersion, (p) => joinUriPath(repoUri, normalizePath(p)));
+		if (status?.detached) {
+			const pausedOpStatus = await this.provider.pausedOps?.getPausedOperationStatus?.(repoPath, void 0, cancellation);
+			if (pausedOpStatus?.type === "rebase") return new GitStatus(repoPath, pausedOpStatus.incoming.name, status.sha, status.files, status.upstream, true);
+		}
+		return status;
+	}
+	async getStatusForFile(repoPath, pathOrUri, options, cancellation) {
+		return (await this.getStatusForPathCore(repoPath, toFsPath(pathOrUri), {
+			...options,
+			exact: true
+		}, cancellation))?.[0];
+	}
+	async getStatusForPath(repoPath, pathOrUri, options, cancellation) {
+		return this.getStatusForPathCore(repoPath, toFsPath(pathOrUri), {
+			...options,
+			exact: false
+		}, cancellation);
+	}
+	async getStatusForPathCore(repoPath, pathOrUri, options, cancellation) {
+		const relativePath = stripFolderGlob(splitPath(pathOrUri, repoPath)[0]);
+		if (options.renames !== false) {
+			const status = await this.getStatus(repoPath, void 0, cancellation);
+			if (status == null) return void 0;
+			if (options.exact) {
+				const file = status.files.find((f) => f.path === relativePath);
+				return file ? [file] : void 0;
+			}
+			return status.files.filter((f) => f.path.startsWith(relativePath));
+		}
+		return this.dedupeByStatusGeneration(repoPath, `getStatusForPath:${relativePath}`, (correlationKey, signal) => this.getStatusForPathScoped(repoPath, relativePath, correlationKey, signal), cancellation);
+	}
+	async getStatusForPathScoped(repoPath, relativePath, correlationKey, cancellation) {
+		const porcelainVersion = await this.git.supports("git:status:porcelain-v2") ? 2 : 1;
+		const result = await this.statusCore(repoPath, porcelainVersion, {
+			similarityThreshold: this.context.config?.commits.similarityThreshold,
+			correlationKey
+		}, cancellation, relativePath);
+		const repoUri = fileUri(normalizePath(repoPath));
+		return parseGitStatus(result.stdout, repoPath, porcelainVersion, (p) => joinUriPath(repoUri, normalizePath(p)))?.files;
+	}
+	async statusCore(repoPath, porcelainVersion = 1, options, cancellation, ...pathspecs) {
+		const params = [
+			"status",
+			porcelainVersion >= 2 ? `--porcelain=v${porcelainVersion}` : "--porcelain",
+			"--branch",
+			"-u"
+		];
+		if (await this.git.supports("git:status:find-renames")) params.push(`--find-renames${options?.similarityThreshold == null ? "" : `=${options.similarityThreshold}%`}`);
+		return this.git.run({
+			cwd: repoPath,
+			cancellation,
+			configs: gitConfigsStatus,
+			env: { GIT_OPTIONAL_LOCKS: "0" },
+			correlationKey: options?.correlationKey,
+			...options?.priority != null ? { priority: options.priority } : void 0
+		}, ...params, "--", ...pathspecs);
+	}
+	hasWorkingChanges(repoPath, options, cancellation) {
+		const scope = getScopedLogger();
+		const staged = options?.staged ?? true;
+		const unstaged = options?.unstaged ?? true;
+		const untracked = options?.untracked ?? true;
+		const throwOnError = options?.throwOnError ?? false;
+		const priority = options?.priority ?? "default";
+		return this.dedupeByStatusGeneration(repoPath, `hasWorkingChanges:${staged}:${unstaged}:${untracked}:${throwOnError}:${priority}`, async (correlationKey, signal) => {
+			try {
+				if (staged || unstaged) {
+					if ((await this.git.run({
+						cwd: repoPath,
+						cancellation: signal,
+						errors: "ignore",
+						correlationKey,
+						...options?.priority != null ? { priority: options.priority } : void 0
+					}, "diff", "--quiet", staged && unstaged ? "HEAD" : staged ? "--staged" : void 0)).exitCode === 1) {
+						if (staged && unstaged) scope?.addExitInfo("has staged and unstaged changes");
+						else if (staged) scope?.addExitInfo("has staged changes");
+						else scope?.addExitInfo("has unstaged changes");
+						return true;
+					}
+				}
+				if (untracked) {
+					if (await this.hasUntrackedFiles(repoPath, signal)) {
+						scope?.addExitInfo("has untracked files");
+						return true;
+					}
+				}
+				scope?.addExitInfo("no working changes");
+				return false;
+			} catch (ex) {
+				if (isCancellationError(ex)) throw ex;
+				scope?.error(ex);
+				scope?.addExitInfo("error checking for changes");
+				if (throwOnError) throw ex;
+				return false;
+			}
+		}, cancellation);
+	}
+	getWorkingChangesState(repoPath, cancellation) {
+		const scope = getScopedLogger();
+		return this.dedupeByStatusGeneration(repoPath, "getWorkingChangesState", async (correlationKey, signal) => {
+			try {
+				const [stagedResult, unstagedResult, untrackedResult] = await Promise.allSettled([
+					this.git.run({
+						cwd: repoPath,
+						cancellation: signal,
+						errors: "ignore",
+						correlationKey
+					}, "diff", "--quiet", "--staged"),
+					this.git.run({
+						cwd: repoPath,
+						cancellation: signal,
+						errors: "ignore",
+						correlationKey
+					}, "diff", "--quiet"),
+					this.hasUntrackedFiles(repoPath, signal)
+				]);
+				const result = {
+					staged: getSettledValue(stagedResult)?.exitCode === 1,
+					unstaged: getSettledValue(unstagedResult)?.exitCode === 1,
+					untracked: getSettledValue(untrackedResult) === true
+				};
+				scope?.addExitInfo(result.staged || result.unstaged || result.untracked ? `has ${result.staged ? "staged" : ""}${result.unstaged ? result.staged ? ", unstaged" : "unstaged " : ""}${result.untracked ? result.staged || result.unstaged ? ", untracked" : "untracked" : ""} changes` : "no working changes");
+				return result;
+			} catch (ex) {
+				if (isCancellationError(ex)) throw ex;
+				scope?.error(ex);
+				scope?.addExitInfo("error checking for changes");
+				return {
+					staged: false,
+					unstaged: false,
+					untracked: false
+				};
+			}
+		}, cancellation);
+	}
+	hasConflictingFiles(repoPath, cancellation) {
+		return this.dedupeByStatusGeneration(repoPath, "hasConflictingFiles", async (_correlationKey, signal) => {
+			try {
+				try {
+					var _usingCtx$1 = _usingCtx();
+					const stream = this.git.stream({
+						cwd: repoPath,
+						cancellation: signal
+					}, "ls-files", "--unmerged");
+					_usingCtx$1.u(createDisposable(() => void stream.return?.(void 0)));
+					for await (const _chunk of stream) return true;
+					return false;
+				} catch (_) {
+					_usingCtx$1.e = _;
+				} finally {
+					_usingCtx$1.d();
+				}
+			} catch (ex) {
+				if (isCancellationError(ex)) throw ex;
+				return false;
+			}
+		}, cancellation);
+	}
+	getConflictingFiles(repoPath, cancellation) {
+		const scope = getScopedLogger();
+		return this.dedupeByStatusGeneration(repoPath, "getConflictingFiles", async (correlationKey, signal) => {
+			try {
+				const result = await this.git.run({
+					cwd: repoPath,
+					cancellation: signal,
+					errors: "ignore",
+					correlationKey
+				}, "ls-files", "-z", "--unmerged");
+				if (!result.stdout) {
+					scope?.addExitInfo("no conflicting files");
+					return [];
+				}
+				const files = parseGitConflictFiles(result.stdout, repoPath);
+				scope?.addExitInfo(`${String(files.length)} conflicting file(s)`);
+				return files;
+			} catch (ex) {
+				if (isCancellationError(ex)) throw ex;
+				scope?.error(ex);
+				scope?.addExitInfo("error getting conflicting files");
+				return [];
+			}
+		}, cancellation);
+	}
+	async hasUntrackedFiles(repoPath, cancellation) {
+		try {
+			try {
+				var _usingCtx3 = _usingCtx();
+				const stream = this.git.stream({
+					cwd: repoPath,
+					cancellation
+				}, "ls-files", "--others", "--exclude-standard");
+				_usingCtx3.u(createDisposable(() => void stream.return?.(void 0)));
+				for await (const _chunk of stream) return true;
+				return false;
+			} catch (_) {
+				_usingCtx3.e = _;
+			} finally {
+				_usingCtx3.d();
+			}
+		} catch (ex) {
+			if (isCancellationError(ex)) throw ex;
+			return false;
+		}
+	}
+	getUntrackedFiles(repoPath, cancellation) {
+		const scope = getScopedLogger();
+		return this.dedupeByStatusGeneration(repoPath, "getUntrackedFiles", async (correlationKey, signal) => {
+			try {
+				const result = await this.git.run({
+					cwd: repoPath,
+					cancellation: signal,
+					errors: "ignore",
+					correlationKey
+				}, "ls-files", "-z", "--others", "--exclude-standard");
+				if (!result.stdout) {
+					scope?.addExitInfo("no untracked files");
+					return [];
+				}
+				const files = [];
+				for (const line of iterateByDelimiter(result.stdout, "\0")) {
+					if (!line.length) continue;
+					files.push({
+						path: line,
+						repoPath,
+						status: GitFileWorkingTreeStatus.Untracked
+					});
+				}
+				scope?.addExitInfo(`${String(files.length)} untracked file(s)`);
+				return files;
+			} catch (ex) {
+				if (isCancellationError(ex)) throw ex;
+				scope?.error(ex);
+				scope?.addExitInfo("error getting untracked files");
+				return [];
+			}
+		}, cancellation);
+	}
+};
+__decorate([debug()], StatusGitSubProvider.prototype, "getStatus", null);
+__decorate([debug()], StatusGitSubProvider.prototype, "getStatusForFile", null);
+__decorate([debug()], StatusGitSubProvider.prototype, "getStatusForPath", null);
+__decorate([debug()], StatusGitSubProvider.prototype, "hasWorkingChanges", null);
+__decorate([debug()], StatusGitSubProvider.prototype, "getWorkingChangesState", null);
+__decorate([debug()], StatusGitSubProvider.prototype, "getConflictingFiles", null);
+__decorate([debug()], StatusGitSubProvider.prototype, "getUntrackedFiles", null);
+//#endregion
+export { StatusGitSubProvider, computeDeadlockBackstopMs };
+
 //# sourceMappingURL=status.js.map