LinearMafDisplay

Auto-generated from the @jbrowse/mobx-state-tree model in the source — see the developer guide for concepts. Provided by the maf plugin. View source.

Example usage

A complete MafTrack config to paste into tracks. samples lists the aligned species in track order; rowHeight sets the per-sample band height in px (or 0 to stretch rows to fill the track height):

{
  type: 'MafTrack',
  trackId: 'multiz',
  name: 'Multiz alignment',
  assemblyNames: ['hg38'],
  adapter: {
    type: 'BigMafAdapter',
    bigBedLocation: { uri: 'https://example.com/multiz.bb' },
    samples: ['hg38', 'panTro4', 'mm10'],
  },
  displays: [
    {
      type: 'LinearMafDisplay',
      displayId: 'multiz-LinearMafDisplay',
      rowHeight: 16,
      showCoverage: true,
    },
  ],
}

Draws the multiple alignment in a MafTrack, one row per aligned species, under a conservation band.

The configuration slots for this model are documented on its config schema page.

Each section ends with the members a composed model contributes, linked to the page that documents them.

Properties

Member	Description
type `type: types.literal('LinearMafDisplay')`
configuration `configuration: ConfigurationReference(configSchema)`

4 inherited properties from 2 models

From BaseDisplay: id

From TreeSidebarMixin: runClustering, clusterRegion, sortRowsBy

Volatiles

Member	Description
framesGateBlocked `boolean`	The last frames fetch was refused by its `byteLimit`, so the strip stops drawing; the menu reads this to say so. Never in `rpcProps()`: the fetch writes it, the loop trap ARCHITECTURE.md names.
sourcesVolatile `MafSource[]`	The worker's authoritative row set, in tree (leaf) order. `editableSources` arranges it by `rows` and `rowColor`, and `sources` narrows that by the focus.
treeNewickVolatile `string \| undefined`	The adapter's guide tree as newick, which `rowTree` draws while some rotation of it lists `rows.domain` in order.
speciesListed `boolean`	Whether the adapter lists its species, by a `samples` config or its guide tree, rather than discovering them from the blocks it reads.
refSampleIdVolatile `string \| undefined`	The reference sample row the worker resolved, held here because the region store that delivers it empties on chromosome navigation. Last write wins, not a latch: a re-pointed adapter or edited `refAssemblyName` keeps the display instance.

31 inherited volatiles from 11 models

From BaseDisplay: error, statusMessage, statusProgress

From StoredHoverMixin: storedHoveredFeature

From TrackHeightMixin: scrollTop, hostHeight

From MultiRegionDisplayMixin: loadedRegions

From RegionTooLargeMixin: forceLoadTrack, byteEstimate, gateMeasuredViewportKey

From RenderLifecycleMixin: canvasDrawn, paintCount, currentRenderingBackend, renderTick, autorunsInstalled, renderError, offScreen

From FetchMixin: activeSignal, fetchGeneration, reloadCounter, statusWindow, fetchCanceled, fetchRotation

From CoarseTierMixin: coarseTier, coarseTierRead, coarseTierLoading

From LegendMixin: dismissedLegendSections

From TreeSidebarMixin: hoveredTreeNode, treeCanvas, mouseoverCanvas

From ContextMenuMixin: contextMenuInfo

Getters

Member	Description
view ModelInstanceTypeProps<…> & {…} & {…} & {…} & {…} & {…} & {…} & {…} & {…} & {…} & {…} & {…} & {…} & {…} & {…} & {…} & {…} & {…} & {…} & {…} & {…} & {…} & {…} & {…} & {…} & {…} & { rubberbandClickMenuItems(clickOffset: BpOffset): MenuItem[]; highlightMenuItems(_highlight: HighlightType): MenuItem[]; } & { flyTo: (centerBp: number, windowWidthBp: number) => void; flyToCenter(coord: number, refName: string, displayedRegionIndex?: number \| undefined): void; flyToFit(centerBp: number, fitWidthBp: number): void; } & { afterCreate(): void; afterAttach(): void; } & IStateTreeNode<…>
prefersOffset `boolean`	Offsets the track label above the plot, since the left y-axis gutter would sit under an overlapping label.
statedBandBounds `BandBounds \| undefined`	The legal range for a band height that is stated by a config, session snapshot or menu rather than dragged. Undefined when the track height derives from the bands.
rowProportion `number`
showAllLetters `boolean`
showAsUpperCase `boolean`
showCoverage `boolean`
showAlignments `boolean`
coverageHeight `number`
showConservation `boolean`
conservationHeight `number`
conservationMode `"base" \| "codon"`
colorField `"base" \| "chromosome" \| "codon" \| "identity" \| "mismatch"`
colorSetting `ColorSetting & { value: undefined; }`	The `color` object as written, with the key's labels and title.
colorEncoding `FieldColorEncoding`	The `color` object as it paints, through its field's preset: one scale per field, so `scale` is never written.
colorKeyTitle `string`	The key's heading: the written `title`, else the field's own.
identityColors `Uint32Array<ArrayBufferLike>`	The identity ramp's packed color at each hundredth, the default ramp unless `color` is identity. One array per ramp, so a color edit that leaves the ramp alone re-encodes nothing.
sourceChromColors `readonly number[]`	Each source chromosome rank's packed color, `color.range`'s while `color` is chromosome. One array per range, as `identityColors`.
yField `"identity" \| undefined`
rowIdentityAutoZoom `boolean`
showAnnotations `boolean`
showInversions `boolean`
showReferenceRow `boolean`
referenceSampleId `string \| undefined`	The reference sample row as the worker resolved it (`MafRegionSink`), falling back to the view's assembly name until a detail region loads. `refSampleIdVolatile` holds the resolved value. Every consumer reads this getter, so the codon conservation band and the per-base band exclude the same row.
annotationAdapterConfig `Record<string, unknown> \| undefined`	The CDS-frame annotation adapter snapshot (UCSC `mafFrames`) from the MAF adapter config, or undefined when unset. Read by array slot path off the live parent track: a slot read against a snapshot misses defaulted slots (`core/configuration/CLAUDE.md`).
annotationsActive `boolean`	Whether the per-species CDS frame strip draws: an annotation adapter is configured and "Show CDS frames" is on. Codon view gates separately on `framesInUse`.
framesInUse `boolean`	An annotation adapter is configured and something reads its frames: the strip, the codon view or the codon band.
discoveredRows `MafSource[]`	`TreeSidebarMixin`'s hook: the worker's species, in the order it reported them. Empty until the first fetch populates the set; `sourcesKnown` is the readiness question.
guideTreeNewick `string \| undefined`	`TreeSidebarMixin`'s hook: the adapter's guide tree.
rowColorFields `readonly string[]`	`TreeSidebarMixin`'s hook: none, since a species row carries no attribute to color it by.
rowAlias `RowAlias \| undefined`	`TreeSidebarMixin`'s hook: a copy row answers to its sample, so an order, label, color or focus written against the sample reaches its copies. None while no row is a copy.
rowOrder `readonly string[]`	`TreeSidebarMixin`'s hook: rows follow the leaves of the rotated `parsedTree` that `rows.domain` uses, then any rows the tree does not name. Without a tree, the species `rows.domain` lists lead and the rest keep adapter order.
clusterableSources `MafSource[]`	`editableSources` narrowed to the focus as the worker's `visibleSamples` narrows: on a track that lists its species, a focus naming none of them shows every row; on a discovering track the focus applies as given.
sources `MafSource[]`	The display rows: `clusterableSources`, less the reference row when `showReferenceRow` is off. An empty array means no fetch yet or a focus with no rows; `sourcesKnown` tells them apart.
sourcesKnown `boolean`	Whether the species list has arrived from the adapter. `rowsVisible` and the render callback's first-paint gate read this, since an empty `sources` cannot tell.
rowFocusKey `string[] \| undefined`	The focus `rows.kept` as the worker sees it: a sorted plain array read off config alone. Sorting keeps a re-cluster's new leaf order out of the fetch key (reference/FETCH_KEYS.md, "Row order is not a fetch input").
coarseAdapterSlot `string`
coarseTierPastThreshold `boolean`	Whether the view is zoomed out past the force-load floor, read from `RegionTooLargeMixin`'s gate so the tier swap and the gate agree on the floor.
coarseReadKey `{ settings: unknown; frames: boolean; }`	The detail fetch's settings, and whether the strip wants frames read beside the summary: the detail tier always reads them, the summary tier only for the strip.
coverageBandActive `boolean`	The coverage band is on and has data: `showCoverage` alone is not enough, since the summary tier carries no `coverage.coverageDepths`. Layout, paint, hit tests and export read this; only the track menu reads `showCoverage`, so the tick keeps the user's choice across zoom. Same split as `basesRenderingActive` vs `activeRowRendering`.
conservationBandActive `boolean`	The conservation band is on and has data: twin of `coverageBandActive`, since the identity scores come off alignment blocks the summary tier does not carry. Layout, paint and export read this; the menu tick reads `showConservation`.
samples `Sample[]`	Sample list keyed by sample id (alias of `sources` mapped to the project's canonical `{ id, label, color }` shape). Consumed by MafSequenceWidget, color legend, etc.
rowIndexBySrc `Map<string, number>`	Maps a `src` (species) to its display row index. The single source for the `src`→row projection used by the summary-bar and CDS-frame overlays and the frame hover lookup, so they can't disagree on row placement.
defaultCodonSpecies `string \| undefined`	The anchor species whose `mafFrames` reading frame translates every row (UCSC `codonDefault`). Tied to the reference assembly's `referenceSampleId`, not the top row, since codons compare against the reference sequence (`block.refSeqBytes`). Falls back to the worker's first row when the reference is not a listed sample.
referenceRowIndex `number`	The reference's display row for the band's codon mode, matching the per-base band's worker-side `refSampleId`; -1 where the reference is no drawn row.
detailPayloads `ReadonlyMap<number, MafRegionPayload<MafWireRegionData>>`	The detail tier's store: `MultiRegionDisplayMixin`'s per-region payloads narrowed to the worker's columnar rows plus the CDS frames from the same fetch. A reorder re-places from here without refetching.
rpcDataMap `ReadonlyMap<number, MafRegionData>`	`detailPayloads` with every row assigned its on-screen `rowIndex` (`placeMafRegionData`). Everything that draws, hit-tests or measures rows reads this. The memo lives in this closure to outlive a context-loss recovery; `afterAttach` installs the observer it needs.
detailOnScreen `ReadonlyMap<number, MafRegionData>`	`rpcDataMap` while the detail tier draws, and nothing on the summary tier: `CoarseTierMixin` keeps the detail store under the tier, so whatever marks, hovers or navigates by the alignment reads this.
framesDataMap `ReadonlyMap<number, MafFrameRecord[]>`	Per-region CDS frame rows (UCSC `mafFrames`) for the annotation overlay. The tier on screen is checked first and the other tier fills gaps, so the overlay stays visible across the summary-detail swap.
topBands `BandStack<"conservation" \| "coverage">`	The band stack, coverage above conservation, where the order is stated once. Every top, height and offset reads this fold; an off band spends 0 px.
coverageDisplayHeight `number`	Height of the coverage band above the rows (0 when hidden, and on the summary path, where it has nothing to draw).
conservationDisplayHeight `number`	Height of the conservation (percent identity) band: 0 when hidden or on the summary path. Painters, axis, handles and export read this, not the `conservationHeight` slot, which `statedBandBounds` only bounds at read time. It is what the stack reserves, not a ceiling: in fit mode with no `height` the slot passes through verbatim.
rowsHeaderHeight `number`	`TreeSidebarMixin`'s hook: where the band stack ends. Every rows hit-test, draw and export offset reads the mixin's `rowsTopOffset` over it, so adding a band or the focus chip's line can't desync them.
nrow `number`	Number of displayed rows (at least 1, so the fit-mode division is safe).
rowsVisible `boolean`	The per-sample rows area has something to draw: the view can place it, the rows are shown and the row set is known. The `visible*` getters share this gate instead of re-spelling it.
maxRowsHeight `number`	Max CSS-px height the rows canvas may take before its backing store (`× dpr`) hits the browser/GPU canvas limit. The single ceiling both the fit-target sizing and the `rowHeight` cap respect.
fitTargetHeight `number`	The track height that fit-to-height mode divides among rows: the explicit `height` slot after a drag, else enough to show every row at the default px height. Bounded by `DEFAULTS.maxAutoFitHeight`, past which the rows shrink instead of the track growing. `maxRowsHeight` stays the hard floor under a deliberate drag.
rowsHeight `number`	Height of the per-sample rows viewport: the track height minus the stacked bands, which is the rows canvas. Zero when alignments are hidden. A viewport, not the content: extra rows are reached by scrolling (`scrollContentHeight`, `scrollableHeight`). Capped at `maxRowsHeight` to stay under the canvas backing-store limit.
resizableBandBounds `{ max: number; }`	The legal range for the two drag-resizable bands over the rows (coverage, conservation). Each band is bounded against `fitTargetHeight`, separately from the other, so a drag cannot squash the rows to nothing or push its own resize handle off the display.
autoRowHeight `number`	Per-row height in fit-to-height mode: the rows viewport split evenly across rows, so the display never scrolls. Not floored at 1px: a sub-pixel row is the right answer for more species than pixels, and flooring would regrow the track past `fitTargetHeight`. The non-positive guard lives in `effectiveRowHeight`. A fixed height is used as-is; the canvas-size ceiling lives on `rowsHeight`.
scrollContentHeight `number`	The rows' scrolled content behind the `rowsHeight` viewport, `rowsContentHeight` while the alignments show. Equal to the viewport in fit-to-height mode, so that mode never scrolls.
scrollViewportHeight `number`
drawsTree `boolean`	`TreeSidebarMixin`'s hook: off while the alignments are hidden, since the tree lays against rows that are not drawn.
height `number`	Override BaseLinearDisplay.height so the track container matches the rendering canvases exactly (stacked bands + rows viewport).
treeRoot `HierarchyNode<NewickNode> \| undefined`	`TreeSidebarMixin`'s hook: `root` with a hidden reference row pruned, since `root` is already narrowed to the focus.
svgSidebar `SvgSidebarProps`
colorPalette `MafColorPalette`	Theme-derived color palette (per-base colors plus match, gap, mismatch, unknown, insertion), read by `rowsEncodeProps()` and `renderState`. Derived from the session theme, so it exists in headless SVG export and RPC. A theme change re-encodes on the main thread without a refetch.
encodeBinBp `number`	Genomic bp the GPU encoder collapses into one cell: the foundation's `settledSubPixelBinBp`. Zoomed in this is `1`; once a base falls below half a CSS pixel the encoder samples one per bin.
coverageDomain `[number, number] \| undefined`	[min, max] coverage domain over the visible content blocks, from the worker-shipped `coverage.coverageDepths`. Linear and unbounded; feeds `axes`.
axes `YAxis[]`	The band axes the chrome places: the coverage band's, off its autoscaled domain, and the conservation band's fixed 0-100%. Answers the resolved axes directly rather than composing `ScoreScaleMixin`.
coverageBandColors `CoverageBandColors`	The coverage band's palette slots, packed. Separate from `renderState` so the nine-color CSS parse memoizes against the palette.
coverageBandState `CoverageBandState`	The coverage band as the shared marks and their hit test take it. Height 0 draws no band: the setting is off or the summary tier owns the view. Linear and unbounded, counting every mismatch column.
renderState `MafGPURenderState`	Render state passed to the GPU/Canvas2D backend each frame. `canvasHeight` is the whole canvas, stacked bands plus rows viewport, because the coverage band draws on the same canvas as the rows. `rowsTop` and `rowsHeight` are the rows band inside it.
inversionConsensus `StrandConsensus`	The orientation each (row, source chromosome) is measured against for the inversion indicator (`consensusStrandByRowChr`). Memoized because it walks every block and row of every loaded region while its consumer runs on every pan and zoom. Empty when the indicator is off.
visibleEmptyLines `EmptyLineSegment[]`	Positioned bridge-line segments for `e`-line (empty/bridged) rows.
visibleInversions `InversionMarker[]`	Positioned strand-flip (inversion) markers for the visible aligned rows. Empty unless the indicator is toggled on.
zoomedToBaseLevel `boolean`	At base level each reference base spans at least a pixel (UCSC's `zoomedToBaseLevel`). Reads the debounced `coarseBpPerPx` so the rendering swap does not thrash mid-zoom. False until the view is initialized.
notices `string[]`	What the `color` object says that cannot paint as written, as the corner indicator lists it: the lines `plotProblems` and `jbrowse validate` report, then the ones only this display can tell.
selectedRowRendering `RowRendering`	The Row coloring radio's tick: the X-Y plot where `y` is identity, else the color field, with codon falling back to the bases where no frames file defines a reading frame. Zoom-independent.
identityYields `boolean`	Identity yields to the bases at base level while `rowIdentityAutoZoom` is on, where the letters say more than a mean.
rowsColor `"base" \| "chromosome" \| "codon" \| "identity" \| "mismatch"`	What colors the cells now: the color field, or the mismatches where it cannot draw (summary tier, codons without base level or a frames file, identity at base level via `identityYields`).
rowsY `"identity" \| undefined`	What the row bars' height carries now, or undefined where each row is one band of cells.
activeRowRendering `RowRendering`	What the rows paint now: the X-Y plot while `rowsY` is set, else `rowsColor`. Every painter, the key and the export branch on it.
basesRenderingActive `boolean`	The cells are drawn base by base, so the letters, the insertion markers and the deletion counts draw over them. Not on the summary tier, whose rows are the summary bars.
identityEncoding `IdentityEncoding \| undefined`	How identity draws now: the heatmap's cells, the X-Y plot's bars in one color, or its bars on the ramp where `color` is identity too.
visibleLabels `VisibleLabel[]`	Positioned per-base letters, over the bases only.
visibleDeletions `DeletionMarker[]`	Positioned deletion runs, labelled with their length where it fits. Only the bases paint the gap cells the count is colored against.
summaryDataMap `ReadonlyMap<number, MafSummaryRecord[]>`	The summary records each region's rows draw as per-species presence bars, keyed by displayedRegionIndex. Drawn on the summary tier and as the stand-in for a region whose detail tier has not landed, so zooming in past the floor does not blank the track. Suppressed per region, since tiers arrive per region; `coarseTierActive` short-circuits it because both maps hold a region side by side.
visibleFrames `FrameMarker[]`	Positioned per-species CDS frame boxes for the annotation overlay. Empty unless an annotation adapter is configured and the overlay is on. Reuses the `src`-to-row mapping of the summary bars.
codonCellsActive `boolean`	The codon overlay is what the rows area is painting.
codonConservationActive `boolean`	The conservation band is in per-codon (amino-acid identity) mode, with frames to define codons and per-base blocks to translate — the cheap summary path ships neither.
sourceChromRanks `{ ranks: Map<number, Map<string, number>>; maxRank: number; }`	Each row's source chromosomes ranked by aligned bp over the loaded regions, so a pan within loaded data keeps every block's color. Empty unless the rows are colored by chromosome.
bandLabels `{ text: string; top: number; }[]`	Titles for the stacked bands, with the y they sit at; empty unless both bands draw. The on-screen labels and the SVG export both read it. The conservation title names what the band draws (`codonConservationActive`), not the mode asked for.
colorScales `ColorScale[]`	`LegendMixin`'s hook: the key for whatever `activeRowRendering` paints, then the CDS frame key while the strip draws, then the row color key. Each key is built by the module that paints the rendering, so the swatches match the screen.
hasLegendKey `boolean`	Whether this display has a color key, as opposed to whether one is drawn now: the question "Show legend" is offered on. Bases key nothing; every other rendering keys what it paints. Overrides `LegendMixin`'s, whose scale reads decline on an uninitialized view and would drop the row while a track loads.
rowsSources `ReadonlyMap<number, MafRowsSource>`	Each region's detail and summary tiers, paired: what its rows draw from. A pair keeps its identity while neither tier moved.
encodedUpload `ReadonlyMap<number, MafUploadPayload>`	Every loaded region's upload payload, the rows band's `span` channels beside the coverage band's buffers, keyed by displayedRegionIndex. Held here rather than in the upload's setup thunk so a theme or color change re-encodes without an RPC roundtrip and the memo outlives a context-loss recovery.
visibleCodonGlyphs `CodonGlyph[]`	The amino-acid letters over the codon view's cells.
gateEnabled `boolean`	Enables byte-estimate gating: a MAF-aware estimate (per-species sequence x span) is checked against `fetchSizeLimit` inside the tier's own RPC, blocking the fetch with a force-load prompt. On for both tiers: each RPC measures the file it reads, the alignment index on detail and the `summaryAdapter` sub-adapter on summary (`CoarseTierMixin`), since the summary read is a whole-feature download over every zoom from 20kb up.

125 inherited getters from 11 models

From BaseDisplay: parentTrack, RenderingComponent, DisplayBlurb, adapterConfig, isMinimized, hoveredFeature, featureNoun, featureWidgetType, plotKeys, plot, plotExamples, configDocsUrl

From TrackHeightMixin: configuredHeight, allottedHeight, resizing, scrollableHeight

From MultiRegionDisplayMixin: host, canvasWidthPx, settledSubPixelBinBp, canRender, rendersCanvas, trackVisibleRegions, viewportWithinLoadedData, viewportEmpty, fetchSuspended, layoutReady, dataSuperseded, renderBlocks, fetchInputs, regionPayloads, hasRegionData, staleSettingsDrawn, dataCurrent, loadedAssembly, phaseViewportCurrent, svgReady, paintInert, paintSuperseded, displayPhase

From RegionTooLargeMixin: byteGateAdapterConfig, configuredFetchSizeLimit, densityTooLarge, byteGateAdapterPath, adapterFetchSizeLimit, configForceLoad, gateViewportSpanBp, gateViewport, aboveForceLoadFloor, gateExempt, estimatedFetchBytes, gateMeasurementStale, gateByteLimit, gateActive, densityGateActive, tooLargeStatus, regionTooLarge, regionTooLargeReason, zoomCanReleaseGate, gateSkipsMeasuredViewport

From RenderLifecycleMixin: painted

From FetchMixin: isLoading, isLoadingOrCanceled, fetchInert, awaitingPrerequisite, awaitingDependentData, settingsFetchInputs

From CoarseTierMixin: coarseSourceConfig, hasCoarseSource, coarseTierActive, coarseTierStandsIn, coarseTierIssueKey

From LegendMixin: showLegend, legendTop, legendRight, legendSpec

From ColorWritesMixin: writtenColor

From RowHeightMixin: rowHeight, effectiveRowHeight

From TreeSidebarMixin: showTree, showBranchLength, showRowLabels, treeAreaWidth, rowDomain, rowLabels, rowTreeProvenance, rowFocus, rowColorSetting, baseRowColor, baseRowDomain, unlistedRowsSort, rowBanding, rowFocusLineHeight, rowsTopOffset, guideTree, guideTreeHonoursDomain, rowTree, expandedRows, sharesPanel, rowColorPaintsMarks, rowNoun, internalRowFields, rowBandingNotices, rowPaletteDeals, rowColorDealRows, rowStylingIsCustom, rowColorChoice, rowColorAttribute, dealtRowColors, rowColorAttributesOffered, resolvedRowColors, rowArrangementIsCustom, editableSources, rowColorKeyInputs, rowColorScales, parsedTree, root, bandedRows, bandedSources, rowBands, rowsContentHeight, hierarchy, spatialIndex, clusterPartition, treelessBandCount, treeHasBranchLengths

Methods

Member	Description
contextMenuItems `() => MenuItem[]`	Items for the right-click menu, built from the column the click landed on. Captured when the menu opens, since `closeContextMenu` runs before an item's onClick.
rowGeometry `() => MafRowGeometryParams`	Where the rows sit on screen: the resolved row height plus the scroll offset and viewport. Every rows layer reads this one method, so no layer draws from the raw `rowHeight` sentinel or omits the scroll offset.
rpcProps `() => { rowFocus: string[] \| undefined; }`	The fetch inputs both tiers send through `rpcArgs` and cache under. The focus is a row set since the worker ships only those genomes; the row order is not, since the client places the rows. Nothing fetch-derived goes here (`singleFetchPerRegion.test.ts`).
rowNavigationTargets `(displayedRegionIndex: number, startBp: number, endBp: number, startRow: number, endRow: number) => (RowSpan & { assemblyName: string; assemblyConfigLocation?: UriLocation \| undefined; sampleLabel: string; rowIndex: number; })[]`	Where the rows `[startRow, endRow)` sit in their own genomes across the reference bp range `[startBp, endBp)`, the loci an "open this species here" navigation targets. A row contributes nothing with no aligned base in the range, no fetched block covering it, or a genome not loaded as an assembly (`Sample.assemblyName` unset). Takes the whole row range at once, since the menu builds an entry per row on every open.
frameHoverInfo `(displayedRegionIndex: number, bp: number, rowIndex: number) => { name: string; } \| undefined`	The CDS frame record covering absolute genomic `bp` (uint32) on display `rowIndex`, or undefined. Gated on `framesInUse`, so the gene name reads on hover in codon view with the strip off. `bp` is a base index (`MafPointer.baseBp`), not a floored `gposFrac`, matching the row hover and coverage tooltip on a reversed region.
coverageBandHit `(displayedRegionIndex: number, x: number, y: number) => CoverageBandHit \| undefined`	The interbase bar or indicator triangle under a canvas point in the coverage band, through the shared band's own hit test, or undefined for the depth area and everywhere else.
coverageTooltipBin (displayedRegionIndex: number, basePos: number, bpPerPx: number, reversed?: boolean) => { identity: number; position: number; depth: number; fwdDepth?: number \| undefined; revDepth?: number \| undefined; interbaseDepth: number; snps: Record<…>; deletions?: { count: number; minLen: number; maxLen: number; avgLen: number; } \| undefined; interbase: Record<…>; modifications?: { count: number; fwd: number; rev: number; probabilityTotal: number; color: string; name: string; }[] \| undefined; } \| undefined	The depth and SNP tooltip bin at the base under the cursor, with the percent identity at that position. Undefined when the region has no fetched data or depth is zero.
interbaseTooltipBin `(displayedRegionIndex: number, position: number) => { interbase: Record<string, { count: number; minLen: number; maxLen: number; avgLen: number; topSeq?: string \| undefined; topSeqCount?: number \| undefined; }>; interbaseDepth: number; } \| undefined`	The insertions at a band boundary the hit test named, summarized the way the alignments band summarizes its interbase events.
rowHoverInfo `(displayedRegionIndex: number, bp: HoverBp, rowIndex: number, bpPerPx: number) => {…} \| { sampleLabel: string; kind: "insertion"; length: number; sequence: string; chr?: string \| undefined; pos?: number \| undefined; strand?: number \| undefined; } \| { sampleLabel: string; kind: "deletion"; length: number; } \| { sampleLabel: string; kind: "empty"; status: MafStatus; chr: string; srcStart: number; size: number; strand: number; } \| undefined`	The hover on `rowIndex` at the cursor's genomic position: an aligned base, an insertion, a deletion or a bridged region, tagged with the sample label. `bp` carries both readings of the cursor (`HoverBp`), which differ on a reversed region.
identityHoverInfo `(displayedRegionIndex: number, bp: number, rowIndex: number) => { identity: number; bases: number; } \| undefined`	The mean identity of the window a heatmap cell or X-Y bar paints at base `bp` on `rowIndex`, and how many bases it averages, while identity draws.
colorScalesIn `(palette: JBrowsePalette) => ColorScale[]`	`colorScales` in another theme: the SVG export's, whose codon and CDS-frame swatches follow it.
trackMenuItems `() => MenuItem[]`
rowsEncodePropsIn `(colorPalette: MafColorPalette) => MafRowsEncodeProps`	What a region's rows encode reads beyond the region, in a given palette, since the SVG export's theme need not be the session's. A mode flip lives here so it re-encodes every region as a declared input.
rowsEncodeProps `() => MafRowsEncodeProps`	`rowsEncodePropsIn` in the session's palette, for the on-screen encode.
codonHoverInfo `(displayedRegionIndex: number, bp: number, rowIndex: number) => CodonHit \| undefined`	The codon under the cursor on `rowIndex` at base `bp`, while the codon view draws, from the codons its cells were encoded from.
summaryHoverInfo `(rowIndex: number, x: number) => MafSummaryRecord \| undefined`	The summary record whose bar is drawn at canvas x `x` on display row `rowIndex`, or undefined: the hover on the summary tier.

16 inherited methods from 5 models

From BaseDisplay: renderingProps, liftPlot, plotProblems, plotWrites

From MultiRegionDisplayMixin: regionHasData, isCacheValid

From RegionTooLargeMixin: resolvedByteLimit, gateFetchState

From LegendMixin: svgLegendWidth, legendSpecIn

From TreeSidebarMixin: expandRows, svgSidebarWidth, rowBand, dealtRowColorsFor, rowColorFor, rowOrderWillDropTree

Actions

Member	Description
setRowProportion `(n: number) => void`
setShowAllLetters `(f: boolean) => void`
setSamples `({ samples, treeNewick, samplesCanonical, }: { samples: Sample[]; treeNewick: string \| undefined; samplesCanonical: boolean; }) => void`	Receive the worker's `samples` and serialized Newick tree. `samplesCanonical` marks the set authoritative (config- or tree-derived), so it replaces the rows. A discovery set names only the genomes its region's blocks hold, so it unions into the known rows (`unionSources`). The deepEqual guard covers the sample set only; a tree can change while the set does not.
setShowAsUpperCase `(arg: boolean) => void`
setShowCoverage `(arg: boolean) => void`
setShowAlignments `(arg: boolean) => void`
setShowConservation `(arg: boolean) => void`
setConservationMode `(arg: "base" \| "codon") => void`
setYField `(field: "identity" \| undefined) => void`
setRowIdentityAutoZoom `(arg: boolean) => void`
setShowAnnotations `(arg: boolean) => void`
setShowInversions `(arg: boolean) => void`
setShowReferenceRow `(arg: boolean) => void`
setFitToHeight `() => void`	Switch to fit-to-height mode: rows stretch to fill the track height. Seeds the `height` slot from the current content height so toggling on does not jump.
resizeCoverageHeight `(distance: number) => void`	Apply one drag delta to the coverage band. Reads the current height inside the action because `ResizeHandle` emits one delta per animation frame. Mirrors `resizeHeight`.
resizeConservationHeight `(distance: number) => void`	Per-frame drag delta for the conservation band — see `resizeCoverageHeight` for why this reads the height itself.
sortRowsByBaseAt `(refName: string, pos: number) => boolean`	Reorder the rows by the base each species carries in the reference column at (refName, pos), writing the order to `rows.domain` as clustering and the arrangement dialog do, so "Reset row order" undoes all three. Declines with fewer than two rows or at a column no loaded region covers; `sortRowsAtColumn` owns both gates and the returned "did it sort".
setRowRendering `(rendering: RowRendering) => void`	Write a Row coloring pick: its color field and bar height.
setRefSampleId `(id: string \| undefined) => void`	The reference row the last detail batch named — see `refSampleIdVolatile`. Written beside `setSamples` in the batch commit, so a stale batch names nothing.
setFramesGateBlocked `(blocked: boolean) => void`	Record whether the last frames read was declined as over budget. Set both ways by every fetch pass that reaches the annotation adapter, so zooming back in clears it without anything else having to.
clearDisplaySpecificData `() => void`	Clears the verdict with the data: it describes a read of the viewport just thrown away, and chromosome nav would otherwise carry "too much data" onto an unmeasured region.
startRenderingBackend `(backend: MafRenderingBackend) => void`
fetchNeeded `(needed: IndexedRegion[]) => Promise<void>`	The detail fetch. The summary tier's is `fetchCoarseTier` below, and `CoarseTierMixin` suspends this one while the tier is up.
fetchCoarseTier `(read: CoarseTierRead, ctx: FetchContext) => Promise<CoarseTierResult<MafRegionPayload<MafSummaryRecord[]>>>`
renderSvg `(opts: ExportSvgDisplayOptions) => Promise<ReactElement<unknown, string \| JSXElementConstructor<any>> \| Iterable<ReactNode> \| AwaitedReactNode>`	Dynamic import so the export path — and everything it pulls in — stays out of the bundle until someone actually exports.