@gitkraken/gitkraken-components 13.0.0-vnext.19 → 13.0.0-vnext.26

package/dist/components/graph/GraphColumn.d.ts

@@ -20,7 +20,7 @@ type GraphColumnProps = {
     graphZones: GraphZone[];
     hasMoreCommits: boolean;
     horizontalScrollHeight: number;
-    isCommitListFiltered: boolean;
+    isFilteredSearch: boolean;
     isLoadingRows: boolean;
     markerColors: GraphMarkerColors;
     markerRowIndices: GraphMarkerRowIndices;
@@ -42,5 +42,5 @@ type GraphColumnProps = {
     translate: TranslationFn;
     verticalScrollWidth: number;
 };
-export declare function GraphColumn({ branchUpstreamRowIndices, rowCount, cellRenderersByIds, columnIndex, customFooterRow, enabledScrollMarkerTypes, enableResizer, getExternalIcon, getKeyForCell, graphHeight, graphWidth, graphZoneType, graphZones, hasMoreCommits, horizontalScrollHeight, isCommitListFiltered, isLoadingRows, markerColors, markerRowIndices, onResize, onResizeEnd, onResizeFromPropChange, onScroll, onScrollToRowCausedUpdate, onZoneEnter, processedRows, scrollLeft, scrollToAlignment, scrollToIndex, scrollTop, smartCellRangeRenderer, stickyTimeline, translate, verticalScrollWidth, }: GraphColumnProps): ReactElement<any> | null;
+export declare function GraphColumn({ branchUpstreamRowIndices, rowCount, cellRenderersByIds, columnIndex, customFooterRow, enabledScrollMarkerTypes, enableResizer, getExternalIcon, getKeyForCell, graphHeight, graphWidth, graphZoneType, graphZones, hasMoreCommits, horizontalScrollHeight, isFilteredSearch, isLoadingRows, markerColors, markerRowIndices, onResize, onResizeEnd, onResizeFromPropChange, onScroll, onScrollToRowCausedUpdate, onZoneEnter, processedRows, scrollLeft, scrollToAlignment, scrollToIndex, scrollTop, smartCellRangeRenderer, stickyTimeline, translate, verticalScrollWidth, }: GraphColumnProps): ReactElement<any> | null;
 export {};

package/dist/components/graph/GraphContainer.d.ts

@@ -6,14 +6,24 @@ import type { CssVariables } from '../../domain/generic/GenericTypes';
 import type { GraphCommitDescDisplayMode, GraphMarkerType, GraphSearchMode, GraphZone, GraphZoneType, ShiftSelectMode } from '../../domain/graph/GraphConstants';
 import type { ThrottledFn } from '../../domain/graph/GraphHelpers';
 import type { AbsoluteNodeLeftByColumn, AvatarUrlByEmail, AvatarUrlRequestedByEmail, ChildrenBySha, ColumnColorByColumn, DownstreamsByUpstream, EdgeByColumn, ExcludeByType, ExcludeRefsById, ExcludeRemotesByName, FormatCommitMessage, FormatRefShorthand, GetExternalIcon, GetMissingAvatar, GetMissingRefMetadata, GraphColumnSetting, GraphColumnsSettings, GraphContexts, GraphMarkerColors, GraphMarkerRowIndices, GraphPlatform, GraphRefGroup, GraphRow, GraphZoneModeConstants, GraphZonesByType, Head, HighlightedShas, IncludeOnlyRefsById, IncludeOnlyRemotesByName, IsRefShorthandValid, IsSelectedBySha, NodeOffsetByColumn, NodeOpacityByColumn, OnClearCurrentlyHoveredGraphCommit, OnClickCommit, OnClickGraphRef, OnClickGraphRow, OnClickRef, OnCommitContextMenu, OnCommitMessageChange, OnCurrentlyHoveredGraphCommit, OnDoubleClickCommit, OnDoubleClickGraphRef, OnDoubleClickGraphRow, OnDoubleClickRef, OnEmailsMissingAvatarUrls, OnFilterColumnClick, OnFormatCommitDateTime, OnGraphColumnReOrdered, OnGraphColumnResized, OnGraphColumnsReOrdered, OnGraphMouseEnter, OnGraphMouseLeave, OnGraphRefNodeHovered, OnGraphRefNodeUnhovered, OnGraphResized, OnGraphRowHovered, OnGraphRowUnhovered, OnGraphScrollForZone, OnGraphVisibleRowsChanged, OnGraphZoneResize, OnGraphZoneResizeEnd, OnLoadSelectedGraphRow, OnPopupGraphHeaderContextMenu, OnRefBeginDrag, OnRefCanDrag, OnRefCanDrop, OnRefContextMenu, OnRefCreate, OnRefCreateCancel, OnRefCreateContextMenu, OnRefDragEnter, OnRefDragLeave, OnRefDrop, OnRefEndDrag, OnRefNodeHovered, OnRefNodeUnhovered, OnRefShorthandChange, OnRefsMissingMetadata, OnRefZoneContextMenu, OnRefZoneHovered, OnRefZoneUnhovered, OnRowContextMenu, OnScrollForZone, OnSelectGraphRows, OnSettingsClick, OnShowMoreCommits, OnToggleRefNodesShown, OnToggleRefsVisibilityClick, OnWipMessageBlur, OnWipMessageFocus, ProcessedGraphRow, ProcessedGraphRowBySha, ReadonlyGraphRow, RefMetadataById, RefMetadataRequestedById, RefMetadataType, RefsMissingMetadata, Remote, ReserverInfoBySha, RowEdges, RowStats, RowStatsConstraints, ShaByRefId, Tag, TopAndBottomVisibleRowIndex } from '../../domain/graph/GraphTypes';
+import type { RowAdornmentProvider } from '../../domain/graph/rowAdornment/RowAdornmentTypes';
 import type { TranslationFn } from '../../domain/language/LanguageTypes';
 import type { CreateRefFormData, RefIconsPosition } from '../../domain/ref/RefTypes';
-import type { OnBlur, OnKeyDown, OnKeyUp, OnMouseDown, OnResizeParams } from '../../domain/ui/UiTypes';
+import type { OnKeyDown, OnKeyUp, OnMouseDown, OnResizeParams } from '../../domain/ui/UiTypes';
 import type { WorkDirStats } from '../../domain/workdir/WorkDirTypes';
 import type { IGraphContainer } from './IGraphContainer';
 type ClearScrollToIndex = () => void;
 type OnZoneEnter = (e: React.MouseEvent<any>, zoneType: GraphZoneType, hoveredRefGroup?: GraphRefGroup, hoveredSha?: Sha) => void;
 type OnGraphContainerBlurred = (event: React.FocusEvent<any>, hoveredRefGroup?: GraphRefGroup, hoveredSha?: Sha) => void;
+/**
+ * Options for the public selectCommits method.
+ */
+export interface SelectCommitsOptions {
+    /** If true, toggle selection; if false, replace selection. Default: false */
+    toggle?: boolean;
+    /** If true, scroll to ensure the focused commit is visible. Default: false */
+    ensureVisible?: boolean;
+}
 interface OwnProps {
     formatCommitDateTime?: OnFormatCommitDateTime;
     formatCommitMessage?: FormatCommitMessage;
@@ -69,6 +79,11 @@ export interface StateProps {
     rowsStatsLoading?: boolean;
     wipMessageEditable?: boolean;
     workDirStats?: WorkDirStats;
+    /**
+     * Provider for row adornments.
+     * Graph subscribes to invalidate events and calls provide/resolve as needed.
+     */
+    rowAdornmentProvider?: RowAdornmentProvider;
 }
 export interface DispatchProps {
     onDoubleClickGraphRef?: OnDoubleClickGraphRef;
@@ -219,6 +234,7 @@ declare class GraphContainer extends React.Component<Props, ComponentState> impl
     missingRefsMetadataTimer?: ReturnType<typeof setTimeout>;
     pendingMissingRefsMetadata: RefsMissingMetadata;
     requestedMissingRefsMetadata: RefMetadataRequestedById;
+    previousRefMetadataById: RefMetadataById | null;
     branchUpstreamRowIndices: number[];
     downstreamsByUpstream: DownstreamsByUpstream;
     timelinesInterval?: ReturnType<typeof setInterval>;
@@ -251,8 +267,49 @@ declare class GraphContainer extends React.Component<Props, ComponentState> impl
     onRefDragLeave: OnRefDragLeave;
     onRefDrop: OnRefDrop;
     onRefEndDrag: OnRefEndDrag;
+    private performRangeSelection;
     onZoneRowClick(event: React.MouseEvent<any>, graphZoneType: GraphZoneType, sha: Sha): void;
+    private handleToggleSelection;
     getShiftSelectRange(currentSha: Sha, shiftSelectMode: ShiftSelectMode): Sha[] | undefined;
+    /**
+     * Check if a commit can extend the current topological selection via Ctrl+Click.
+     *
+     * In topological mode, we maintain a contiguous path through the git graph.
+     * This method determines if adding a commit would maintain that contiguity.
+     *
+     * Graph orientation:
+     * - Lower row index = NEWER commits (children, at top of graph)
+     * - Higher row index = OLDER commits (parents, at bottom of graph)
+     * - `getDirectTopologicalPathBetween(A, B)` finds path from A to B following parent pointers,
+     *   meaning B must be an ancestor (older) of A
+     *
+     * Three cases based on clicked commit's position relative to selection bounds:
+     *
+     * 1. NEWER than newest selected (clickedIndex < newestIndex):
+     *    - Clicked commit would extend the TOP of the selection
+     *    - Check: clicked → newest (is newest an ancestor of clicked?)
+     *    - Example: Selection is rows 5-10, clicking row 3
+     *      Must verify row 3 can reach row 5 by following parents
+     *
+     * 2. OLDER than oldest selected (clickedIndex > oldestIndex):
+     *    - Clicked commit would extend the BOTTOM of the selection
+     *    - Check: oldest → clicked (is clicked an ancestor of oldest?)
+     *    - Example: Selection is rows 5-10, clicking row 12
+     *      Must verify row 10 can reach row 12 by following parents
+     *
+     * 3. BETWEEN newest and oldest (newestIndex < clickedIndex < oldestIndex):
+     *    - Clicked commit must be ON the existing path, not a parallel branch
+     *    - Check BOTH directions:
+     *      - newest → clicked (is clicked an ancestor of newest?)
+     *      - clicked → oldest (is oldest an ancestor of clicked?)
+     *    - Example: Selection is rows 5-10, clicking row 7
+     *      Must verify row 5 → row 7 → row 10 forms a valid path
+     *    - This prevents selecting commits on parallel branches that happen
+     *      to merge into the same ancestor
+     *
+     * @returns true if the commit can be added while maintaining topological contiguity
+     */
+    private canExtendTopologicalSelection;
     private getTopologicalPathBetween;
     private getDirectTopologicalPathBetween;
     /**
@@ -267,12 +324,19 @@ declare class GraphContainer extends React.Component<Props, ComponentState> impl
      * (excluding the explicit start and end points).
      */
     private hasOnlyTwoEndpoints;
+    /**
+     * Checks if a set of rows form a topologically contiguous set
+     * Rows are contiguous if all rows are connected via parent-child relationships (i.e., they form a single connected subgraph)
+     */
+    areRowsContiguous(rows: ReadonlyGraphRow[]): boolean;
     onClickRef: OnClickRef;
     onClickCommit: OnClickCommit;
     onDoubleClickCommit: OnDoubleClickCommit;
-    onWindowKeyUp: OnKeyUp;
-    onWindowBlur: OnBlur;
-    onWindowKeyDown: OnKeyDown;
+    onWindowBlur: (e: FocusEvent) => void;
+    onWindowKeyUp: () => void;
+    onWindowKeyDown: (e: KeyboardEvent) => void;
+    onWindowMouseDown: () => void;
+    private isKeyboardNavigating;
     onKeyUp: OnKeyUp;
     onKeyDown: OnKeyDown;
     isNavigationKey(key: string): boolean;
@@ -301,9 +365,18 @@ declare class GraphContainer extends React.Component<Props, ComponentState> impl
      * Deep equality check for isSelectedBySha objects to avoid unnecessary scroll-to-selection
      * when object reference changes but content is the same (e.g., after postMessage serialization)
      */
-    private isSelectedByShaEqual;
+    private areSelectedByShaEqual;
     private _pendingRowsUpdate;
     private _selectionVersion;
+    private _cachedSmartCellRangeRenderer;
+    private _cachedScrollLeftForRenderer;
+    private _cachedForceCache;
+    /**
+     * Gets or creates a cached smartCellRangeRenderer.
+     * Only recreates when scrollLeft or forceCache changes.
+     * This prevents react-virtualized from invalidating its cache on every render.
+     */
+    private getOrCreateSmartCellRangeRenderer;
     /**
      * Gets commits rows by SHA
      *
@@ -313,24 +386,31 @@ declare class GraphContainer extends React.Component<Props, ComponentState> impl
     getCommits(shas: Sha[]): ReadonlyGraphRow[];
     /**
      * Selects commits in the graph
-     *
      * @param shas - Array of commit SHAs to select
-     * @param includeToPrevSel - If true, toggle selection; if false, replace selection
-     * @param isAutoOrKeyScroll - Whether this is an auto-scroll or keyboard navigation
+     * @param options - Selection options (toggle, ensureVisible)
      * @returns Array of selected ReadonlyGraphRow objects
      */
-    selectCommits(shas: Sha[], includeToPrevSel: boolean, isAutoOrKeyScroll: boolean): ReadonlyGraphRow[];
+    selectCommits(shas: Sha[], options?: SelectCommitsOptions): ReadonlyGraphRow[];
+    /**
+     * Internal method to select commits with full control over selection behavior
+     * @param shas - Array of commit SHAs to select
+     * @param options - Selection options including toggle, ensureVisible, isKeyboardNav, isTopological, isContiguous
+     * @returns Array of selected ReadonlyGraphRow objects
+     */
+    private selectCommitsCore;
+    private predictScrollTop;
     getCommitZoneContentWidthBetweenGutters(): number;
     getExcludeRemotesByName(): ExcludeRemotesByName;
     getIncludeOnlyRemotesByName(): IncludeOnlyRemotesByName;
     clearScrollToIndex: ClearScrollToIndex;
+    getVisibleRows: () => ProcessedGraphRow[];
     getTopAndBottomVisibleRowIndex(): TopAndBottomVisibleRowIndex;
-    getOffsetSha(sha: Sha, scrollDirection: 'up' | 'down' | 'none', lastScrollDirection: 'up' | 'down' | 'none' | undefined, isAutoOrKeyScroll: boolean): Sha;
+    getOffsetSha(sha: Sha, scrollDirection: 'up' | 'down' | 'none', lastScrollDirection: 'up' | 'down' | 'none' | undefined, isKeyboardNav: boolean): Sha;
     private _pendingScrollUpdate;
     private _lastSelectedRowIndex;
     private _lastScrollDirection;
     private _scrollToAlignmentOverride;
-    selectSha(sha: Sha, isAutoOrKeyScroll?: boolean): void;
+    selectSha(sha: Sha, isKeyboardNav?: boolean): void;
     updateWidthByZone(widthToAssignForZone: number, graphZoneType: GraphZoneType, updatePreferredWidth?: boolean): void;
     updateCommitZoneContentWidthFromChange(): void;
     getCurrentWidthByZone(graphZoneType: GraphZoneType, withoutVerticalScrollWidth?: boolean): number;
@@ -383,13 +463,60 @@ declare class GraphContainer extends React.Component<Props, ComponentState> impl
     getIconCallback: GetExternalIcon;
     onMissingAvatar: GetMissingAvatar;
     onMissingRefMetadata: GetMissingRefMetadata;
-    selectNext(topological?: boolean): void;
-    selectPrevious(topological?: boolean): void;
+    selectNext(shiftKey?: boolean, topological?: boolean, shiftSelectMode?: ShiftSelectMode): void;
+    selectPrevious(shiftKey?: boolean, topological?: boolean, shiftSelectMode?: ShiftSelectMode): void;
+    /**
+     * Navigate selection in the specified direction.
+     * @param direction - 'up' (towards newer/children) or 'down' (towards older/parents)
+     */
+    private selectInDirection;
+    /**
+     * Determine the next SHA to select based on direction and mode.
+     */
+    private getNextShaInDirection;
+    private getNextTopologicalSha;
+    private getPreviousTopologicalSha;
+    /**
+     * Find the next commit in the given direction that is topologically reachable from the anchor.
+     * Uses a hybrid approach: fast path for common cases, BFS fallback for complex graphs.
+     * @param preferSameColumn - If true, tries same-column navigation first (faster, used for ctrl+shift+arrow)
+     */
+    private findNextReachableFromAnchor;
+    /**
+     * Fast reachability check - determines if targetSha is reachable from startSha.
+     * Uses BFS with visit limit for performance.
+     */
+    private isReachableFrom;
+    /**
+     * Get the same-column child of a commit.
+     * Prefers children on the same column, then falls back to children where this commit is the first parent.
+     */
+    private getSameColumnChild;
+    /**
+     * Jump to the previous branching point (towards newer commits), or tip if none.
+     * A branching point is a commit with visible children on a different column.
+     */
+    private selectPreviousBranchingPoint;
+    /**
+     * Check if a commit is a branching point (has visible children on a different column).
+     */
+    private isBranchingPoint;
+    /**
+     * Get the same-column parent of a commit.
+     */
+    private getSameColumnParent;
+    /**
+     * Jump to the next branching point (towards older commits), or root if none.
+     * A branching point is a commit with visible children on a different column.
+     */
+    private selectNextBranchingPoint;
+    selectNextRef(): void;
+    selectPreviousRef(): void;
     selectHead(upstream?: boolean): void;
-    selectFirst(shiftKey?: boolean): void;
-    selectLast(shiftKey?: boolean): void;
-    selectPageUp(shiftKey?: boolean): void;
-    selectPageDown(shiftKey?: boolean): void;
+    selectFirst(shiftKey?: boolean, shiftSelectMode?: ShiftSelectMode): void;
+    selectLast(shiftKey?: boolean, shiftSelectMode?: ShiftSelectMode): void;
+    selectPageUp(shiftKey?: boolean, shiftSelectMode?: ShiftSelectMode): void;
+    selectPageDown(shiftKey?: boolean, shiftSelectMode?: ShiftSelectMode): void;
     getAvailableColumnAndUseIt(): number;
     getColumns(graphRow: GraphRow): number;
     getFilteredHeadsForGraphRow(row: GraphRow, hasIncludes: boolean): Head[];
@@ -428,7 +555,7 @@ declare class GraphContainer extends React.Component<Props, ComponentState> impl
     onGraphVisibleRowsUpdated(): void;
     getCurrentPlatform(): string;
     isMacOSPlatform(): boolean;
-    isCommitListFiltered(): boolean;
+    isFilteredSearch(): boolean;
     getGraphColumnSettingFromZoneType(graphZone: GraphZone): GraphColumnSetting;
     decorateWithHelmet: (container: ReactElement<"div">, cssVariables: CssVariables, nonce?: string) => React.JSX.Element;
     render(): React.JSX.Element;

package/dist/components/graph/refzone/RefNode.d.ts

@@ -33,6 +33,7 @@ export type RefNodeProps = {
     refGroupContext: GraphItemContext | null;
     refIconsPosition: RefIconsPosition;
     refMetadata: RefMetadataById | null;
+    fallbackRefMetadata?: RefMetadataById | null;
     sha: Sha;
     showRemoteNamesOnRefs: boolean;
     enabledRefMetadataTypes: RefMetadataType[];

package/dist/components/graph/refzone/RefNodes.d.ts

@@ -26,6 +26,7 @@ type RefNodesProps = {
     refGroupsByName: RefGroup[];
     refIconsPosition: RefIconsPosition;
     refMetadata: RefMetadataById | null;
+    fallbackRefMetadata?: RefMetadataById | null;
     refNodeHovered: OnRefNodeHovered;
     onToggleRefNodesShown: OnToggleRefNodesShown;
     onRefBeginDrag: OnRefBeginDrag;
@@ -42,5 +43,5 @@ type RefNodesProps = {
     type: CommitType;
     useColumnHeaderIcons: boolean;
 };
-declare function RefNodes({ enabledRefMetadataTypes, column, columnForColoring, context, enableShowHideRefsOptions, targetRef, hasActive, hasRefs, getExternalIcon, includeOnlyRefsById, includeOnlyRemotesByName, isGhostRef, isHovered, isInUnsupportedRebase, numGraphColumns, onMissingRefMetadata, refGroupContexts, refGroupsByName, refIconsPosition, refMetadata, refNodeHovered, sha, showRemoteNamesOnRefs, showContextMenuForGroupedRef, onClickRef, onDoubleClickRef, onToggleRefNodesShown, onRefBeginDrag, onRefCanDrag, onRefCanDrop, onRefDragEnter, onRefDragLeave, onRefDrop, onRefEndDrag, translate, type, useColumnHeaderIcons, }: RefNodesProps): ReactElement<'span' | 'div'>;
+declare function RefNodes({ enabledRefMetadataTypes, column, columnForColoring, context, enableShowHideRefsOptions, targetRef, hasActive, hasRefs, getExternalIcon, includeOnlyRefsById, includeOnlyRemotesByName, isGhostRef, isHovered, isInUnsupportedRebase, numGraphColumns, onMissingRefMetadata, refGroupContexts, refGroupsByName, refIconsPosition, refMetadata, fallbackRefMetadata, refNodeHovered, sha, showRemoteNamesOnRefs, showContextMenuForGroupedRef, onClickRef, onDoubleClickRef, onToggleRefNodesShown, onRefBeginDrag, onRefCanDrag, onRefCanDrop, onRefDragEnter, onRefDragLeave, onRefDrop, onRefEndDrag, translate, type, useColumnHeaderIcons, }: RefNodesProps): ReactElement<'span' | 'div'>;
 export default RefNodes;

package/dist/components/graph/refzone/RefZone.d.ts

@@ -40,6 +40,7 @@ type RefZoneProps = {
     refGroupsByName: GraphRefGroup[];
     refIconsPosition: RefIconsPosition;
     refMetadata: RefMetadataById | null;
+    fallbackRefMetadata?: RefMetadataById | null;
     refNodeHovered: OnRefNodeHovered;
     refNodeUnhovered: OnRefNodeUnhovered;
     refZoneHovered: OnRefZoneHovered;

package/dist/components/graph/rowAdornment/RowAdornmentLayer.d.ts

@@ -0,0 +1,52 @@
+import * as React from 'react';
+import type { Sha } from '../../../domain/commit/CommitTypes';
+import type { ProcessedGraphRow } from '../../../domain/graph/GraphTypes';
+import type { RowAdornmentProvider } from '../../../domain/graph/rowAdornment/RowAdornmentTypes';
+interface RowAdornmentLayerProps {
+    /** The row adornment provider */
+    provider: RowAdornmentProvider;
+    /** Lazily get currently visible rows - only called when needed */
+    getVisibleRows: () => ProcessedGraphRow[];
+    /** All processed rows for index lookups */
+    allRows: ProcessedGraphRow[];
+    /** Set of selected SHAs */
+    selectedShas: Set<Sha>;
+    /** Currently hovered commit SHA */
+    hoveredSha?: Sha;
+    /** Currently focused commit SHA */
+    focusedSha?: Sha;
+    /** Whether vertical scrollbar is visible (to offset adornments) */
+    hasVerticalScrollbar?: boolean;
+}
+interface RowAdornmentLayerState {
+    /** Trigger re-render when cache changes */
+    cacheVersion: number;
+}
+/**
+ * Manages row adornment state and rendering.
+ * Encapsulates all adornment caching, provide/resolve flows, and overlay rendering.
+ */
+declare class RowAdornmentLayer extends React.Component<RowAdornmentLayerProps, RowAdornmentLayerState> {
+    /** Cached adornment info per SHA */
+    private adornments;
+    /** Tracks pending async resolve calls to cancel stale ones */
+    private pendingResolves;
+    /** Abort controller for canceling in-flight provide calls */
+    private provideAbortController?;
+    /** Counter for generating unique resolve IDs */
+    private resolveIdCounter;
+    state: RowAdornmentLayerState;
+    componentDidMount(): void;
+    componentDidUpdate(prevProps: RowAdornmentLayerProps): void;
+    componentWillUnmount(): void;
+    private setupProvider;
+    private teardownProvider;
+    private onInvalidate;
+    private provideForVisibleRows;
+    private applyProvideResults;
+    private evictDistantAdornments;
+    private shouldShowAdornment;
+    private getOrResolveContent;
+    render(): React.ReactNode;
+}
+export default RowAdornmentLayer;

package/dist/components/graph/rowAdornment/RowAdornmentOverlay.d.ts

@@ -0,0 +1,19 @@
+import type { ReactNode } from 'react';
+import * as React from 'react';
+import type { Sha } from '../../../domain/commit/CommitTypes';
+interface RowAdornmentOverlayProps {
+    /** The SHA of the row this adornment is for */
+    sha: Sha;
+    /** The content to render */
+    content: ReactNode;
+    /** Whether the row is hovered */
+    isHovered?: boolean;
+    /** Whether the row is selected */
+    isSelected?: boolean;
+}
+/**
+ * Renders a row adornment overlay positioned at the right edge of a row.
+ * Uses CSS anchor positioning to attach to the row element.
+ */
+declare function RowAdornmentOverlay({ sha, content, isHovered, isSelected, }: RowAdornmentOverlayProps): React.ReactElement | null;
+export default RowAdornmentOverlay;

package/dist/components/graph/rowRenderers/RefZoneRow.d.ts

@@ -17,6 +17,7 @@ interface StateProps {
     hoveredRefZoneSha?: Sha;
     refIconsPosition: RefIconsPosition;
     refMetadataById?: RefMetadataById | null;
+    fallbackRefMetadataById?: RefMetadataById | null;
     shouldShowRefLine: boolean;
 }
 interface DispatchProps {

package/dist/domain/generic/GenericTypes.d.ts

@@ -15,6 +15,8 @@ export type GitRemoteUrl = GitHttpsUrl | GitSshUrl;
 export type Platform = 'darwin' | 'linux' | 'win32';
 export declare enum NamedKeys {
     arrowDownKey = "ArrowDown",
+    arrowLeftKey = "ArrowLeft",
+    arrowRightKey = "ArrowRight",
     arrowUpKey = "ArrowUp",
     controlKey = "Control",
     endKey = "End",

package/dist/domain/graph/GraphHelpers.d.ts

@@ -17,7 +17,7 @@ export declare function hasScrolledToBottom(htmlElement: HTMLElement): boolean;
 export declare function hasScrolledToRight(htmlElement: HTMLElement): boolean;
 export declare function parseContext(context?: GraphItemContext | null): string | null;
 export declare function getRowStatsConstraints(stats: number[]): RowStatsConstraints;
-export declare function getOrAskForRefMetadata(ref: GraphRef, refMetadata: RefMetadataById | undefined, onMissingRefMetadata: GetMissingRefMetadata, refMetadataType?: RefMetadataType): RefMetadata | BaseMetadata | BaseMetadata[] | null | undefined;
+export declare function getOrAskForRefMetadata(ref: GraphRef, refMetadata: RefMetadataById | undefined, onMissingRefMetadata: GetMissingRefMetadata, refMetadataType?: RefMetadataType, fallbackRefMetadata?: RefMetadataById | null): RefMetadata | BaseMetadata | BaseMetadata[] | null | undefined;
 export declare function getTimelineLabelAndValue(diffMs: number): {
     label: string;
     value: number;

package/dist/domain/graph/GraphTypes.d.ts

@@ -317,6 +317,7 @@ type ReadonlyDeep<T> = T extends Record<string, unknown> ? {
     readonly [K in keyof T]: ReadonlyDeep<T[K]>;
 } : T extends Array<infer U> ? ReadonlyArray<ReadonlyDeep<U>> : T;
 export interface ReadonlyGraphRow extends ReadonlyDeep<GraphRow> {
+    rowIndex?: number;
     readonly hasRefs?: boolean;
     /** Whether the row is hidden from the graph (filtered out by type or other filters). Output only */
     readonly hidden: boolean;
@@ -475,7 +476,13 @@ export type OnDoubleClickGraphRef = (event: React.MouseEvent<any>, refGroup: Gra
 export type OnRowContextMenu = (event: React.MouseEvent<any>, graphZoneType: GraphZoneType, graphRow: GraphRow) => void;
 export type OnRefContextMenu = (event: React.MouseEvent<any>, refGroup: GraphRefGroup, graphRow: GraphRow) => void;
 export type OnToggleRefsVisibilityClick = (event: React.MouseEvent<any>, refs: GraphRefOptData[], visible: boolean, graphRow?: GraphRow) => void;
-export type OnSelectGraphRows = (selectedRows: ReadonlyGraphRow[]) => void;
+export interface GraphSelectionState {
+    /** Whether the selected rows form a topologically contiguous selection (connected via parent-child relationships) */
+    isContiguous: boolean;
+    /** Whether the selection was made topologically (via shift+click following graph topology) */
+    isTopological: boolean;
+}
+export type OnSelectGraphRows = (rows: ReadonlyGraphRow[], focusedRow: ReadonlyGraphRow | undefined, state: GraphSelectionState) => void;
 export type OnGraphRowHovered = (event: React.MouseEvent<any>, graphZoneType: GraphZoneType, graphRow: GraphRow) => void;
 export type OnGraphRowUnhovered = (event: React.MouseEvent<any>, graphZoneType: GraphZoneType, graphRow: GraphRow) => void;
 export type OnGraphRefNodeHovered = (event: React.MouseEvent<any>, refGroup: GraphRefGroup, graphRow: GraphRow) => void;

package/dist/domain/graph/rowAdornment/RowAdornmentTypes.d.ts

@@ -0,0 +1,97 @@
+import type { ReactNode } from 'react';
+import type { Sha } from '../../commit/CommitTypes';
+import type { ReadonlyGraphRow } from '../GraphTypes';
+/**
+ * When the adornment should be visible:
+ * - `true` = always visible
+ * - Array of triggers = visible when ANY of the specified triggers are active
+ */
+export type AdornmentVisibility = true | readonly ('hover' | 'focus' | 'selected')[];
+/**
+ * Adornment configuration returned from provideAdornments for each row.
+ * @template TContext - Type of context data passed from provide to resolve
+ */
+export interface RowAdornment<TContext = unknown> {
+    /** When the adornment is visible */
+    visibility?: AdornmentVisibility;
+    /**
+     * Optional context data to pass to resolveAdornment.
+     * Use for passing batch-fetched data (e.g., PR status) to the resolve phase.
+     */
+    context?: TContext;
+    /**
+     * If true, resolve() is called on every render (content not cached).
+     * Use for adornments whose content depends on external state.
+     * Default: false (content is cached until invalidated)
+     */
+    dynamic?: boolean;
+}
+/**
+ * Invalidation level
+ */
+export type InvalidationType = 'all' | 'content';
+/**
+ * Custom event dispatched when adornments need re-evaluation
+ */
+export declare class RowAdornmentInvalidateEvent extends CustomEvent<{
+    shas?: Set<Sha>;
+    type: InvalidationType;
+}> {
+    static readonly type = "invalidate";
+    constructor(type: InvalidationType, shas?: Iterable<Sha>);
+}
+/**
+ * Provider interface - consumer implements, graph consumes
+ * @template TContext - Type of context data passed from provide to resolve
+ */
+export interface RowAdornmentProvider<TContext = unknown> {
+    /**
+     * Batch evaluation: which rows should have adornments?
+     *
+     * Called for:
+     *   - Newly visible rows (scrolled into view)
+     *   - Rows with 'all' invalidation
+     *
+     * Can return sync or async:
+     *   - Sync: Result applied immediately
+     *   - Async: Rows render without adornments until resolved
+     *           (AbortSignal can be used to cancel in-flight requests)
+     *
+     * @param rows - Rows needing evaluation
+     * @param signal - Abort signal (check before applying async results)
+     * @returns Map of SHA → adornment config. Rows not in result have no adornment.
+     */
+    provideAdornments(rows: readonly ReadonlyGraphRow[], signal: AbortSignal): Record<Sha, RowAdornment<TContext>> | Promise<Record<Sha, RowAdornment<TContext>>>;
+    /**
+     * Render content for a specific row.
+     *
+     * Called when:
+     *   - Row becomes active (visible for 'always', hovered/focused for triggers)
+     *   - Row has 'content' invalidation and is active
+     *   - Row is dynamic (every render when active)
+     *
+     * Can return sync or async:
+     *   - Sync (ReactNode): Content rendered immediately
+     *   - Async (Promise<ReactNode>): Nothing shown until resolved
+     *
+     * @param row - The row to render adornment for
+     * @param context - Context data from provideAdornments (if any)
+     * @returns Content to render, or null/Promise for no/pending content
+     */
+    resolveAdornment(row: ReadonlyGraphRow, context?: TContext): ReactNode | null | Promise<ReactNode | null>;
+    /**
+     * EventTarget for invalidation.
+     * - Graph subscribes to 'invalidate' events
+     * - Consumer dispatches RowAdornmentInvalidateEvent to trigger re-evaluation
+     */
+    invalidate?: EventTarget;
+}
+/**
+ * Cached adornment state per row. Single map contains everything.
+ */
+export interface CachedAdornment {
+    visibility: AdornmentVisibility;
+    dynamic: boolean;
+    context?: unknown;
+    content?: ReactNode;
+}

package/dist/domain/reactvirtualized/ReactVirtualizedHelpers.d.ts

@@ -8,4 +8,4 @@ export type CustomCellCacheValue = {
 export type CustomCellCache = {
     [key: string]: CustomCellCacheValue;
 };
-export declare const makeSmartCellRangeRenderer: (getRealKeyForCell: GetRealKeyForCellFunc, scrollLeft?: number) => GridCellRangeRenderer;
+export declare const makeSmartCellRangeRenderer: (getRealKeyForCell: GetRealKeyForCellFunc, scrollLeft?: number, forceCache?: boolean) => GridCellRangeRenderer;

package/dist/index.d.ts

@@ -8,6 +8,7 @@ export * from './domain/generic/GenericTypes';
 export * from './domain/commit/CommitTypes';
 export * from './domain/graph/GraphConstants';
 export * from './domain/graph/GraphTypes';
+export * from './domain/graph/rowAdornment/RowAdornmentTypes';
 export * from './domain/hostingservice/HostingServiceTypes';
 export * from './domain/ref/RefConstants';
 export * from './domain/ref/RefTypes';