@gitkraken/core-gitlens 0.5.116 → 0.7.0

package/dist/git-cli/providers/maintenance.d.ts

@@ -1,306 +1,308 @@
-import type { Cache } from '../../git/cache.js';
-import type { GitServiceContext } from '../../git/context.js';
-import type { GitHealthDetails, GitHealthSnapshot, GitMaintenanceSubProvider, GitMaintenanceTask, GitOptimizationCapability, GitOptimizationId } from '../../git/providers/maintenance.js';
-import type { CliGitProviderInternal } from '../cliGitProvider.js';
-import type { Git } from '../exec/git.js';
+import { GitServiceContext } from "../../git/context.js";
+import { GitHealthDetails, GitHealthSnapshot, GitMaintenanceSubProvider, GitMaintenanceTask, GitOptimizationCapability, GitOptimizationId } from "../../git/providers/maintenance.js";
+import { Cache } from "../../git/cache.js";
+import { Git } from "../exec/git.js";
+import { CliGitProviderInternal } from "../cliGitProvider.js";
+//#region ../git-cli/src/providers/maintenance.d.ts
 export declare class MaintenanceGitSubProvider implements GitMaintenanceSubProvider {
-    private readonly context;
-    private readonly git;
-    private readonly cache;
-    private readonly provider;
-    constructor(context: GitServiceContext, git: Git, cache: Cache, provider: CliGitProviderInternal);
-    private readonly commitGraphWrittenAt;
-    private readonly commitGraphWriteInflight;
-    request(repoPath: string, task: GitMaintenanceTask): Promise<boolean> | undefined;
-    /**
-     * Opportunistically refreshes git's commit-graph (the demand cadence behind `request('commit-graph')`).
-     * Without one that COVERS the history, any ordered walk (`--date-order`/`--topo-order` — exactly the
-     * graph's initial load) must inflate every commit object to sort BEFORE the first row can be emitted,
-     * costing a full-history walk per open; the commit-graph also accelerates `git log`, merge-base, and
-     * ahead/behind across the whole extension. It's a standard acceleration cache (`git gc`/`git maintenance`
-     * write it routinely) and is always safe to delete. Fire-and-forget: refreshed at most every few minutes
-     * per object database (a current chain makes the write a near-no-op), at background queue priority,
-     * failures swallowed. Cross-WINDOW writes aren't coordinated here — git's own `commit-graph-chain.lock`
-     * serializes them; a loser errors and is swallowed. Resolves `true` only when the write completes; the
-     * health service uses that signal for one post-write freshness probe, while graph consumers ignore it.
-     */
-    private ensureCommitGraph;
-    /** Shared opt-out gate for automatic and explicit writes. */
-    private isCommitGraphWriteDisabled;
-    /**
-     * The commit-graph write itself. Always a `--split` write: mere existence isn't enough (a stale or thin
-     * chain — e.g. one auto-gc increment — accelerates nothing); `--split` appends an incremental layer
-     * covering only the uncovered commits (near-no-op when current) and git self-merges layers by its
-     * geometric policy. Background priority: a first write on a huge repo can run for a while and must never
-     * hold a queue slot ahead of interactive work. Throws on failure — callers decide whether to swallow.
-     */
-    private writeCommitGraph;
-    /** Config-only partial/promisor detection; never examines an object and therefore cannot itself lazy-fetch. */
-    private isPartialClone;
-    /** Honors an explicit MIDX opt-out on both automatic and user-invoked incremental repacks. */
-    private isMultiPackIndexEnabled;
-    getHealthSnapshot(repoPath: string, cancellation?: AbortSignal): Promise<GitHealthSnapshot>;
-    /**
-     * Reads all Git Health gk markers (not-applicable flags + `gk.applied.*` ownership) from ONE bulk
-     * `.git/gk/config` read (git lowercases the section + variable in `--get-regexp` output, preserving the
-     * `applied` subsection). A read failure degrades to all-false — the report just re-suggests, never crashes.
-     */
-    private probeGkMarkers;
-    getHealthDetails(repoPath: string, cancellation?: AbortSignal): Promise<GitHealthDetails>;
-    private _capabilities;
-    getCapabilities(_repoPath: string): Promise<GitOptimizationCapability[]>;
-    private getCapabilitiesCore;
-    runMaintenanceTask(repoPath: string, task: GitMaintenanceTask, options?: {
-        readonly auto?: boolean;
-        readonly cancellation?: AbortSignal;
-    }): Promise<boolean>;
-    applyOptimization(repoPath: string, id: GitOptimizationId, cancellation?: AbortSignal): Promise<boolean>;
-    revertOptimization(repoPath: string, id: GitOptimizationId, cancellation?: AbortSignal): Promise<void>;
-    /**
-     * The Git Health per-repository commit-graph off switch (`gk.commitGraphDisabled`). Unlike the
-     * ownership markers above, this isn't a "record prior, then restore" lever — it's a plain flag with no
-     * underlying config value to protect — so it needs no marker lock; two windows toggling it concurrently
-     * just resolve to whichever write lands last.
-     */
-    setCommitGraphDisabled(repoPath: string, disabled: boolean, cancellation?: AbortSignal): Promise<void>;
-    private applyUntrackedCache;
-    /** Whether git's filesystem probe says the untracked cache can be used here (exit 0). */
-    private testUntrackedCacheSupport;
-    private applyFsmonitor;
-    private applyManyFiles;
-    /** Enables sparse-directory index entries for an existing cone-mode sparse checkout. */
-    private applySparseIndex;
-    /** Expands a sparse index only when this worktree's marker proves GitLens enabled it. */
-    private revertSparseIndex;
-    private runSparseCheckoutReapply;
-    /**
-     * The `git maintenance start` version gate for the current platform: launchctl/schtasks scheduling
-     * (win/mac) needs 2.31; Linux relies on a systemd timer (2.34), since 2.31–2.33 is cron-only and
-     * modern distros often ship without cron.
-     */
-    private get backgroundMaintenanceFeature();
-    private startBackgroundMaintenance;
-    private revertBackgroundMaintenance;
-    /**
-     * Records a config lever's prior LOCAL value (or the `unset` sentinel) under its ownership marker BEFORE
-     * mutating, so undo restores the exact prior and never a hardcoded inverse; the marker's presence also
-     * means "applied by GitLens" (so undo is never offered for a user-enabled lever).
-     */
-    private recordPriorAndMark;
-    /** The body of {@link recordPriorAndMark}, for callers already holding the marker lock. */
-    private recordPriorUnlocked;
-    /**
-     * Reconciles write-ahead records left by an interrupted direct config mutation. The cached namespace read
-     * keeps the normal probe free of extra subprocesses; an actual pending record is re-read under the marker
-     * lock before it is finalized or cleared.
-     */
-    private reconcilePendingConfigChanges;
-    /** Body of {@link reconcilePendingConfigChanges} for a caller already holding the marker lock. */
-    private reconcilePendingConfigChangesUnlocked;
-    /**
-     * Applies direct config levers for a caller holding the ownership-marker lock. A write-ahead record closes
-     * the crash gap between the local config and ownership files; an ordinary failure restores every config
-     * value and marker without cancellation.
-     */
-    private applyConfigChangesUnlocked;
-    claimMaintenancePass(repoPath: string, intervalMs: number): Promise<boolean>;
-    /** The `.git/gk/` directory (common dir, so worktrees of a repo share it). */
-    private getGkDir;
-    private getSparseIndexMarkerPaths;
-    /**
-     * Reconciles the sparse-index command's worktree-local write-ahead marker. The fast path is filesystem
-     * only; a pending or stale-applied marker takes the worktree's sparse-index operation lock and re-reads
-     * Git config before mutating anything, so it cannot act on a snapshot that raced another window's
-     * apply/undo. A live operation keeps that lock across the index rewrite, but snapshots never wait for it:
-     * they return the last committed marker state until the operation publishes its result.
-     */
-    private reconcileSparseIndexMarkers;
-    /** Body of {@link reconcileSparseIndexMarkers} for a caller already holding the ownership lock. */
-    private reconcileSparseIndexMarkersUnlocked;
-    /** Reads the effective worktree-scoped sparse-index switch without relying on a cached config map. */
-    private probeSparseIndexEnabled;
-    /** Reads an ownership marker straight from `.git/gk/config`, bypassing every cache. */
-    private readGkMarkerUncached;
-    /**
-     * Runs `fn` holding an exclusive on-disk lock over one ownership-marker scope. By default that is the
-     * repository family's config-marker scope; callers can provide a worktree-local lock location for an
-     * operation whose state is isolated per worktree. Two layers make this safe across processes:
-     *
-     * - **Exclusive-create ownership, with an identity record.** `open(lockPath, 'wx')` — the same `O_EXCL`
-     *   primitive git uses for its own `*.lock` files — is the only atomic step; a contender that loses the
-     *   race retries for up to `maxAttempts`, then fails loudly rather than proceeding unlocked (see below).
-     *   The winner immediately writes its host, pid, and a fresh random `ownerId` into the lock file — an
-     *   identity record, not a liveness lease, since nothing here ever acts on it while another holder is
-     *   still running.
-     * - **Ownership-verified release.** On the way out, the lock file is removed only if its `ownerId` still
-     *   matches the one this call wrote — a fresh random value per acquisition can't collide with a
-     *   re-created lock the way an inode COULD in principle on some filesystems, so it's the primary check;
-     *   the inode is also compared as a cheap secondary one.
-     *
-     * A lock left behind by a crashed window is deliberately NOT recovered automatically. Two designs were
-     * tried and rejected. Time-based leasing can't tell a dead owner from a slow one — an age alone doesn't
-     * distinguish them (git timeouts are user-configurable, and can be disabled entirely), and making it tell
-     * them apart takes a full lease-plus-fencing-token protocol this lock has no need for otherwise.
-     * Automatic stealing (rename the lock aside once a PID probe says its owner is provably dead) was tried
-     * next, and is unsound for a different reason: automatic recovery of an abandoned fixed-path lock cannot
-     * be made race-free using only the portable stock-Node primitives available here (exclusive-create and
-     * rename) — every recovery attempt separates observation from mutation, so a delayed stealer can rename
-     * away a NEW, live lock a fresh contender created in the gap between the probe and the rename, evicting a
-     * holder that was never dead. Kernel-managed advisory locking (`flock`) would close that gap, but Node
-     * exposes no portable interface to it and a native, platform-sensitive dependency is disproportionate
-     * here. Therefore a contender NEVER mutates an existing lock — only the creator removes one, and no stale
-     * observation can authorize mutation. Recovery is a guided MANUAL step instead: a give-up runs the same PID
-     * probe ONCE, purely to choose the error's wording. For the sparse-operation lock, a confirmed-live owner gets
-     * wait-only guidance, a confirmed-dead owner gets crash-recovery guidance, and an unverifiable owner gets the
-     * lock path plus guarded manual-recovery guidance. The shared marker lock retains its generic non-dead error.
-     * No verdict authorizes an automatic steal.
-     *
-     * Because a live holder can't lose its lock, `fn` needs no cancellation coupling to the lock itself — the
-     * critical section only ever ends on its own terms.
-     *
-     * Acquisition beyond the initial `open` is not atomic: the ownership record is written in a separate step
-     * just after. A crash landing exactly there — not caught by anything, since the process is gone — leaves
-     * a permanently-empty orphan lock; the give-up error's manual-deletion instructions are the only recovery
-     * for that case, same as for a confirmed-dead owner. A failure our OWN code can observe in that window
-     * (the post-`mkdir` setup, or the ownership write itself) is different: it fails closed, removing the
-     * lock it just created — ownership is certain there, since we hold the only handle — before rethrowing,
-     * so a transient error (e.g. `ENOSPC`) never strands a lock nothing can ever prove dead.
-     *
-     * Deliberately NOT named `config.lock` — that's the name git takes when writing `.git/gk/config` itself.
-     */
-    private withMarkerLock;
-    /**
-     * Diagnoses the process recorded in `lockPath` for the give-up error's wording ONLY — see
-     * `withMarkerLock`'s doc comment for why a verdict never causes an automatic steal. Returns 'dead' only when
-     * the OS kill-probe returns `ESRCH`, 'alive' when it succeeds, and 'unverifiable' for unreadable/malformed
-     * content, a lock recorded on another host, or a probe that fails with anything but `ESRCH`.
-     */
-    private probeLockOwner;
-    /**
-     * Reverts a config lever GitLens applied: restores its recorded prior LOCAL value (set it back, or unset
-     * when the prior was absent) and clears the marker. Returns `false` (a no-op) when no marker exists —
-     * a lever the user enabled themselves is never touched.
-     */
-    private revertConfigLever;
-    /** Restores a lever's config to its recorded prior after a failed apply, then drops the ownership marker. */
-    private restorePriorAndClear;
-    /** Sets a local config value back to a recorded prior, decoding the `unset`/`empty` sentinels. */
-    private restoreLocalConfig;
-    /** Writes a gk marker, swallowing+logging any failure — a marker write must never fail the apply itself. */
-    private markGkConfigSafe;
-    /**
-     * Throws when a run that swallowed its errors (`errors: 'ignore'`) was actually cancelled or never ran.
-     * Such a run resolves with no meaningful exit code, so `completion` — not `exitCode` — is the only thing
-     * that proves a command ran. Without this a timeout reads as a clean success, and a safety probe or an
-     * undo would act on a command that never happened.
-     */
-    private throwIfDidNotComplete;
-    /**
-     * Reads a config key's LOCAL-scope value (independent of global/system config). `undefined` when unset.
-     *
-     * Uses `--get-regex` (anchored to the exact key), not `--get`: `--get` exits 0 with EMPTY stdout for
-     * BOTH a bareword entry (`[section]\n\tkey`, valid syntax, git-boolean TRUE) and an explicit empty value
-     * (`key =`, git-boolean FALSE) — indistinguishable, which would record a bareword-true prior as the
-     * `unset` sentinel and let undo flip the user's true to false. `--get-regex` prints the two differently
-     * (a bareword line has no space; an empty value keeps a trailing one), which `parseConfigRegexOutput`'s
-     * `includeValueless` tells apart; for a multi-valued key it also prints every value in file order, so the
-     * LAST line in the map is still the `--get`-equivalent value.
-     */
-    private getLocalConfig;
-    /** Sets a LOCAL config value. Throws the git error on a genuine write failure (config refused). */
-    private setLocalConfig;
-    private unsetLocalConfig;
-    /** Best-effort run; returns the result so callers that must distinguish "didn't run" can check it. */
-    private runQuietly;
-    private probeConfig;
-    private _registeredMaintenanceRepos;
-    /** The global `maintenance.repo` list. Throws rather than reporting an unreadable list as "none". */
-    private readRegisteredMaintenancePaths;
-    /**
-     * `git maintenance register` stores the symlink-RESOLVED worktree path, while GitLens deliberately keeps
-     * the symlinked path as the repo path — so match against both spellings.
-     */
-    private matchesRegistered;
-    /** Each path plus its symlink-resolved spelling — `maintenance register` stores the resolved one. */
-    private resolveRegistrationCandidates;
-    /**
-     * Whether ANY worktree of this repo family is registered — the DETECTION question ("should we suggest
-     * this?"). Family-wide, because a sibling the user registered already covers the shared object database,
-     * and suggesting it again would leave two scheduled entries for one repo.
-     */
-    private isMaintenanceRegistered;
-    /**
-     * Whether ONE specific path is registered — the OWNERSHIP question ("did our unregister take?"). Never
-     * ask this family-wide: a sibling the user registered is theirs, and it would block undo forever.
-     */
-    private isPathRegistered;
-    private readonly _worktreePaths;
-    /**
-     * Every worktree path of this repo, MAIN FIRST — git's `worktree list` order, which holds regardless of
-     * which worktree it runs from, and lists the repo itself for a bare one.
-     *
-     * `git maintenance register` records the CURRENT worktree's path, so a repo family can accumulate
-     * several `maintenance.repo` entries — several scheduled runs over a single shared object database —
-     * while the `gk.applied.*` ownership marker lives in the shared common git dir and can only describe
-     * one of them. GitLens therefore REGISTERS the main worktree ({@link resolveMaintenanceRepoPath}) but
-     * DETECTS across the whole family, so a registration the user made from a sibling isn't missed.
-     */
-    private resolveWorktreePaths;
-    /** The path GitLens registers for background maintenance: the repo's MAIN worktree. */
-    private resolveMaintenanceRepoPath;
-    private probeCommitGraph;
-    /**
-     * Whether the NEWEST commit-graph layer carries changed-path Bloom filters (the `BIDX` chunk). Only the
-     * newest layer matters here — `--changed-paths` computes filters for the just-written batch, so an older
-     * base layer written without them says nothing about current coverage. Reads only the header + chunk
-     * lookup table (a handful of bytes), never the graph body. Never throws — any failure (missing file, a
-     * malformed chain, a truncated read) reads as "no filters", matching every other probe in this file.
-     */
-    private probeChangedPathFilters;
-    /** The newest graph layer's file path: the chain's last-listed layer when split, else the single file. */
-    private resolveNewestCommitGraphLayer;
-    /**
-     * Reads a commit-graph file's fixed 8-byte header (`CGPH` magic, version, hash version, chunk count,
-     * base-graph count) plus the chunk lookup table (`(chunkCount + 1)` entries of 4-byte id + 8-byte
-     * big-endian offset), and reports whether a `BIDX` (Bloom-filter-index) chunk id is present. Bounded to
-     * the header + table only — never reads the graph body.
-     */
-    private hasBloomFilterChunk;
-    /**
-     * Reads the pack names represented by the active classic or incremental MIDX. A classic MIDX wins when
-     * both layouts exist, matching Git's own lookup order. Malformed metadata is reported as unknown instead
-     * of treating every pack as uncovered and silently launching repair work.
-     */
-    private probeMultiPackIndex;
-    /** Reads and validates the `PNAM` chunk of one MIDX file. */
-    private readMultiPackIndexPackNames;
-    private probePacks;
-    private sampleLooseObjects;
-    /**
-     * Counts loose refs without traversing past the point where the recommendation decision is already made.
-     * `readDirectory` is a test seam for deterministic ref-layout races between parent and child reads.
-     */
-    private probeLooseRefs;
-    private statMtime;
-    /** Presence probe that distinguishes a missing path from an unreadable one. */
-    private probePathPresence;
-    private fileBytes;
-    /**
-     * Reads the index entry count straight from the index header — `DIRC` signature, version, entry count,
-     * all big-endian, the first 12 bytes of `.git/index` — for free, no `git` invocation needed.
-     * `undefined` on any failure (missing index, short read, wrong signature): never a guess, never a throw.
-     */
-    private probeIndexEntryCount;
-    /**
-     * Conservative split-index detection without spawning git or scanning index bodies. A shared-index file
-     * proves this worktree uses split indexes; its largest base file is included in the byte-size proxy. Stale
-     * bases can only make that explicitly-approximate signal larger.
-     */
-    private probeSharedIndex;
-    /**
-     * Conflict stages duplicate paths in the header count. Operation-state files conservatively suppress the
-     * exact claim without an unconditional `ls-files --unmerged` index scan on every staging event.
-     */
-    private probeConflictOperation;
+  private readonly context;
+  private readonly git;
+  private readonly cache;
+  private readonly provider;
+  constructor(context: GitServiceContext, git: Git, cache: Cache, provider: CliGitProviderInternal);
+  private readonly commitGraphWrittenAt;
+  private readonly commitGraphWriteInflight;
+  request(repoPath: string, task: GitMaintenanceTask): Promise<boolean> | undefined;
+  /**
+   * Opportunistically refreshes git's commit-graph (the demand cadence behind `request('commit-graph')`).
+   * Without one that COVERS the history, any ordered walk (`--date-order`/`--topo-order` — exactly the
+   * graph's initial load) must inflate every commit object to sort BEFORE the first row can be emitted,
+   * costing a full-history walk per open; the commit-graph also accelerates `git log`, merge-base, and
+   * ahead/behind across the whole extension. It's a standard acceleration cache (`git gc`/`git maintenance`
+   * write it routinely) and is always safe to delete. Fire-and-forget: refreshed at most every few minutes
+   * per object database (a current chain makes the write a near-no-op), at background queue priority,
+   * failures swallowed. Cross-WINDOW writes aren't coordinated here — git's own `commit-graph-chain.lock`
+   * serializes them; a loser errors and is swallowed. Resolves `true` only when the write completes; the
+   * health service uses that signal for one post-write freshness probe, while graph consumers ignore it.
+   */
+  private ensureCommitGraph;
+  /** Shared opt-out gate for automatic and explicit writes. */
+  private isCommitGraphWriteDisabled;
+  /**
+   * The commit-graph write itself. Always a `--split` write: mere existence isn't enough (a stale or thin
+   * chain — e.g. one auto-gc increment — accelerates nothing); `--split` appends an incremental layer
+   * covering only the uncovered commits (near-no-op when current) and git self-merges layers by its
+   * geometric policy. Background priority: a first write on a huge repo can run for a while and must never
+   * hold a queue slot ahead of interactive work. Throws on failure — callers decide whether to swallow.
+   */
+  private writeCommitGraph;
+  /** Config-only partial/promisor detection; never examines an object and therefore cannot itself lazy-fetch. */
+  private isPartialClone;
+  /** Honors an explicit MIDX opt-out on both automatic and user-invoked incremental repacks. */
+  private isMultiPackIndexEnabled;
+  getHealthSnapshot(repoPath: string, cancellation?: AbortSignal): Promise<GitHealthSnapshot>;
+  /**
+   * Reads all Git Health gk markers (not-applicable flags + `gk.applied.*` ownership) from ONE bulk
+   * `.git/gk/config` read (git lowercases the section + variable in `--get-regexp` output, preserving the
+   * `applied` subsection). A read failure degrades to all-false — the report just re-suggests, never crashes.
+   */
+  private probeGkMarkers;
+  getHealthDetails(repoPath: string, cancellation?: AbortSignal): Promise<GitHealthDetails>;
+  private _capabilities;
+  getCapabilities(_repoPath: string): Promise<GitOptimizationCapability[]>;
+  private getCapabilitiesCore;
+  runMaintenanceTask(repoPath: string, task: GitMaintenanceTask, options?: {
+    readonly auto?: boolean;
+    readonly cancellation?: AbortSignal;
+  }): Promise<boolean>;
+  applyOptimization(repoPath: string, id: GitOptimizationId, cancellation?: AbortSignal): Promise<boolean>;
+  revertOptimization(repoPath: string, id: GitOptimizationId, cancellation?: AbortSignal): Promise<void>;
+  /**
+   * The Git Health per-repository commit-graph off switch (`gk.commitGraphDisabled`). Unlike the
+   * ownership markers above, this isn't a "record prior, then restore" lever — it's a plain flag with no
+   * underlying config value to protect — so it needs no marker lock; two windows toggling it concurrently
+   * just resolve to whichever write lands last.
+   */
+  setCommitGraphDisabled(repoPath: string, disabled: boolean, cancellation?: AbortSignal): Promise<void>;
+  private applyUntrackedCache;
+  /** Whether git's filesystem probe says the untracked cache can be used here (exit 0). */
+  private testUntrackedCacheSupport;
+  private applyFsmonitor;
+  private applyManyFiles;
+  /** Enables sparse-directory index entries for an existing cone-mode sparse checkout. */
+  private applySparseIndex;
+  /** Expands a sparse index only when this worktree's marker proves GitLens enabled it. */
+  private revertSparseIndex;
+  private runSparseCheckoutReapply;
+  /**
+   * The `git maintenance start` version gate for the current platform: launchctl/schtasks scheduling
+   * (win/mac) needs 2.31; Linux relies on a systemd timer (2.34), since 2.31–2.33 is cron-only and
+   * modern distros often ship without cron.
+   */
+  private get backgroundMaintenanceFeature();
+  private startBackgroundMaintenance;
+  private revertBackgroundMaintenance;
+  /**
+   * Records a config lever's prior LOCAL value (or the `unset` sentinel) under its ownership marker BEFORE
+   * mutating, so undo restores the exact prior and never a hardcoded inverse; the marker's presence also
+   * means "applied by GitLens" (so undo is never offered for a user-enabled lever).
+   */
+  private recordPriorAndMark;
+  /** The body of {@link recordPriorAndMark}, for callers already holding the marker lock. */
+  private recordPriorUnlocked;
+  /**
+   * Reconciles write-ahead records left by an interrupted direct config mutation. The cached namespace read
+   * keeps the normal probe free of extra subprocesses; an actual pending record is re-read under the marker
+   * lock before it is finalized or cleared.
+   */
+  private reconcilePendingConfigChanges;
+  /** Body of {@link reconcilePendingConfigChanges} for a caller already holding the marker lock. */
+  private reconcilePendingConfigChangesUnlocked;
+  /**
+   * Applies direct config levers for a caller holding the ownership-marker lock. A write-ahead record closes
+   * the crash gap between the local config and ownership files; an ordinary failure restores every config
+   * value and marker without cancellation.
+   */
+  private applyConfigChangesUnlocked;
+  claimMaintenancePass(repoPath: string, intervalMs: number): Promise<boolean>;
+  /** The `.git/gk/` directory (common dir, so worktrees of a repo share it). */
+  private getGkDir;
+  private getSparseIndexMarkerPaths;
+  /**
+   * Reconciles the sparse-index command's worktree-local write-ahead marker. The fast path is filesystem
+   * only; a pending or stale-applied marker takes the worktree's sparse-index operation lock and re-reads
+   * Git config before mutating anything, so it cannot act on a snapshot that raced another window's
+   * apply/undo. A live operation keeps that lock across the index rewrite, but snapshots never wait for it:
+   * they return the last committed marker state until the operation publishes its result.
+   */
+  private reconcileSparseIndexMarkers;
+  /** Body of {@link reconcileSparseIndexMarkers} for a caller already holding the ownership lock. */
+  private reconcileSparseIndexMarkersUnlocked;
+  /** Reads the effective worktree-scoped sparse-index switch without relying on a cached config map. */
+  private probeSparseIndexEnabled;
+  /** Reads an ownership marker straight from `.git/gk/config`, bypassing every cache. */
+  private readGkMarkerUncached;
+  /**
+   * Runs `fn` holding an exclusive on-disk lock over one ownership-marker scope. By default that is the
+   * repository family's config-marker scope; callers can provide a worktree-local lock location for an
+   * operation whose state is isolated per worktree. Two layers make this safe across processes:
+   *
+   * - **Exclusive-create ownership, with an identity record.** `open(lockPath, 'wx')` — the same `O_EXCL`
+   *   primitive git uses for its own `*.lock` files — is the only atomic step; a contender that loses the
+   *   race retries for up to `maxAttempts`, then fails loudly rather than proceeding unlocked (see below).
+   *   The winner immediately writes its host, pid, and a fresh random `ownerId` into the lock file — an
+   *   identity record, not a liveness lease, since nothing here ever acts on it while another holder is
+   *   still running.
+   * - **Ownership-verified release.** On the way out, the lock file is removed only if its `ownerId` still
+   *   matches the one this call wrote — a fresh random value per acquisition can't collide with a
+   *   re-created lock the way an inode COULD in principle on some filesystems, so it's the primary check;
+   *   the inode is also compared as a cheap secondary one.
+   *
+   * A lock left behind by a crashed window is deliberately NOT recovered automatically. Two designs were
+   * tried and rejected. Time-based leasing can't tell a dead owner from a slow one — an age alone doesn't
+   * distinguish them (git timeouts are user-configurable, and can be disabled entirely), and making it tell
+   * them apart takes a full lease-plus-fencing-token protocol this lock has no need for otherwise.
+   * Automatic stealing (rename the lock aside once a PID probe says its owner is provably dead) was tried
+   * next, and is unsound for a different reason: automatic recovery of an abandoned fixed-path lock cannot
+   * be made race-free using only the portable stock-Node primitives available here (exclusive-create and
+   * rename) — every recovery attempt separates observation from mutation, so a delayed stealer can rename
+   * away a NEW, live lock a fresh contender created in the gap between the probe and the rename, evicting a
+   * holder that was never dead. Kernel-managed advisory locking (`flock`) would close that gap, but Node
+   * exposes no portable interface to it and a native, platform-sensitive dependency is disproportionate
+   * here. Therefore a contender NEVER mutates an existing lock — only the creator removes one, and no stale
+   * observation can authorize mutation. Recovery is a guided MANUAL step instead: a give-up runs the same PID
+   * probe ONCE, purely to choose the error's wording. For the sparse-operation lock, a confirmed-live owner gets
+   * wait-only guidance, a confirmed-dead owner gets crash-recovery guidance, and an unverifiable owner gets the
+   * lock path plus guarded manual-recovery guidance. The shared marker lock retains its generic non-dead error.
+   * No verdict authorizes an automatic steal.
+   *
+   * Because a live holder can't lose its lock, `fn` needs no cancellation coupling to the lock itself — the
+   * critical section only ever ends on its own terms.
+   *
+   * Acquisition beyond the initial `open` is not atomic: the ownership record is written in a separate step
+   * just after. A crash landing exactly there — not caught by anything, since the process is gone — leaves
+   * a permanently-empty orphan lock; the give-up error's manual-deletion instructions are the only recovery
+   * for that case, same as for a confirmed-dead owner. A failure our OWN code can observe in that window
+   * (the post-`mkdir` setup, or the ownership write itself) is different: it fails closed, removing the
+   * lock it just created — ownership is certain there, since we hold the only handle — before rethrowing,
+   * so a transient error (e.g. `ENOSPC`) never strands a lock nothing can ever prove dead.
+   *
+   * Deliberately NOT named `config.lock` — that's the name git takes when writing `.git/gk/config` itself.
+   */
+  private withMarkerLock;
+  /**
+   * Diagnoses the process recorded in `lockPath` for the give-up error's wording ONLY — see
+   * `withMarkerLock`'s doc comment for why a verdict never causes an automatic steal. Returns 'dead' only when
+   * the OS kill-probe returns `ESRCH`, 'alive' when it succeeds, and 'unverifiable' for unreadable/malformed
+   * content, a lock recorded on another host, or a probe that fails with anything but `ESRCH`.
+   */
+  private probeLockOwner;
+  /**
+   * Reverts a config lever GitLens applied: restores its recorded prior LOCAL value (set it back, or unset
+   * when the prior was absent) and clears the marker. Returns `false` (a no-op) when no marker exists —
+   * a lever the user enabled themselves is never touched.
+   */
+  private revertConfigLever;
+  /** Restores a lever's config to its recorded prior after a failed apply, then drops the ownership marker. */
+  private restorePriorAndClear;
+  /** Sets a local config value back to a recorded prior, decoding the `unset`/`empty` sentinels. */
+  private restoreLocalConfig;
+  /** Writes a gk marker, swallowing+logging any failure — a marker write must never fail the apply itself. */
+  private markGkConfigSafe;
+  /**
+   * Throws when a run that swallowed its errors (`errors: 'ignore'`) was actually cancelled or never ran.
+   * Such a run resolves with no meaningful exit code, so `completion` — not `exitCode` — is the only thing
+   * that proves a command ran. Without this a timeout reads as a clean success, and a safety probe or an
+   * undo would act on a command that never happened.
+   */
+  private throwIfDidNotComplete;
+  /**
+   * Reads a config key's LOCAL-scope value (independent of global/system config). `undefined` when unset.
+   *
+   * Uses `--get-regex` (anchored to the exact key), not `--get`: `--get` exits 0 with EMPTY stdout for
+   * BOTH a bareword entry (`[section]\n\tkey`, valid syntax, git-boolean TRUE) and an explicit empty value
+   * (`key =`, git-boolean FALSE) — indistinguishable, which would record a bareword-true prior as the
+   * `unset` sentinel and let undo flip the user's true to false. `--get-regex` prints the two differently
+   * (a bareword line has no space; an empty value keeps a trailing one), which `parseConfigRegexOutput`'s
+   * `includeValueless` tells apart; for a multi-valued key it also prints every value in file order, so the
+   * LAST line in the map is still the `--get`-equivalent value.
+   */
+  private getLocalConfig;
+  /** Sets a LOCAL config value. Throws the git error on a genuine write failure (config refused). */
+  private setLocalConfig;
+  private unsetLocalConfig;
+  /** Best-effort run; returns the result so callers that must distinguish "didn't run" can check it. */
+  private runQuietly;
+  private probeConfig;
+  private _registeredMaintenanceRepos;
+  /** The global `maintenance.repo` list. Throws rather than reporting an unreadable list as "none". */
+  private readRegisteredMaintenancePaths;
+  /**
+   * `git maintenance register` stores the symlink-RESOLVED worktree path, while GitLens deliberately keeps
+   * the symlinked path as the repo path — so match against both spellings.
+   */
+  private matchesRegistered;
+  /** Each path plus its symlink-resolved spelling — `maintenance register` stores the resolved one. */
+  private resolveRegistrationCandidates;
+  /**
+   * Whether ANY worktree of this repo family is registered — the DETECTION question ("should we suggest
+   * this?"). Family-wide, because a sibling the user registered already covers the shared object database,
+   * and suggesting it again would leave two scheduled entries for one repo.
+   */
+  private isMaintenanceRegistered;
+  /**
+   * Whether ONE specific path is registered — the OWNERSHIP question ("did our unregister take?"). Never
+   * ask this family-wide: a sibling the user registered is theirs, and it would block undo forever.
+   */
+  private isPathRegistered;
+  private readonly _worktreePaths;
+  /**
+   * Every worktree path of this repo, MAIN FIRST — git's `worktree list` order, which holds regardless of
+   * which worktree it runs from, and lists the repo itself for a bare one.
+   *
+   * `git maintenance register` records the CURRENT worktree's path, so a repo family can accumulate
+   * several `maintenance.repo` entries — several scheduled runs over a single shared object database —
+   * while the `gk.applied.*` ownership marker lives in the shared common git dir and can only describe
+   * one of them. GitLens therefore REGISTERS the main worktree ({@link resolveMaintenanceRepoPath}) but
+   * DETECTS across the whole family, so a registration the user made from a sibling isn't missed.
+   */
+  private resolveWorktreePaths;
+  /** The path GitLens registers for background maintenance: the repo's MAIN worktree. */
+  private resolveMaintenanceRepoPath;
+  private probeCommitGraph;
+  /**
+   * Whether the NEWEST commit-graph layer carries changed-path Bloom filters (the `BIDX` chunk). Only the
+   * newest layer matters here — `--changed-paths` computes filters for the just-written batch, so an older
+   * base layer written without them says nothing about current coverage. Reads only the header + chunk
+   * lookup table (a handful of bytes), never the graph body. Never throws — any failure (missing file, a
+   * malformed chain, a truncated read) reads as "no filters", matching every other probe in this file.
+   */
+  private probeChangedPathFilters;
+  /** The newest graph layer's file path: the chain's last-listed layer when split, else the single file. */
+  private resolveNewestCommitGraphLayer;
+  /**
+   * Reads a commit-graph file's fixed 8-byte header (`CGPH` magic, version, hash version, chunk count,
+   * base-graph count) plus the chunk lookup table (`(chunkCount + 1)` entries of 4-byte id + 8-byte
+   * big-endian offset), and reports whether a `BIDX` (Bloom-filter-index) chunk id is present. Bounded to
+   * the header + table only — never reads the graph body.
+   */
+  private hasBloomFilterChunk;
+  /**
+   * Reads the pack names represented by the active classic or incremental MIDX. A classic MIDX wins when
+   * both layouts exist, matching Git's own lookup order. Malformed metadata is reported as unknown instead
+   * of treating every pack as uncovered and silently launching repair work.
+   */
+  private probeMultiPackIndex;
+  /** Reads and validates the `PNAM` chunk of one MIDX file. */
+  private readMultiPackIndexPackNames;
+  private probePacks;
+  private sampleLooseObjects;
+  /**
+   * Counts loose refs without traversing past the point where the recommendation decision is already made.
+   * `readDirectory` is a test seam for deterministic ref-layout races between parent and child reads.
+   */
+  private probeLooseRefs;
+  private statMtime;
+  /** Presence probe that distinguishes a missing path from an unreadable one. */
+  private probePathPresence;
+  private fileBytes;
+  /**
+   * Reads the index entry count straight from the index header — `DIRC` signature, version, entry count,
+   * all big-endian, the first 12 bytes of `.git/index` — for free, no `git` invocation needed.
+   * `undefined` on any failure (missing index, short read, wrong signature): never a guess, never a throw.
+   */
+  private probeIndexEntryCount;
+  /**
+   * Conservative split-index detection without spawning git or scanning index bodies. A shared-index file
+   * proves this worktree uses split indexes; its largest base file is included in the byte-size proxy. Stale
+   * bases can only make that explicitly-approximate signal larger.
+   */
+  private probeSharedIndex;
+  /**
+   * Conflict stages duplicate paths in the header count. Operation-state files conservatively suppress the
+   * exact claim without an unconditional `ls-files --unmerged` index scan on every staging event.
+   */
+  private probeConflictOperation;
 }
+//#endregion
 //# sourceMappingURL=maintenance.d.ts.map