@gitkraken/gitkraken-components 13.0.0-vnext.3 → 13.0.0-vnext.30

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

@@ -4,11 +4,16 @@ import type { CssVariables } from '../generic/GenericTypes';
 import type { GetRealKeyForCellFunc } from '../reactvirtualized/ReactVirtualizedHelpers';
 import type { GraphRefType } from '../ref/RefTypes';
 import type { WorkDirStats } from '../workdir/WorkDirTypes';
-import type { GraphMarkerType, GraphZone, GraphZoneType, TimelineEntriesByPeriod } from './GraphConstants';
+import type { GraphMarkerType, GraphZone, GraphZoneType, TimelineEntry } from './GraphConstants';
 import { GraphColumnMode } from './GraphConstants';
-import type { BaseMetadata, GetMissingRefMetadata, GraphColumnWidthConstraints, GraphItemContext, GraphRef, GraphRefGroup, GraphRow, GraphZoneModeConstants, Head, HighlightedShas, ProcessedGraphRow, ProcessedGraphRowBySha, Ref, RefMetadata, RefMetadataById, RefMetadataType, RowStatsConstraints } from './GraphTypes';
+import type { BaseMetadata, ExternalIconKeys, GetMissingRefMetadata, GraphColumnWidthConstraints, GraphItemContext, GraphRef, GraphRefGroup, GraphRow, GraphZoneModeConstants, Head, HighlightedShas, ProcessedGraphRow, ProcessedGraphRowBySha, Ref, RefMetadata, RefMetadataById, RefMetadataType, RowStatsConstraints } from './GraphTypes';
 export type DebouncableFn = (...args: any) => void;
 export type DebouncedFn = (...args: any) => void;
+export type CachedRowVisibilityState = {
+    hasBaseFilteredTags: boolean;
+    hasFilteredBranches: boolean;
+};
+export declare function getVisibleRowShasWithoutStashAnchoring(graphRows: GraphRow[], cachedRowVisibilityByIndex: CachedRowVisibilityState[], tagsRequireBranchOrVisibleChild: boolean): Set<Sha>;
 export declare const debounceFrame: (func: DebouncableFn) => DebouncedFn;
 export type ThrottleableFn = (...args: any) => void;
 export type ThrottledFn = (...args: any) => void;
@@ -17,8 +22,23 @@ 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 getTimelineEntriesByPeriod(): TimelineEntriesByPeriod;
+export declare function getOrAskForRefMetadata(ref: GraphRef, refMetadata: RefMetadataById | undefined | null, onMissingRefMetadata: GetMissingRefMetadata, refMetadataType?: RefMetadataType, fallbackRefMetadata?: RefMetadataById | null): RefMetadata | BaseMetadata | BaseMetadata[] | null | undefined;
+export declare function getTimelineLabelAndValue(diffMs: number): {
+    label: string;
+    value: number;
+};
+export declare function getTimelineEntriesByPeriod(): TimelineEntry[];
+/**
+ * Assigns timeline entries to graph rows based on commit dates.
+ *
+ * Timeline markers act as boundaries between time periods:
+ * - All commits above a marker must be younger (more recent) than the marker time
+ * - All commits at and below a marker must be equal to or older than the marker time
+ *
+ * @param orderedRows - Array of graph rows ordered from newest to oldest
+ * @param entries - Array of timeline entries ordered from newest to oldest
+ */
+export declare function assignTimelineEntriesToRows(orderedRows: ProcessedGraphRow[], entries: TimelineEntry[]): void;
 export declare function getRefIdByBaseRef(refType: GraphRefType, ref: Ref): string;
 export declare function getRefIdByGraphRef(ref: GraphRef): string;
 export declare function getLastShrinkableGraphZone(activeGraphZones: GraphZone[], stoppingIndex?: number): GraphZone | undefined;
@@ -46,14 +66,16 @@ export declare function getGraphZoneModeConstants(graphZoneMode?: GraphColumnMod
 export declare const makeGetKeyForCell: (rows: ProcessedGraphRow[]) => GetRealKeyForCellFunc;
 export declare function getZoneWidthWithVerticalScrollbar(graphZoneType: GraphZoneType, activeGraphZones: GraphZone[]): number;
 export declare function rowContainsCurrentHeadRef(row?: ProcessedGraphRow | GraphRow): boolean;
+export declare function rowIsActiveHead(row?: ProcessedGraphRow | GraphRow): boolean;
 export declare function getHeadRefShaFromGraphRows(graphRows: GraphRow[]): Sha | undefined;
 export declare function isWorkDirNodeType(nodeType: CommitType): boolean;
 export declare function isCommitNodeType(nodeType: CommitType): boolean;
 export declare function workDirStatsHaveChanges(workDirStats?: WorkDirStats): boolean;
+export declare function shouldShowWorkDirRow(workDirStats: WorkDirStats | undefined, wipVisibility: 'always' | 'auto' | undefined): boolean;
 export declare function hasSingleSelectedSha(selectedShas: Set<Sha>): boolean;
 export declare function isSingleSelected(selectedShas: Set<Sha>, sha: Sha): boolean;
 export declare function getScrollToAlignment(rowHeight: number, clientHeight: number, scrollTop: number, scrollToIndex: number): Alignment;
-export declare function getGraphZoneIconByType(zoneType: GraphZoneType): string;
+export declare function getGraphZoneIconByType(zoneType: GraphZoneType): ExternalIconKeys | undefined;
 export declare function isHeadActive(head: Head): boolean;
 export declare function isGraphRefActive(ref: GraphRef): boolean;
 export interface GraphRowHelperProps {
@@ -70,6 +92,7 @@ export interface GraphRowHelperProps {
     selectedShas: Set<Sha>;
     processedRows: ProcessedGraphRow[];
     processedGraphRowBySha: ProcessedGraphRowBySha;
+    scrollTop: number;
     alwaysShowTimelines?: boolean;
 }
 export declare class GraphRowHelper {
@@ -95,6 +118,7 @@ export declare class GraphRowHelper {
     isSingleSelected(rowIndex: number): boolean;
     hasTimeline(rowIndex: number): boolean;
     rowContainsCurrentHeadRef(row?: ProcessedGraphRow): boolean;
+    rowIsActiveHead(row?: ProcessedGraphRow): boolean;
 }
 export declare function first<T>(source: Iterable<T> | IterableIterator<T>): T | undefined;
 export declare function last<T>(source: Iterable<T>): T | undefined;

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

@@ -1,7 +1,7 @@
 import type { GridCellRenderer, ScrollParams } from 'react-virtualized';
-import type { ReactElement } from 'react';
+import type { ReactElement, ReactNode } from 'react';
 import type { CommitDateTimeSources } from '../commit/CommitConstants';
-import type { CommitType, Sha } from '../commit/CommitTypes';
+import type { CommitType, EdgeCommitType, Sha } from '../commit/CommitTypes';
 import type { CssVariables } from '../generic/GenericTypes';
 import type { HostingServiceType, IssueTrackerType } from '../hostingservice/HostingServiceTypes';
 import type { TranslationFn } from '../language/LanguageTypes';
@@ -38,6 +38,7 @@ export type EdgeCache = {
 export type ArcEndpointAngle = 0 | 90 | 180 | 270;
 export interface SvgStyles {
     fill: string;
+    filter?: string;
     shapeRendering: string;
     strokeLinejoin: string;
     strokeWidth: number;
@@ -57,7 +58,7 @@ export type SvgProps = ArcSvgProps | LineSvgProps;
 export type AnySvgProps = ArcSvgProps & LineSvgProps;
 export type Edge = {
     parentSha: Sha;
-    type: CommitType;
+    type: EdgeCommitType;
 };
 export type EdgeByColumn = {
     [column: number]: Edge;
@@ -136,6 +137,56 @@ export type IsSelectedBySha = {
 export type HighlightedShas = {
     [sha: Sha]: boolean;
 };
+export type SyntheticParentsBySha = Map<Sha, Sha[]>;
+export interface GraphScope {
+    /** Full ref id of the specific branch to scope to (e.g. 'refs/heads/feature/x'). NOT necessarily HEAD. */
+    branchRef: string;
+    /** Full ref id of the branch's upstream (e.g. 'refs/remotes/origin/feature/x'). */
+    upstreamRef?: string;
+    /** SHA of the merge-target tip commit. Its ancestors are NOT walked — the tip is kept as a marker. */
+    mergeTargetTipSha?: Sha;
+    /**
+     * Merge base between branchRef and mergeTargetTipSha (or the fork point of branchRef from
+     * its parent line, when mergeTargetTipSha is omitted). When provided, `sha` is the
+     * authoritative boundary — no first-parent inference is performed. The branch ancestor walk
+     * terminates at this sha and the sha is added to forkPointShas (when loaded) or branchTip is
+     * added to unreachableAnchors (when not loaded). Object-typed (rather than a bare Sha) so the
+     * host can attach additional metadata in the future without breaking the type.
+     */
+    mergeBase?: {
+        sha: Sha;
+    };
+    /**
+     * Additional ref ids to include in the scope. Each tip becomes an anchor (same treatment as
+     * branchRef — shows all refs, acts as visibility floor) and its ancestors contribute to
+     * visibleShas subject to the mergeTarget exclusion.
+     *
+     * Primary use case: branches stacked on top of the focal branch (e.g. F2, F3 stacked on F1).
+     * The helper makes no stackedness check — any refs are valid (siblings, comparisons, etc.).
+     */
+    additionalBranchRefs?: string[];
+    /** How to render gaps when an anchor's real parents are hidden. Defaults to 'syntheticEdge'. */
+    collapseStyle?: 'syntheticEdge' | 'gap';
+}
+export interface ScopeVisibility {
+    visibleShas: Set<Sha>;
+    anchorShas: Set<Sha>;
+    /** Fork points (merge bases) where an anchor's ancestor walk terminated. Visual boundary "below" the focus group. */
+    forkPointShas: Set<Sha>;
+    /** The merge-target tip sha, when scope.mergeTargetTipSha was provided. Visual boundary "above" the focus group. */
+    mergeTargetShas: Set<Sha>;
+    syntheticParentsBySha: SyntheticParentsBySha;
+    /** Anchors whose synthetic walk failed — merge base not in loaded rows. Consumer should fetch more data. */
+    unreachableAnchors: Set<Sha>;
+    /**
+     * True when scope walks terminated at identified boundaries — at least one fork point was
+     * found AND no anchor was left unreachable. When false, the scope may be incomplete due to
+     * missing data (merge base not loaded, foreign ref not yet surfaced, partial history). Callers
+     * should NOT suppress commit autoloading while this is false — more data could establish the
+     * missing boundary.
+     */
+    isBounded: boolean;
+}
 export type IsExcludedBySha = {
     [id: Sha]: boolean;
 };
@@ -145,9 +196,12 @@ export type HasSpecialChildBySha = {
 export type ReserverInfoBySha = {
     [id: Sha]: ReserverInfo;
 };
+export type ColumnNumberBySha = {
+    [sha: Sha]: number;
+};
 export type RefTargetFunc = () => Element | null | undefined;
 export type ColumnContentGenerator = () => ReactElement<any>;
-export type GraphItemContext = string | Object;
+export type GraphItemContext = string | object;
 export type RefGroupContexts = {
     [name: string]: GraphItemContext;
 };
@@ -313,21 +367,34 @@ export interface GraphRefsData {
     orderedRefGroups: GraphRefGroup[];
     refGroupsByName: GraphRefGroupsByName;
 }
+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;
+}
+/** Which scope-boundary role this row plays, when an active scope identifies it as one. */
+export type ScopeBoundaryKind = 'forkPoint' | 'mergeTarget';
 export interface ProcessedGraphRow extends GraphRow {
     rowIndex?: number;
     column: number;
     columnForColoring?: number;
-    displayMessage: string;
-    displaySummary: string;
-    displayBody?: string;
+    displaySummary: string | ReactNode;
+    displayBody?: string | ReactNode;
     edges: RowEdges;
     edgeColumnMaxes: number;
     hasRefs?: boolean;
+    /** Whether the row is hidden from the graph (filtered out by type or other filters). Output only */
+    hidden: boolean;
     summary: string;
     body?: string;
     timeLineEntry?: TimelineEntry;
     childRefs?: ChildRefsByType;
     refsData?: GraphRefsData;
+    scopeBoundaryKind?: ScopeBoundaryKind;
 }
 export type TopAndBottomVisibleRowIndex = {
     top: number;
@@ -386,6 +453,13 @@ export type GraphMarkerColors = {
 export type GraphMarkerRowIndices = {
     [marker: string]: number[];
 };
+export interface InteractiveScrollMarker {
+    type: GraphMarkerType;
+    rowIndex: number;
+    sha: Sha;
+    label: string;
+}
+export type OnScrollMarkerClicked = (sha: Sha, rowIndex: number, type: GraphMarkerType) => void;
 export type AvatarUrlByEmail = {
     [email: string]: string;
 };
@@ -396,7 +470,8 @@ export type DownstreamsByUpstream = {
     [upstreamName: string]: string[];
 };
 export type GraphPlatform = 'aix' | 'android' | 'darwin' | 'freebsd' | 'linux' | 'openbsd' | 'sunos' | 'win32' | 'cygwin';
-export type GetExternalIcon = (key: string) => ReactElement<any>;
+export type ExternalIconKeys = 'added' | 'author' | 'branch' | 'changes' | 'check' | 'commit' | 'datetime' | 'deleted' | 'files' | 'filter' | 'graph' | 'head' | 'hide' | `issue-${IssueTrackerType}` | 'loading' | 'message' | 'modified' | 'pin' | 'pull-request' | 'remote' | `remote-${HostingServiceType}` | 'renamed' | 'resolved' | 'settings' | 'show' | 'stash' | 'tag' | 'upstream-ahead' | 'upstream-behind' | 'warning' | 'worktree';
+export type GetExternalIcon = (key: ExternalIconKeys) => ReactElement<any>;
 export type GetMissingAvatar = (email: string, sha: string) => void;
 export type GetMissingRefMetadata = (id: string, types: RefMetadataType[]) => void;
 export type FormatRefShorthand = (shorthand: RefShorthand, sha: Sha, refType: GraphRefType, data?: any | null) => RefShorthand;
@@ -429,7 +504,10 @@ export type OnGraphMouseLeave = (event: React.MouseEvent<any>) => void;
 export type OnClearCurrentlyHoveredGraphCommit = (event: React.MouseEvent<any>, graphZoneType: GraphZoneType, sha: Sha, currentlyHoveredCommitSha?: Sha) => void;
 export type CommitDateTimeSource = CommitDateTimeSources;
 export type OnFormatCommitDateTime = (commitDateTime: number, source?: CommitDateTimeSource) => string;
-export type FormatCommitMessage = (commitMessage: string) => string;
+export type FormatCommitMessage = (commitMessage: string) => {
+    summary: string | ReactNode;
+    body?: string | ReactNode;
+};
 export type OnCurrentlyHoveredGraphCommit = (event: React.MouseEvent<any>, graphZoneType: GraphZoneType, sha: Sha, currentlyHoveredCommitSha?: Sha) => void;
 export type OnClickCommit = (event: React.MouseEvent<any>, graphZoneType: GraphZoneType, sha: Sha) => void;
 export type OnClickRef = (event: React.MouseEvent<any>, refGroup: GraphRefGroup, sha: Sha, metadataItem?: RefMetadataItem) => void;
@@ -462,7 +540,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: GraphRow[]) => 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 ctrl/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;
@@ -473,3 +557,10 @@ export type OnGraphColumnResized = (graphZoneType: GraphZoneType, columnSettings
 export type OnShowMoreCommits = () => void;
 export type OnEmailsMissingAvatarUrls = (emails: AvatarUrlByEmail) => void;
 export type OnRefsMissingMetadata = (refs: RefsMissingMetadata) => void;
+/**
+ * Callback invoked when column numbers are calculated for each commit.
+ * Receives a map of SHA → column number.
+ * Used to sync column layout data back to the parent application.
+ */
+export type OnColumnsCalculated = (columnsBySha: ColumnNumberBySha) => void;
+export {};

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

@@ -0,0 +1,21 @@
+import type { Sha } from '../commit/CommitTypes';
+import type { GraphRow } from './GraphTypes';
+/**
+ * Identifies commits that belong to the pinned branch by following the first-parent chain.
+ * Returns a Set of SHAs that are part of the pinned branch.
+ */
+export declare function identifyPinnedBranchCommits(graphRows: GraphRow[], pinnedBranchFullName?: string | null): Set<Sha>;
+/**
+ * Gets the next available column number, marking it as used.
+ * When reserveColumn0ForPinned is true, starts searching from column 1.
+ */
+export declare function getAvailableColumnAndUseIt(columnsUsed: {
+    [column: number]: boolean;
+}, reserveColumn0ForPinned?: boolean): number;
+/**
+ * Determines the column number for a parent commit based on pinning status and parent index.
+ * For pinned parents, always reserve column 0; for non-pinned, use normal logic.
+ */
+export declare function getParentColumn(columnsUsed: {
+    [column: number]: boolean;
+}, isParentPinned: boolean, parentIndex: number, currentColumn: number, hasPinnedBranch: boolean): number;

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

@@ -0,0 +1,15 @@
+import type { GraphRow, GraphScope, ScopeVisibility } from './GraphTypes';
+export declare function computeScopeVisibility(rows: GraphRow[], scope: GraphScope): ScopeVisibility;
+/**
+ * Returns true when a WIP row should be hidden under an active scope.
+ *
+ * Secondary (per-worktree) WIP rows are kept only when their parent is a branch anchor of the
+ * scope — i.e. the tip of `branchRef`, `upstreamRef`, or one of `additionalBranchRefs` (so a
+ * worktree checked out on a scoped branch still surfaces its WIP, even when empty). The merge
+ * target tip is excluded: it's a boundary, not a focused branch.
+ *
+ * The primary WIP row, merge-conflict node, and unsupported-rebase warning node are tied to
+ * the primary repo's HEAD. They are kept whenever at least one of their parents is in the
+ * scope's visible set; otherwise they would render as floating nodes with no anchoring topology.
+ */
+export declare function shouldHideWipRowForScope(row: GraphRow, scopeVisibility: ScopeVisibility | null): boolean;

package/dist/domain/graph/row/ProcessedGraphRowObj.d.ts

@@ -1,7 +1,8 @@
+import type { ReactNode } from 'react';
 import type { IGraphContainer } from '../../../components/graph/IGraphContainer';
 import type { CommitType, Sha } from '../../commit/CommitTypes';
 import type { TimelineEntry } from '../GraphConstants';
-import type { ChildRefsByType, GraphRefsData, GraphRow, Head, ProcessedGraphRow, Remote, RowContexts, RowEdges, Tag } from '../GraphTypes';
+import type { ChildRefsByType, GraphRefsData, GraphRow, Head, ProcessedGraphRow, Remote, RowContexts, RowEdges, ScopeBoundaryKind, Tag } from '../GraphTypes';
 export declare class ProcessedGraphRowObj implements ProcessedGraphRow {
     private _graph;
     private _message;
@@ -26,11 +27,11 @@ export declare class ProcessedGraphRowObj implements ProcessedGraphRow {
     edges: RowEdges;
     childRefs: ChildRefsByType;
     timeLineEntry?: TimelineEntry;
+    scopeBoundaryKind?: ScopeBoundaryKind;
     summary: string;
     body?: string;
-    displayMessage: string;
-    displaySummary: string;
-    displayBody?: string;
+    displaySummary: string | ReactNode;
+    displayBody?: string | ReactNode;
     set message(message: string);
     get message(): string;
     get heads(): Head[];
@@ -41,9 +42,9 @@ export declare class ProcessedGraphRowObj implements ProcessedGraphRow {
     get tags(): Tag[];
     get hasRefs(): boolean;
     get hasChildRefs(): boolean;
+    get hidden(): boolean;
     get refsData(): GraphRefsData | undefined;
     constructor(graphContainer: IGraphContainer, row: GraphRow, column?: number, edgeColumnMaxes?: number, edges?: RowEdges, childRefs?: ChildRefsByType, timeLineEntry?: TimelineEntry, columnForColoring?: number);
-    private updateSummaryAndBody;
     private initializeRefGroups;
     private addRefToRefGroup;
     private loadGraphRefGroupsData;

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

@@ -0,0 +1,14 @@
+import type { Sha } from '../../commit/CommitTypes';
+/**
+ * Builds the CSS `<dashed-ident>` used to tie a graph row's `anchor-name`
+ * to the overlay's `position-anchor`. Shas are arbitrary caller-provided
+ * strings (e.g. `worktree-wip::/some/path` for multi-WIP rows) and may
+ * contain characters that aren't valid inside a CSS <custom-ident>, so
+ * each unsafe character is prefixed with `\` — a single-character CSS
+ * escape that preserves readability in DevTools while keeping the
+ * identifier parseable by the browser.
+ *
+ * Letters, digits, hyphen, underscore, and non-ASCII code points are
+ * already legal inside a CSS ident and pass through unchanged.
+ */
+export declare function getRowAnchorName(sha: Sha): string;

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/hostingservice/HostingServiceTypes.d.ts

@@ -14,6 +14,7 @@ export type GitLabSelfHostedIssueTrackerType = GitLabSelfHostingServiceType;
 export type JiraCloudIssueTrackerType = 'jiraCloud';
 export type JiraServerIssueTrackerType = 'jiraServer';
 export type TrelloIssueTrackerType = 'trello';
+export type LinearIssueTrackerType = 'linear';
 export type BitbucketIssueTrackerType = 'bitbucket';
-export type IssueTrackerType = GitHubIssueTrackerType | GithubEnterpriseIssueTrackerType | GitLabIssueTrackerType | GitLabSelfHostedIssueTrackerType | JiraCloudIssueTrackerType | JiraServerIssueTrackerType | TrelloIssueTrackerType | AzureDevopsIssueTrackerType | BitbucketIssueTrackerType;
+export type IssueTrackerType = GitHubIssueTrackerType | GithubEnterpriseIssueTrackerType | GitLabIssueTrackerType | GitLabSelfHostedIssueTrackerType | JiraCloudIssueTrackerType | JiraServerIssueTrackerType | TrelloIssueTrackerType | LinearIssueTrackerType | AzureDevopsIssueTrackerType | BitbucketIssueTrackerType;
 export declare function getHostingServiceName(hostingServiceType: HostingServiceType): string;

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) => GridCellRangeRenderer;
+export declare const makeSmartCellRangeRenderer: (getRealKeyForCell: GetRealKeyForCellFunc, scrollLeft?: number, forceCache?: boolean) => GridCellRangeRenderer;

package/dist/domain/ref/RefConstants.d.ts

@@ -1,5 +1,8 @@
 export declare const refTypes: {
-    [key: string]: string;
+    readonly HEAD: "head";
+    readonly REMOTE: "remote";
+    readonly TAG: "tag";
+    readonly WORKTREE: "worktree";
 };
 export declare enum refIconsPositions {
     LEFT = "LEFT",

package/dist/domain/ref/RefTypes.d.ts

@@ -1,6 +1,6 @@
 import type { Sha } from '../commit/CommitTypes';
 import type * as RefConstants from './RefConstants';
-export type GraphRefType = keyof typeof RefConstants.refTypes;
+export type GraphRefType = (typeof RefConstants.refTypes)[keyof typeof RefConstants.refTypes];
 export type RefFullName = string;
 export type RefShorthand = string;
 export type CreateRefFormData = {

package/dist/domain/workdir/WorkDirHelpers.d.ts

@@ -0,0 +1,50 @@
+import type { ReactElement } from 'react';
+import type { Sha } from '../commit/CommitTypes';
+import type { VisibleWipShas, WipNodeMetadataBySha, WipShasMissingStats, WorkDirStats } from './WorkDirTypes';
+/** Translation key for the WIP row's label, selected based on stats state. */
+export type WipRowMessageKey = 'Graph-WorkInProgress' | 'Graph-WorkInProgress-Changes' | 'Graph-WorkInProgress-Clean';
+/**
+ * Picks the translation key for a WIP row's label based on the stats it has (or doesn't have):
+ * - `Graph-WorkInProgress-Changes` when stats show any added/modified/deleted activity
+ * - `Graph-WorkInProgress-Clean` when stats are present but all zero (queried, clean)
+ * - `Graph-WorkInProgress` when stats are not yet known (neutral fallback)
+ */
+export declare function getWipRowMessageKey(workDirStats: WorkDirStats | undefined): WipRowMessageKey;
+export type ResolvedWipState = {
+    isPrimaryWip: boolean;
+    effectiveWorkDirStats: WorkDirStats | undefined;
+    hasWorkDirChanges: boolean;
+    isWipEditable: boolean;
+    customWipContent: ReactElement<any> | null;
+    needsWipStatsRequest: boolean;
+};
+/**
+ * Resolves the effective WIP state for a given row.
+ *
+ * For the primary WIP row (sha === workDirType), uses the global workDirStats.
+ * For secondary WIP rows, uses the per-row metadata from wipNodeMetadataBySha. There is
+ * NO fallback to the global workDirStats — secondary rows belong to other worktrees, and
+ * painting the primary repo's counts on them would be wrong. Until per-row stats arrive,
+ * the pill renders nothing and `needsWipStatsRequest` triggers a deferred fetch.
+ */
+export declare function resolveWipState(sha: Sha, type: string, workDirStats: WorkDirStats | undefined, wipNodeMetadataBySha: WipNodeMetadataBySha | undefined, wipMessageEditable: boolean): ResolvedWipState;
+/** Predicate for secondary-WIP rows (per-worktree WIPs), excluding the primary WIP row. */
+export declare function isSecondaryWipRow(row: {
+    sha: Sha;
+    type?: string;
+}): boolean;
+/** Key-set equality for `VisibleWipShas` / `WipShasMissingStats`-shaped records (values are always `true`). */
+export declare function areVisibleWipShasEqual(a: VisibleWipShas, b: VisibleWipShas): boolean;
+/**
+ * Given the set of currently-visible secondary-WIP shas, the prior dedup map of shas already
+ * requested, and the per-sha metadata, compute (a) the pruned dedup map that only retains entries
+ * for shas still visible, and (b) the set of shas whose stats should be requested this tick.
+ *
+ * Shas that have left the viewport are dropped from the dedup so they can be re-asked on re-entry.
+ * Shas with `customContent` override or with non-stale `workDirStats` already populated are not
+ * added to `missing`.
+ */
+export declare function computeWipMissingShasUpdate(current: VisibleWipShas, priorRequestedDedup: WipShasMissingStats, metadataBySha: WipNodeMetadataBySha | undefined): {
+    missing: WipShasMissingStats;
+    prunedRequestedDedup: WipShasMissingStats;
+};

package/dist/domain/workdir/WorkDirTypes.d.ts

@@ -1,3 +1,5 @@
+import type { ReactElement } from 'react';
+import type { Sha } from '../commit/CommitTypes';
 import type { GraphItemContext } from '../graph/GraphTypes';
 export type WorkDirStats = {
     added: number;
@@ -6,3 +8,52 @@ export type WorkDirStats = {
     context?: GraphItemContext;
     renamed?: number;
 };
+/**
+ * Per-row decoration for a secondary (worktree) WIP graph row. Looked up by the row's `sha`.
+ *
+ * Not applied to the primary WIP row (`sha === workDirType`); use the `workDirStats` prop for that one.
+ *
+ * @see docs/multi-wip-rows.md
+ */
+export type WipNodeMetadata = {
+    /**
+     * Stats for this secondary WIP row's worktree. Omit to have the library request them via
+     * `onWipShasMissingStats`. Until per-row stats arrive, the pill renders nothing — the library does
+     * NOT fall back to the global `workDirStats` (which belongs to the primary repo).
+     */
+    workDirStats?: WorkDirStats;
+    /** When true, the library requests fresh stats while continuing to render `workDirStats` (stale-while-revalidate). */
+    workDirStatsStale?: boolean;
+    /** If provided, renders this element in place of the default WIP stats pill. Suppresses any stats request. */
+    customContent?: ReactElement<any>;
+    /** If provided, renders this avatar URL inside the graph node circle instead of the default WIP dot. */
+    nodeAvatarUrl?: string;
+};
+/**
+ * Decoration map for secondary WIP rows, keyed by the row's `sha`. The library does not create rows from
+ * this map — provide the row in `graphRows` and this map augments it.
+ */
+export type WipNodeMetadataBySha = Record<Sha, WipNodeMetadata>;
+/**
+ * Batched set of secondary-WIP shas for which the library is requesting stats. Delivered to the
+ * `onWipShasMissingStats` callback after a 100ms debounce with dedup.
+ */
+export type WipShasMissingStats = Record<Sha, true>;
+/**
+ * Caller-supplied handler invoked when one or more secondary WIP rows need stats fetched.
+ * Handler should async-fetch and push back an updated `wipNodeMetadataBySha` reference with
+ * `workDirStats` populated for each requested sha.
+ */
+export type OnWipShasMissingStats = (shas: WipShasMissingStats) => void;
+/**
+ * Batched set of secondary-WIP shas currently rendered in the viewport. Delivered to the
+ * `onVisibleWipShasChanged` callback after a 100ms debounce when the set changes.
+ */
+export type VisibleWipShas = Record<Sha, true>;
+/**
+ * Caller-supplied handler invoked when the set of secondary WIP rows visible in the viewport changes.
+ * Use this to acquire/release per-worktree resources (filesystem watchers, subscriptions, etc.) as
+ * rows scroll in and out of view. Consumers diff the provided set against their own tracking to
+ * decide what to hook/unhook.
+ */
+export type OnVisibleWipShasChanged = (shas: VisibleWipShas) => void;

package/dist/index.d.ts

@@ -3,6 +3,21 @@ import ScrollbarContainer from './components/graph/common/ScrollbarContainer';
 import GraphContainer from './components/graph/GraphContainer';
 export * from './components/graph/GraphContainer';
 export * from './components/dnd/DndComponent';
-export * from './types';
+export * from './domain/commit/CommitConstants';
+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';
+export * from './domain/workdir/WorkDirTypes';
+export * from './domain/ui/UiTypes';
+export * from './domain/language/LanguageTypes';
+export * from './domain/language/LanguageConstants';
+export * from './domain/cssvariable/CssVariableConstants';
+export * from './domain/diff/DiffTypes';
+export * from './domain/diff/DiffConstants';
 export { DndComponent, ScrollbarContainer };
 export default GraphContainer;