@gitkraken/core-gitlens 0.6.0 → 0.7.0

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

@@ -1,84 +1,85 @@
-import type { GitCommitReachability } from '../providers/commits.js';
-import type { GitBranch } from './branch.js';
-import type { GitStashCommit } from './commit.js';
-import type { GitRemote } from './remote.js';
-import type { GkProviderId } from './repositoryIdentities.js';
-import type { GitWorktree } from './worktree.js';
+import { GitStashCommit } from "./commit.js";
+import { GitBranch } from "./branch.js";
+import { GkProviderId } from "./repositoryIdentities.js";
+import { GitRemote } from "./remote.js";
+import { GitWorktree } from "./worktree.js";
+import { GitCommitReachability } from "../providers/commits.js";
+//#region ../git/src/models/graph.d.ts
 export type GitGraphRowKind = 'commit' | 'merge' | 'stash' | 'workdir';
 export interface GitGraphRowHead {
-    /**
-     * Stable ref id. **Its presence is the provider-tier marker** — the one signal separating a ref that
-     * can be acted on from a lean, name-only one, now that neither carries a serialized context.
-     *
-     * The CLI provider stamps an id on every ref it emits (`git-cli/providers/graph.ts:781`, `:805`,
-     * `:836`); the GitHub provider never does, because it has no branch metadata to key
-     * (`git-github/providers/github/graph.ts:231`, `:239`). So `id == null` means "this ref came from a
-     * provider that computes nothing beyond a name", and every id-keyed feature — ref metadata, exclusions,
-     * pinning, PR/issue lookup — must degrade rather than guess. Consumers already do this; it is written
-     * down here because until now it was an accident of two providers rather than a stated contract.
-     *
-     * ⚠ An id means the ref is **identifiable and actionable** — it does NOT mean its enrichment is
-     * complete. The CLI resolves branches, remotes and worktrees with `Promise.allSettled`
-     * (`git-cli/providers/graph.ts:546`) and still synthesizes ids when any of those settle rejected, so an
-     * id-bearing ref can carry a missing `starred`/`upstream` that means "not computed" rather than "no".
-     * Treat every optional field as enrichment that may be absent, and never report a capability from its
-     * absence. If a consumer ever needs to tell "unavailable" from "false", that wants one graph-level
-     * completeness flag, not a per-ref field on every row.
-     */
-    id?: string;
+  /**
+   * Stable ref id. **Its presence is the provider-tier marker** — the one signal separating a ref that
+   * can be acted on from a lean, name-only one, now that neither carries a serialized context.
+   *
+   * The CLI provider stamps an id on every ref it emits (`git-cli/providers/graph.ts:781`, `:805`,
+   * `:836`); the GitHub provider never does, because it has no branch metadata to key
+   * (`git-github/providers/github/graph.ts:231`, `:239`). So `id == null` means "this ref came from a
+   * provider that computes nothing beyond a name", and every id-keyed feature — ref metadata, exclusions,
+   * pinning, PR/issue lookup — must degrade rather than guess. Consumers already do this; it is written
+   * down here because until now it was an accident of two providers rather than a stated contract.
+   *
+   * ⚠ An id means the ref is **identifiable and actionable** — it does NOT mean its enrichment is
+   * complete. The CLI resolves branches, remotes and worktrees with `Promise.allSettled`
+   * (`git-cli/providers/graph.ts:546`) and still synthesizes ids when any of those settle rejected, so an
+   * id-bearing ref can carry a missing `starred`/`upstream` that means "not computed" rather than "no".
+   * Treat every optional field as enrichment that may be absent, and never report a capability from its
+   * absence. If a consumer ever needs to tell "unavailable" from "false", that wants one graph-level
+   * completeness flag, not a per-ref field on every row.
+   */
+  id?: string;
+  name: string;
+  isCurrentHead: boolean;
+  /**
+   * The tracked upstream. `missing`/`state` are optional here while {@link GitTrackingUpstream} makes
+   * them required, and the difference is meaningful: absent means the producer did NOT compute them
+   * (the GitHub provider has no branch metadata at all), NOT "present and false/zero". Consumers must
+   * treat `undefined` as unknown rather than folding it into the negative case.
+   */
+  upstream?: {
     name: string;
-    isCurrentHead: boolean;
-    /**
-     * The tracked upstream. `missing`/`state` are optional here while {@link GitTrackingUpstream} makes
-     * them required, and the difference is meaningful: absent means the producer did NOT compute them
-     * (the GitHub provider has no branch metadata at all), NOT "present and false/zero". Consumers must
-     * treat `undefined` as unknown rather than folding it into the negative case.
-     */
-    upstream?: {
-        name: string;
-        id: string;
-        missing?: boolean;
-        state?: {
-            ahead: number;
-            behind: number;
-        };
+    id: string;
+    missing?: boolean;
+    state?: {
+      ahead: number;
+      behind: number;
     };
-    /** Starred (a GitKraken branch disposition). Structured so `+starred` stops being baked into the
-     *  serialized context at row-build time, where starring a branch left the label stale. */
-    starred?: boolean;
-    /** Set when this branch is checked out in ANY worktree, including the default one. Grouped so
-     *  producers can't half-populate id-without-path or vice versa. Consumers that mean "checked out
-     *  somewhere other than here" — the ref-ordering tier and the worktree glyph — must test
-     *  `isDefault` too; the default worktree's checkout is the ordinary case, not a worktree badge.
-     *  Note `isDefault` here describes the WORKTREE; the sibling `isDefault` below describes the BRANCH. */
-    worktree?: {
-        id: string;
-        path: string;
-        isDefault: boolean;
-    };
-    /** True when this head is the repository's default branch. */
-    isDefault?: boolean;
+  };
+  /** Starred (a GitKraken branch disposition). Structured so `+starred` stops being baked into the
+   *  serialized context at row-build time, where starring a branch left the label stale. */
+  starred?: boolean;
+  /** Set when this branch is checked out in ANY worktree, including the default one. Grouped so
+   *  producers can't half-populate id-without-path or vice versa. Consumers that mean "checked out
+   *  somewhere other than here" — the ref-ordering tier and the worktree glyph — must test
+   *  `isDefault` too; the default worktree's checkout is the ordinary case, not a worktree badge.
+   *  Note `isDefault` here describes the WORKTREE; the sibling `isDefault` below describes the BRANCH. */
+  worktree?: {
+    id: string;
+    path: string;
+    isDefault: boolean;
+  };
+  /** True when this head is the repository's default branch. */
+  isDefault?: boolean;
 }
 export interface GitGraphRowRemoteHead {
-    /** Stable ref id; see {@link GitGraphRowHead.id} — its presence is the provider-tier marker. */
-    id?: string;
-    name: string;
-    url?: string;
-    owner: string;
-    avatarUrl?: string;
-    current?: boolean;
-    /** True when this remote ref IS the repository's default branch and no local branch tracks it (no
-     *  local checkout) — so the default-branch tier still applies for remote-only defaults. */
-    isDefault?: boolean;
-    hostingServiceType?: GkProviderId;
-    /** See {@link GitGraphRowHead.starred}. */
-    starred?: boolean;
+  /** Stable ref id; see {@link GitGraphRowHead.id} — its presence is the provider-tier marker. */
+  id?: string;
+  name: string;
+  url?: string;
+  owner: string;
+  avatarUrl?: string;
+  current?: boolean;
+  /** True when this remote ref IS the repository's default branch and no local branch tracks it (no
+   *  local checkout) — so the default-branch tier still applies for remote-only defaults. */
+  isDefault?: boolean;
+  hostingServiceType?: GkProviderId;
+  /** See {@link GitGraphRowHead.starred}. */
+  starred?: boolean;
 }
 export interface GitGraphRowTag {
-    /** Stable ref id; see {@link GitGraphRowHead.id} — its presence is the provider-tier marker. */
-    id?: string;
-    name: string;
-    annotated: boolean;
+  /** Stable ref id; see {@link GitGraphRowHead.id} — its presence is the provider-tier marker. */
+  id?: string;
+  name: string;
+  annotated: boolean;
 }
 /**
  * Compact, host-computed flags for a commit/stash row, shipped instead of the bulky serialized
@@ -99,34 +100,34 @@ export interface GitGraphRowTag {
  * (`+HEAD` derives from `row.heads[].isCurrentHead`; contributor `+current` from `row.isCurrentUser`.)
  */
 export declare const enum GitGraphRowContextFlags {
-    None = 0,
-    ReachableFromHead = 1,
-    UniqueToBranch = 2,
-    HasChildren = 4,
-    Unpublished = 8,
-    RewriteableFromHead = 16,
-    Unpulled = 32
+  None = 0,
+  ReachableFromHead = 1,
+  UniqueToBranch = 2,
+  HasChildren = 4,
+  Unpublished = 8,
+  RewriteableFromHead = 16,
+  Unpulled = 32
 }
 /** Context data attached to graph rows for command/menu handling. */
 export interface GitGraphRowContexts {
-    /** Compact replacement for the serialized commit `row`/`avatar` contexts; see {@link GitGraphRowContextFlags}. */
-    flags?: GitGraphRowContextFlags;
-    /**
-     * Index into the per-graph `GraphReachabilityTable.sets` for this row's reachable-refs set,
-     * shipped instead of the per-row `reachability` object (which dominated the graph payload). The
-     * webview rebuilds `row.reachability` from the shared table. Absent ⇒ no reachability for this row.
-     */
-    reachabilityIndex?: number;
-    /** Serialized right-click context. Built here only for stash rows; commit rows ship {@link flags}
-     *  instead and have theirs rebuilt on demand (see `rowContext.utils`). */
-    row?: string | object;
-    /** Serialized context per grouped-ref name, for the group's own menu. */
-    refGroups?: Record<string, string | object>;
+  /** Compact replacement for the serialized commit `row`/`avatar` contexts; see {@link GitGraphRowContextFlags}. */
+  flags?: GitGraphRowContextFlags;
+  /**
+   * Index into the per-graph `GraphReachabilityTable.sets` for this row's reachable-refs set,
+   * shipped instead of the per-row `reachability` object (which dominated the graph payload). The
+   * webview rebuilds `row.reachability` from the shared table. Absent ⇒ no reachability for this row.
+   */
+  reachabilityIndex?: number;
+  /** Serialized right-click context. Built here only for stash rows; commit rows ship {@link flags}
+   *  instead and have theirs rebuilt on demand (see `rowContext.utils`). */
+  row?: string | object;
+  /** Serialized context per grouped-ref name, for the group's own menu. */
+  refGroups?: Record<string, string | object>;
 }
 export interface GitGraphRowStats {
-    files: number;
-    additions: number;
-    deletions: number;
+  files: number;
+  additions: number;
+  deletions: number;
 }
 /**
  * Wire encoding for per-row reachability, shipped once per graph payload instead of inline on every
@@ -143,147 +144,141 @@ export interface GitGraphRowStats {
  * its decode cache). A fresh `getGraph` walk mints a new `id`; `more()` keeps the same one.
  */
 export interface GraphReachabilityTable {
-    /** Generation id — stable across `more()` pagination, new per fresh graph walk. */
-    readonly id: number;
-    readonly dictionary: GitCommitReachability['refs'];
-    /** Distinct ref-membership bitmaps, base64-encoded `Uint8Array` of `ceil(dictionary.length/8)` bytes. */
-    readonly sets: string[];
+  /** Generation id — stable across `more()` pagination, new per fresh graph walk. */
+  readonly id: number;
+  readonly dictionary: GitCommitReachability['refs'];
+  /** Distinct ref-membership bitmaps, base64-encoded `Uint8Array` of `ceil(dictionary.length/8)` bytes. */
+  readonly sets: string[];
 }
 /** Library-owned graph row type. */
 export interface GitGraphRow {
-    sha: string;
-    parents: string[];
-    author: string;
-    email: string;
-    date: number;
-    commitDate?: number;
-    message: string;
-    kind: GitGraphRowKind;
-    heads?: GitGraphRowHead[];
-    remotes?: GitGraphRowRemoteHead[];
-    tags?: GitGraphRowTag[];
-    contexts?: GitGraphRowContexts;
-    stats?: GitGraphRowStats;
-    /** Stash rows only: the `{n}` of `stash@{n}`, so consumers stop parsing it back out of the message. */
-    stashNumber?: string;
-    /**
-     * Transient, set only for the duration of {@link GraphRowProcessor.processRow} (the row processor's
-     * `+unique` decision reads it). The provider strips it before pushing the row and records the
-     * reachable-ref set into the shared {@link GitGraph.reachability} table instead (see
-     * {@link GitGraphRowContexts.reachabilityIndex}), so emitted rows do NOT retain the per-row arrays.
-     */
-    reachability?: GitCommitReachability;
-    isCurrentUser?: boolean;
+  sha: string;
+  parents: string[];
+  author: string;
+  email: string;
+  date: number;
+  commitDate?: number;
+  message: string;
+  kind: GitGraphRowKind;
+  heads?: GitGraphRowHead[];
+  remotes?: GitGraphRowRemoteHead[];
+  tags?: GitGraphRowTag[];
+  contexts?: GitGraphRowContexts;
+  stats?: GitGraphRowStats;
+  /** Stash rows only: the `{n}` of `stash@{n}`, so consumers stop parsing it back out of the message. */
+  stashNumber?: string;
+  /**
+   * Transient, set only for the duration of {@link GraphRowProcessor.processRow} (the row processor's
+   * `+unique` decision reads it). The provider strips it before pushing the row and records the
+   * reachable-ref set into the shared {@link GitGraph.reachability} table instead (see
+   * {@link GitGraphRowContexts.reachabilityIndex}), so emitted rows do NOT retain the per-row arrays.
+   */
+  reachability?: GitCommitReachability;
+  isCurrentUser?: boolean;
 }
 export interface GitGraph {
-    readonly repoPath: string;
-    /** A map of all avatar urls */
-    readonly avatars: Map<string, string>;
-    /** A set of all "seen" commit ids */
-    readonly ids: Set<string>;
-    readonly includes: {
-        stats?: boolean;
-    } | undefined;
-    readonly branches: ReadonlyMap<string, GitBranch>;
-    readonly remotes: ReadonlyMap<string, GitRemote>;
-    readonly downstreams: ReadonlyMap<string, string[]>;
-    readonly stashes: ReadonlyMap<string, GitStashCommit> | undefined;
-    readonly worktrees: ReadonlyArray<GitWorktree> | undefined;
-    readonly worktreesByBranch: ReadonlyMap<string, GitWorktree> | undefined;
-    /** SHAs reachable from HEAD (for enrichment: marking commits on the current branch) */
-    readonly reachableFromHEAD?: ReadonlySet<string>;
-    /**
-     * Ref tips as of this walk: canonical refname (`refs/heads/…`, `refs/remotes/…`, `refs/tags/…`) →
-     * PEELED tip sha (annotated tags map to the commit their badge sits on). Captured so the host can seed
-     * the NEXT rebuild's {@link GraphIncrementalSeed.tips} — the map the R6b fast path diffs against to find
-     * the structural changes that force a full fallback. The CLI provider populates it on both paths (full
-     * walk + fast path); the GitHub provider leaves it undefined.
-     */
-    readonly refTips?: ReadonlyMap<string, string>;
-    /**
-     * Fingerprint of every SIDE INPUT row construction embeds into row decorations as of this walk —
-     * default branch, per-branch upstreams, HEAD's upstream, remote urls/providers, worktree assignments,
-     * and the current user. These can all change WITHOUT moving any ref tip (`git remote set-head`,
-     * `branch --set-upstream-to`, `worktree add`, remote/user config edits), and the R6b fast path reuses
-     * prior rows wholesale (only flags/reachability are re-derived) — so it must compare this against the
-     * seed's and fall back to a full walk on ANY change. The CLI provider populates it on both paths; the
-     * GitHub provider leaves it undefined.
-     */
-    readonly decorationFingerprint?: string;
-    /**
-     * Whether the repo was a SHALLOW clone (a `$GIT_DIR/shallow` file was present) as of this walk. Captured
-     * so the host can seed the NEXT rebuild's {@link GraphIncrementalSeed.shallow}: an un-shallow (or
-     * re-shallow) while the graph is closed passes every ref-tip gate — the branch tips don't move — yet
-     * changes what history exists BELOW the loaded window, so a stale-false `hasMore` would hide the newly
-     * deepened commits. The R6b fast path falls back on any change. The CLI provider populates it on both
-     * paths (full walk + fast path); the GitHub provider leaves it undefined.
-     */
-    readonly shallow?: boolean;
-    /**
-     * SHAs on the first-parent chain from HEAD up to (excluding) the first merge commit — i.e. the
-     * commits a plain interactive rebase can safely rewrite. Empty when HEAD itself is a merge. Used by
-     * the graph's history-rewriting commands (squash/drop/reword/modify) to validate selections.
-     */
-    readonly rewriteableFromHEAD?: ReadonlySet<string>;
-    /**
-     * Shared, append-only reachability table for the loaded rows (the primary representation — rows
-     * carry only a {@link GitGraphRowContexts.reachabilityIndex} into it, not per-row ref arrays).
-     * Grows monotonically across {@link more} pagination within a graph session: indices already
-     * assigned never change, so consumers can decode any row on demand and cache by index. Absent ⇒
-     * no row in the graph has reachability. See {@link GraphReachabilityTable}.
-     */
-    readonly reachability?: GraphReachabilityTable;
-    /** The rows for the set of commits requested */
-    readonly rows: GitGraphRow[];
-    readonly id?: string;
-    readonly rowsStats?: GitGraphRowsStats;
-    readonly rowsStatsDeferred?: {
-        isLoaded: () => boolean;
-        promise: Promise<void>;
-    };
-    readonly paging?: {
-        readonly limit: number | undefined;
-        readonly startingCursor: string | undefined;
-        readonly hasMore: boolean;
-    };
-    /**
-     * Loads more commits for the graph.
-     *
-     * @param limit - The number of commits to load (page size)
-     * @param id - Optional SHA to find
-     * @param cancellation - Cancellation token
-     *
-     * **Behavior based on parameters:**
-     *
-     * - **`id` provided + `limit > 0`**: Find the commit with the given SHA, then ensure at least `limit` commits are loaded.
-     *   - If SHA is found early (e.g., at position 100), continues loading to reach `limit` total commits.
-     *   - If SHA is found late (e.g., at position 2000 when limit is 1000), loads all commits up to and including the SHA.
-     *   - This ensures the target commit is included AND provides a full page of context.
-     *
-     * - **`id` provided + `limit === 0`**: Find the commit with the given SHA and stop immediately.
-     *   - Loads only as many commits as needed to reach the target SHA.
-     *   - Used when you want to find a specific commit without loading extra commits.
-     *
-     * - **No `id` + `limit > 0`**: Load exactly `limit` commits (normal pagination).
-     *   - Standard page-based loading without a specific target.
-     *
-     * - **No `id` + `limit === 0`**: Load all remaining commits.
-     *   - Loads everything from the current position to the end of history.
-     *   - Use with caution as this can load a large number of commits.
-     *
-     * @example
-     * // Load next page of 1000 commits
-     * await graph.more(1000);
-     *
-     * @example
-     * // Find a specific commit and ensure a full page is loaded
-     * await graph.more(1000, 'abc123');
-     *
-     * @example
-     * // Find a specific commit and stop (minimal loading)
-     * await graph.more(0, 'abc123');
-     */
-    more?(limit: number, id?: string, cancellation?: AbortSignal): Promise<GitGraph | undefined>;
+  readonly repoPath: string;
+  /** A map of all avatar urls */
+  readonly avatars: Map<string, string>;
+  /** A set of all "seen" commit ids */
+  readonly ids: Set<string>;
+  readonly includes: {
+    stats?: boolean;
+  } | undefined;
+  readonly branches: ReadonlyMap<string, GitBranch>;
+  readonly remotes: ReadonlyMap<string, GitRemote>;
+  readonly downstreams: ReadonlyMap<string, string[]>;
+  readonly stashes: ReadonlyMap<string, GitStashCommit> | undefined;
+  readonly worktrees: ReadonlyArray<GitWorktree> | undefined;
+  readonly worktreesByBranch: ReadonlyMap<string, GitWorktree> | undefined;
+  /** SHAs reachable from HEAD (for enrichment: marking commits on the current branch) */
+  readonly reachableFromHEAD?: ReadonlySet<string>;
+  /**
+   * Ref tips as of this walk: canonical refname (`refs/heads/…`, `refs/remotes/…`, `refs/tags/…`) →
+   * PEELED tip sha (annotated tags map to the commit their badge sits on). Captured so the host can seed
+   * the NEXT rebuild's {@link GraphIncrementalSeed.tips} — the map the R6b fast path diffs against to find
+   * the structural changes that force a full fallback. The CLI provider populates it on both paths (full
+   * walk + fast path); the GitHub provider leaves it undefined.
+   */
+  readonly refTips?: ReadonlyMap<string, string>;
+  /**
+   * Fingerprint of every SIDE INPUT row construction embeds into row decorations as of this walk —
+   * default branch, per-branch upstreams, HEAD's upstream, remote urls/providers, worktree assignments,
+   * and the current user. These can all change WITHOUT moving any ref tip (`git remote set-head`,
+   * `branch --set-upstream-to`, `worktree add`, remote/user config edits), and the R6b fast path reuses
+   * prior rows wholesale (only flags/reachability are re-derived) — so it must compare this against the
+   * seed's and fall back to a full walk on ANY change. The CLI provider populates it on both paths; the
+   * GitHub provider leaves it undefined.
+   */
+  readonly decorationFingerprint?: string;
+  /** Canonical shallow boundary OIDs for this window. Empty means complete history; undefined means
+   *  unknown (or unsupported by the provider), so a CLI refresh cannot reuse ancestry-dependent data. */
+  readonly shallowBoundary?: string;
+  /**
+   * SHAs on the first-parent chain from HEAD up to (excluding) the first merge commit — i.e. the
+   * commits a plain interactive rebase can safely rewrite. Empty when HEAD itself is a merge. Used by
+   * the graph's history-rewriting commands (squash/drop/reword/modify) to validate selections.
+   */
+  readonly rewriteableFromHEAD?: ReadonlySet<string>;
+  /**
+   * Shared, append-only reachability table for the loaded rows (the primary representation — rows
+   * carry only a {@link GitGraphRowContexts.reachabilityIndex} into it, not per-row ref arrays).
+   * Grows monotonically across {@link more} pagination within a graph session: indices already
+   * assigned never change, so consumers can decode any row on demand and cache by index. Absent ⇒
+   * no row in the graph has reachability. See {@link GraphReachabilityTable}.
+   */
+  readonly reachability?: GraphReachabilityTable;
+  /** The rows for the set of commits requested */
+  readonly rows: GitGraphRow[];
+  readonly id?: string;
+  readonly rowsStats?: GitGraphRowsStats;
+  readonly rowsStatsDeferred?: {
+    isLoaded: () => boolean;
+    promise: Promise<void>;
+  };
+  readonly paging?: {
+    readonly limit: number | undefined;
+    readonly startingCursor: string | undefined;
+    readonly hasMore: boolean;
+  };
+  /**
+   * Loads more commits for the graph.
+   *
+   * @param limit - The number of commits to load (page size)
+   * @param id - Optional SHA to find
+   * @param cancellation - Cancellation token
+   *
+   * **Behavior based on parameters:**
+   *
+   * - **`id` provided + `limit > 0`**: Find the commit with the given SHA, then ensure at least `limit` commits are loaded.
+   *   - If SHA is found early (e.g., at position 100), continues loading to reach `limit` total commits.
+   *   - If SHA is found late (e.g., at position 2000 when limit is 1000), loads all commits up to and including the SHA.
+   *   - This ensures the target commit is included AND provides a full page of context.
+   *
+   * - **`id` provided + `limit === 0`**: Find the commit with the given SHA and stop immediately.
+   *   - Loads only as many commits as needed to reach the target SHA.
+   *   - Used when you want to find a specific commit without loading extra commits.
+   *
+   * - **No `id` + `limit > 0`**: Load exactly `limit` commits (normal pagination).
+   *   - Standard page-based loading without a specific target.
+   *
+   * - **No `id` + `limit === 0`**: Load all remaining commits.
+   *   - Loads everything from the current position to the end of history.
+   *   - Use with caution as this can load a large number of commits.
+   *
+   * @example
+   * // Load next page of 1000 commits
+   * await graph.more(1000);
+   *
+   * @example
+   * // Find a specific commit and ensure a full page is loaded
+   * await graph.more(1000, 'abc123');
+   *
+   * @example
+   * // Find a specific commit and stop (minimal loading)
+   * await graph.more(0, 'abc123');
+   */
+  more?(limit: number, id?: string, cancellation?: AbortSignal): Promise<GitGraph | undefined>;
 }
 export type GitGraphRowsStats = Map<string, GitGraphRowStats>;
 /**
@@ -296,67 +291,72 @@ export type GitGraphRowsStats = Map<string, GitGraphRowStats>;
  * lists the option).
  */
 export interface GraphIncrementalSeed {
-    /**
-     * Prior generation's emitted rows, in walk order. R6b stitches the unchanged tail from these once the
-     * streamed head region CONVERGES with them (K consecutive shas aligned at a stable offset), and reads
-     * their parent lists to re-derive reachability/flags in memory (no git) over the stitched window.
-     */
-    readonly rows: readonly GitGraphRow[];
-    /**
-     * Ref tips as of the prior walk: canonical refname (e.g. `refs/heads/main`, `refs/remotes/origin/main`,
-     * `refs/tags/v1`) → tip sha. R6b enumerates the new commits via `git log --all --not <these shas>`
-     * (cheap, exact) and diffs this map against the current tips to detect the structural changes that force
-     * a full fallback: any ref DELETION (key gone) or a NON-fast-forward move (old tip not an ancestor of the
-     * new tip).
-     */
-    readonly tips: ReadonlyMap<string, string>;
-    /**
-     * Ordering the prior rows were walked in. The convergence + date-boundary reasoning R6b relies on is only
-     * sound for `date` order in v1; a seed whose ordering is `author-date`/`topo`, or that disagrees with the
-     * current walk's ordering, is discarded (full fallback).
-     */
-    readonly ordering: 'date' | 'author-date' | 'topo';
-    /**
-     * Prior generation's reachability table, to CONTINUE (same role as the sub-provider's `reachabilitySeed`)
-     * so rows retained across the rebuild keep stable {@link GitGraphRowContexts.reachabilityIndex} values and
-     * only appended entries ship. R6b decides whether the stitched window extends this builder or needs a
-     * fresh generation; see `createReachabilityTableBuilder`.
-     */
-    readonly reachability?: GraphReachabilityTable;
-    /**
-     * Prior generation's per-sha stats (immutable per sha), so the deferred stats query recomputes only the
-     * new shas — same role as `rowsStatsSeed`.
-     */
-    readonly rowsStats?: GitGraphRowsStats;
-    /**
-     * Whether the prior generation had more rows below its loaded window (`paging.hasMore`). The fast path
-     * can only reconstruct rows the seed carries; when the seed was a partial (paged) load and no new commit
-     * pushes the window past its limit, `hasMore` must still be reported so the caller keeps paging. Absent ⇒
-     * treated as `false` (the seed loaded the full history).
-     */
-    readonly hasMore?: boolean;
-    /**
-     * The `graph.onlyFollowFirstParent` setting the prior rows were walked under. When first-parent is on the
-     * emitted rows carry sliced (first-parent-only) parents, which the in-memory re-derivation can't expand
-     * back to the full parent set the walk propagates reachability through — so a seed built under (or a
-     * current config of) first-parent forces a full fallback. Absent ⇒ treated as `false`.
-     */
-    readonly onlyFollowFirstParent?: boolean;
-    /**
-     * Whether the repo was a SHALLOW clone when the prior rows were walked. R6b falls back to a full walk on
-     * ANY change vs. the current state (shallow→unshallowed, unshallowed→shallow): an un-shallow deepens
-     * history below the loaded window while every branch tip stays put, so the cached tail / stale-false
-     * `hasMore` would hide the newly deepened commits. Absent ⇒ treated as `false` (not shallow).
-     */
-    readonly shallow?: boolean;
-    /**
-     * {@link GitGraph.decorationFingerprint} of the prior walk. R6b falls back to a full walk on ANY change:
-     * reused rows keep their embedded decorations (upstream/worktree/default/remote/user metadata), so a
-     * metadata-only change — one that moves no ref tip — would otherwise ship stale pills indefinitely.
-     * Optional because providers without the incremental machinery (e.g. GitHub) never populate it; absent ⇒
-     * never matches ⇒ safe full fallback.
-     */
-    readonly decorationFingerprint?: string;
+  /**
+   * Prior generation's emitted rows, in walk order. R6b stitches the unchanged tail from these once the
+   * streamed head region CONVERGES with them (K consecutive shas aligned at a stable offset), and reads
+   * their parent lists to re-derive reachability/flags in memory (no git) over the stitched window.
+   */
+  readonly rows: readonly GitGraphRow[];
+  /**
+   * Ref tips as of the prior walk: canonical refname (e.g. `refs/heads/main`, `refs/remotes/origin/main`,
+   * `refs/tags/v1`) → tip sha. R6b enumerates the new commits via `git log --all --not <these shas>`
+   * (cheap, exact) and diffs this map against the current tips to detect the structural changes that force
+   * a full fallback: any ref DELETION (key gone) or a NON-fast-forward move (old tip not an ancestor of the
+   * new tip).
+   */
+  readonly tips: ReadonlyMap<string, string>;
+  /**
+   * Ordering the prior rows were walked in. The convergence + date-boundary reasoning R6b relies on is only
+   * sound for `date` order in v1; a seed whose ordering is `author-date`/`topo`, or that disagrees with the
+   * current walk's ordering, is discarded (full fallback).
+   */
+  readonly ordering: 'date' | 'author-date' | 'topo';
+  /**
+   * Prior generation's reachability table, to CONTINUE (same role as the sub-provider's `reachabilitySeed`)
+   * so rows retained across the rebuild keep stable {@link GitGraphRowContexts.reachabilityIndex} values and
+   * only appended entries ship. R6b decides whether the stitched window extends this builder or needs a
+   * fresh generation; see `createReachabilityTableBuilder`.
+   */
+  readonly reachability?: GraphReachabilityTable;
+  /**
+   * Prior generation's per-sha stats. With unchanged ancestry the deferred query recomputes only new
+   * shas; shallow-boundary or replacement changes invalidate the seed — same role as `rowsStatsSeed`.
+   */
+  readonly rowsStats?: GitGraphRowsStats;
+  /**
+   * Whether the prior generation had more rows below its loaded window (`paging.hasMore`). The fast path
+   * can only reconstruct rows the seed carries; when the seed was a partial (paged) load and no new commit
+   * pushes the window past its limit, `hasMore` must still be reported so the caller keeps paging. Absent ⇒
+   * treated as `false` (the seed loaded the full history).
+   */
+  readonly hasMore?: boolean;
+  /**
+   * The `graph.onlyFollowFirstParent` setting the prior rows were walked under. When first-parent is on the
+   * emitted rows carry sliced (first-parent-only) parents, which the in-memory re-derivation can't expand
+   * back to the full parent set the walk propagates reachability through — so a seed built under (or a
+   * current config of) first-parent forces a full fallback. Absent ⇒ treated as `false`.
+   */
+  readonly onlyFollowFirstParent?: boolean;
+  /** The prior window's shallow boundary. Compare contents, since partial deepening stays shallow. */
+  readonly shallowBoundary?: string;
+  /**
+   * {@link GitGraph.decorationFingerprint} of the prior walk. R6b falls back to a full walk on ANY change:
+   * reused rows keep their embedded decorations (upstream/worktree/default/remote/user metadata), so a
+   * metadata-only change — one that moves no ref tip — would otherwise ship stale pills indefinitely.
+   * Optional because providers without the incremental machinery (e.g. GitHub) never populate it; absent ⇒
+   * never matches ⇒ safe full fallback.
+   */
+  readonly decorationFingerprint?: string;
+  /**
+   * HEAD's tracking upstream (e.g. `origin/main`) as of the prior walk — carried separately from
+   * {@link decorationFingerprint} so a session REBIND can neutralize it: moving HEAD to another
+   * worktree's branch changes the fingerprint even though nothing in the repo did, so recomputing the
+   * seed-comparable fingerprint from this value (old repoPath, everything else current) cancels exactly
+   * that perspective move. Sound because it feeds only `remotes[].current` on a reused row, which the
+   * rebind re-derives in memory. Absent compares as "no upstream", so an older seed with a real upstream
+   * compares unequal ⇒ safe full fallback.
+   */
+  readonly headRefUpstreamName?: string;
 }
 /**
  * Which path a seeded {@link GitGraphSubProvider.getGraph} call took: the R6b incremental head-walk fast
@@ -365,10 +365,10 @@ export interface GraphIncrementalSeed {
  * observational — it never changes the returned graph.
  */
 export interface IncrementalGraphOutcome {
-    readonly path: 'fast' | 'fallback';
-    readonly reason?: IncrementalGraphFallbackReason;
-    /** Fast path only: how many NEW commit rows the incremental enumeration added at the head. */
-    readonly added?: number;
+  readonly path: 'fast' | 'fallback';
+  readonly reason?: IncrementalGraphFallbackReason;
+  /** Fast path only: how many NEW commit rows the incremental enumeration added at the head. */
+  readonly added?: number;
 }
 export type IncrementalGraphFallbackReason = 'no-row-processor' | 'ordering-not-date' | 'rev-outside-seed' | 'first-parent' | 'limit-exceeds-seed' | 'ref-deleted' | 'ref-non-fast-forward' | 'replace-refs-changed' | 'shallow-changed' | 'stash-changed' | 'stash-window-conflict' | 'date-boundary' | 'metadata-changed' | 'error';
 /**
@@ -387,30 +387,38 @@ export type IncrementalGraphFallbackReason = 'no-row-processor' | 'ordering-not-
  * automatically gets processing for free — no wrapping needed.
  */
 export interface GraphRowProcessor {
-    processRow(row: GitGraphRow, context: GraphContext): void;
+  processRow(row: GitGraphRow, context: GraphContext): void;
+  /**
+   * Rebuild a reused row's HOST-SERIALIZED contexts (`contexts.refGroups`, a stash row's `contexts.row`)
+   * for a session rebind. The row's ref ids are already re-stamped by the walk (`restampGraphRowIds`)
+   * before this runs — since this processor is optional, implementations must read ids as already
+   * correct and must NOT touch them again, nor message/author (not idempotent).
+   */
+  restampRow?(row: GitGraphRow, context: GraphContext): void;
 }
 export interface GraphContext {
-    readonly repoPath: string;
-    readonly useAvatars: boolean;
-    readonly branches: ReadonlyMap<string, GitBranch>;
-    readonly remotes: ReadonlyMap<string, GitRemote>;
-    readonly worktreesByBranch: ReadonlyMap<string, GitWorktree> | undefined;
-    readonly branchIdOfMainWorktree: string | undefined;
-    readonly stashes: ReadonlyMap<string, GitStashCommit> | undefined;
-    readonly reachableFromHEAD: ReadonlySet<string>;
-    /** SHAs on the first-parent chain from HEAD up to (excluding) the first merge commit — the commits
-     *  a plain interactive rebase can safely rewrite. Empty when HEAD is a merge. Sets the
-     *  {@link GitGraphRowContextFlags.RewriteableFromHead} flag, gating squash/drop/reword/modify. */
-    readonly rewriteableFromHEAD: ReadonlySet<string>;
-    /** The subset of undo-eligible tip shas (active HEAD + worktree HEADs) that have at least one
-     *  child — i.e. are NOT leaves. Scoped to tips (not all commits) for performance; do not treat as
-     *  a general has-children signal. Sets the {@link GitGraphRowContextFlags.HasChildren} flag, which
-     *  gates Undo Commit to leaf tips. */
-    readonly tipShasWithChildren: ReadonlySet<string>;
-    /** SHAs reachable from HEAD's tracking-upstream tip, or `undefined` when HEAD has no upstream.
-     * A commit reachable from HEAD but NOT from this set is unpushed (`+unpublished`); `undefined`
-     * means there's no upstream to be ahead of, so nothing is flagged. */
-    readonly reachableFromHeadUpstream: ReadonlySet<string> | undefined;
-    readonly avatars: Map<string, string>;
+  readonly repoPath: string;
+  readonly useAvatars: boolean;
+  readonly branches: ReadonlyMap<string, GitBranch>;
+  readonly remotes: ReadonlyMap<string, GitRemote>;
+  readonly worktreesByBranch: ReadonlyMap<string, GitWorktree> | undefined;
+  readonly branchIdOfMainWorktree: string | undefined;
+  readonly stashes: ReadonlyMap<string, GitStashCommit> | undefined;
+  readonly reachableFromHEAD: ReadonlySet<string>;
+  /** SHAs on the first-parent chain from HEAD up to (excluding) the first merge commit — the commits
+   *  a plain interactive rebase can safely rewrite. Empty when HEAD is a merge. Sets the
+   *  {@link GitGraphRowContextFlags.RewriteableFromHead} flag, gating squash/drop/reword/modify. */
+  readonly rewriteableFromHEAD: ReadonlySet<string>;
+  /** The subset of undo-eligible tip shas (active HEAD + worktree HEADs) that have at least one
+   *  child — i.e. are NOT leaves. Scoped to tips (not all commits) for performance; do not treat as
+   *  a general has-children signal. Sets the {@link GitGraphRowContextFlags.HasChildren} flag, which
+   *  gates Undo Commit to leaf tips. */
+  readonly tipShasWithChildren: ReadonlySet<string>;
+  /** SHAs reachable from HEAD's tracking-upstream tip, or `undefined` when HEAD has no upstream.
+   * A commit reachable from HEAD but NOT from this set is unpushed (`+unpublished`); `undefined`
+   * means there's no upstream to be ahead of, so nothing is flagged. */
+  readonly reachableFromHeadUpstream: ReadonlySet<string> | undefined;
+  readonly avatars: Map<string, string>;
 }
+//#endregion
 //# sourceMappingURL=graph.d.ts.map