@gitkraken/core-gitlens 0.6.0 → 0.7.1

package/dist/git/repositoryService.js

@@ -1,54 +1,57 @@
+//#region ../git/src/repositoryService.ts
 let _repositoryServiceResolver;
 /** Clears the global repository resolver */
-export function clearGlobalRepositoryServiceResolver() {
-    _repositoryServiceResolver = undefined;
+function clearGlobalRepositoryServiceResolver() {
+	_repositoryServiceResolver = void 0;
 }
 /**
- * Returns a repo-scoped {@link RepositoryService} for the given path.
- * Returns undefined if no resolver is configured or the path is unrecognized.
- *
- * @warning This function depends on {@link setGlobalRepositoryServiceResolver} being called at startup.
- * If called before configuration, it will return undefined. Ensure proper initialization order.
- */
-export function getRepositoryService(repoPath) {
-    return _repositoryServiceResolver?.(repoPath);
+* Returns a repo-scoped {@link RepositoryService} for the given path.
+* Returns undefined if no resolver is configured or the path is unrecognized.
+*
+* @warning This function depends on {@link setGlobalRepositoryServiceResolver} being called at startup.
+* If called before configuration, it will return undefined. Ensure proper initialization order.
+*/
+function getRepositoryService(repoPath) {
+	return _repositoryServiceResolver?.(repoPath);
 }
 /**
- * Sets a global repository resolver for models
- * Call this at application startup to enable model-level
- * repository access (e.g., {@link GitWorktree.hasWorkingChanges}).
- * @internal Called by {@link GitService} constructor.
- */
-export function setGlobalRepositoryServiceResolver(resolver) {
-    _repositoryServiceResolver = resolver;
+* Sets a global repository resolver for models
+* Call this at application startup to enable model-level
+* repository access (e.g., {@link GitWorktree.hasWorkingChanges}).
+* @internal Called by {@link GitService} constructor.
+*/
+function setGlobalRepositoryServiceResolver(resolver) {
+	_repositoryServiceResolver = resolver;
 }
 /**
- * Creates a repo-scoped wrapper for a sub-provider.
- * Returns a plain object where every method is pre-bound with `repoPath` as the first argument.
- *
- * Every method on the sub-provider must declare `repoPath: string` as its FIRST parameter.
- * The proxy automatically injects `repoPath` as the first argument to all method calls.
- * Operations that don't take `repoPath` (like `clone`) belong on `GitProvider` directly.
- *
- * @param target The sub-provider to wrap
- * @param repoPath The repository path to auto-inject
- * @returns A wrapped sub-provider where repoPath is pre-bound to all methods
- */
-export function createSubProviderProxyForRepo(target, repoPath) {
-    const bound = Object.create(null);
-    let proto = target;
-    while (proto != null && proto !== Object.prototype) {
-        for (const key of Reflect.ownKeys(proto)) {
-            if (key === 'constructor' || key in bound)
-                continue;
-            const desc = Object.getOwnPropertyDescriptor(proto, key);
-            if (desc?.value != null && typeof desc.value === 'function') {
-                const fn = desc.value;
-                bound[key] = (...args) => fn.call(target, repoPath, ...args);
-            }
-        }
-        proto = Object.getPrototypeOf(proto);
-    }
-    return bound;
+* Creates a repo-scoped wrapper for a sub-provider.
+* Returns a plain object where every method is pre-bound with `repoPath` as the first argument.
+*
+* Every method on the sub-provider must declare `repoPath: string` as its FIRST parameter.
+* The proxy automatically injects `repoPath` as the first argument to all method calls.
+* Operations that don't take `repoPath` (like `clone`) belong on `GitProvider` directly.
+*
+* @param target The sub-provider to wrap
+* @param repoPath The repository path to auto-inject
+* @returns A wrapped sub-provider where repoPath is pre-bound to all methods
+*/
+function createSubProviderProxyForRepo(target, repoPath) {
+	const bound = Object.create(null);
+	let proto = target;
+	while (proto != null && proto !== Object.prototype) {
+		for (const key of Reflect.ownKeys(proto)) {
+			if (key === "constructor" || key in bound) continue;
+			const desc = Object.getOwnPropertyDescriptor(proto, key);
+			if (desc?.value != null && typeof desc.value === "function") {
+				const fn = desc.value;
+				bound[key] = (...args) => fn.call(target, repoPath, ...args);
+			}
+		}
+		proto = Object.getPrototypeOf(proto);
+	}
+	return bound;
 }
+//#endregion
+export { clearGlobalRepositoryServiceResolver, createSubProviderProxyForRepo, getRepositoryService, setGlobalRepositoryServiceResolver };
+
 //# sourceMappingURL=repositoryService.js.map

package/dist/git/repositoryService.js.map

@@ -1 +1 @@
-{"version":3,"file":"repositoryService.js","sourceRoot":"","sources":["../../src/git/repositoryService.ts"],"names":[],"mappings":"AA4DA,IAAI,0BAA6F,CAAC;AAElG,4CAA4C;AAC5C,MAAM,UAAU,oCAAoC;IACnD,0BAA0B,GAAG,SAAS,CAAC;AACxC,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,oBAAoB,CAAC,QAAgB;IACpD,OAAO,0BAA0B,EAAE,CAAC,QAAQ,CAAC,CAAC;AAC/C,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,kCAAkC,CACjD,QAA6D;IAE7D,0BAA0B,GAAG,QAAQ,CAAC;AACvC,CAAC;AA6DD;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,6BAA6B,CAAmB,MAAS,EAAE,QAAgB;IAC1F,MAAM,KAAK,GAAqC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IAEpE,IAAI,KAAK,GAAkB,MAAM,CAAC;IAClC,OAAO,KAAK,IAAI,IAAI,IAAI,KAAK,KAAK,MAAM,CAAC,SAAS,EAAE,CAAC;QACpD,KAAK,MAAM,GAAG,IAAI,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;YAC1C,IAAI,GAAG,KAAK,aAAa,IAAI,GAAG,IAAI,KAAK;gBAAE,SAAS;YAEpD,MAAM,IAAI,GAAG,MAAM,CAAC,wBAAwB,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;YACzD,IAAI,IAAI,EAAE,KAAK,IAAI,IAAI,IAAI,OAAO,IAAI,CAAC,KAAK,KAAK,UAAU,EAAE,CAAC;gBAC7D,MAAM,EAAE,GAAG,IAAI,CAAC,KAAwC,CAAC;gBACzD,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,IAAe,EAAE,EAAE,CAAC,EAAE,CAAC,IAAI,CAAC,MAAM,EAAE,QAAQ,EAAE,GAAG,IAAI,CAAC,CAAC;YACzE,CAAC;QACF,CAAC;QACD,KAAK,GAAG,MAAM,CAAC,cAAc,CAAC,KAAK,CAAkB,CAAC;IACvD,CAAC;IAED,OAAO,KAAyC,CAAC;AAClD,CAAC"}
+{"version":3,"file":"repositoryService.js","names":[],"sources":["../../../git/src/repositoryService.ts"],"sourcesContent":["import type { Uri } from '@gitlens/utils/uri.js';\nimport type { GitProvider, GitProviderDescriptor } from './providers/provider.js';\n\n/**\n * A repo-scoped view of a {@link GitProvider}'s sub-providers.\n *\n * Every sub-provider method has its `repoPath` parameter auto-injected,\n * so callers don't need to pass the repository path repeatedly.\n *\n * Created lazily by {@link GitService.forRepo} and cached\n * for proxy reuse. The service trusts the caller — if the path isn't\n * a real repository, git commands will fail naturally.\n *\n * @example\n * ```typescript\n * const repo = service.forRepo('/path/to/repo');\n * const branches = await repo.branches.getBranches(); // repoPath auto-injected\n * const status = await repo.status.getStatus();\n * ```\n */\nexport interface RepositoryService {\n\t/** Normalized path or URI-string identifying the repository root */\n\treadonly path: string;\n\t/** Descriptor of the provider that manages this repository */\n\treadonly provider: GitProviderDescriptor;\n\n\t/** Resolves a relative path within this repository to an absolute URI */\n\tgetAbsoluteUri(relativePath: string): Uri;\n\n\t/**\n\t * Monotonic counter tracking working tree filesystem changes.\n\t * Used by `GitCommit.hasFullDetails()` for uncommitted commit staleness.\n\t * Returns `undefined` when no watch service is configured (headless/test).\n\t */\n\treadonly etagWorkingTree: number | undefined;\n\n\t// Required sub-providers (repoPath auto-injected)\n\treadonly branches: SubProviderForRepo<GitProvider['branches']>;\n\treadonly commits: SubProviderForRepo<GitProvider['commits']>;\n\treadonly config: SubProviderForRepo<GitProvider['config']>;\n\treadonly contributors: SubProviderForRepo<GitProvider['contributors']>;\n\treadonly diff: SubProviderForRepo<GitProvider['diff']>;\n\treadonly graph: SubProviderForRepo<GitProvider['graph']>;\n\treadonly refs: SubProviderForRepo<GitProvider['refs']>;\n\treadonly remotes: SubProviderForRepo<GitProvider['remotes']>;\n\treadonly revision: SubProviderForRepo<GitProvider['revision']>;\n\treadonly status: SubProviderForRepo<GitProvider['status']>;\n\treadonly tags: SubProviderForRepo<GitProvider['tags']>;\n\n\t// Optional sub-providers\n\treadonly blame?: SubProviderForRepo<NonNullable<GitProvider['blame']>>;\n\treadonly maintenance?: SubProviderForRepo<NonNullable<GitProvider['maintenance']>>;\n\treadonly ops?: SubProviderForRepo<NonNullable<GitProvider['ops']>>;\n\treadonly patch?: SubProviderForRepo<NonNullable<GitProvider['patch']>>;\n\treadonly pausedOps?: SubProviderForRepo<NonNullable<GitProvider['pausedOps']>>;\n\treadonly staging?: SubProviderForRepo<NonNullable<GitProvider['staging']>>;\n\treadonly stash?: SubProviderForRepo<NonNullable<GitProvider['stash']>>;\n\treadonly worktrees?: SubProviderForRepo<NonNullable<GitProvider['worktrees']>>;\n}\n\nlet _repositoryServiceResolver: ((repoPath: string) => RepositoryService | undefined) | undefined;\n\n/** Clears the global repository resolver */\nexport function clearGlobalRepositoryServiceResolver(): void {\n\t_repositoryServiceResolver = undefined;\n}\n\n/**\n * Returns a repo-scoped {@link RepositoryService} for the given path.\n * Returns undefined if no resolver is configured or the path is unrecognized.\n *\n * @warning This function depends on {@link setGlobalRepositoryServiceResolver} being called at startup.\n * If called before configuration, it will return undefined. Ensure proper initialization order.\n */\nexport function getRepositoryService(repoPath: string): RepositoryService | undefined {\n\treturn _repositoryServiceResolver?.(repoPath);\n}\n\n/**\n * Sets a global repository resolver for models\n * Call this at application startup to enable model-level\n * repository access (e.g., {@link GitWorktree.hasWorkingChanges}).\n * @internal Called by {@link GitService} constructor.\n */\nexport function setGlobalRepositoryServiceResolver(\n\tresolver: (repoPath: string) => RepositoryService | undefined,\n): void {\n\t_repositoryServiceResolver = resolver;\n}\n\n/**\n * Utility for creating repo-scoped sub-provider wrappers.\n *\n * **Contract:** Every method on a sub-provider must accept `repoPath: string` as its\n * first parameter. The proxy auto-injects `repoPath` so callers don't have to pass it\n * repeatedly. Methods that don't take `repoPath` (e.g. `clone`) belong on `GitProvider`\n * directly, not on a sub-provider interface.\n *\n * @example\n * ```typescript\n * const branches = createSubProviderProxyForRepo(provider.branches, '/repo/path');\n * // Now: branches.getBranch('main') instead of provider.branches.getBranch('/repo/path', 'main')\n * ```\n */\n\n// Note: OmitFirstArg handles function overloads (up to 4 deep).\n// This is needed because some sub-provider methods have overloaded signatures.\n// The `First` type parameter constrains what the first argument must extend —\n// pass `string` to enforce that every method takes `repoPath: string` as its first parameter.\ntype OmitFirstArg<F, First = any> = F extends {\n\t(first: First, ...args: infer A1): infer R1;\n\t(first: First, ...args: infer A2): infer R2;\n\t(first: First, ...args: infer A3): infer R3;\n\t(first: First, ...args: infer A4): infer R4;\n}\n\t? ((...args: A1) => R1) & ((...args: A2) => R2) & ((...args: A3) => R3) & ((...args: A4) => R4)\n\t: F extends {\n\t\t\t\t(first: First, ...args: infer A1): infer R1;\n\t\t\t\t(first: First, ...args: infer A2): infer R2;\n\t\t\t\t(first: First, ...args: infer A3): infer R3;\n\t\t  }\n\t\t? ((...args: A1) => R1) & ((...args: A2) => R2) & ((...args: A3) => R3)\n\t\t: F extends {\n\t\t\t\t\t(first: First, ...args: infer A1): infer R1;\n\t\t\t\t\t(first: First, ...args: infer A2): infer R2;\n\t\t\t  }\n\t\t\t? ((...args: A1) => R1) & ((...args: A2) => R2)\n\t\t\t: F extends {\n\t\t\t\t\t\t(first: First, ...args: infer A1): infer R1;\n\t\t\t\t  }\n\t\t\t\t? (...args: A1) => R1\n\t\t\t\t: never;\n\n/**\n * Transforms a sub-provider type by removing the first `repoPath` parameter\n * from every method signature. Used to create repo-scoped views of sub-providers.\n *\n * Passes `string` as the `First` constraint to `OmitFirstArg`, which enforces that\n * every method on the sub-provider takes `string` (i.e. `repoPath`) as its first\n * parameter. Methods that don't will produce `never`, causing a compile error at call sites.\n *\n * Uses `NonNullable` before the conditional check so that optional methods\n * (whose type includes `| undefined`) are still matched and transformed.\n * Property optionality is preserved automatically by the mapped-type `[K in keyof T]`.\n */\nexport type SubProviderForRepo<T> = {\n\t[K in keyof T]: NonNullable<T[K]> extends (...args: any[]) => any ? OmitFirstArg<NonNullable<T[K]>, string> : T[K];\n};\n\n/**\n * Creates a repo-scoped wrapper for a sub-provider.\n * Returns a plain object where every method is pre-bound with `repoPath` as the first argument.\n *\n * Every method on the sub-provider must declare `repoPath: string` as its FIRST parameter.\n * The proxy automatically injects `repoPath` as the first argument to all method calls.\n * Operations that don't take `repoPath` (like `clone`) belong on `GitProvider` directly.\n *\n * @param target The sub-provider to wrap\n * @param repoPath The repository path to auto-inject\n * @returns A wrapped sub-provider where repoPath is pre-bound to all methods\n */\nexport function createSubProviderProxyForRepo<T extends object>(target: T, repoPath: string): SubProviderForRepo<T> {\n\tconst bound: Record<string | symbol, unknown> = Object.create(null);\n\n\tlet proto: object | null = target;\n\twhile (proto != null && proto !== Object.prototype) {\n\t\tfor (const key of Reflect.ownKeys(proto)) {\n\t\t\tif (key === 'constructor' || key in bound) continue;\n\n\t\t\tconst desc = Object.getOwnPropertyDescriptor(proto, key);\n\t\t\tif (desc?.value != null && typeof desc.value === 'function') {\n\t\t\t\tconst fn = desc.value as (...args: unknown[]) => unknown;\n\t\t\t\tbound[key] = (...args: unknown[]) => fn.call(target, repoPath, ...args);\n\t\t\t}\n\t\t}\n\t\tproto = Object.getPrototypeOf(proto) as object | null;\n\t}\n\n\treturn bound as unknown as SubProviderForRepo<T>;\n}\n"],"mappings":";AA4DA,IAAI;;AAGJ,SAAgB,uCAA6C;CAC5D,6BAA6B,KAAA;AAC9B;;;;;;;;AASA,SAAgB,qBAAqB,UAAiD;CACrF,OAAO,6BAA6B,QAAQ;AAC7C;;;;;;;AAQA,SAAgB,mCACf,UACO;CACP,6BAA6B;AAC9B;;;;;;;;;;;;;AAyEA,SAAgB,8BAAgD,QAAW,UAAyC;CACnH,MAAM,QAA0C,OAAO,OAAO,IAAI;CAElE,IAAI,QAAuB;CAC3B,OAAO,SAAS,QAAQ,UAAU,OAAO,WAAW;EACnD,KAAK,MAAM,OAAO,QAAQ,QAAQ,KAAK,GAAG;GACzC,IAAI,QAAQ,iBAAiB,OAAO,OAAO;GAE3C,MAAM,OAAO,OAAO,yBAAyB,OAAO,GAAG;GACvD,IAAI,MAAM,SAAS,QAAQ,OAAO,KAAK,UAAU,YAAY;IAC5D,MAAM,KAAK,KAAK;IAChB,MAAM,QAAQ,GAAG,SAAoB,GAAG,KAAK,QAAQ,UAAU,GAAG,IAAI;GACvE;EACD;EACA,QAAQ,OAAO,eAAe,KAAK;CACpC;CAEA,OAAO;AACR"}

package/dist/git/run.types.d.ts

@@ -1,5 +1,7 @@
-import type { CacheController } from '../utils/promiseCache.js';
-import type { GitWarningKey } from './errors.js';
+import { CacheController } from "../utils/promiseCache.js";
+import { GitWarningKey } from "./errors.js";
+import { GitHealthSlownessCategory } from "./gitHealth.js";
+//#region ../git/src/run.types.d.ts
 export type GitErrorHandling = 'throw' | 'ignore';
 /**
  * Why a run was aborted. DIAGNOSTIC ONLY — log it, never branch control flow on it. A timeout kill and a
@@ -13,11 +15,11 @@ export type GitRunCancellation = 'aborted' | 'timeout' | 'unknown';
  * There is deliberately no `untrusted` member: an untrusted workspace is refused before the command is ever
  * attempted, so it REJECTS with `WorkspaceUntrustedError` rather than resolving a result.
  */
-export type GitRunFailure = 
+export type GitRunFailure =
 /** Terminated by a signal other than SIGTERM. Any `stdout` is partial. */
-'signal'
+'signal' |
 /** No process ever ran — queue rejection, spawn failure (e.g. ENOENT). */
- | 'unstarted';
+'unstarted';
 /**
  * How a run ended — the answer to "can I trust `stdout`?", which `exitCode` alone cannot give.
  *
@@ -26,12 +28,12 @@ export type GitRunFailure =
  * empty `stdout` of a `warned`/`cancelled`/`failed` run as a real result — which is what a bare
  * `exitCode === 0` check does, since several failure paths report zero.
  */
-export type GitRunCompletion = 
+export type GitRunCompletion =
 /** Ran to completion. Interpreting `code` is the caller's business; `stdout` is trustworthy. */
 {
-    readonly status: 'exited';
-    readonly code: number;
-}
+  readonly status: 'exited';
+  readonly code: number;
+} |
 /**
  * Exited non-zero, but stderr matched a known-benign pattern, so the error was swallowed and `stdout`
  * is empty. Whether that empty is a real ANSWER (`noCommits` on a fresh repo) or a failure
@@ -41,39 +43,39 @@ export type GitRunCompletion =
  * haven't explicitly whitelisted, i.e. not an answer. The process did exit, so `exitCode` is present
  * whenever git reported a numeric one.
  */
- | {
-    readonly status: 'warned';
-    readonly warning: GitWarningKey | undefined;
-    readonly error: Error;
+{
+  readonly status: 'warned';
+  readonly warning: GitWarningKey | undefined;
+  readonly error: Error;
 } | {
-    readonly status: 'cancelled';
-    readonly reason: GitRunCancellation;
-    readonly error: Error;
+  readonly status: 'cancelled';
+  readonly reason: GitRunCancellation;
+  readonly error: Error;
 } | {
-    readonly status: 'failed';
-    readonly reason: GitRunFailure;
-    readonly error: Error;
+  readonly status: 'failed';
+  readonly reason: GitRunFailure;
+  readonly error: Error;
 };
 export type GitResult<T extends string | Buffer | unknown = string> = {
-    /**
-     * The process's exit code. ABSENT when no process exited — see {@link completion}. Deliberately optional:
-     * defaulting to `0` made a failed run indistinguishable from a clean success.
-     */
-    readonly exitCode?: number;
-    readonly stdout: T;
-    readonly stderr?: T;
-    readonly completion: GitRunCompletion;
+  /**
+   * The process's exit code. ABSENT when no process exited — see {@link completion}. Deliberately optional:
+   * defaulting to `0` made a failed run indistinguishable from a clean success.
+   */
+  readonly exitCode?: number;
+  readonly stdout: T;
+  readonly stderr?: T;
+  readonly completion: GitRunCompletion;
 };
 /**
  * Cache store interface for git command output caching.
  * Stores full GitResult to preserve exitCode/stderr.
  */
 export interface GitResultCache {
-    getOrCreate(repoPath: string, key: string, factory: (cacheable: CacheController, signal?: AbortSignal) => Promise<GitResult<unknown>>, options?: {
-        createTTL?: number;
-        accessTTL?: number;
-        cancellation?: AbortSignal;
-    }): Promise<GitResult<unknown>>;
+  getOrCreate(repoPath: string, key: string, factory: (cacheable: CacheController, signal?: AbortSignal) => Promise<GitResult<unknown>>, options?: {
+    createTTL?: number;
+    accessTTL?: number;
+    cancellation?: AbortSignal;
+  }): Promise<GitResult<unknown>>;
 }
 /**
  * Priority levels for git commands.
@@ -83,42 +85,48 @@ export interface GitResultCache {
  */
 export type GitCommandPriority = 'interactive' | 'normal' | 'background';
 export interface GitRunOptions {
-    cancellation?: AbortSignal;
-    configs?: readonly string[];
-    readonly correlationKey?: string;
-    errors?: GitErrorHandling;
-    /** Priority level for queue ordering. If not specified, will be inferred from the command type. */
-    priority?: GitCommandPriority;
-    /** Specifies that this command should always be executed locally if possible (for live share sessions) */
-    runLocally?: boolean;
-    /**
-     * Marks a command GitLens issues as its OWN maintenance work (the Git Health auto pass, the
-     * commit-graph write, an explicit "Run Maintenance Now"). Such commands are legitimately slow by
-     * design, so they are excluded from the `onSlowCommand` health signal — otherwise our own
-     * optimization work becomes the evidence that recommends more of it. Matching on the git
-     * subcommand can't express this: the same `update-index`/`status` also serve real user work.
-     */
-    selfMaintenance?: boolean;
-    /**
-     * If provided, cache the command's result (stdout, stderr, exitCode) in this store via an auto-generated cache key
-     * Only use for commands with stable output (e.g., `git remote -v`)
-     */
-    caching?: {
-        cache: GitResultCache;
-        /** The common repository path for worktree-shared caching. If not provided, defaults to cwd. */
-        commonPath?: string;
-        options?: {
-            createTTL?: number;
-            accessTTL?: number;
-        };
+  cancellation?: AbortSignal;
+  configs?: readonly string[];
+  readonly correlationKey?: string;
+  errors?: GitErrorHandling;
+  /** Priority level for queue ordering. If not specified, will be inferred from the command type. */
+  priority?: GitCommandPriority;
+  /** Specifies that this command should always be executed locally if possible (for live share sessions) */
+  runLocally?: boolean;
+  /**
+   * Marks a command GitLens issues as its OWN maintenance work (the Git Health auto pass, the
+   * commit-graph write, an explicit "Run Maintenance Now"). Such commands are legitimately slow by
+   * design, so they are excluded from the `onSlowCommand` health signal — otherwise our own
+   * optimization work becomes the evidence that recommends more of it. Matching on the git
+   * subcommand can't express this: the same `update-index`/`status` also serve real user work.
+   */
+  selfMaintenance?: boolean;
+  /**
+   * Files this command's `onSlowCommand` health sample under this operation family instead of the one
+   * inferred from its git subcommand. A paged `log` carrying per-commit file details is slow because
+   * `--numstat` diffs every changed blob, not because history is slow — only the caller knows which.
+   */
+  slownessCategory?: GitHealthSlownessCategory;
+  /**
+   * If provided, cache the command's result (stdout, stderr, exitCode) in this store via an auto-generated cache key
+   * Only use for commands with stable output (e.g., `git remote -v`)
+   */
+  caching?: {
+    cache: GitResultCache;
+    /** The common repository path for worktree-shared caching. If not provided, defaults to cwd. */
+    commonPath?: string;
+    options?: {
+      createTTL?: number;
+      accessTTL?: number;
     };
-    cwd?: string;
-    readonly env?: Record<string, string | undefined>;
-    readonly encoding?: BufferEncoding | 'buffer' | string;
-    readonly maxBuffer?: number;
-    readonly stdin?: string | Buffer;
-    readonly stdinEncoding?: string;
-    readonly timeout?: number;
+  };
+  cwd?: string;
+  readonly env?: Record<string, string | undefined>;
+  readonly encoding?: BufferEncoding | 'buffer' | string;
+  readonly maxBuffer?: number;
+  readonly stdin?: string | Buffer;
+  readonly stdinEncoding?: string;
+  readonly timeout?: number;
 }
 /**
  * Untyped escape hatch for raw `git <args>` invocation, returned by
@@ -137,16 +145,23 @@ export interface GitRunOptions {
  * abstraction exists so it can be handed off, not used directly.
  */
 export interface UnsafeGit {
-    run(args: readonly string[], options?: GitRunOptions): Promise<GitResult>;
+  run(args: readonly string[], options?: GitRunOptions): Promise<GitResult>;
 }
 export interface GitSpawnOptions {
-    cancellation?: AbortSignal;
-    configs?: readonly string[];
-    cwd?: string;
-    readonly env?: Record<string, string | undefined>;
-    readonly encoding?: BufferEncoding | 'buffer' | string;
-    readonly stdin?: string | Buffer;
-    readonly stdinEncoding?: string;
-    readonly timeout?: number;
+  cancellation?: AbortSignal;
+  configs?: readonly string[];
+  /**
+   * Files this command's `onSlowCommand` health sample under this operation family instead of the one
+   * inferred from its git subcommand. A paged `log` carrying per-commit file details is slow because
+   * `--numstat` diffs every changed blob, not because history is slow — only the caller knows which.
+   */
+  slownessCategory?: GitHealthSlownessCategory;
+  cwd?: string;
+  readonly env?: Record<string, string | undefined>;
+  readonly encoding?: BufferEncoding | 'buffer' | string;
+  readonly stdin?: string | Buffer;
+  readonly stdinEncoding?: string;
+  readonly timeout?: number;
 }
+//#endregion
 //# sourceMappingURL=run.types.d.ts.map

package/dist/git/run.types.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=run.types.js.map

package/dist/git/service.d.ts

@@ -1,14 +1,15 @@
-import type { UnifiedDisposable } from '../utils/disposable.js';
-import type { Event } from '../utils/event.js';
-import type { Uri } from '../utils/uri.js';
-import type { GitProvider } from './providers/provider.js';
-import type { RepositoryService } from './repositoryService.js';
-import type { FileWatchingProvider } from './watching/provider.js';
-import { RepositoryWatchService } from './watching/watchService.js';
+import { Uri } from "../utils/uri.js";
+import { UnifiedDisposable } from "../utils/disposable.js";
+import { Event } from "../utils/event.js";
+import { FileWatchingProvider } from "./watching/provider.js";
+import { RepositoryWatchService } from "./watching/watchService.js";
+import { GitProvider } from "./providers/provider.js";
+import { RepositoryService } from "./repositoryService.js";
+//#region ../git/src/service.d.ts
 export interface ProvidersChangeEvent {
-    readonly added: readonly GitProvider[];
-    readonly removed: readonly GitProvider[];
-    readonly etag: number;
+  readonly added: readonly GitProvider[];
+  readonly removed: readonly GitProvider[];
+  readonly etag: number;
 }
 /**
  * Result of {@link GitService.validateRepo}.
@@ -18,17 +19,17 @@ export interface ProvidersChangeEvent {
  * - `valid: false` — not a git repository, no registered provider can handle the path, or the routed provider doesn't implement `getRepositoryInfo`
  */
 export type ValidateRepoResult = {
-    valid: true;
-    safe: true;
-    repoPath: string;
-    gitDir?: string;
-    commonGitDir?: string;
-    superprojectPath?: string;
+  valid: true;
+  safe: true;
+  repoPath: string;
+  gitDir?: string;
+  commonGitDir?: string;
+  superprojectPath?: string;
 } | {
-    valid: true;
-    safe: false;
+  valid: true;
+  safe: false;
 } | {
-    valid: false;
+  valid: false;
 };
 /**
  * Entry point — provider router, repo-scoped proxy cache, and global configuration.
@@ -56,57 +57,58 @@ export type ValidateRepoResult = {
  * ```
  */
 export declare class GitService implements UnifiedDisposable {
-    private static _instance;
-    static createSingleton(watchingProvider?: FileWatchingProvider): GitService;
-    private readonly _onDidChangeProviders;
-    get onDidChangeProviders(): Event<ProvidersChangeEvent>;
-    private _etag;
-    private readonly _providers;
-    private readonly _serviceCache;
-    private readonly _watchService;
-    private constructor();
-    [Symbol.dispose](): void;
-    dispose(): void;
-    /** Monotonically increasing counter incremented on structural changes. */
-    get etag(): number;
-    /** Whether any providers are registered. */
-    get hasProviders(): boolean;
-    get watchService(): RepositoryWatchService | undefined;
-    /**
-     * Registers a provider with a routing predicate.
-     *
-     * @returns A disposable that unregisters the provider.
-     */
-    register(provider: GitProvider, canHandle: (repoPath: string) => boolean): UnifiedDisposable;
-    /** Returns the provider that can handle the given path, or undefined if none matches. */
-    getProvider(repoPath: string): {
-        provider: GitProvider;
-        path: string;
-    } | undefined;
-    /** Returns all registered providers. */
-    getProviders(): Iterable<GitProvider>;
-    /**
-     * Routes a repo URI/path to a provider and returns a cached
-     * {@link RepositoryService} with repo-scoped sub-provider proxies.
-     * Returns undefined if no provider can handle the path.
-     */
-    forRepo(repoUri: Uri | string): RepositoryService | undefined;
-    /**
-     * Evicts the cached {@link RepositoryService} for a closed or removed repository.
-     * No-op if the path isn't cached.
-     */
-    closeRepo(repoUri: Uri | string): void;
-    /**
-     * Validates whether `pathOrUri` points to (or resides inside) a git repository,
-     * and returns information about it when it does.
-     *
-     * Routes the path to a registered provider and delegates to its config sub-provider's
-     * `getRepositoryInfo` implementation, then normalizes the raw result into a clean
-     * discriminated union. For a simple yes/no check, use `(await validateRepo(path)).valid`.
-     *
-     * Returns `{ valid: false }` if no provider can handle the path or if the routed
-     * provider does not implement `getRepositoryInfo`.
-     */
-    validateRepo(pathOrUri: Uri | string): Promise<ValidateRepoResult>;
+  private static _instance;
+  static createSingleton(watchingProvider?: FileWatchingProvider): GitService;
+  private readonly _onDidChangeProviders;
+  get onDidChangeProviders(): Event<ProvidersChangeEvent>;
+  private _etag;
+  private readonly _providers;
+  private readonly _serviceCache;
+  private readonly _watchService;
+  private constructor();
+  [Symbol.dispose](): void;
+  dispose(): void;
+  /** Monotonically increasing counter incremented on structural changes. */
+  get etag(): number;
+  /** Whether any providers are registered. */
+  get hasProviders(): boolean;
+  get watchService(): RepositoryWatchService | undefined;
+  /**
+   * Registers a provider with a routing predicate.
+   *
+   * @returns A disposable that unregisters the provider.
+   */
+  register(provider: GitProvider, canHandle: (repoPath: string) => boolean): UnifiedDisposable;
+  /** Returns the provider that can handle the given path, or undefined if none matches. */
+  getProvider(repoPath: string): {
+    provider: GitProvider;
+    path: string;
+  } | undefined;
+  /** Returns all registered providers. */
+  getProviders(): Iterable<GitProvider>;
+  /**
+   * Routes a repo URI/path to a provider and returns a cached
+   * {@link RepositoryService} with repo-scoped sub-provider proxies.
+   * Returns undefined if no provider can handle the path.
+   */
+  forRepo(repoUri: Uri | string): RepositoryService | undefined;
+  /**
+   * Evicts the cached {@link RepositoryService} for a closed or removed repository.
+   * No-op if the path isn't cached.
+   */
+  closeRepo(repoUri: Uri | string): void;
+  /**
+   * Validates whether `pathOrUri` points to (or resides inside) a git repository,
+   * and returns information about it when it does.
+   *
+   * Routes the path to a registered provider and delegates to its config sub-provider's
+   * `getRepositoryInfo` implementation, then normalizes the raw result into a clean
+   * discriminated union. For a simple yes/no check, use `(await validateRepo(path)).valid`.
+   *
+   * Returns `{ valid: false }` if no provider can handle the path or if the routed
+   * provider does not implement `getRepositoryInfo`.
+   */
+  validateRepo(pathOrUri: Uri | string): Promise<ValidateRepoResult>;
 }
+//#endregion
 //# sourceMappingURL=service.d.ts.map