@gitkraken/core-gitlens 0.5.116 → 0.7.0

package/src/git/models/graph.ts

@@ -1,444 +0,0 @@
-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';
-
-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;
-	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 } };
-	/** 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;
-}
-
-export interface GitGraphRowTag {
-	/** 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
- * `contexts.row`/`contexts.avatar` blobs (which duplicated sha/message/repoPath already on the row).
- * The webview reconstructs the full webview-item contexts from these flags + row fields + repoPath.
- * Bit 0: reachable-from-HEAD (`+current`); Bit 1: unique-to-one-local-branch (`+unique`);
- * Bit 2: has-children — set ONLY on undo-eligible tip rows (active HEAD + worktree HEADs) that have a
- * child, to gate Undo Commit to leaf tips (undoing a commit other work is stacked on is unsafe). It is
- * NOT a general has-children signal: non-tip rows never carry it (the host only computes it for tips);
- * Bit 3: unpushed/ahead-of-upstream (`+unpublished`).
- * Bit 4: history-rewriteable (`+rewriteable`) — on the first-parent chain from HEAD up to (excluding)
- * the first merge commit, so a plain (non-`--rebase-merges`) interactive rebase can safely rewrite it;
- * gates squash/drop/reword/modify. Strictly narrower than `+current` (reachable-from-HEAD includes a
- * merge's other-parent ancestry, which is NOT safely rewriteable).
- * Bit 5: unpulled/behind-the-upstream — the exact mirror of bit 3: on HEAD's upstream tip but NOT on HEAD
- * (i.e. `HEAD..@{u}`). Drives the graph's read-only unpulled indicator; it has no `webviewItem` segment
- * (no command gates on it). Mutually exclusive with `Unpublished` by construction.
- * (`+HEAD` derives from `row.heads[].isCurrentHead`; contributor `+current` from `row.isCurrentUser`.)
- */
-export const enum GitGraphRowContextFlags {
-	None = 0,
-	ReachableFromHead = 1 << 0,
-	UniqueToBranch = 1 << 1,
-	HasChildren = 1 << 2,
-	Unpublished = 1 << 3,
-	RewriteableFromHead = 1 << 4,
-	Unpulled = 1 << 5,
-}
-
-/** 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>;
-}
-
-export interface GitGraphRowStats {
-	files: number;
-	additions: number;
-	deletions: number;
-}
-
-/**
- * Wire encoding for per-row reachability, shipped once per graph payload instead of inline on every
- * row. Git reachability is monotone (adjacent commits share ref-sets), so the rows collapse to a
- * relatively small number of distinct sets over the repo's ref universe — `dictionary` (the shared
- * ref list) + `sets` (distinct membership bitmaps, base64; bit i ⇒ `dictionary[i]` reachable) + a
- * per-row index (`GitGraphRowContexts.reachabilityIndex`) reconstructs every row's `reachability`
- * client-side for a fraction of the bytes the inline objects cost. `current` is a per-ref property
- * (the checked-out HEAD branch) and lives in the dictionary entry.
- *
- * The table is append-only within a graph generation, so the host ships only the entries appended
- * since its last push (a delta) on same-generation pagination and the full table on a new generation;
- * `id` lets the webview tell the two apart (same `id` ⇒ append the delta, new `id` ⇒ replace + reset
- * 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[];
-}
-
-/** 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;
-}
-
-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>;
-}
-
-export type GitGraphRowsStats = Map<string, GitGraphRowStats>;
-
-/**
- * Seed for the R6b incremental head-walk fast path. Carries the prior generation's walk artifacts so a
- * repo-change rebuild can walk ONLY the changed head region, stitch the cached tail, and re-derive
- * flags/reachability in memory — instead of re-walking every loaded row.
- *
- * The CLI provider consumes this on its incremental fast path, degrading to the full ordered walk
- * whenever any gate below rejects the seed. The GitHub provider ignores it structurally (it never
- * 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;
-}
-
-/**
- * Which path a seeded {@link GitGraphSubProvider.getGraph} call took: the R6b incremental head-walk fast
- * path, or a full ordered walk (with the gate/boundary `reason` that forced it). Reported via the
- * `onIncrementalResult` option so the host can log it and the equivalence harness can assert it. Purely
- * 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;
-}
-
-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'
-	// A decoration side input changed without moving any ref tip (default branch, an upstream, a worktree
-	// assignment, a remote's url/provider, the current user) — reused rows would keep stale embedded
-	// decorations, so the walk must rebuild them. See `GitGraph.decorationFingerprint`.
-	| 'metadata-changed'
-	// The fast path threw (spawn/arg limits on huge ref sets, queue overflow, transient git errors) —
-	// never an eligibility gate. The fast path must never fail where the full walk it accelerates
-	// would succeed, so any unexpected error degrades to the full walk (cancellation still propagates).
-	| 'error';
-
-/**
- * Processes a single graph row — mutates the row in place.
- *
- * Sets `row.contexts` and `row.message` (e.g., emojified), and resolves `remoteHead.avatarUrl`.
- * Also populates `context.avatars` with email → URL mappings.
- *
- * Per-ref contexts are NOT serialized here. The webview builds them from the structured ref fields
- * (`webviews/apps/plus/graph/utils/refContext.utils.ts`), where live state the host would have baked in
- * stale — whether a branch is starred, which ref is pinned — is actually visible. What remains here needs
- * something the webview cannot reach: the extension's asset URIs, or the whole-row grouping.
- *
- * Called inline during graph row iteration in the library's row-building
- * loop, once per row. Because it runs inside the loop, `more()` pagination
- * automatically gets processing for free — no wrapping needed.
- */
-export interface GraphRowProcessor {
-	processRow(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>;
-}

package/src/git/models/graphSearch.ts

@@ -1,53 +0,0 @@
-import type { SearchQuery, SearchQueryFilters } from './search.js';
-
-export interface GitGraphSearchResultData {
-	readonly date: number;
-	readonly i: number;
-	readonly files?: ReadonlyArray<Readonly<{ readonly path: string }>>;
-}
-export type GitGraphSearchResults = Map<string, GitGraphSearchResultData>;
-
-export interface GitGraphSearchProgress {
-	readonly repoPath: string;
-	readonly query: SearchQuery;
-	readonly queryFilters: SearchQueryFilters;
-	readonly comparisonKey: string;
-	/** Whether there are more results available beyond the current limit */
-	readonly hasMore: boolean;
-	/** New results since the last progress update */
-	readonly results: GitGraphSearchResults;
-	/** Total count of all results accumulated so far */
-	readonly runningTotal: number;
-}
-
-export interface CliGitGraphSearchCursorState {
-	readonly iterations: number;
-	readonly totalSeen: number;
-	readonly sha: string;
-	readonly skip: number;
-}
-
-export type GitGraphSearchCursorState = CliGitGraphSearchCursorState | string;
-
-export interface GitGraphSearchCursor {
-	readonly search: SearchQuery;
-	readonly state: GitGraphSearchCursorState;
-}
-
-export interface GitGraphSearch {
-	readonly repoPath: string;
-	readonly query: SearchQuery;
-	readonly queryFilters: SearchQueryFilters;
-	readonly comparisonKey: string;
-	/** Whether there are more results available beyond the current limit */
-	readonly hasMore: boolean;
-	/** Complete set of results up to the current limit */
-	readonly results: GitGraphSearchResults;
-
-	readonly paging?: {
-		readonly limit: number | undefined;
-		readonly cursor?: GitGraphSearchCursor;
-	};
-
-	more?(limit: number): Promise<GitGraphSearch>;
-}

package/src/git/models/graphSession.ts

@@ -1,102 +0,0 @@
-import type { GitGraph, GitGraphRow, IncrementalGraphFallbackReason } from './graph.js';
-
-/**
- * A provider-owned, stateful graph window for a single repo. It is the canonical accumulated window and
- * the single builder of the incremental rebuild seed — the host no longer mirrors loaded rows, stamps
- * ref tips, or hand-assembles the {@link GraphIncrementalSeed}; the session owns its own walk shape and
- * cannot be handed a lying seed.
- *
- * R7a is a behavior-neutral ownership move: {@link refresh} is a facade over the provider's existing
- * `getGraph` incremental machinery (it internally builds the seed from the accumulated window, tips, and
- * prior artifacts, with the same shape gating), {@link more} delegates to the prior result's `more()`,
- * and {@link current} mirrors today's `GitGraph` result shape so the publisher/wire semantics stay
- * byte-identical. R7b (refresh-result-driven channel marking) extends this without breaking —
- * {@link refresh} returns a result object, never a bare `GitGraph`.
- */
-export interface GitGraphSession {
-	readonly repoPath: string;
-
-	/** Canonical accumulated window (the FULL loaded rows, never page-scoped after pagination). */
-	readonly window: readonly GitGraphRow[];
-
-	/**
-	 * Last-operation view mirroring today's `GitGraph` result shape: page-scoped `rows` after a
-	 * {@link more}, the full window after a {@link refresh}. Keeps the publisher's `getRows`/`getPaging`
-	 * and every graph-level read (`branches`, `remotes`, `stashes`, `ids`, `avatars`, `rowsStats`, …)
-	 * exactly as they read `_graph` today.
-	 */
-	readonly current: GitGraph;
-
-	/**
-	 * Re-walk the repo, accumulating the fresh full window. Internally seeds the incremental head-walk
-	 * fast path from the prior window/tips/artifacts (same shape gating as the host did) and falls back
-	 * to a full walk on any structural change; the result surfaces which path ran so a later stage can
-	 * mark channels precisely.
-	 */
-	refresh(options?: GitGraphSessionRefreshOptions, cancellation?: AbortSignal): Promise<GitGraphSessionRefreshResult>;
-
-	/**
-	 * Page more rows into the window (accumulates; `current` becomes the page view). Returns `false` when
-	 * there was nothing to add or a concurrent {@link refresh} superseded the page.
-	 */
-	more(limit?: number, targetId?: string, cancellation?: AbortSignal): Promise<boolean>;
-
-	dispose(): void;
-}
-
-export interface GitGraphSessionRefreshOptions {
-	/** Rebuild anchor / find target — the loaded window's bottom sha (pins the walk's bottom boundary),
-	 *  or a selection/centering hint. Mirrors the `rev` the host passed to `getGraph` today. */
-	rev?: string;
-	limit?: number;
-	include?: { stats?: boolean };
-	/**
-	 * Force a FULL walk (skip the incremental seed) so every row's decorations — including the
-	 * host-serialized webview-item contexts reused rows otherwise keep — are rebuilt from fresh inputs.
-	 * For host-known invalidations the provider can't observe (pinned-ref changes, integration
-	 * connections); rare events, so the full-walk cost is acceptable.
-	 */
-	rebuild?: boolean;
-}
-
-/**
- * Outcome of a {@link GitGraphSession.refresh}. `path` is `'fast'` only when the incremental head-walk
- * fast path ran; a seeded fallback and an unseeded full walk both report `'full'` — a seeded fallback
- * additionally carries `reason` (an unseeded full walk carries none), so a consumer can distinguish the
- * two exactly as the host's `[graph] incremental walk` log did (log on `'fast'` or a `reason`, silent
- * otherwise).
- */
-export interface GitGraphSessionRefreshResult {
-	readonly path: 'fast' | 'full';
-	/** Present only on a SEEDED refresh that fell back to the full walk — the gate/boundary that forced it. */
-	readonly reason?: IncrementalGraphFallbackReason;
-	/** Fast path only: how many NEW commit rows the incremental enumeration added at the head. */
-	readonly added?: number;
-	/**
-	 * Which rows-plane channels this refresh actually changed, so the host marks the publisher precisely
-	 * instead of dirtying all six on every refresh. Filled by BOTH paths: the full path reports every
-	 * channel changed (a fresh walk replaces all); the fast path derives each honestly from its own work.
-	 * Correctness rule: a false negative is data loss, so a channel is reported `false` only when it
-	 * PROVABLY didn't change — never merely when uncertain. Excludes `refsMetadata`, which the session
-	 * doesn't produce (the host marks it via its own dedicated enrichment path).
-	 */
-	readonly changed: GitGraphSessionChangedChannels;
-}
-
-/** Per-channel change flags a {@link GitGraphSession.refresh} reports (see {@link GitGraphSessionRefreshResult.changed}). */
-export interface GitGraphSessionChangedChannels {
-	/** The loaded rows window — always `true` on a refresh (a head-walk reshapes it; the publisher's ledger
-	 *  diff derives the precise splice, including reused-row flag/reachability-index changes). */
-	readonly rows: boolean;
-	/** The shared reachability table grew (new dictionary/set entries appended) or started a new generation. */
-	readonly reachability: boolean;
-	/** New commit shas were introduced whose stats will be (re)queried. */
-	readonly rowsStats: boolean;
-	/** Full fallbacks that rewrite parents (unshallow / replace-ref change) recompute stats whose
-	 *  values may differ for already-shipped shas — the host must resend, not just append. */
-	readonly rowsStatsRecomputed?: boolean;
-	/** New avatar emails appeared in the map (value replacements ride the host's dedicated avatar path). */
-	readonly avatars: boolean;
-	/** The downstreams map (upstream name → tracking branch names) changed. */
-	readonly downstreams: boolean;
-}