@gitkraken/core-gitlens 0.6.0 → 0.7.0

package/dist/git/providers/config.d.ts

@@ -1,60 +1,61 @@
-import type { GkConfigInvalidationTarget } from '../cache.js';
-import type { GitDir } from '../models/repository.js';
-import type { SigningConfig, ValidationResult } from '../models/signature.js';
-import type { GitUser } from '../models/user.js';
-export type GitCoreConfigKeys = 'commit.gpgsign' | 'core.excludesFile' | 'diff.guitool' | 'diff.tool'
+import { GitDir } from "../models/repository.js";
+import { SigningConfig, ValidationResult } from "../models/signature.js";
+import { GitUser } from "../models/user.js";
+import { GkConfigInvalidationTarget } from "../cache.js";
+//#region ../git/src/providers/config.d.ts
+export type GitCoreConfigKeys = 'commit.gpgsign' | 'core.excludesFile' | 'diff.guitool' | 'diff.tool' |
 /** `fetch.prune` — whether `git fetch` removes remote-tracking branches that no longer exist on the remote */
- | 'fetch.prune' | 'gpg.format' | 'gpg.program' | 'gpg.ssh.program' | 'gpg.ssh.allowedSignersFile' | 'init.defaultBranch'
+'fetch.prune' | 'gpg.format' | 'gpg.program' | 'gpg.ssh.program' | 'gpg.ssh.allowedSignersFile' | 'init.defaultBranch' |
 /** `merge.autoStash` — whether `git merge` (and so a merging `git pull`) stashes and reapplies uncommitted changes */
- | 'merge.autoStash'
+'merge.autoStash' |
 /** `merge.ff` — whether `git merge` fast-forwards when possible; also accepts `'only'` to require it */
- | 'merge.ff'
+'merge.ff' |
 /** `pull.autoStash` — overrides `merge.autoStash`/`rebase.autoStash` for `git pull`, in either mode */
- | 'pull.autoStash'
+'pull.autoStash' |
 /** `pull.rebase` — whether `git pull` rebases instead of merging; also accepts `merges`/`interactive` */
- | 'pull.rebase'
+'pull.rebase' |
 /** `rebase.autoStash` — whether `git rebase` (and so a rebasing `git pull`) stashes and reapplies uncommitted changes */
- | 'rebase.autoStash'
+'rebase.autoStash' |
 /** `rebase.autosquash` — whether `git rebase` automatically folds `fixup!`/`squash!` commits into the commits they target */
- | 'rebase.autosquash'
+'rebase.autosquash' |
 /** `rebase.updateRefs` — whether `git rebase` also updates branches pointing to the rebased commits */
- | 'rebase.updateRefs'
+'rebase.updateRefs' |
 /** `remote.pushDefault` — the remote `git push` targets when a branch has no explicit push remote configured */
- | 'remote.pushDefault' | 'user.email' | 'user.name' | 'user.signingkey';
-export type GitConfigKeys = GitCoreConfigKeys
+'remote.pushDefault' | 'user.email' | 'user.name' | 'user.signingkey';
+export type GitConfigKeys = GitCoreConfigKeys |
 /** `vscode-merge-base` — value determined by VS Code that is used to determine the merge base for the current branch. Once `gk-merge-base` is determined, we stop using `vscode-merge-base` */
- | `branch.${string}.vscode-merge-base`
+`branch.${string}.vscode-merge-base` |
 /** `github-pr-owner-number` — value determined by VS Code/GitHub PR extension that is used to determine the PR number for the current branch */
- | `branch.${string}.github-pr-owner-number`
+`branch.${string}.github-pr-owner-number` |
 /** `rebase` — per-branch override of `pull.rebase`; takes precedence over the repository-wide setting */
- | `branch.${string}.rebase`;
-export type GkConfigKeys = 
+`branch.${string}.rebase`;
+export type GkConfigKeys =
 /** `gk-merge-base` — the branch that the current branch was created from (the original base at branch creation time) */
-`branch.${string}.gk-merge-base`
+`branch.${string}.gk-merge-base` |
 /** `gk-merge-target` — the auto-detected branch that the current branch will likely be merged into (used for comparisons, PR targets, etc.) */
- | `branch.${string}.gk-merge-target`
+`branch.${string}.gk-merge-target` |
 /** `gk-merge-target-user` — user-specified merge target branch; takes precedence over auto-detected `gk-merge-target` */
- | `branch.${string}.gk-merge-target-user`
+`branch.${string}.gk-merge-target-user` |
 /** `gk-associated-issues` — JSON array of issue/PR entity identifiers linked to this branch */
- | `branch.${string}.gk-associated-issues`
+`branch.${string}.gk-associated-issues` |
 /** `gk-last-accessed` — ISO 8601 timestamp of when the branch was last checked out or viewed */
- | `branch.${string}.gk-last-accessed`
+`branch.${string}.gk-last-accessed` |
 /** `gk-last-modified` — ISO 8601 timestamp of when the branch last received a commit */
- | `branch.${string}.gk-last-modified`
+`branch.${string}.gk-last-modified` |
 /** `gk-agent-last-activity` — ISO 8601 timestamp of when an AI agent was last active on this branch */
- | `branch.${string}.gk-agent-last-activity`
+`branch.${string}.gk-agent-last-activity` |
 /** `gk-disposition` — user-assigned branch disposition: 'starred' or 'archived' */
- | `branch.${string}.gk-disposition`
+`branch.${string}.gk-disposition` |
 /** `gk.defaultRemote` — the user-designated default remote for the repository */
- | 'gk.defaultRemote'
+'gk.defaultRemote' |
 /** `gk.maintenanceLastRun` — ISO 8601 timestamp of the last auto-tier git-optimization maintenance pass */
- | 'gk.maintenanceLastRun'
+'gk.maintenanceLastRun' |
 /** `gk.commitGraphDisabled` — `'true'` once the user disables GitLens's automatic commit-graph maintenance for this repo */
- | 'gk.commitGraphDisabled'
+'gk.commitGraphDisabled' |
 /** `gk.fsmonitorNotApplicable` — `'true'` once FSMonitor failed to enable for this repo, so it's never re-suggested */
- | 'gk.fsmonitorNotApplicable'
+'gk.fsmonitorNotApplicable' |
 /** `gk.untrackedCacheNotApplicable` — `'true'` once the untracked cache failed git's filesystem probe here, so it's never re-suggested */
- | 'gk.untrackedCacheNotApplicable'
+'gk.untrackedCacheNotApplicable' |
 /**
  * `gk.applied.*` — Git Health ownership + undo markers under `[gk "applied"]`. Each value is the lever's
  * prior LOCAL-scope value (so undo restores it exactly) or the literal `unset` sentinel when it was absent;
@@ -63,60 +64,61 @@ export type GkConfigKeys =
  * unregister), and `maintenanceAuto` holds the prior `maintenance.auto` that `git maintenance start` sets
  * to false and unregister does not restore.
  */
- | 'gk.applied.untrackedCache' | 'gk.applied.fsmonitor' | 'gk.applied.manyFiles' | 'gk.applied.skipHash' | 'gk.applied.backgroundMaintenance' | 'gk.applied.maintenanceAuto'
+'gk.applied.untrackedCache' | 'gk.applied.fsmonitor' | 'gk.applied.manyFiles' | 'gk.applied.skipHash' | 'gk.applied.backgroundMaintenance' | 'gk.applied.maintenanceAuto' |
 /** `git maintenance register` sets `maintenance.strategy` too, and `unregister` does NOT restore it. */
- | 'gk.applied.maintenanceStrategy'
+'gk.applied.maintenanceStrategy' |
 /**
  * Write-ahead records for direct Git Health config mutations. A pending record is finalized into the
  * corresponding `gk.applied.*` marker only after the local config write succeeds; interrupted records are
  * reconciled on the next probe so a crash cannot silently lose ownership or claim a failed write.
  */
- | 'gk.pending.untrackedCache' | 'gk.pending.fsmonitor' | 'gk.pending.manyFiles' | 'gk.pending.skipHash';
+'gk.pending.untrackedCache' | 'gk.pending.fsmonitor' | 'gk.pending.manyFiles' | 'gk.pending.skipHash';
 export type DeprecatedGkConfigKeys = `branch.${string}.gk-target-base`;
 export type GitConfigType = 'bool' | 'int' | 'bool-or-int' | 'path' | 'expiry-date' | 'color';
 export interface GitConfigSubProvider {
-    getConfig?(repoPath: string | undefined, key: GitConfigKeys, options?: {
-        global?: boolean;
-        runGitLocally?: boolean;
-        type?: GitConfigType;
-    }): Promise<string | undefined>;
-    getConfigRegex?(repoPath: string | undefined, pattern: string, options?: {
-        global?: boolean;
-        runGitLocally?: boolean;
-    }): Promise<Map<string, string>>;
-    setConfig?(repoPath: string | undefined, key: GitConfigKeys, value: string | undefined, options?: {
-        global?: boolean;
-        runGitLocally?: boolean;
-    }): Promise<void>;
-    getCurrentUser(repoPath: string): Promise<GitUser | undefined>;
-    getDefaultWorktreePath?(repoPath: string): Promise<string | undefined>;
-    getGitDir?(repoPath: string): Promise<GitDir | undefined>;
-    getRepositoryInfo?(cwd: string): Promise<{
-        repoPath: string;
-        gitDir: string;
-        commonGitDir: string | undefined;
-        superprojectPath: string | undefined;
-    } | [safe: true, repoPath: string] | [safe: false] | []>;
-    getGkConfig?(repoPath: string, key: GkConfigKeys | DeprecatedGkConfigKeys): Promise<string | undefined>;
-    getGkConfigRegex?(repoPath: string, pattern: string): Promise<Map<string, string>>;
-    setGkConfig?(repoPath: string, key: GkConfigKeys | DeprecatedGkConfigKeys, value: string | undefined, options?: {
-        skipInvalidation?: readonly GkConfigInvalidationTarget[];
-    }): Promise<void>;
-    /**
-     * Drops every gk key stored for `ref` — call when a branch stops existing under that name. Deliberately
-     * includes user-owned values (`gk-merge-target-user`, `gk-disposition`, `gk-associated-issues`): the
-     * branch is confirmed gone, and leaving them would hand the next branch reusing that name a dead one's
-     * starred state and issue links. Only call where git guarantees the name is free —
-     * a completed delete.
-     */
-    removeGkConfigBranchSection?(repoPath: string, ref: string): Promise<void>;
-    /** Moves every gk key stored for `oldRef` to `newRef` — call when a branch is renamed. */
-    renameGkConfigBranchSection?(repoPath: string, oldRef: string, newRef: string): Promise<void>;
-    getSigningConfig?(repoPath: string): Promise<SigningConfig>;
-    getSigningConfigFlags?(config: SigningConfig): string[];
-    setSigningConfig?(repoPath: string, config: Partial<SigningConfig>, options?: {
-        global?: boolean;
-    }): Promise<void>;
-    validateSigningSetup?(repoPath: string): Promise<ValidationResult>;
+  getConfig?(repoPath: string | undefined, key: GitConfigKeys, options?: {
+    global?: boolean;
+    runGitLocally?: boolean;
+    type?: GitConfigType;
+  }): Promise<string | undefined>;
+  getConfigRegex?(repoPath: string | undefined, pattern: string, options?: {
+    global?: boolean;
+    runGitLocally?: boolean;
+  }): Promise<Map<string, string>>;
+  setConfig?(repoPath: string | undefined, key: GitConfigKeys, value: string | undefined, options?: {
+    global?: boolean;
+    runGitLocally?: boolean;
+  }): Promise<void>;
+  getCurrentUser(repoPath: string): Promise<GitUser | undefined>;
+  getDefaultWorktreePath?(repoPath: string): Promise<string | undefined>;
+  getGitDir?(repoPath: string): Promise<GitDir | undefined>;
+  getRepositoryInfo?(cwd: string): Promise<{
+    repoPath: string;
+    gitDir: string;
+    commonGitDir: string | undefined;
+    superprojectPath: string | undefined;
+  } | [safe: true, repoPath: string] | [safe: false] | []>;
+  getGkConfig?(repoPath: string, key: GkConfigKeys | DeprecatedGkConfigKeys): Promise<string | undefined>;
+  getGkConfigRegex?(repoPath: string, pattern: string): Promise<Map<string, string>>;
+  setGkConfig?(repoPath: string, key: GkConfigKeys | DeprecatedGkConfigKeys, value: string | undefined, options?: {
+    skipInvalidation?: readonly GkConfigInvalidationTarget[];
+  }): Promise<void>;
+  /**
+   * Drops every gk key stored for `ref` — call when a branch stops existing under that name. Deliberately
+   * includes user-owned values (`gk-merge-target-user`, `gk-disposition`, `gk-associated-issues`): the
+   * branch is confirmed gone, and leaving them would hand the next branch reusing that name a dead one's
+   * starred state and issue links. Only call where git guarantees the name is free —
+   * a completed delete.
+   */
+  removeGkConfigBranchSection?(repoPath: string, ref: string): Promise<void>;
+  /** Moves every gk key stored for `oldRef` to `newRef` — call when a branch is renamed. */
+  renameGkConfigBranchSection?(repoPath: string, oldRef: string, newRef: string): Promise<void>;
+  getSigningConfig?(repoPath: string): Promise<SigningConfig>;
+  getSigningConfigFlags?(config: SigningConfig): string[];
+  setSigningConfig?(repoPath: string, config: Partial<SigningConfig>, options?: {
+    global?: boolean;
+  }): Promise<void>;
+  validateSigningSetup?(repoPath: string): Promise<ValidationResult>;
 }
+//#endregion
 //# sourceMappingURL=config.d.ts.map

package/dist/git/providers/config.js

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

package/dist/git/providers/contributors.d.ts

@@ -1,26 +1,28 @@
-import type { GitContributor, GitContributorsStats } from '../models/contributor.js';
+import { GitContributor, GitContributorsStats } from "../models/contributor.js";
+//#region ../git/src/providers/contributors.d.ts
 export interface GitContributorsResult {
-    readonly contributors: GitContributor[];
-    readonly cancelled?: {
-        reason: 'cancelled' | 'timedout';
-    } | undefined;
+  readonly contributors: GitContributor[];
+  readonly cancelled?: {
+    reason: 'cancelled' | 'timedout';
+  } | undefined;
 }
 export interface GitContributorsSubProvider {
-    getContributors(repoPath: string, rev?: string, options?: {
-        all?: boolean;
-        merges?: boolean | 'first-parent';
-        pathspec?: string;
-        since?: string;
-        stats?: boolean;
-    }, cancellation?: AbortSignal, timeout?: number): Promise<GitContributorsResult>;
-    getContributorsLite(repoPath: string, rev?: string, options?: {
-        all?: boolean;
-        merges?: boolean | 'first-parent';
-        since?: string;
-    }, cancellation?: AbortSignal): Promise<GitContributor[]>;
-    getContributorsStats(repoPath: string, options?: {
-        merges?: boolean | 'first-parent';
-        since?: string;
-    }, cancellation?: AbortSignal, timeout?: number): Promise<GitContributorsStats | undefined>;
+  getContributors(repoPath: string, rev?: string, options?: {
+    all?: boolean;
+    merges?: boolean | 'first-parent';
+    pathspec?: string;
+    since?: string;
+    stats?: boolean;
+  }, cancellation?: AbortSignal, timeout?: number): Promise<GitContributorsResult>;
+  getContributorsLite(repoPath: string, rev?: string, options?: {
+    all?: boolean;
+    merges?: boolean | 'first-parent';
+    since?: string;
+  }, cancellation?: AbortSignal): Promise<GitContributor[]>;
+  getContributorsStats(repoPath: string, options?: {
+    merges?: boolean | 'first-parent';
+    since?: string;
+  }, cancellation?: AbortSignal, timeout?: number): Promise<GitContributorsStats | undefined>;
 }
+//#endregion
 //# sourceMappingURL=contributors.d.ts.map

package/dist/git/providers/contributors.js

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

package/dist/git/providers/diff.d.ts

@@ -1,75 +1,77 @@
-import type { Uri } from '../../utils/uri.js';
-import type { GitDiff, GitDiffFiles, GitDiffFilter, GitDiffShortStat, ParsedGitDiff, ParsedGitDiffHunks } from '../models/diff.js';
-import type { GitFile } from '../models/file.js';
-import type { GitRevisionRange, GitRevisionRangeNotation } from '../models/revision.js';
-import type { DisposableTemporaryGitIndex } from './staging.js';
-import type { DiffRange, RevisionUri } from './types.js';
+import { Uri } from "../../utils/uri.js";
+import { DiffRange, RevisionUri } from "./types.js";
+import { GitRevisionRange, GitRevisionRangeNotation } from "../models/revision.js";
+import { GitDiff, GitDiffFiles, GitDiffFilter, GitDiffShortStat, ParsedGitDiff, ParsedGitDiffHunks } from "../models/diff.js";
+import { GitFile } from "../models/file.js";
+import { DisposableTemporaryGitIndex } from "./staging.js";
+//#region ../git/src/providers/diff.d.ts
 export interface NextComparisonUrisResult {
-    current: RevisionUri;
-    next: RevisionUri | undefined;
-    deleted?: boolean | undefined;
+  current: RevisionUri;
+  next: RevisionUri | undefined;
+  deleted?: boolean | undefined;
 }
 export interface PreviousComparisonUrisResult {
-    current: RevisionUri;
-    previous: RevisionUri | undefined;
+  current: RevisionUri;
+  previous: RevisionUri | undefined;
 }
 export interface PreviousRangeComparisonUrisResult extends PreviousComparisonUrisResult {
-    range: DiffRange;
+  range: DiffRange;
 }
 export interface GitDiffSubProvider {
-    getChangedFilesCount(repoPath: string, to?: string, from?: string, options?: {
-        uris?: (string | Uri)[];
-        includeUntracked?: boolean;
-    }, cancellation?: AbortSignal): Promise<GitDiffShortStat | undefined>;
-    getDiff?(repoPath: string, to: string, from?: string, options?: {
-        context?: number;
-        index?: DisposableTemporaryGitIndex;
-        notation?: GitRevisionRangeNotation;
-        uris?: (string | Uri)[];
-    }, cancellation?: AbortSignal): Promise<GitDiff | undefined>;
-    /**
-     * Runs `git diff` and returns the fully parsed structure (files with hunks together) in a
-     * single call. Equivalent to `getDiff` followed by `parseGitDiff` on the resulting contents.
-     *
-     * For rendering-friendly line ordering, split each `hunk.content` on newlines and read the
-     * `+`/`-`/` ` prefix on each line.
-     */
-    getParsedDiff?(repoPath: string, to: string, from?: string, options?: {
-        context?: number;
-        notation?: GitRevisionRangeNotation;
-        uris?: (string | Uri)[];
-    }, cancellation?: AbortSignal): Promise<ParsedGitDiff | undefined>;
-    getDiffFiles?(repoPath: string, contents: string, cancellation?: AbortSignal): Promise<GitDiffFiles | undefined>;
-    getDiffStatus(repoPath: string, ref1OrRange: string | GitRevisionRange, ref2?: string, options?: {
-        filters?: GitDiffFilter[];
-        includeUntracked?: boolean;
-        path?: string;
-        renameLimit?: number;
-        similarityThreshold?: number;
-    }): Promise<GitFile[] | undefined>;
-    getDiffTool?(repoPath?: string): Promise<string | undefined>;
-    getNextComparisonUris(repoPath: string, pathOrUri: string | Uri, rev: string | undefined, skip?: number, options?: {
-        ordering?: 'date' | 'author-date' | 'topo' | null;
-    }, cancellation?: AbortSignal): Promise<NextComparisonUrisResult | undefined>;
-    getPreviousComparisonUris(repoPath: string, pathOrUri: string | Uri, rev: string | undefined, skip?: number, unsaved?: boolean, options?: {
-        ordering?: 'date' | 'author-date' | 'topo' | null;
-    }, cancellation?: AbortSignal): Promise<PreviousComparisonUrisResult | undefined>;
-    getPreviousComparisonUrisForRange(repoPath: string, pathOrUri: string | Uri, rev: string | undefined, range: DiffRange, options?: {
-        ordering?: 'date' | 'author-date' | 'topo' | null;
-        skipFirstRev?: boolean;
-    }, cancellation?: AbortSignal): Promise<PreviousRangeComparisonUrisResult | undefined>;
-    openDiffTool?(repoPath: string, pathOrUri: string | Uri, options?: {
-        ref1?: string | undefined;
-        ref2?: string | undefined;
-        staged?: boolean | undefined;
-        tool?: string | undefined;
-    }): Promise<void>;
-    openDirectoryCompare?(repoPath: string, ref1: string, ref2?: string, tool?: string): Promise<void>;
-    getDiffForFile?(repoPath: string, path: string, ref1: string | undefined, ref2?: string, options?: {
-        encoding?: string;
-    }): Promise<ParsedGitDiffHunks | undefined>;
-    getDiffForFileContents?(repoPath: string, path: string, ref: string, contents: string, options?: {
-        encoding?: string;
-    }): Promise<ParsedGitDiffHunks | undefined>;
+  getChangedFilesCount(repoPath: string, to?: string, from?: string, options?: {
+    uris?: (string | Uri)[];
+    includeUntracked?: boolean;
+  }, cancellation?: AbortSignal): Promise<GitDiffShortStat | undefined>;
+  getDiff?(repoPath: string, to: string, from?: string, options?: {
+    context?: number;
+    index?: DisposableTemporaryGitIndex;
+    notation?: GitRevisionRangeNotation;
+    uris?: (string | Uri)[];
+  }, cancellation?: AbortSignal): Promise<GitDiff | undefined>;
+  /**
+   * Runs `git diff` and returns the fully parsed structure (files with hunks together) in a
+   * single call. Equivalent to `getDiff` followed by `parseGitDiff` on the resulting contents.
+   *
+   * For rendering-friendly line ordering, split each `hunk.content` on newlines and read the
+   * `+`/`-`/` ` prefix on each line.
+   */
+  getParsedDiff?(repoPath: string, to: string, from?: string, options?: {
+    context?: number;
+    notation?: GitRevisionRangeNotation;
+    uris?: (string | Uri)[];
+  }, cancellation?: AbortSignal): Promise<ParsedGitDiff | undefined>;
+  getDiffFiles?(repoPath: string, contents: string, cancellation?: AbortSignal): Promise<GitDiffFiles | undefined>;
+  getDiffStatus(repoPath: string, ref1OrRange: string | GitRevisionRange, ref2?: string, options?: {
+    filters?: GitDiffFilter[];
+    includeUntracked?: boolean;
+    path?: string;
+    renameLimit?: number;
+    similarityThreshold?: number;
+  }): Promise<GitFile[] | undefined>;
+  getDiffTool?(repoPath?: string): Promise<string | undefined>;
+  getNextComparisonUris(repoPath: string, pathOrUri: string | Uri, rev: string | undefined, skip?: number, options?: {
+    ordering?: 'date' | 'author-date' | 'topo' | null;
+  }, cancellation?: AbortSignal): Promise<NextComparisonUrisResult | undefined>;
+  getPreviousComparisonUris(repoPath: string, pathOrUri: string | Uri, rev: string | undefined, skip?: number, unsaved?: boolean, options?: {
+    ordering?: 'date' | 'author-date' | 'topo' | null;
+  }, cancellation?: AbortSignal): Promise<PreviousComparisonUrisResult | undefined>;
+  getPreviousComparisonUrisForRange(repoPath: string, pathOrUri: string | Uri, rev: string | undefined, range: DiffRange, options?: {
+    ordering?: 'date' | 'author-date' | 'topo' | null;
+    skipFirstRev?: boolean;
+  }, cancellation?: AbortSignal): Promise<PreviousRangeComparisonUrisResult | undefined>;
+  openDiffTool?(repoPath: string, pathOrUri: string | Uri, options?: {
+    ref1?: string | undefined;
+    ref2?: string | undefined;
+    staged?: boolean | undefined;
+    tool?: string | undefined;
+  }): Promise<void>;
+  openDirectoryCompare?(repoPath: string, ref1: string, ref2?: string, tool?: string): Promise<void>;
+  getDiffForFile?(repoPath: string, path: string, ref1: string | undefined, ref2?: string, options?: {
+    encoding?: string;
+  }): Promise<ParsedGitDiffHunks | undefined>;
+  getDiffForFileContents?(repoPath: string, path: string, ref: string, contents: string, options?: {
+    encoding?: string;
+  }): Promise<ParsedGitDiffHunks | undefined>;
 }
+//#endregion
 //# sourceMappingURL=diff.d.ts.map

package/dist/git/providers/diff.js

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

package/dist/git/providers/graph.d.ts

@@ -1,69 +1,80 @@
-import type { GitGraph, GitGraphRowsStats, GraphIncrementalSeed, GraphReachabilityTable, GraphRowProcessor, IncrementalGraphOutcome } from '../models/graph.js';
-import type { GitGraphSearch, GitGraphSearchCursor, GitGraphSearchProgress, GitGraphSearchResults } from '../models/graphSearch.js';
-import type { GitGraphSession } from '../models/graphSession.js';
-import type { SearchQuery } from '../models/search.js';
+import { SearchQuery } from "../models/search.js";
+import { GitGraph, GitGraphRowsStats, GraphIncrementalSeed, GraphReachabilityTable, GraphRowProcessor, IncrementalGraphOutcome } from "../models/graph.js";
+import { GitGraphSearch, GitGraphSearchCursor, GitGraphSearchProgress, GitGraphSearchResults } from "../models/graphSearch.js";
+import { GitGraphSession } from "../models/graphSession.js";
+//#region ../git/src/providers/graph.d.ts
 export interface GitGraphSubProvider {
+  /**
+   * Opens a stateful {@link GitGraphSession} for `repoPath` — the canonical accumulated graph window and
+   * the single builder of incremental rebuild seeds. Performs the initial walk (equivalent to a first
+   * `getGraph` with no seed); subsequent rebuilds go through `session.refresh()`, pagination through
+   * `session.more()`. Prefer this over `getGraph` for a live, repeatedly-refreshed window; `getGraph`
+   * remains for one-shot walks (and is what the session is built on).
+   */
+  openGraphSession(repoPath: string, options?: {
+    rowProcessor?: GraphRowProcessor;
+    rev?: string;
+    limit?: number;
+    include?: {
+      stats?: boolean;
+    };
+  }, cancellation?: AbortSignal): Promise<GitGraphSession>;
+  getGraph(repoPath: string, rev: string | undefined, options?: {
+    include?: {
+      stats?: boolean;
+    };
+    limit?: number;
+    rowProcessor?: GraphRowProcessor;
     /**
-     * Opens a stateful {@link GitGraphSession} for `repoPath` — the canonical accumulated graph window and
-     * the single builder of incremental rebuild seeds. Performs the initial walk (equivalent to a first
-     * `getGraph` with no seed); subsequent rebuilds go through `session.refresh()`, pagination through
-     * `session.more()`. Prefer this over `getGraph` for a live, repeatedly-refreshed window; `getGraph`
-     * remains for one-shot walks (and is what the session is built on).
+     * Prior generation's reachability table to CONTINUE (same repo rebuilds only). Keeps
+     * `reachabilityIndex` values stable for unchanged rows, which is what lets the caller ship a
+     * rows splice-delta instead of the full row set. See `createReachabilityTableBuilder`.
      */
-    openGraphSession(repoPath: string, options?: {
-        rowProcessor?: GraphRowProcessor;
-        rev?: string;
-        limit?: number;
-        include?: {
-            stats?: boolean;
-        };
-    }, cancellation?: AbortSignal): Promise<GitGraphSession>;
-    getGraph(repoPath: string, rev: string | undefined, options?: {
-        include?: {
-            stats?: boolean;
-        };
-        limit?: number;
-        rowProcessor?: GraphRowProcessor;
-        /**
-         * Prior generation's reachability table to CONTINUE (same repo rebuilds only). Keeps
-         * `reachabilityIndex` values stable for unchanged rows, which is what lets the caller ship a
-         * rows splice-delta instead of the full row set. See `createReachabilityTableBuilder`.
-         */
-        reachabilitySeed?: GraphReachabilityTable;
-        /**
-         * Prior generation's per-sha stats to CONTINUE (same-repo rebuilds only). Stats are immutable per
-         * sha, so the deferred stats query recomputes only shas absent from the seed.
-         */
-        rowsStatsSeed?: GitGraphRowsStats;
-        /**
-         * R6b incremental head-walk seed. When present (and the gate holds) the Node provider walks only the
-         * changed head region, stitches the seed's cached tail, and re-derives flags/reachability in memory
-         * instead of re-walking every loaded row. Any structural change (ref deletion, non-fast-forward move,
-         * stash-set change, old-dated interleave, …) degrades to the full walk. See {@link GraphIncrementalSeed}.
-         */
-        incrementalSeed?: GraphIncrementalSeed;
-        /**
-         * Observational callback invoked once per seeded call reporting whether the fast path was taken or a
-         * full fallback occurred (with the reason). Never affects the returned graph. See
-         * {@link IncrementalGraphOutcome}.
-         */
-        onIncrementalResult?: (outcome: IncrementalGraphOutcome) => void;
-    }, cancellation?: AbortSignal): Promise<GitGraph>;
-    searchGraph(repoPath: string, search: SearchQuery, options?: {
-        limit?: number;
-        ordering?: 'date' | 'author-date' | 'topo';
-    }, cancellation?: AbortSignal): AsyncGenerator<GitGraphSearchProgress, GitGraphSearch, void>;
-    continueSearchGraph(repoPath: string, cursor: GitGraphSearchCursor, existingResults: GitGraphSearchResults, options?: {
-        limit?: number;
-    }, cancellation?: AbortSignal): AsyncGenerator<GitGraphSearchProgress, GitGraphSearch, void>;
+    reachabilitySeed?: GraphReachabilityTable;
     /**
-     * Counts commits matching `search` without materializing results — used to probe whether a relaxed
-     * (broadened) variant of a zero-result search would actually find anything, before offering it as a
-     * calm inline chip. Optional: providers that can't cheaply count (e.g. GitHub) simply omit it, and
-     * callers treat a missing implementation the same as "no relaxations available" (never an error).
+     * Prior generation's per-sha stats to CONTINUE (same-repo rebuilds only). Reuse requires matching
+     * ancestry supplied by `ancestrySeed` or `incrementalSeed`; otherwise stats are recomputed.
      */
-    countSearchResults?(repoPath: string, search: SearchQuery, options?: {
-        maxCount?: number;
-    }, cancellation?: AbortSignal): Promise<number>;
+    rowsStatsSeed?: GitGraphRowsStats;
+    /** Ancestry under which the stats were computed, independent of incremental row eligibility. */
+    ancestrySeed?: Pick<GitGraph, 'shallowBoundary' | 'refTips'>;
+    /**
+     * R6b incremental head-walk seed. When present (and the gate holds) the Node provider walks only the
+     * changed head region, stitches the seed's cached tail, and re-derives flags/reachability in memory
+     * instead of re-walking every loaded row. Any structural change (ref deletion, non-fast-forward move,
+     * stash-set change, old-dated interleave, …) degrades to the full walk. See {@link GraphIncrementalSeed}.
+     */
+    incrementalSeed?: GraphIncrementalSeed;
+    /**
+     * Observational callback invoked once per seeded call reporting whether the fast path was taken or a
+     * full fallback occurred (with the reason). Never affects the returned graph. See
+     * {@link IncrementalGraphOutcome}.
+     */
+    onIncrementalResult?: (outcome: IncrementalGraphOutcome) => void;
+    /**
+     * Set only by {@link GitGraphSession.rebind} — the path the session was bound to before this call.
+     * Enables the rebind fast path: unchanged tips, HEAD endpoints refetched, flags/reachability
+     * replayed over the existing window, and every row's `repoPath`-derived decorations re-stamped
+     * from this path onto `repoPath` (see {@link GraphRowProcessor.restampRow}).
+     */
+    rebindFromRepoPath?: string;
+  }, cancellation?: AbortSignal): Promise<GitGraph>;
+  searchGraph(repoPath: string, search: SearchQuery, options?: {
+    limit?: number;
+    ordering?: 'date' | 'author-date' | 'topo';
+  }, cancellation?: AbortSignal): AsyncGenerator<GitGraphSearchProgress, GitGraphSearch, void>;
+  continueSearchGraph(repoPath: string, cursor: GitGraphSearchCursor, existingResults: GitGraphSearchResults, options?: {
+    limit?: number;
+  }, cancellation?: AbortSignal): AsyncGenerator<GitGraphSearchProgress, GitGraphSearch, void>;
+  /**
+   * Counts commits matching `search` without materializing results — used to probe whether a relaxed
+   * (broadened) variant of a zero-result search would actually find anything, before offering it as a
+   * calm inline chip. Optional: providers that can't cheaply count (e.g. GitHub) simply omit it, and
+   * callers treat a missing implementation the same as "no relaxations available" (never an error).
+   */
+  countSearchResults?(repoPath: string, search: SearchQuery, options?: {
+    maxCount?: number;
+  }, cancellation?: AbortSignal): Promise<number>;
 }
+//#endregion
 //# sourceMappingURL=graph.d.ts.map

package/dist/git/providers/graph.js

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