@gitkraken/core-gitlens 0.5.116 → 0.7.0

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

@@ -1,842 +1,623 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-import { promises as fs } from 'fs';
-import { hostname, userInfo } from 'os';
-import { env as process_env } from 'process';
-import { WorkspaceUntrustedError } from '../../git/errors.js';
-import { gate } from '../../utils/decorators/gate.js';
-import { debug, trace } from '../../utils/decorators/log.js';
-import { first, some } from '../../utils/iterable.js';
-import { Logger } from '../../utils/logger.js';
-import { getScopedLogger } from '../../utils/logger.scoped.js';
-import { dirname, getBestPath, isAbsolute, joinPaths, normalizePath } from '../../utils/path.js';
-import { fileUri } from '../../utils/uri.js';
-import { fsExists } from '../exec/exec.js';
+import { first, some } from "../../utils/iterable.js";
+import { Logger as _logger } from "../../utils/logger.js";
+import { getScopedLogger } from "../../utils/logger.scoped.js";
+import { debug, trace } from "../../utils/decorators/log.js";
+import { fileUri } from "../../utils/uri.js";
+import { dirname, getBestPath, isAbsolute, joinPaths, normalizePath } from "../../utils/path.js";
+import __decorate from "../../_virtual/@oxc-project+runtime/helpers/esm/decorate.js";
+import { WorkspaceUntrustedError } from "../../git/errors.js";
+import { fsExists } from "../../utils/env/node/exec.js";
+import { gate } from "../../utils/decorators/gate.js";
+import { promises } from "fs";
+import { env } from "process";
+import { hostname, userInfo } from "os";
+//#region ../git-cli/src/providers/config.ts
 const mappedAuthorRegex = /(.+)\s<(.+)>/;
 const emptyArray = Object.freeze([]);
 /** Catch-all pattern matching every key in `.git/gk/config` for the one-shot bulk read. */
-const gkConfigAllPattern = '.';
+const gkConfigAllPattern = ".";
 /**
- * Canonicalizes a git config key for lookup against `--get-regexp` output, which git emits with the
- * section and variable-name lowercased and only the subsection case-preserved. Without this a
- * subsection-less key like `gk.defaultRemote` would miss the lowercased `gk.defaultremote` in the map.
- */
-export function canonicalizeGitConfigKey(key) {
-    const first = key.indexOf('.');
-    if (first === -1)
-        return key.toLowerCase();
-    const last = key.lastIndexOf('.');
-    // `section.name` (no subsection) → fully lowercased; `section.subsection.name` → lowercase
-    // section + name, preserve the case-sensitive subsection in the middle.
-    if (first === last)
-        return key.toLowerCase();
-    return `${key.slice(0, first).toLowerCase()}${key.slice(first, last)}${key.slice(last).toLowerCase()}`;
+* Canonicalizes a git config key for lookup against `--get-regexp` output, which git emits with the
+* section and variable-name lowercased and only the subsection case-preserved. Without this a
+* subsection-less key like `gk.defaultRemote` would miss the lowercased `gk.defaultremote` in the map.
+*/
+function canonicalizeGitConfigKey(key) {
+	const first = key.indexOf(".");
+	if (first === -1) return key.toLowerCase();
+	const last = key.lastIndexOf(".");
+	if (first === last) return key.toLowerCase();
+	return `${key.slice(0, first).toLowerCase()}${key.slice(first, last)}${key.slice(last).toLowerCase()}`;
 }
 /**
- * Parses git config --get-regex output into a Map.
- * The output format is "key value" per line, where key and value are space-separated.
- *
- * A line with NO space at all is git's rendering of a bareword/valueless entry (`key`, no `=`) — git's
- * OWN config parser reads that as boolean TRUE (git-config(1): "a variable defined without `= <value>`
- * is taken as true"), confirmed against git's `format_config` (builtin/config.c): the key-delimiter is
- * appended unconditionally, then backed out ONLY when the stored value is NULL (the bareword case) —
- * an explicit empty value (`key =`) is a real, non-NULL empty string, so its line KEEPS the trailing
- * space and is already handled by the branch below, byte-distinct from a bareword line.
- *
- * By default a bareword line is skipped (the historical behavior, which reads as "unset" — wrong, but
- * safe); pass `includeValueless` to map it to the literal string `'true'` instead, so `parseGitBoolean`
- * and callers checking `.has()` for "configured" both read it correctly.
- */
-export function parseConfigRegexOutput(data, options) {
-    const configMap = new Map();
-    if (!data)
-        return configMap;
-    for (const line of data.split('\n')) {
-        if (!line)
-            continue;
-        const spaceIndex = line.indexOf(' ');
-        if (spaceIndex === -1) {
-            if (options?.includeValueless) {
-                configMap.set(line, 'true');
-            }
-            continue;
-        }
-        configMap.set(line.substring(0, spaceIndex), line.substring(spaceIndex + 1));
-    }
-    return configMap;
+* Parses git config --get-regex output into a Map.
+* The output format is "key value" per line, where key and value are space-separated.
+*
+* A line with NO space at all is git's rendering of a bareword/valueless entry (`key`, no `=`) — git's
+* OWN config parser reads that as boolean TRUE (git-config(1): "a variable defined without `= <value>`
+* is taken as true"), confirmed against git's `format_config` (builtin/config.c): the key-delimiter is
+* appended unconditionally, then backed out ONLY when the stored value is NULL (the bareword case) —
+* an explicit empty value (`key =`) is a real, non-NULL empty string, so its line KEEPS the trailing
+* space and is already handled by the branch below, byte-distinct from a bareword line.
+*
+* By default a bareword line is skipped (the historical behavior, which reads as "unset" — wrong, but
+* safe); pass `includeValueless` to map it to the literal string `'true'` instead, so `parseGitBoolean`
+* and callers checking `.has()` for "configured" both read it correctly.
+*/
+function parseConfigRegexOutput(data, options) {
+	const configMap = /* @__PURE__ */ new Map();
+	if (!data) return configMap;
+	for (const line of data.split("\n")) {
+		if (!line) continue;
+		const spaceIndex = line.indexOf(" ");
+		if (spaceIndex === -1) {
+			if (options?.includeValueless) configMap.set(line, "true");
+			continue;
+		}
+		configMap.set(line.substring(0, spaceIndex), line.substring(spaceIndex + 1));
+	}
+	return configMap;
 }
-export function parseGitBoolean(value) {
-    if (value == null)
-        return false;
-    const normalized = value.toLowerCase().trim();
-    return normalized === 'true' || normalized === 'yes' || normalized === 'on' || normalized === '1';
+function parseGitBoolean(value) {
+	if (value == null) return false;
+	const normalized = value.toLowerCase().trim();
+	return normalized === "true" || normalized === "yes" || normalized === "on" || normalized === "1";
 }
 /** Whether a git config value spells boolean-false (`false`/`no`/`off`/`0`/empty), per git's maybe-bool parsing. */
-export function isGitBooleanFalse(value) {
-    const normalized = value.toLowerCase().trim();
-    return (normalized === '' || normalized === 'false' || normalized === 'no' || normalized === 'off' || normalized === '0');
-}
-export class ConfigGitSubProvider {
-    context;
-    git;
-    cache;
-    provider;
-    constructor(context, git, cache, provider) {
-        this.context = context;
-        this.git = git;
-        this.cache = cache;
-        this.provider = provider;
-        this.cache.setGkConfigReconciler((repoPath, priorSnapshot) => this.reconcileGkConfig(repoPath, priorSnapshot));
-    }
-    /**
-     * In-flight gk-config reconciles keyed by commonPath. `pending` records that another `'gkConfig'`
-     * event landed mid-pass, so one trailing pass runs after the current one settles. `paths` holds every
-     * worktree path that reported the change, mapped to its close generation at that moment — the pass
-     * reads through one that's still open and notifies all of them.
-     */
-    _gkConfigReconciles = new Map();
-    /**
-     * Pending `setGkConfig` writes keyed by `(commonPath, key, value, skip-option)`. Concurrent
-     * callers writing the same `(key, value)` pair share the in-flight Promise so only one
-     * `git config --set` subprocess actually runs. Cleared on settle.
-     */
-    _pendingGkConfigWrites = new Map();
-    getConfig(repoPath, key, options) {
-        const global = options?.global || repoPath == null;
-        return this.cache.getConfig(global ? undefined : repoPath, key, () => this.getConfigCore(repoPath, key, options));
-    }
-    async getConfigCore(repoPath, key, options) {
-        const args = ['config', '--get'];
-        if (options?.file) {
-            args.push('-f', options.file);
-        }
-        else if (options?.global || repoPath == null) {
-            args.push('--global');
-        }
-        if (options?.type) {
-            args.push(`--type=${options.type}`);
-        }
-        args.push(key);
-        const result = await this.git.run({ cwd: repoPath ?? '', errors: 'ignore', runLocally: options?.runGitLocally }, ...args);
-        return result.stdout.trim() || undefined;
-    }
-    getConfigRegex(repoPath, pattern, options) {
-        const global = options?.global || repoPath == null;
-        return this.cache.getConfigRegex(global ? undefined : repoPath, pattern, () => this.getConfigRegexCore(repoPath, pattern, options));
-    }
-    async getConfigRegexCore(repoPath, pattern, options) {
-        const args = ['config', '--get-regex'];
-        if (options?.file) {
-            args.push('-f', options.file);
-        }
-        else if (options?.global || repoPath == null) {
-            args.push('--global');
-        }
-        args.push(pattern);
-        const result = await this.git.run({ cwd: repoPath ?? '', errors: 'ignore', runLocally: options?.runGitLocally }, ...args);
-        // Deliberately NOT `.trim()`-ed: an explicit-empty value's LAST line ends in a meaningful trailing
-        // space, and `.trim()`-ing the whole (possibly multi-line) buffer strips it — `parseConfigRegexOutput`
-        // already skips the blank line a trailing newline produces, so no trim is needed.
-        return parseConfigRegexOutput(result.stdout);
-    }
-    async setConfig(repoPath, key, value, options) {
-        return this.setConfigCore(repoPath, key, value, options);
-    }
-    async setConfigCore(repoPath, key, value, options) {
-        const args = ['config'];
-        if (options?.file) {
-            args.push('-f', options.file);
-        }
-        else {
-            const global = options?.global || repoPath == null;
-            args.push(global ? '--global' : '--local');
-        }
-        if (value == null) {
-            args.push('--unset', key);
-        }
-        else {
-            args.push(key, value);
-        }
-        await this.git.run({ cwd: repoPath ?? '', runLocally: true }, ...args);
-        // Only invalidate cache when not using a custom file (custom files aren't cached)
-        if (!options?.file) {
-            const global = options?.global || repoPath == null;
-            // Invalidate the cached value for this key and clear all regex patterns for this scope
-            this.cache.deleteConfig(global ? undefined : repoPath, key);
-        }
-    }
-    async getCurrentUser(repoPath) {
-        if (!repoPath)
-            return undefined;
-        const scope = getScopedLogger();
-        const cached = this.cache.currentUser.get(repoPath);
-        if (cached != null)
-            return cached;
-        // If we found null, user data was not found - don't bother trying again
-        if (cached === null)
-            return undefined;
-        const user = { name: undefined, email: undefined };
-        try {
-            const configMap = await this.getConfigRegex(repoPath, '^user\\.(name|email)$', {
-                runGitLocally: true,
-            });
-            if (configMap.size) {
-                user.name = configMap.get('user.name');
-                user.email = configMap.get('user.email');
-            }
-            else {
-                user.name =
-                    process_env.GIT_AUTHOR_NAME || process_env.GIT_COMMITTER_NAME || userInfo()?.username || undefined;
-                if (!user.name) {
-                    // If we found no user data, mark it so we won't bother trying again
-                    this.cache.currentUser.set(repoPath, null);
-                    return undefined;
-                }
-                user.email =
-                    process_env.GIT_AUTHOR_EMAIL ||
-                        process_env.GIT_COMMITTER_EMAIL ||
-                        process_env.EMAIL ||
-                        `${user.name}@${hostname()}`;
-            }
-            const author = `${user.name} <${user.email}>`;
-            // Check if there is a mailmap for the current user
-            const result = await this.git.run({ cwd: repoPath, errors: 'ignore' }, 'check-mailmap', author);
-            if (result.stdout && result.stdout !== author) {
-                const match = mappedAuthorRegex.exec(result.stdout);
-                if (match != null) {
-                    [, user.name, user.email] = match;
-                }
-            }
-            this.cache.currentUser.set(repoPath, user);
-            return user;
-        }
-        catch (ex) {
-            scope?.error(ex);
-            // Mark it so we won't bother trying again
-            this.cache.currentUser.set(repoPath, null);
-            return undefined;
-        }
-    }
-    async getDefaultWorktreePath(repoPath) {
-        const gitDir = await this.getGitDir(repoPath);
-        if (gitDir == null)
-            return undefined;
-        const basePath = (gitDir.commonUri ?? gitDir.uri).fsPath;
-        return getBestPath(normalizePath(joinPaths(basePath, '..')));
-    }
-    async getGitDir(repoPath) {
-        const cached = this.cache.gitDir.get(repoPath);
-        if (cached != null)
-            return cached;
-        const scope = getScopedLogger();
-        const repoInfo = await this.getRepositoryInfo(repoPath);
-        let gitDir;
-        if (!Array.isArray(repoInfo) && repoInfo != null) {
-            gitDir = {
-                uri: fileUri(repoInfo.gitDir),
-                commonUri: repoInfo.commonGitDir ? fileUri(repoInfo.commonGitDir) : undefined,
-                parentUri: repoInfo.superprojectPath ? fileUri(repoInfo.superprojectPath) : undefined,
-            };
-        }
-        else {
-            gitDir = {
-                uri: this.provider.getAbsoluteUri(joinPaths(repoPath, '.git'), repoPath),
-            };
-            const gitDirPath = gitDir.uri.toString(true);
-            scope?.warn(`rev-parse failed for '${repoPath}'; falling back to '${gitDirPath}'`);
-            this.context.hooks?.operations?.onGitDirResolveFailed?.(repoPath, gitDirPath, `rev_parse returned ${JSON.stringify(repoInfo)}`);
-        }
-        this.cache.gitDir.set(repoPath, gitDir);
-        return gitDir;
-    }
-    /**
-     * Gets the path to the .git/gk/config file for storing GitKraken-specific metadata.
-     * Uses commonPath for worktrees so all worktrees share the same data.
-     */
-    async getGkConfigPath(repoPath) {
-        const gitDir = await this.getGitDir(repoPath);
-        if (gitDir == null)
-            return undefined;
-        // Use commonUri (main .git dir) for worktrees, otherwise use uri
-        const basePath = (gitDir.commonUri ?? gitDir.uri).fsPath;
-        return joinPaths(basePath, 'gk', 'config');
-    }
-    async getGkConfig(repoPath, key) {
-        // Served in-memory from a single bulk read of the whole `.git/gk/config` (no gk read needs `--type`).
-        // Canonicalize the key the way git does for `--get-regexp` output so subsection-less keys
-        // (e.g. `gk.defaultRemote`) match, and coerce an empty value to undefined to match the old
-        // `git config --get` (`.trim() || undefined`) contract.
-        return (await this.getGkConfigMap(repoPath)).get(canonicalizeGitConfigKey(key)) || undefined;
-    }
-    async getGkConfigRegex(repoPath, pattern) {
-        const all = await this.getGkConfigMap(repoPath);
-        // Filter the bulk map in-memory. The old path passed `pattern` to `git config --get-regex`
-        // (errors ignored → empty result on a bad pattern); preserve that no-throw contract here
-        // rather than letting an invalid-JS pattern reject the read.
-        let re;
-        try {
-            re = new RegExp(pattern);
-        }
-        catch {
-            return new Map();
-        }
-        const result = new Map();
-        for (const [k, v] of all) {
-            if (re.test(k)) {
-                result.set(k, v);
-            }
-        }
-        return result;
-    }
-    /**
-     * Reads the entire `.git/gk/config` in one `git config --get-regexp` and caches the parsed map
-     * per commonPath. Per-key (getGkConfig) and per-namespace (getGkConfigRegex) lookups are served
-     * from this single cached read — so a branch-overview render that fans out across several gk
-     * namespaces costs one `git config` call instead of one per namespace.
-     */
-    async getGkConfigMap(repoPath) {
-        // Migrate BEFORE populating the cache, not inside the factory: a first-time migration calls
-        // clearCaches('gkConfig'), which would otherwise evict the in-flight gkConfigMap entry the
-        // cache wrapper synchronously stored and force a redundant bulk re-read.
-        await this.migrateGkConfigFromGitConfig(this.cache.getCommonPath(repoPath));
-        return this.cache.getGkConfigMap(repoPath, async (cacheable) => {
-            const { map, failed } = await this.getGkConfigRegexCore(repoPath, gkConfigAllPattern);
-            // This map has no TTL and everything gk-related reads through it, so a failed read cached as an
-            // empty map would report every branch as having no stored base or merge target for the session —
-            // and would make the section-cleanup pre-checks skip real work. Only cache a read that happened.
-            if (failed) {
-                cacheable.invalidate();
-            }
-            return map;
-        });
-    }
-    async getGkConfigRegexCore(repoPath, pattern) {
-        const gkConfigPath = await this.getGkConfigPath(repoPath);
-        // No `.git/gk/config` yet is a real answer, not a failure — a repo GitLens has never written to.
-        if (!gkConfigPath)
-            return { map: new Map(), failed: false };
-        const result = await this.git.run({ cwd: repoPath, errors: 'ignore', runLocally: true }, 'config', '--get-regex', '-f', gkConfigPath, pattern);
-        // `--get-regex` exits 1 when nothing matches, which IS an answer (an empty gk config).
-        const exited = result.completion.status === 'exited';
-        return {
-            // Deliberately NOT `.trim()`-ed — see `getConfigRegexCore`'s comment: it strips the trailing
-            // space that marks an explicit-empty value's LAST line, silently dropping it from the map.
-            map: parseConfigRegexOutput(result.stdout),
-            failed: !exited || (result.exitCode !== 0 && result.exitCode !== 1),
-        };
-    }
-    async setGkConfig(repoPath, key, value, options) {
-        // Encode the skip-invalidation option in the dedup key: a self-write (with skip targets)
-        // and a user-driven write of the same `(key, value)` (no skip targets) have different
-        // cache-invalidation semantics, so sharing their Promise would silently let the user-driven
-        // write skip invalidation. Sort the array so callers passing the same targets in different
-        // orders share a single in-flight write.
-        const commonPath = this.cache.getCommonPath(repoPath);
-        const skipKey = options?.skipInvalidation?.length ? options.skipInvalidation.toSorted().join(',') : '';
-        const dedupKey = `${commonPath}\0${key}\0${value ?? ''}\0${skipKey}`;
-        const pending = this._pendingGkConfigWrites.get(dedupKey);
-        if (pending != null)
-            return pending;
-        const promise = this.setGkConfigCore(repoPath, key, value, options);
-        this._pendingGkConfigWrites.set(dedupKey, promise);
-        // Swallow the cleanup chain's rejection so a failed write doesn't surface as an unhandled
-        // rejection separate from the caller's own handling of the returned promise.
-        void promise.finally(() => this._pendingGkConfigWrites.delete(dedupKey)).catch(() => { });
-        return promise;
-    }
-    async setGkConfigCore(repoPath, key, value, options) {
-        const scope = getScopedLogger();
-        const gkConfigPath = await this.getGkConfigPath(repoPath);
-        if (!gkConfigPath)
-            return;
-        const gkConfigFolder = joinPaths(gkConfigPath, '..');
-        if (!(await this.ensureGkConfigFolder(gkConfigFolder, scope)))
-            return;
-        await this.setConfigCore(repoPath, key, value, { file: gkConfigPath });
-        // Invalidate the bulk map (so the next read re-fetches) and the derived caches for this key's
-        // ref. The `.git/gk/config` file-watcher also fires `'gkConfig'` shortly after, which reconciles
-        // the same change (see `reconcileGkConfig`) — recording our own write here keeps that later
-        // reconcile from re-diffing this key as an external change.
-        this.cache.deleteGkConfig(repoPath, key, options);
-        this.cache.recordGkConfigWrite(repoPath, key, value);
-    }
-    async removeGkConfigBranchSection(repoPath, ref) {
-        await this.runGkConfigSectionCommand(repoPath, ref, '--remove-section', `branch.${ref}`);
-    }
-    async renameGkConfigBranchSection(repoPath, oldRef, newRef) {
-        // Clear the destination first, unconditionally. `--rename-section` onto a section that already
-        // exists APPENDS rather than replaces, leaving duplicate keys — and git resolves a duplicated key
-        // to its LAST value, so the orphan left by an earlier branch of this name would win over the
-        // metadata being moved. Doing this outside `runGkConfigSectionCommand` also covers the case where
-        // the source has no gk keys at all, where its pre-check would otherwise skip the whole call and
-        // leave the orphan in place for the renamed branch to inherit.
-        await this.removeGkConfigBranchSection(repoPath, newRef);
-        await this.runGkConfigSectionCommand(repoPath, oldRef, '--rename-section', `branch.${oldRef}`, `branch.${newRef}`);
-    }
-    /**
-     * Runs a section-level `git config` against `.git/gk/config` for `ref`'s section, skipping the
-     * subprocess entirely when the bulk map (already cached on any warm path) shows that ref has no gk
-     * keys — the overwhelmingly common case, since most branches never get gk metadata written at all.
-     *
-     * Never throws: callers invoke this as bookkeeping after a branch op has already succeeded, so a
-     * failure here must not be reported as (or roll back) the branch/checkout/worktree operation itself.
-     * The worst case is metadata that stays behind until the next op on that name.
-     */
-    async runGkConfigSectionCommand(repoPath, ref, ...args) {
-        const scope = getScopedLogger();
-        try {
-            const prefix = `branch.${ref}.`;
-            const map = await this.getGkConfigMap(repoPath);
-            // The shortcut needs a map with CONTENT to be trustworthy. A failed bulk read resolves empty
-            // (see `getGkConfigMap`) — the cache refuses it, but this caller still holds it — and an empty map
-            // read as authoritative would skip the removal entirely, leaving a deleted branch's base,
-            // disposition and issue links behind for the next branch reusing that name. When it's empty, run
-            // the command: worst case is a no-op on a section that isn't there.
-            if (map.size && !some(map.keys(), k => k.startsWith(prefix)))
-                return;
-            const gkConfigPath = await this.getGkConfigPath(repoPath);
-            if (!gkConfigPath)
-                return;
-            // `getGkConfigPath` only joins a path, so check the file: with no `.git/gk/config` there is
-            // genuinely nothing to remove, and running the command would fail with a fatal we'd then warn
-            // about on every branch delete in a repo that has never had gk metadata.
-            if (!(await fsExists(gkConfigPath)))
-                return;
-            const result = await this.git.run({ cwd: repoPath, runLocally: true, errors: 'ignore' }, 'config', '-f', gkConfigPath, ...args);
-            // `errors: 'ignore'` is deliberate — see the note above on why this must never throw — but that
-            // also means the `catch` below never sees a failed write, so without this the metadata silently
-            // stays behind (or, on a rename, stays under the old name) with nothing recorded anywhere.
-            // Reported, not thrown: the branch op it follows has already succeeded.
-            if (result.completion.status !== 'exited' || result.exitCode !== 0) {
-                scope?.warn(`Failed to update gk config section for '${ref}' in '${repoPath}': ${result.completion.status === 'exited'
-                    ? `git config exited ${result.exitCode}`
-                    : `${result.completion.status} · ${result.completion.error.message}`}`);
-            }
-            // A whole section moved or vanished, which the per-key `deleteGkConfig` cascade can't express.
-            // Drop the bulk map so the next read hits disk; the derived caches for the affected ref are
-            // evicted by the caller's own `deleteBaseBranchName` plus the `'branches'` cascade it fires.
-            this.cache.deleteGkConfigMap(repoPath);
-        }
-        catch (ex) {
-            scope?.error(ex, `Failed to update gk config section for '${ref}' in '${repoPath}'`);
-        }
-    }
-    /**
-     * Reconciles a watcher-observed `'gkConfig'` change — registered with the shared `Cache` as its
-     * gk-config reconciler (see the constructor). Re-reads the bulk map (hard-evicted by
-     * `Cache.handleGkConfigChanged`, so this hits disk) and diffs it against `priorSnapshot` to cascade
-     * `baseBranchName`/`branchOverviews` only for refs whose merge-relevant keys actually changed.
-     *
-     * Serialized per commonPath: a reconcile is a read-then-diff against a single shared baseline, so
-     * two overlapping passes would both diff against the same snapshot and the later change could fall
-     * out entirely. An event arriving mid-pass instead queues one trailing pass, which re-reads and
-     * diffs against the baseline the previous pass just established.
-     *
-     * `.git/gk/config` lives in the common dir, so the watcher delivers one event per worktree sharing it
-     * (see `WatchGroup.onCommonEvent`). Siblings never run concurrently — the later ones fold into the
-     * in-flight pass — but folding in arms the trailing pass, so a fan-out costs one extra read that
-     * re-reads and diffs an unchanged file. However many siblings land while a pass is running, they
-     * coalesce into that single trailing pass; the cost is the price of never dropping a real change.
-     * Every reporting path is retained because `Repository` matches the follow-up change event on exact
-     * path, and a sibling worktree that never receives one would sit on stale derived values.
-     */
-    reconcileGkConfig(repoPath, priorSnapshot) {
-        const commonPath = this.cache.getCommonPath(repoPath);
-        const inflight = this._gkConfigReconciles.get(commonPath);
-        if (inflight != null) {
-            inflight.paths.set(repoPath, this.cache.getCloseGeneration(repoPath));
-            inflight.pending = true;
-            // Handed to the in-flight pass's trailing loop, so it IS being reconciled — just not by this
-            // call. Reporting a failure here would coarse-clear on every write in a burst.
-            return 'deferred';
-        }
-        const entry = { pending: false, paths: new Map([[repoPath, this.cache.getCloseGeneration(repoPath)]]) };
-        this._gkConfigReconciles.set(commonPath, entry);
-        return this.runGkConfigReconcile(commonPath, priorSnapshot, entry);
-    }
-    /** Drops paths that closed since they reported the change; returns whichever remain. */
-    pruneClosedReconcilePaths(paths) {
-        for (const [path, generation] of paths) {
-            if (this.cache.getCloseGeneration(path) !== generation) {
-                paths.delete(path);
-            }
-        }
-        return paths;
-    }
-    async runGkConfigReconcile(commonPath, priorSnapshot, entry) {
-        const scope = getScopedLogger();
-        let snapshot = priorSnapshot;
-        try {
-            do {
-                entry.pending = false;
-                // Read through a path that's still open — one worktree closing must not drop the event for
-                // its still-open siblings, which is why this reads from the surviving set rather than from
-                // whichever path happened to report first.
-                const readPath = first(this.pruneClosedReconcilePaths(entry.paths).keys());
-                // Every path that reported the change has since closed — nothing left to reconcile, and
-                // nothing left holding a stale derived value either.
-                if (readPath == null)
-                    return 'reconciled';
-                // A trailing pass must not reuse the entry the pass before it installed.
-                this.cache.deleteGkConfigMap(readPath);
-                const freshMap = await this.getGkConfigMap(readPath);
-                // Paths may have closed while the re-read was in flight; if every one did, there's nothing
-                // left to reconcile against.
-                if (!this.pruneClosedReconcilePaths(entry.paths).size)
-                    return 'reconciled';
-                if (this.cache.reconcileGkConfigMap(readPath, snapshot, freshMap)) {
-                    // Fire a follow-up change: a consumer that re-read on the original event may have done so
-                    // before this async cascade landed, so it would otherwise hold a stale derived value with
-                    // nothing left to prompt another re-read.
-                    for (const path of entry.paths.keys()) {
-                        this.context.hooks?.repository?.onChanged?.(path, ['gkConfig']);
-                    }
-                }
-                // `reconcileGkConfigMap` advanced the stored baseline to what we just read; a trailing pass
-                // diffs its own read against that.
-                snapshot = this.cache.getGkConfigMergeSnapshot(readPath);
-            } while (entry.pending);
-            return 'reconciled';
-        }
-        catch (ex) {
-            scope?.error(ex, `Failed to reconcile gk config for '${commonPath}'`);
-            // The caller falls back to the coarse clear — derived caches are otherwise left holding
-            // pre-change values with nothing to correct them.
-            return 'failed';
-        }
-        finally {
-            this._gkConfigReconciles.delete(commonPath);
-        }
-    }
-    async getSigningConfig(repoPath) {
-        // Fetch all signing-related config in one call
-        const configMap = await this.getConfigRegex(repoPath, '^(commit\\.gpgsign|gpg\\.format|user\\.signingkey|gpg\\.program|gpg\\.ssh\\.program|gpg\\.ssh\\.allowedsignersfile)$');
-        // Extract values (keys are lowercase in git output)
-        const enabledRaw = configMap.get('commit.gpgsign');
-        const format = configMap.get('gpg.format');
-        const signingKey = configMap.get('user.signingkey');
-        const gpgProgram = configMap.get('gpg.program');
-        const sshProgram = configMap.get('gpg.ssh.program');
-        const allowedSignersFile = configMap.get('gpg.ssh.allowedsignersfile');
-        // Check if git config has commit signing enabled, falling back to the host-level override
-        // (e.g. VS Code's `git.enableCommitSigning`) when `commit.gpgsign` is unset/false. The host
-        // override can only enable signing, never force it off.
-        const isEnabled = parseGitBoolean(enabledRaw) || this.context.config?.signing?.enabled === true;
-        return {
-            enabled: isEnabled,
-            format: format ?? 'gpg',
-            signingKey: signingKey,
-            gpgProgram: gpgProgram,
-            sshProgram: sshProgram,
-            allowedSignersFile: allowedSignersFile,
-        };
-    }
-    async validateSigningSetup(repoPath) {
-        const config = await this.getSigningConfig(repoPath);
-        if (!config.signingKey) {
-            return { valid: false, error: 'No signing key configured' };
-        }
-        // Basic validation: just check that a signing key is configured
-        // Git will handle the actual validation when signing commits
-        return { valid: true };
-    }
-    async setSigningConfig(repoPath, config, options) {
-        const scope = getScopedLogger();
-        try {
-            if (config.enabled != null) {
-                await this.setConfig(repoPath, 'commit.gpgsign', config.enabled ? 'true' : 'false', options);
-            }
-            if (config.format != null) {
-                await this.setConfig(repoPath, 'gpg.format', config.format, options);
-            }
-            if (config.signingKey != null) {
-                await this.setConfig(repoPath, 'user.signingkey', config.signingKey, options);
-            }
-            if (config.gpgProgram != null) {
-                await this.setConfig(repoPath, 'gpg.program', config.gpgProgram, options);
-            }
-            if (config.sshProgram != null) {
-                await this.setConfig(repoPath, 'gpg.ssh.program', config.sshProgram, options);
-            }
-            if (config.allowedSignersFile != null) {
-                await this.setConfig(repoPath, 'gpg.ssh.allowedSignersFile', config.allowedSignersFile, options);
-            }
-        }
-        catch (ex) {
-            scope?.error(ex);
-            throw ex;
-        }
-    }
-    getSigningConfigFlags(config) {
-        const flags = [];
-        if (config.gpgProgram) {
-            flags.push('-c', `gpg.program=${config.gpgProgram}`);
-        }
-        if (config.format && config.format !== 'gpg') {
-            flags.push('-c', `gpg.format=${config.format}`);
-        }
-        if (config.sshProgram) {
-            flags.push('-c', `gpg.ssh.program=${config.sshProgram}`);
-        }
-        if (config.allowedSignersFile) {
-            flags.push('-c', `gpg.ssh.allowedSignersFile=${config.allowedSignersFile}`);
-        }
-        return flags;
-    }
-    async getRepositoryInfo(cwd) {
-        let result;
-        if (this.context.workspace?.isTrusted === false) {
-            try {
-                await fs.stat(joinPaths(cwd, 'HEAD'));
-                result = await this.git.run({ cwd: cwd, errors: 'throw', configs: ['-C', cwd] }, 'rev-parse', '--show-cdup');
-                if (!result.stdout.trim()) {
-                    Logger.warn(`Skipping (untrusted); bare clone repository detected in '${cwd}'`);
-                    return emptyArray;
-                }
-            }
-            catch {
-                // If this throws, we should be good to open the repo
-            }
-        }
-        try {
-            result = await this.git.run({ cwd: cwd, errors: 'throw' }, 'rev-parse', '--show-toplevel', '--git-dir', '--git-common-dir', '--show-superproject-working-tree');
-            if (!result.stdout)
-                return emptyArray;
-            // Output is 3-4 lines: show-toplevel, git-dir, git-common-dir, [show-superproject-working-tree]
-            // The 4th line is only present for submodules
-            const lines = result.stdout.split('\n').map(r => r.trimStart());
-            const [repoPath, dotGitPath, commonDotGitPath, superprojectPath] = lines;
-            if (!repoPath)
-                return emptyArray;
-            const normalizedRepoPath = normalizePath(repoPath.replace(/[\r|\n]+$/, ''));
-            let gitDir = dotGitPath;
-            if (gitDir && !isAbsolute(gitDir)) {
-                gitDir = joinPaths(cwd, gitDir);
-            }
-            gitDir = normalizePath(gitDir);
-            let commonGitDir;
-            if (commonDotGitPath) {
-                commonGitDir = commonDotGitPath;
-                if (!isAbsolute(commonGitDir)) {
-                    commonGitDir = joinPaths(cwd, commonGitDir);
-                }
-                commonGitDir = normalizePath(commonGitDir);
-                if (commonGitDir === gitDir) {
-                    commonGitDir = undefined;
-                }
-            }
-            return {
-                repoPath: normalizedRepoPath,
-                gitDir: gitDir,
-                commonGitDir: commonGitDir,
-                superprojectPath: superprojectPath?.trim() || undefined,
-            };
-        }
-        catch (ex) {
-            if (ex instanceof WorkspaceUntrustedError)
-                return emptyArray;
-            const unsafeMatch = /(?:^fatal:\s*detected dubious ownership in repository at '([^']+)'|unsafe repository \('([^']+)' is owned by someone else\))[\s\S]*(git config --global --add safe\.directory [^\n\u2022]+)/m.exec(ex.stderr);
-            if (unsafeMatch != null) {
-                Logger.warn(`Skipping; unsafe repository detected in '${unsafeMatch[1] || unsafeMatch[2]}'; run '${unsafeMatch[3]}' to allow it`);
-                return [false];
-            }
-            const inDotGit = /this operation must be run in a work tree/.test(ex.stderr);
-            if (inDotGit && this.context.workspace?.isTrusted !== false) {
-                result = await this.git.run({ cwd: cwd, errors: 'ignore' }, 'rev-parse', '--is-bare-repository');
-                if (result.stdout.trim() === 'true') {
-                    const result = await this.revParseGitDir(cwd);
-                    const repoPath = result?.commonPath ?? result?.path;
-                    if (repoPath?.length)
-                        return [true, repoPath];
-                }
-            }
-            if (inDotGit || ex.code === 'ENOENT') {
-                let exists = inDotGit ? false : await fsExists(cwd);
-                if (!exists) {
-                    do {
-                        const parent = dirname(cwd);
-                        if (parent === cwd || parent.length === 0)
-                            return emptyArray;
-                        cwd = parent;
-                        exists = await fsExists(cwd);
-                    } while (!exists);
-                    return this.getRepositoryInfo(cwd);
-                }
-            }
-            return emptyArray;
-        }
-    }
-    async revParseGitDir(cwd) {
-        const result = await this.git.run({ cwd: cwd, errors: 'ignore' }, 'rev-parse', '--git-dir', '--git-common-dir');
-        if (!result.stdout)
-            return undefined;
-        let [dotGitPath, commonDotGitPath] = result.stdout.split('\n').map(r => r.trimStart());
-        if (!isAbsolute(dotGitPath)) {
-            dotGitPath = joinPaths(cwd, dotGitPath);
-        }
-        dotGitPath = normalizePath(dotGitPath);
-        if (commonDotGitPath) {
-            if (!isAbsolute(commonDotGitPath)) {
-                commonDotGitPath = joinPaths(cwd, commonDotGitPath);
-            }
-            commonDotGitPath = normalizePath(commonDotGitPath);
-            return { path: dotGitPath, commonPath: commonDotGitPath !== dotGitPath ? commonDotGitPath : undefined };
-        }
-        return { path: dotGitPath };
-    }
-    /**
-     * Ensures the `.git/gk/` folder exists, but only if the parent `.git` directory already exists.
-     * This prevents creating stray `.git` directories if the computed path is wrong.
-     * Returns `true` if the folder was ensured, `false` if the parent `.git` does not exist.
-     */
-    async ensureGkConfigFolder(gkConfigFolder, scope) {
-        // Verify the .git directory already exists — never create it from scratch
-        const dotGitDir = joinPaths(gkConfigFolder, '..');
-        try {
-            await fs.stat(dotGitDir);
-        }
-        catch {
-            scope?.warn(`Skipping GK config write — expected git directory '${dotGitDir}' does not exist`);
-            return false;
-        }
-        try {
-            await fs.mkdir(gkConfigFolder, { recursive: true });
-        }
-        catch (ex) {
-            scope?.error(ex, `Failed to create '${gkConfigFolder}' directory`);
-            return false;
-        }
-        return true;
-    }
-    _migratedRepos = new Set();
-    /**
-     * One-time migration of GK config entries from regular git config to `.git/gk/config`.
-     * If `.git/gk/config` already exists, assumes migration is complete (or data is already there).
-     * Preserves existing `.git/gk/config` values as source of truth (won't overwrite).
-     * Removes migrated keys from regular git config to stop cluttering it.
-     */
-    async migrateGkConfigFromGitConfig(repoPath) {
-        if (this._migratedRepos.has(repoPath))
-            return;
-        const scope = getScopedLogger();
-        const gkConfigPath = await this.getGkConfigPath(repoPath);
-        if (!gkConfigPath) {
-            this._migratedRepos.add(repoPath);
-            return;
-        }
-        const gkConfigFolder = joinPaths(gkConfigPath, '..');
-        // If .git/gk/config already exists, consider migration done — it was either
-        // already migrated or values were written there directly via setGkConfig
-        try {
-            await fs.stat(gkConfigPath);
-            this._migratedRepos.add(repoPath);
-            return;
-        }
-        catch {
-            // file doesn't exist, proceed with migration
-        }
-        // If .git/gk/config doesn't exist, create an empty file to prevent multiple migration attempts in future sessions
-        if (!(await this.ensureGkConfigFolder(gkConfigFolder, scope)))
-            return;
-        try {
-            await fs.writeFile(gkConfigPath, new Uint8Array());
-        }
-        catch (ex) {
-            scope?.error(ex, `Failed to create '${gkConfigPath}' file`);
-        }
-        // Read legacy gk-* keys from regular git config
-        let migrateConfig;
-        try {
-            migrateConfig = await this.getConfigRegexCore(repoPath, '^branch\\..*\\.gk-', { runGitLocally: true });
-        }
-        catch (ex) {
-            scope?.error(ex, 'Failed to read legacy GK config entries');
-            this._migratedRepos.add(repoPath);
-            return;
-        }
-        if (!migrateConfig.size) {
-            this._migratedRepos.add(repoPath);
-            return;
-        }
-        scope?.info(`Migrating ${String(migrateConfig.size)} GK config entries from git config to .git/gk/config`);
-        // Copy legacy entries to .git/gk/config
-        for (const [key, value] of [...migrateConfig]) {
-            try {
-                await this.setConfigCore(repoPath, key, value, { file: gkConfigPath });
-            }
-            catch (ex) {
-                scope?.error(ex, `Failed to migrate key '${key}' to GK config`);
-                // If we failed to migrate, delete it from the list so we won't try to remove it from git config later
-                migrateConfig.delete(key);
-            }
-        }
-        // Remove legacy keys from regular git config (use --unset-all defensively)
-        for (const [key] of migrateConfig) {
-            try {
-                await this.git.run({ cwd: repoPath, errors: 'ignore', runLocally: true }, 'config', '--local', '--unset-all', key);
-            }
-            catch (ex) {
-                scope?.error(ex, `Failed to remove migrated key '${key}' from git config`);
-            }
-        }
-        // Clear caches since we modified both config files
-        this.cache.clearCaches(repoPath, 'config', 'gkConfig');
-        this._migratedRepos.add(repoPath);
-    }
+function isGitBooleanFalse(value) {
+	const normalized = value.toLowerCase().trim();
+	return normalized === "" || normalized === "false" || normalized === "no" || normalized === "off" || normalized === "0";
 }
-__decorate([
-    trace()
-], ConfigGitSubProvider.prototype, "getConfig", null);
-__decorate([
-    trace()
-], ConfigGitSubProvider.prototype, "getConfigRegex", null);
-__decorate([
-    debug()
-], ConfigGitSubProvider.prototype, "setConfig", null);
-__decorate([
-    gate(),
-    debug()
-], ConfigGitSubProvider.prototype, "getCurrentUser", null);
-__decorate([
-    gate(),
-    trace({ exit: r => `returned ${r}` })
-], ConfigGitSubProvider.prototype, "getDefaultWorktreePath", null);
-__decorate([
-    gate(),
-    trace({
-        exit: r => `returned ${r.uri.toString(true)}, commonUri=${r.commonUri?.toString(true)}, parentUri=${r.parentUri?.toString(true)}`,
-    })
-], ConfigGitSubProvider.prototype, "getGitDir", null);
-__decorate([
-    debug()
-], ConfigGitSubProvider.prototype, "getGkConfig", null);
-__decorate([
-    debug()
-], ConfigGitSubProvider.prototype, "getGkConfigRegex", null);
-__decorate([
-    debug()
-], ConfigGitSubProvider.prototype, "setGkConfig", null);
-__decorate([
-    debug()
-], ConfigGitSubProvider.prototype, "removeGkConfigBranchSection", null);
-__decorate([
-    debug()
-], ConfigGitSubProvider.prototype, "renameGkConfigBranchSection", null);
-__decorate([
-    debug()
-], ConfigGitSubProvider.prototype, "getSigningConfig", null);
-__decorate([
-    debug()
-], ConfigGitSubProvider.prototype, "validateSigningSetup", null);
-__decorate([
-    debug()
-], ConfigGitSubProvider.prototype, "setSigningConfig", null);
-__decorate([
-    gate(),
-    debug()
-], ConfigGitSubProvider.prototype, "migrateGkConfigFromGitConfig", null);
+var ConfigGitSubProvider = class {
+	context;
+	git;
+	cache;
+	provider;
+	constructor(context, git, cache, provider) {
+		this.context = context;
+		this.git = git;
+		this.cache = cache;
+		this.provider = provider;
+		this.cache.setGkConfigReconciler((repoPath, priorSnapshot) => this.reconcileGkConfig(repoPath, priorSnapshot));
+	}
+	/**
+	* In-flight gk-config reconciles keyed by commonPath. `pending` records that another `'gkConfig'`
+	* event landed mid-pass, so one trailing pass runs after the current one settles. `paths` holds every
+	* worktree path that reported the change, mapped to its close generation at that moment — the pass
+	* reads through one that's still open and notifies all of them.
+	*/
+	_gkConfigReconciles = /* @__PURE__ */ new Map();
+	/**
+	* Pending `setGkConfig` writes keyed by `(commonPath, key, value, skip-option)`. Concurrent
+	* callers writing the same `(key, value)` pair share the in-flight Promise so only one
+	* `git config --set` subprocess actually runs. Cleared on settle.
+	*/
+	_pendingGkConfigWrites = /* @__PURE__ */ new Map();
+	getConfig(repoPath, key, options) {
+		const global = options?.global || repoPath == null;
+		return this.cache.getConfig(global ? void 0 : repoPath, key, () => this.getConfigCore(repoPath, key, options));
+	}
+	async getConfigCore(repoPath, key, options) {
+		const args = ["config", "--get"];
+		if (options?.file) args.push("-f", options.file);
+		else if (options?.global || repoPath == null) args.push("--global");
+		if (options?.type) args.push(`--type=${options.type}`);
+		args.push(key);
+		return (await this.git.run({
+			cwd: repoPath ?? "",
+			errors: "ignore",
+			runLocally: options?.runGitLocally
+		}, ...args)).stdout.trim() || void 0;
+	}
+	getConfigRegex(repoPath, pattern, options) {
+		const global = options?.global || repoPath == null;
+		return this.cache.getConfigRegex(global ? void 0 : repoPath, pattern, () => this.getConfigRegexCore(repoPath, pattern, options));
+	}
+	async getConfigRegexCore(repoPath, pattern, options) {
+		const args = ["config", "--get-regex"];
+		if (options?.file) args.push("-f", options.file);
+		else if (options?.global || repoPath == null) args.push("--global");
+		args.push(pattern);
+		return parseConfigRegexOutput((await this.git.run({
+			cwd: repoPath ?? "",
+			errors: "ignore",
+			runLocally: options?.runGitLocally
+		}, ...args)).stdout);
+	}
+	async setConfig(repoPath, key, value, options) {
+		return this.setConfigCore(repoPath, key, value, options);
+	}
+	async setConfigCore(repoPath, key, value, options) {
+		const args = ["config"];
+		if (options?.file) args.push("-f", options.file);
+		else {
+			const global = options?.global || repoPath == null;
+			args.push(global ? "--global" : "--local");
+		}
+		if (value == null) args.push("--unset", key);
+		else args.push(key, value);
+		await this.git.run({
+			cwd: repoPath ?? "",
+			runLocally: true
+		}, ...args);
+		if (!options?.file) {
+			const global = options?.global || repoPath == null;
+			this.cache.deleteConfig(global ? void 0 : repoPath, key);
+		}
+	}
+	async getCurrentUser(repoPath) {
+		if (!repoPath) return void 0;
+		const scope = getScopedLogger();
+		const cached = this.cache.currentUser.get(repoPath);
+		if (cached != null) return cached;
+		if (cached === null) return void 0;
+		const user = {
+			name: void 0,
+			email: void 0
+		};
+		try {
+			const configMap = await this.getConfigRegex(repoPath, "^user\\.(name|email)$", { runGitLocally: true });
+			if (configMap.size) {
+				user.name = configMap.get("user.name");
+				user.email = configMap.get("user.email");
+			} else {
+				user.name = env.GIT_AUTHOR_NAME || env.GIT_COMMITTER_NAME || userInfo()?.username || void 0;
+				if (!user.name) {
+					this.cache.currentUser.set(repoPath, null);
+					return;
+				}
+				user.email = env.GIT_AUTHOR_EMAIL || env.GIT_COMMITTER_EMAIL || env.EMAIL || `${user.name}@${hostname()}`;
+			}
+			const author = `${user.name} <${user.email}>`;
+			const result = await this.git.run({
+				cwd: repoPath,
+				errors: "ignore"
+			}, "check-mailmap", author);
+			if (result.stdout && result.stdout !== author) {
+				const match = mappedAuthorRegex.exec(result.stdout);
+				if (match != null) [, user.name, user.email] = match;
+			}
+			this.cache.currentUser.set(repoPath, user);
+			return user;
+		} catch (ex) {
+			scope?.error(ex);
+			this.cache.currentUser.set(repoPath, null);
+			return;
+		}
+	}
+	async getDefaultWorktreePath(repoPath) {
+		const gitDir = await this.getGitDir(repoPath);
+		if (gitDir == null) return void 0;
+		const basePath = (gitDir.commonUri ?? gitDir.uri).fsPath;
+		return getBestPath(normalizePath(joinPaths(basePath, "..")));
+	}
+	async getGitDir(repoPath) {
+		const cached = this.cache.gitDir.get(repoPath);
+		if (cached != null) return cached;
+		const scope = getScopedLogger();
+		const repoInfo = await this.getRepositoryInfo(repoPath);
+		let gitDir;
+		if (!Array.isArray(repoInfo) && repoInfo != null) gitDir = {
+			uri: fileUri(repoInfo.gitDir),
+			commonUri: repoInfo.commonGitDir ? fileUri(repoInfo.commonGitDir) : void 0,
+			parentUri: repoInfo.superprojectPath ? fileUri(repoInfo.superprojectPath) : void 0
+		};
+		else {
+			gitDir = { uri: this.provider.getAbsoluteUri(joinPaths(repoPath, ".git"), repoPath) };
+			const gitDirPath = gitDir.uri.toString(true);
+			scope?.warn(`rev-parse failed for '${repoPath}'; falling back to '${gitDirPath}'`);
+			this.context.hooks?.operations?.onGitDirResolveFailed?.(repoPath, gitDirPath, `rev_parse returned ${JSON.stringify(repoInfo)}`);
+		}
+		this.cache.gitDir.set(repoPath, gitDir);
+		return gitDir;
+	}
+	/**
+	* Gets the path to the .git/gk/config file for storing GitKraken-specific metadata.
+	* Uses commonPath for worktrees so all worktrees share the same data.
+	*/
+	async getGkConfigPath(repoPath) {
+		const gitDir = await this.getGitDir(repoPath);
+		if (gitDir == null) return void 0;
+		const basePath = (gitDir.commonUri ?? gitDir.uri).fsPath;
+		return joinPaths(basePath, "gk", "config");
+	}
+	async getGkConfig(repoPath, key) {
+		return (await this.getGkConfigMap(repoPath)).get(canonicalizeGitConfigKey(key)) || void 0;
+	}
+	async getGkConfigRegex(repoPath, pattern) {
+		const all = await this.getGkConfigMap(repoPath);
+		let re;
+		try {
+			re = new RegExp(pattern);
+		} catch {
+			return /* @__PURE__ */ new Map();
+		}
+		const result = /* @__PURE__ */ new Map();
+		for (const [k, v] of all) if (re.test(k)) result.set(k, v);
+		return result;
+	}
+	/**
+	* Reads the entire `.git/gk/config` in one `git config --get-regexp` and caches the parsed map
+	* per commonPath. Per-key (getGkConfig) and per-namespace (getGkConfigRegex) lookups are served
+	* from this single cached read — so a branch-overview render that fans out across several gk
+	* namespaces costs one `git config` call instead of one per namespace.
+	*/
+	async getGkConfigMap(repoPath) {
+		await this.migrateGkConfigFromGitConfig(this.cache.getCommonPath(repoPath));
+		return this.cache.getGkConfigMap(repoPath, async (cacheable) => {
+			const { map, failed } = await this.getGkConfigRegexCore(repoPath, gkConfigAllPattern);
+			if (failed) cacheable.invalidate();
+			return map;
+		});
+	}
+	async getGkConfigRegexCore(repoPath, pattern) {
+		const gkConfigPath = await this.getGkConfigPath(repoPath);
+		if (!gkConfigPath) return {
+			map: /* @__PURE__ */ new Map(),
+			failed: false
+		};
+		const result = await this.git.run({
+			cwd: repoPath,
+			errors: "ignore",
+			runLocally: true
+		}, "config", "--get-regex", "-f", gkConfigPath, pattern);
+		const exited = result.completion.status === "exited";
+		return {
+			map: parseConfigRegexOutput(result.stdout),
+			failed: !exited || result.exitCode !== 0 && result.exitCode !== 1
+		};
+	}
+	async setGkConfig(repoPath, key, value, options) {
+		const commonPath = this.cache.getCommonPath(repoPath);
+		const skipKey = options?.skipInvalidation?.length ? options.skipInvalidation.toSorted().join(",") : "";
+		const dedupKey = `${commonPath}\0${key}\0${value ?? ""}\0${skipKey}`;
+		const pending = this._pendingGkConfigWrites.get(dedupKey);
+		if (pending != null) return pending;
+		const promise = this.setGkConfigCore(repoPath, key, value, options);
+		this._pendingGkConfigWrites.set(dedupKey, promise);
+		promise.finally(() => this._pendingGkConfigWrites.delete(dedupKey)).catch(() => {});
+		return promise;
+	}
+	async setGkConfigCore(repoPath, key, value, options) {
+		const scope = getScopedLogger();
+		const gkConfigPath = await this.getGkConfigPath(repoPath);
+		if (!gkConfigPath) return;
+		const gkConfigFolder = joinPaths(gkConfigPath, "..");
+		if (!await this.ensureGkConfigFolder(gkConfigFolder, scope)) return;
+		await this.setConfigCore(repoPath, key, value, { file: gkConfigPath });
+		this.cache.deleteGkConfig(repoPath, key, options);
+		this.cache.recordGkConfigWrite(repoPath, key, value);
+	}
+	async removeGkConfigBranchSection(repoPath, ref) {
+		await this.runGkConfigSectionCommand(repoPath, ref, "--remove-section", `branch.${ref}`);
+	}
+	async renameGkConfigBranchSection(repoPath, oldRef, newRef) {
+		await this.removeGkConfigBranchSection(repoPath, newRef);
+		await this.runGkConfigSectionCommand(repoPath, oldRef, "--rename-section", `branch.${oldRef}`, `branch.${newRef}`);
+	}
+	/**
+	* Runs a section-level `git config` against `.git/gk/config` for `ref`'s section, skipping the
+	* subprocess entirely when the bulk map (already cached on any warm path) shows that ref has no gk
+	* keys — the overwhelmingly common case, since most branches never get gk metadata written at all.
+	*
+	* Never throws: callers invoke this as bookkeeping after a branch op has already succeeded, so a
+	* failure here must not be reported as (or roll back) the branch/checkout/worktree operation itself.
+	* The worst case is metadata that stays behind until the next op on that name.
+	*/
+	async runGkConfigSectionCommand(repoPath, ref, ...args) {
+		const scope = getScopedLogger();
+		try {
+			const prefix = `branch.${ref}.`;
+			const map = await this.getGkConfigMap(repoPath);
+			if (map.size && !some(map.keys(), (k) => k.startsWith(prefix))) return;
+			const gkConfigPath = await this.getGkConfigPath(repoPath);
+			if (!gkConfigPath) return;
+			if (!await fsExists(gkConfigPath)) return;
+			const result = await this.git.run({
+				cwd: repoPath,
+				runLocally: true,
+				errors: "ignore"
+			}, "config", "-f", gkConfigPath, ...args);
+			if (result.completion.status !== "exited" || result.exitCode !== 0) scope?.warn(`Failed to update gk config section for '${ref}' in '${repoPath}': ${result.completion.status === "exited" ? `git config exited ${result.exitCode}` : `${result.completion.status} · ${result.completion.error.message}`}`);
+			this.cache.deleteGkConfigMap(repoPath);
+		} catch (ex) {
+			scope?.error(ex, `Failed to update gk config section for '${ref}' in '${repoPath}'`);
+		}
+	}
+	/**
+	* Reconciles a watcher-observed `'gkConfig'` change — registered with the shared `Cache` as its
+	* gk-config reconciler (see the constructor). Re-reads the bulk map (hard-evicted by
+	* `Cache.handleGkConfigChanged`, so this hits disk) and diffs it against `priorSnapshot` to cascade
+	* `baseBranchName`/`branchOverviews` only for refs whose merge-relevant keys actually changed.
+	*
+	* Serialized per commonPath: a reconcile is a read-then-diff against a single shared baseline, so
+	* two overlapping passes would both diff against the same snapshot and the later change could fall
+	* out entirely. An event arriving mid-pass instead queues one trailing pass, which re-reads and
+	* diffs against the baseline the previous pass just established.
+	*
+	* `.git/gk/config` lives in the common dir, so the watcher delivers one event per worktree sharing it
+	* (see `WatchGroup.onCommonEvent`). Siblings never run concurrently — the later ones fold into the
+	* in-flight pass — but folding in arms the trailing pass, so a fan-out costs one extra read that
+	* re-reads and diffs an unchanged file. However many siblings land while a pass is running, they
+	* coalesce into that single trailing pass; the cost is the price of never dropping a real change.
+	* Every reporting path is retained because `Repository` matches the follow-up change event on exact
+	* path, and a sibling worktree that never receives one would sit on stale derived values.
+	*/
+	reconcileGkConfig(repoPath, priorSnapshot) {
+		const commonPath = this.cache.getCommonPath(repoPath);
+		const inflight = this._gkConfigReconciles.get(commonPath);
+		if (inflight != null) {
+			inflight.paths.set(repoPath, this.cache.getCloseGeneration(repoPath));
+			inflight.pending = true;
+			return "deferred";
+		}
+		const entry = {
+			pending: false,
+			paths: /* @__PURE__ */ new Map([[repoPath, this.cache.getCloseGeneration(repoPath)]])
+		};
+		this._gkConfigReconciles.set(commonPath, entry);
+		return this.runGkConfigReconcile(commonPath, priorSnapshot, entry);
+	}
+	/** Drops paths that closed since they reported the change; returns whichever remain. */
+	pruneClosedReconcilePaths(paths) {
+		for (const [path, generation] of paths) if (this.cache.getCloseGeneration(path) !== generation) paths.delete(path);
+		return paths;
+	}
+	async runGkConfigReconcile(commonPath, priorSnapshot, entry) {
+		const scope = getScopedLogger();
+		let snapshot = priorSnapshot;
+		try {
+			do {
+				entry.pending = false;
+				const readPath = first(this.pruneClosedReconcilePaths(entry.paths).keys());
+				if (readPath == null) return "reconciled";
+				this.cache.deleteGkConfigMap(readPath);
+				const freshMap = await this.getGkConfigMap(readPath);
+				if (!this.pruneClosedReconcilePaths(entry.paths).size) return "reconciled";
+				if (this.cache.reconcileGkConfigMap(readPath, snapshot, freshMap)) for (const path of entry.paths.keys()) this.context.hooks?.repository?.onChanged?.(path, ["gkConfig"]);
+				snapshot = this.cache.getGkConfigMergeSnapshot(readPath);
+			} while (entry.pending);
+			return "reconciled";
+		} catch (ex) {
+			scope?.error(ex, `Failed to reconcile gk config for '${commonPath}'`);
+			return "failed";
+		} finally {
+			this._gkConfigReconciles.delete(commonPath);
+		}
+	}
+	async getSigningConfig(repoPath) {
+		const configMap = await this.getConfigRegex(repoPath, "^(commit\\.gpgsign|gpg\\.format|user\\.signingkey|gpg\\.program|gpg\\.ssh\\.program|gpg\\.ssh\\.allowedsignersfile)$");
+		const enabledRaw = configMap.get("commit.gpgsign");
+		const format = configMap.get("gpg.format");
+		const signingKey = configMap.get("user.signingkey");
+		const gpgProgram = configMap.get("gpg.program");
+		const sshProgram = configMap.get("gpg.ssh.program");
+		const allowedSignersFile = configMap.get("gpg.ssh.allowedsignersfile");
+		return {
+			enabled: parseGitBoolean(enabledRaw) || this.context.config?.signing?.enabled === true,
+			format: format ?? "gpg",
+			signingKey,
+			gpgProgram,
+			sshProgram,
+			allowedSignersFile
+		};
+	}
+	async validateSigningSetup(repoPath) {
+		if (!(await this.getSigningConfig(repoPath)).signingKey) return {
+			valid: false,
+			error: "No signing key configured"
+		};
+		return { valid: true };
+	}
+	async setSigningConfig(repoPath, config, options) {
+		const scope = getScopedLogger();
+		try {
+			if (config.enabled != null) await this.setConfig(repoPath, "commit.gpgsign", config.enabled ? "true" : "false", options);
+			if (config.format != null) await this.setConfig(repoPath, "gpg.format", config.format, options);
+			if (config.signingKey != null) await this.setConfig(repoPath, "user.signingkey", config.signingKey, options);
+			if (config.gpgProgram != null) await this.setConfig(repoPath, "gpg.program", config.gpgProgram, options);
+			if (config.sshProgram != null) await this.setConfig(repoPath, "gpg.ssh.program", config.sshProgram, options);
+			if (config.allowedSignersFile != null) await this.setConfig(repoPath, "gpg.ssh.allowedSignersFile", config.allowedSignersFile, options);
+		} catch (ex) {
+			scope?.error(ex);
+			throw ex;
+		}
+	}
+	getSigningConfigFlags(config) {
+		const flags = [];
+		if (config.gpgProgram) flags.push("-c", `gpg.program=${config.gpgProgram}`);
+		if (config.format && config.format !== "gpg") flags.push("-c", `gpg.format=${config.format}`);
+		if (config.sshProgram) flags.push("-c", `gpg.ssh.program=${config.sshProgram}`);
+		if (config.allowedSignersFile) flags.push("-c", `gpg.ssh.allowedSignersFile=${config.allowedSignersFile}`);
+		return flags;
+	}
+	async getRepositoryInfo(cwd) {
+		let result;
+		if (this.context.workspace?.isTrusted === false) try {
+			await promises.stat(joinPaths(cwd, "HEAD"));
+			result = await this.git.run({
+				cwd,
+				errors: "throw",
+				configs: ["-C", cwd]
+			}, "rev-parse", "--show-cdup");
+			if (!result.stdout.trim()) {
+				_logger.warn(`Skipping (untrusted); bare clone repository detected in '${cwd}'`);
+				return emptyArray;
+			}
+		} catch {}
+		try {
+			result = await this.git.run({
+				cwd,
+				errors: "throw"
+			}, "rev-parse", "--show-toplevel", "--git-dir", "--git-common-dir", "--show-superproject-working-tree");
+			if (!result.stdout) return emptyArray;
+			const [repoPath, dotGitPath, commonDotGitPath, superprojectPath] = result.stdout.split("\n").map((r) => r.trimStart());
+			if (!repoPath) return emptyArray;
+			const normalizedRepoPath = normalizePath(repoPath.replace(/[\r|\n]+$/, ""));
+			let gitDir = dotGitPath;
+			if (gitDir && !isAbsolute(gitDir)) gitDir = joinPaths(cwd, gitDir);
+			gitDir = normalizePath(gitDir);
+			let commonGitDir;
+			if (commonDotGitPath) {
+				commonGitDir = commonDotGitPath;
+				if (!isAbsolute(commonGitDir)) commonGitDir = joinPaths(cwd, commonGitDir);
+				commonGitDir = normalizePath(commonGitDir);
+				if (commonGitDir === gitDir) commonGitDir = void 0;
+			}
+			return {
+				repoPath: normalizedRepoPath,
+				gitDir,
+				commonGitDir,
+				superprojectPath: superprojectPath?.trim() || void 0
+			};
+		} catch (ex) {
+			if (ex instanceof WorkspaceUntrustedError) return emptyArray;
+			const unsafeMatch = /(?:^fatal:\s*detected dubious ownership in repository at '([^']+)'|unsafe repository \('([^']+)' is owned by someone else\))[\s\S]*(git config --global --add safe\.directory [^\n\u2022]+)/m.exec(ex.stderr);
+			if (unsafeMatch != null) {
+				_logger.warn(`Skipping; unsafe repository detected in '${unsafeMatch[1] || unsafeMatch[2]}'; run '${unsafeMatch[3]}' to allow it`);
+				return [false];
+			}
+			const inDotGit = /this operation must be run in a work tree/.test(ex.stderr);
+			if (inDotGit && this.context.workspace?.isTrusted !== false) {
+				result = await this.git.run({
+					cwd,
+					errors: "ignore"
+				}, "rev-parse", "--is-bare-repository");
+				if (result.stdout.trim() === "true") {
+					const result = await this.revParseGitDir(cwd);
+					const repoPath = result?.commonPath ?? result?.path;
+					if (repoPath?.length) return [true, repoPath];
+				}
+			}
+			if (inDotGit || ex.code === "ENOENT") {
+				let exists = inDotGit ? false : await fsExists(cwd);
+				if (!exists) {
+					do {
+						const parent = dirname(cwd);
+						if (parent === cwd || parent.length === 0) return emptyArray;
+						cwd = parent;
+						exists = await fsExists(cwd);
+					} while (!exists);
+					return this.getRepositoryInfo(cwd);
+				}
+			}
+			return emptyArray;
+		}
+	}
+	async revParseGitDir(cwd) {
+		const result = await this.git.run({
+			cwd,
+			errors: "ignore"
+		}, "rev-parse", "--git-dir", "--git-common-dir");
+		if (!result.stdout) return void 0;
+		let [dotGitPath, commonDotGitPath] = result.stdout.split("\n").map((r) => r.trimStart());
+		if (!isAbsolute(dotGitPath)) dotGitPath = joinPaths(cwd, dotGitPath);
+		dotGitPath = normalizePath(dotGitPath);
+		if (commonDotGitPath) {
+			if (!isAbsolute(commonDotGitPath)) commonDotGitPath = joinPaths(cwd, commonDotGitPath);
+			commonDotGitPath = normalizePath(commonDotGitPath);
+			return {
+				path: dotGitPath,
+				commonPath: commonDotGitPath !== dotGitPath ? commonDotGitPath : void 0
+			};
+		}
+		return { path: dotGitPath };
+	}
+	/**
+	* Ensures the `.git/gk/` folder exists, but only if the parent `.git` directory already exists.
+	* This prevents creating stray `.git` directories if the computed path is wrong.
+	* Returns `true` if the folder was ensured, `false` if the parent `.git` does not exist.
+	*/
+	async ensureGkConfigFolder(gkConfigFolder, scope) {
+		const dotGitDir = joinPaths(gkConfigFolder, "..");
+		try {
+			await promises.stat(dotGitDir);
+		} catch {
+			scope?.warn(`Skipping GK config write — expected git directory '${dotGitDir}' does not exist`);
+			return false;
+		}
+		try {
+			await promises.mkdir(gkConfigFolder, { recursive: true });
+		} catch (ex) {
+			scope?.error(ex, `Failed to create '${gkConfigFolder}' directory`);
+			return false;
+		}
+		return true;
+	}
+	_migratedRepos = /* @__PURE__ */ new Set();
+	/**
+	* One-time migration of GK config entries from regular git config to `.git/gk/config`.
+	* If `.git/gk/config` already exists, assumes migration is complete (or data is already there).
+	* Preserves existing `.git/gk/config` values as source of truth (won't overwrite).
+	* Removes migrated keys from regular git config to stop cluttering it.
+	*/
+	async migrateGkConfigFromGitConfig(repoPath) {
+		if (this._migratedRepos.has(repoPath)) return;
+		const scope = getScopedLogger();
+		const gkConfigPath = await this.getGkConfigPath(repoPath);
+		if (!gkConfigPath) {
+			this._migratedRepos.add(repoPath);
+			return;
+		}
+		const gkConfigFolder = joinPaths(gkConfigPath, "..");
+		try {
+			await promises.stat(gkConfigPath);
+			this._migratedRepos.add(repoPath);
+			return;
+		} catch {}
+		if (!await this.ensureGkConfigFolder(gkConfigFolder, scope)) return;
+		try {
+			await promises.writeFile(gkConfigPath, /* @__PURE__ */ new Uint8Array());
+		} catch (ex) {
+			scope?.error(ex, `Failed to create '${gkConfigPath}' file`);
+		}
+		let migrateConfig;
+		try {
+			migrateConfig = await this.getConfigRegexCore(repoPath, "^branch\\..*\\.gk-", { runGitLocally: true });
+		} catch (ex) {
+			scope?.error(ex, "Failed to read legacy GK config entries");
+			this._migratedRepos.add(repoPath);
+			return;
+		}
+		if (!migrateConfig.size) {
+			this._migratedRepos.add(repoPath);
+			return;
+		}
+		scope?.info(`Migrating ${String(migrateConfig.size)} GK config entries from git config to .git/gk/config`);
+		for (const [key, value] of [...migrateConfig]) try {
+			await this.setConfigCore(repoPath, key, value, { file: gkConfigPath });
+		} catch (ex) {
+			scope?.error(ex, `Failed to migrate key '${key}' to GK config`);
+			migrateConfig.delete(key);
+		}
+		for (const [key] of migrateConfig) try {
+			await this.git.run({
+				cwd: repoPath,
+				errors: "ignore",
+				runLocally: true
+			}, "config", "--local", "--unset-all", key);
+		} catch (ex) {
+			scope?.error(ex, `Failed to remove migrated key '${key}' from git config`);
+		}
+		this.cache.clearCaches(repoPath, "config", "gkConfig");
+		this._migratedRepos.add(repoPath);
+	}
+};
+__decorate([trace()], ConfigGitSubProvider.prototype, "getConfig", null);
+__decorate([trace()], ConfigGitSubProvider.prototype, "getConfigRegex", null);
+__decorate([debug()], ConfigGitSubProvider.prototype, "setConfig", null);
+__decorate([gate(), debug()], ConfigGitSubProvider.prototype, "getCurrentUser", null);
+__decorate([gate(), trace({ exit: (r) => `returned ${r}` })], ConfigGitSubProvider.prototype, "getDefaultWorktreePath", null);
+__decorate([gate(), trace({ exit: (r) => `returned ${r.uri.toString(true)}, commonUri=${r.commonUri?.toString(true)}, parentUri=${r.parentUri?.toString(true)}` })], ConfigGitSubProvider.prototype, "getGitDir", null);
+__decorate([debug()], ConfigGitSubProvider.prototype, "getGkConfig", null);
+__decorate([debug()], ConfigGitSubProvider.prototype, "getGkConfigRegex", null);
+__decorate([debug()], ConfigGitSubProvider.prototype, "setGkConfig", null);
+__decorate([debug()], ConfigGitSubProvider.prototype, "removeGkConfigBranchSection", null);
+__decorate([debug()], ConfigGitSubProvider.prototype, "renameGkConfigBranchSection", null);
+__decorate([debug()], ConfigGitSubProvider.prototype, "getSigningConfig", null);
+__decorate([debug()], ConfigGitSubProvider.prototype, "validateSigningSetup", null);
+__decorate([debug()], ConfigGitSubProvider.prototype, "setSigningConfig", null);
+__decorate([gate(), debug()], ConfigGitSubProvider.prototype, "migrateGkConfigFromGitConfig", null);
+//#endregion
+export { ConfigGitSubProvider, canonicalizeGitConfigKey, isGitBooleanFalse, parseConfigRegexOutput, parseGitBoolean };
+
 //# sourceMappingURL=config.js.map