LinearAlignmentsDisplay

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

Example usage

The display goes in a track's displays array; here are three complete AlignmentsTrack configs to paste into tracks.

Basic BAM, opened taller:

{
  type: 'AlignmentsTrack',
  trackId: 'ngs_reads',
  name: 'NGS reads',
  assemblyNames: ['hg38'],
  adapter: { type: 'BamAdapter', uri: 'https://example.com/sample.bam' },
  displays: [
    {
      type: 'LinearAlignmentsDisplay',
      displayId: 'ngs_reads-LinearAlignmentsDisplay',
      height: 250,
    },
  ],
}

CRAM colored by CpG methylation (modBAM MM/ML tags):

{
  type: 'AlignmentsTrack',
  trackId: 'methylation',
  name: 'Methylation',
  assemblyNames: ['hg38'],
  adapter: { type: 'CramAdapter', uri: 'https://example.com/sample.cram' },
  displays: [
    {
      type: 'LinearAlignmentsDisplay',
      displayId: 'methylation-LinearAlignmentsDisplay',
      baseColor: 'modifications',
      modifications: { unmodified: 'all' },
    },
  ],
}

Long reads with split/mate reads connected by arcs:

{
  type: 'AlignmentsTrack',
  trackId: 'long_reads',
  name: 'Long reads',
  assemblyNames: ['hg38'],
  adapter: { type: 'BamAdapter', uri: 'https://example.com/longreads.bam' },
  displays: [
    {
      type: 'LinearAlignmentsDisplay',
      displayId: 'long_reads-LinearAlignmentsDisplay',
      height: 400,
      unit: 'chain',
      readConnections: 'arc',
    },
  ],
}

State model factory for LinearAlignmentsDisplay

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('LinearAlignmentsDisplay')`
configuration `configuration: ConfigurationReference(configSchema)`

1 inherited property from one model

From BaseDisplay: id

Volatiles

Member	Description
featureIdUnderMouse `string \| undefined`
mouseoverExtraInformation `TooltipPayload \| undefined`
contextMenuFeature `Feature \| undefined`
collapsedGroups `ObservableSet<string>`	Group keys whose pileup is collapsed to its coverage band, dropped when `groupKeySpace` moves (`dropGroupState`).
groupMaxHeightOverrides `ObservableMap<string, number>`	Per-group pileup height override in px, keyed by group key and dropped with `collapsedGroups`. Absent keys fall back to the display-wide `maxHeight`.
fittedHeightPx `number`	Fitted read pitch in px, written by the afterAttach autorun while `fitHeightToDisplay` is on; 0 until computed. A volatile rather than a getter because it breaks the cycle between `featureHeight` and the layout.
highlightedChainReadIds `string[]`	Read ids of the chain under the cursor — NOT chain ids; see `readIdsByChainName`, which is where they come from.
hoveredJunction `LaneJunction \| undefined`	The sashimi junction under the cursor, whose supporting reads the hover lights.
overCigarItem `boolean`
hoverCoverageBand `HoverCoverageBand \| undefined`	Screen-px coverage band of the section under a coverage/indicator hover; the tooltip's vertical hover bar lands on it. `undefined` when not hovering.
hoveredArcHighlight `ArcHighlight \| undefined`	The read-connection arc under the cursor, as the ink `ArcHoverOverlay` draws. A snapshot from the mousemove that found the arc, like its tooltip.

25 inherited volatiles from 9 models

From BaseDisplay: error, statusMessage, statusProgress

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 ScoreScaleMixin: unclippedQuantile

From LegendMixin: dismissedLegendSections

From ContextMenuMixin: contextMenuInfo

Getters

Member	Description
unit `"chain" \| "read"`
showBezierConnections `boolean`
showCoverage `boolean`
showPileup `boolean`
coverageHeight `number`
coverageSnpMinFrequency `number`
showMismatches `boolean`
showInterbaseIndicators `boolean`
showInterchrom `boolean`
showOrdinaryPairs `boolean`	Whether the band draws its ordinary pairs: the arcs' concordant ones (`isConcordantPairRead`, whose failure on a paired primary read is `filter.svSignal`'s discordant clause) and the cloud's modal-insert ones. Unset, arcs keep them and the cloud drops them.
minInterchromSupport `number`	Reads a translocation must gather, within one fragment length on both sides, before its connector ticks are drawn. See `clusteredInterchromSupport` — the count is over a window because a mate-pair breakpoint is not localized to a base.
showLongRange `boolean`
readConnections `"arc" \| "cloud" \| "off"`
readConnectionsDown `boolean`
showSashimiArcs `boolean`	Whether sashimi arcs draw: the slot, and the coverage band they hang off.
sashimiArcsMode `"auto" \| "down" \| "up"`
minSashimiScore `number`
sashimiArcsHeight `number`
readConnectionsHeight `number`
showSoftClipping `boolean`
colorSetting `AlignmentsColorSetting`
colorEncoding `string \| FieldColorEncoding \| undefined`	`colorSetting` as it paints, through the one resolver every display's color object goes through.
colorLabels `readonly string[]`	`color.labels` as written, read apart from `colorSetting`, which every color tier keys on, so renaming a key entry re-bakes no read.
colorTitle `string \| undefined`	`color.title` as written: unset keeps the key's own heading, `''` draws none.
colorKeyTitle `string \| undefined`	The key's heading: `color.title` as written, else its field preset's while the color paints through the preset, so `{ field: 'mapq' }` keys as "Mapping quality". Unset keeps the key's own heading.
colorKeyDescending `boolean \| undefined`	`color.descending` as written, else its field preset's while the color paints through the preset, so `{ field: 'mapq' }` keys 30+ first. Read apart from `colorSetting`, so turning the key round re-bakes no read.
colorNotices `string[]`	What the `color` object's slots say together that it cannot paint as written, which the corner notice lists.
facetNotices `string[]`	What `facet` names that `unit` cannot group by, which the corner notice lists.
pinnedInsertSizeBand `{ lower: number; upper: number; } \| undefined`	The short/long cut points `color.domain` pins under an insert-size field, undefined while the sampled band decides. Compared by value, so a color write that leaves the cut points alone relayouts nothing.
modificationSettings `ModificationColorBy`
colorBy `ReadColorBy`	The read fill `color` selects.
colorField `string`	The field the read fill paints by, `''` for the plain fill.
arcColorField `"insertSize" \| "insertSizeAndOrientation" \| "pairOrientation"`	The field the arcs and the read cloud paint: `arcColor`'s own, or the reads' where `arcColor` names none.
baseLayer `BaseLayer \| undefined`	The per-base layer `baseColor` selects, with the settings the modification fields read beside it; undefined while none is drawn.
bodyColorScheme `ColorSchemeType`	What the read body paints as: `colorBy`, or the modification layer's own pale strand tint while the fill is plain.
readFilter `ReadFilter`
configuredFeatureHeight `number`
maxHeight `number`
showSashimiLabels `boolean`	Whether to draw the supporting-read count on each sashimi arc.
showNonCanonicalJunctions `boolean`	Whether junctions with a non-canonical splice motif are dropped from the sashimi arcs.
fadeLowFrequencyMismatches `boolean`
fadeLowQualityMismatches `boolean`
layoutOrder `"length" \| "position" \| "spliced" \| "split" \| "svSignal"`	The whole-window row order: `sort`'s type, or `position` under a column sort, which lays the reads off its column out by start (a tier-2 relayout).
facet `Facet \| undefined`	The `facet` object as written, undefined while ungrouped. The worker partitions one fetch into a section per value of its field.
readConnectionsLineWidth `number`
rpcDataMap `ReadonlyMap<number, GroupedAlignmentsResult>`	Region index → grouped worker result. Ungrouped fetches store one group (key '').
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<…>
showLinkedReadLines `boolean`	Whether the straight-line pass connects normal read pairs. Chain layout has its own pass for them. Neither pass reaches across regions; that is `bezierArcScope`'s `crossRegion`.
bezierArcScope `BezierArcScope`	What the SVG connection overlay draws — see `BezierArcScope`. Chain mode claims `crossRegion` even with the curved connectors off: only that pass joins a chain's ends across displayed regions.
featureWidgetType `{ type: string; id: string; }`
selectedFeatureId `string \| undefined`
TooltipComponent `LazyExoticComponent<({ model, mouseState, }: { model: { mouseoverExtraInformation: TooltipPayload \| undefined; hoverCoverageBand: { topOffset: number; coverageHeight: number; } \| undefined; colorPalette: ColorPalette; showModifications: boolean; }; mouseState: MouseState \| undefined; }) => Element \| null>`
detectedModifications `ReadonlyMap<string, string>`	Modification type code -> painted color, for every type the loaded reads declare. Off `rpcDataMap`, not the laid-out map, so a hidden group's types stay offered; the legend asks `presentModifications` instead.
modificationsReady `boolean`	Whether a fetch has landed, so an empty `detectedModifications` means these reads carry none. The modifications menu shows "Loading modifications..." until it turns true.
detectedModificationTypes `string[]`
isFitting `boolean`	Fit-to-display mode is on and a pitch has been computed (`fittedHeightPx > 0`). Both size getters read this gate.
featureHeight `number`	The read body height: the fitted pitch minus `featureSpacing` in fit mode, else `configuredFeatureHeight`, which is what editors that write the size read.
featureSpacing `number`	Derived from the read height, never stored: a 1px gap once there is room (pitch/height > 3), else flush. One rule covers the fixed presets and the fit squeeze.
rowHeight `number`	The per-row pitch: read body plus derived gap. Every "row N sits at N*pitch" computation reads it.
sortColumn `SortColumn \| undefined`	The column sort `sort` names, or undefined under a whole-window order. Normalizes the refName, since a spec can write an alias (`chr1` for `1`) that `sortLayout`'s gate would never match. A column type missing `refName` or `pos` reads as no sort.
effectiveFacet `Facet \| undefined`	The facet the fetch partitions by. Chain mode turns a per-read dimension into ungrouped without changing the slot, so the slot alone does not determine which sections come back.
groupKeySpace `string`	Identity of the key space the fetched group keys live in, and so of every collection this model keys by group key — see `groupKeySpaceOf`.
prefersOffset `boolean`	Whether the grouping will be HONORED, decidable from settings alone since chain mode drops a per-read dimension (`facetForUnit`). Positions the track label, which is placed before data arrives and must not jump afterwards.
collapseGroupRows `boolean`	Whether each group draws as one row, overlap depth carried by the tint layer — the collapse IN EFFECT. Reads `canCollapseGroupRows`, not the slot alone: a config default can be ticked where collapsing is inert.
canCollapseGroupRows `boolean`	Whether collapsing can take effect, so whether the "Show..." menu offers the toggle. Chain mode never collapses (`collapsesRows`). The menu omits the row rather than disabling it: a click would write a slot no getter reads.
sortReadsBlockedReason `string \| undefined`	Why an explicit read ordering cannot take effect, or `undefined`: one value carries both the gate and the copy naming the switch that brings it back. Chain layout takes no `sort`; its rows are chains.
canSortReads `boolean`	Whether an explicit read ordering can take effect. The track menu's "Sort by..." and the context menu's position-anchored sorts both read it.
canSizeGroupHeights `boolean`	Whether a single group's pileup height can be set on its own, offered by the label chip's expand/fit button and the per-group drag handles. Fit mode refuses: an override there opts a lane out of the fit and overflows the display.
groupHeightOverrides `ReadonlyMap<string, number>`	The per-lane height overrides IN EFFECT, not the set banked. Fit solves one pitch from every lane's full row count, so fit mode ignores the overrides without dropping them; returning to fixed restores them.
coverageScaleType `ScaleTypeCode`
autoscaleRange `[number, number] \| undefined`	The depth every SHOWN group spans, so stacked sections share a scale; hidden lanes are excluded.
defaultScoreDomain `[number \| undefined, number \| undefined]`	Depth has a floor of 0 while the axis reaches it, so an unpinned bottom stays there whatever a rule below it asks for; with `scales.y.zero` off it spans the depths in view.
coverageDomain `[number, number] \| undefined`	The autoscaled depth domain. Undefined until some region holds one.
coverageDepthDomain `[number, number] \| undefined`	The domain the coverage band draws against: `coverageDomain` with a log scale's floor pulled up to one read (see `coverageDepthDomain`). Every consumer reads this one — the y-axis ticks and both renderers' normalizers.
coverageTicks `YScaleTicks \| undefined`	The coverage band's own ladder (`computeCoverageTicks`), which `valueScales` hands the chrome in place of the mixin's. Takes the raw `scales.y.symlogConstant`, resolved from the same domain as `renderState`, so the labels sit on the bars.
colorLegendCategories `Set<ReadColorCategory>`	Read-color buckets present across the rendered reads, so the legend lists only relevant swatches. Empty while the legend is hidden, skipping the O(reads) scan.
presentTagValues `ReadonlySet<string> \| undefined`	The per-read values the CPU-baked schemes painted in the rendered reads (tag values, or mate refNames under chromosome painting). `undefined` for other schemes, and the legend then does not filter; the empty set means none are on screen. Gated on showLegend: O(reads).
presentModifications `ReadonlySet<string> \| undefined`	The modification types drawn in the rendered reads. Read from `modificationTypes`, which the worker builds from the drawn marks; `detectedModifications` includes hidden lanes. The legend's bisulfite branch runs before this filter, since the two differ there. `undefined` outside the modification schemes.
colorPalette `ColorPalette`	Derived from the session theme, so headless SVG export and RPC have it without a mounted component.
declaredReadLabels `DeclaredReadLabels`	`color.labels` against the read buckets and values it names, which every key row, hover and connection curve names a bucket by.
arcLegendCategories `Set<ArcCategory>`	The arc color slots plotted, mapped to legend buckets, for curved arcs and the read cloud alike: both paint `arcColorField`, which follows the reads only where they paint a pair field. Empty unless an overlay is on with the legend shown.
overlapLegendKind `"chain" \| "collapsed" \| undefined`	Which overlap mark the legend row names, undefined when none. The row needs the pass to be DRAWING (`shouldDrawOverlaps`, shared with both renderers) and some region to hold an interval, so no row explains an off-screen mark. O(regions).
keySectionOrder `((a: string, b: string) => number) \| undefined`	The sections' order, where the facet reads the field the reads are colored by: a key over one field lists it as the sections stack. Not over `mapq`, whose sections are bins and whose key is its bins or its raw values.
arcLegendTitle `"Arc colors" \| "Read cloud colors"`	Heading for the overlay's own color key, named after the overlay the reader is looking at: flat read-cloud lines are not arcs.
sashimiDownKeysByGroup `Map<string, ReadonlySet<string>>`	Per group, which junctions draw in the strip below coverage (by `junctionKey`): the one sashimi side decision, read by `sashimiDownArcLanes` to reserve the strip and `sashimiFeedsByGroup` to place each arc. refNames come from `loadedRegions`, keeping this a tier-1 (fetch) derivation. A region not yet loaded gets a unique key, so regions not proven to share a chromosome never pool onto one bp line.
sashimiDownArcLanes `Set<string>`	Group keys whose junctions land in the strip below coverage, i.e. the lanes that strip is reserved for.
resizableBandBounds `{ max: number; }`	The ceiling of the three bands stacked over the pileup, which the resize handles drag against and `bandHeights` draws within. Leaves the pileup a row. Reads `fitTargetHeight`, not `height`, which derives from the layout these heights feed in grow mode.
bandHeights `{ coverageHeight: number; readConnectionsHeight: number; sashimiArcsHeight: number; }`	The three band heights as every consumer draws them: the slots bound to `resizableBandBounds`, since a config or a session snapshot states a height no drag clamped.
belowCoverageBandsSettings `BelowCoverageBandsSettings`	The settings half of the below-coverage band geometry: whether each strip MAY be reserved and how tall, with neither data half answered.
belowCoverageBandsInput `{ hasArcs: boolean; hasSashimiDownArcs: boolean; showCoverage: boolean; coverageHeight: number; readConnections: "arc" \| "cloud" \| "off"; readConnectionsDown: boolean; showSashimiArcs: boolean; sashimiArcsHeight: number; readConnectionsHeight: number; }`	Inputs to `belowCoverageBandsGeometry`: the settings above plus whether ANY lane has arcs or a sashimi junction bound for its strip. Pooled over the lanes, so it is the ungrouped answer; the grouped stack's total is `totalBandOverhead`.
totalBandOverhead `number`	The height the below-coverage strips take from the fit-to-viewport row budget: the bands reserved in every lane, summed as `computeStackedSections` reserves them. Fetch-tier inputs only, so the layout reads it without a cycle.
groupRowCaps `ReadonlyMap<string, RowCap>`	The height overrides as row caps, keyed by lane — the layout's input. Keeps its identity while the caps compare equal, so a drag frame that moves no cap relays no read and re-bakes no color.
fitDefaultCap `RowCap`	The cap a lane on the shared fit budget lays out to: its slice of the viewport when grouped, the display-wide ceiling when not, with the policy that set it (a clipped lane reports it as `clippedBy`). Keeps its identity like `groupRowCaps`: its inputs move a px at a time, it moves a row at a time. Grow mode fits to the grow ceiling, fixed/fit to the drag-resizable slot; both read config slots, never the `height` getter, so grow's height → layout chain cannot cycle.
resolvedFitDefaultCap `RowCap`	`fitDefaultCap` recomputed, without the identity it keeps.
fitRows `number`	How many rows the uncollapsed groups need, laid out uncapped. Reads the overlaps and the ceiling only, so a fit drag leaves it alone.
fitCeilingRows `number`	The `maxHeight` ceiling in rows. While fitting it is clamped to the rows the pileup needs, so the quotient holds steady across drag frames and the layout does not re-place every row.
laidOutByGroupUncolored `LaidOutByGroup`	Per-group laid-out data: group key → (region index → laid-out data). Each group lays out independently under its own cap, so a dense group cannot starve the rest. Rows only; the per-read color arrays bake one computed later, in `laidOutByGroup`.
framesChainStrand `boolean`	Whether the unpaired chain-strand framing is on: the one answer the consensus pass, the bake (`readColorOpts`) and the key read. A boolean in its own computed, so a scheme switch that leaves the answer alone does not re-run the frame solve.
laidOutByGroupFramed `LaidOutByGroup`	The laid-out data with every chain's strand frame settled — see `applyChainStrandFrames`.
laidOutByGroupColored `ColoredByGroup`	Per-group laid-out data with the per-read color arrays baked on. Nothing in `readColorContext` moves a read's row, so a recolor keeps the layout memoized and `readYs` keeps its identity: the GPU upload memo checks `readYs` to rewrite only the read pass. Tag colors bake here, not in the worker, so tag coloring stays a main-thread tier-2 setting.
laidOutByGroup `ColoredByGroup`	`laidOutByGroupColored` with the straight-line pass's records spread on, so a curved-connector toggle re-spreads the lines and keeps both the layout and the colors.
connectorsByGroup `Map<string, GroupConnectors>`	Every read connector per group, from one walk of its reads: the straight-line pass's records and the pairs the connector mark draws. Reads the layout tier, so a band resize, height drag or recolor reuses them.
groupLayoutContext `{ order: GroupId[]; rawByGroup: ReadonlyMap<string, ReadonlyMap<number, ChainedPileupData>>; unit: "chain" \| "read"; sortColumn: SortColumn \| undefined; showSoftClipping: boolean; layoutOrder: "length" \| "position" \| "spliced" \| "split" \| "svSignal"; regions: ObservableMap<number, LoadedRegion>; collapseGroupRows: boolean; }`	The layout mechanics (grouping, sort, soft-clip) shared by the viewport fit pass and ad-hoc layouts such as `fittedFeatureHeight`. Excludes the fit policy (row caps) and the color inputs, which invalidate a later tier.
readColorContext `{ colorBy: ReadColorBy; bodyScheme: ColorSchemeType; readColorOpts: { chainMode: boolean; framesChainStrand: boolean; }; bakedScale: BakedColorScale \| undefined; }`	The per-read color bake's inputs, kept out of `groupLayoutContext` so a recolor never relays.
bakedColorExtent `NumericExtent \| undefined`	The span of a linear color field over the loaded reads, which a ramp's open ends stretch across: their extremes, or below a `domainQuantile` of 1 that quantile of each sign. Undefined while `domainMin` and `domainMax` both pin the ramp or another scale paints, so a region arriving rebakes nothing then.
tagValueExtent `NumericExtent \| undefined`	`linearFieldExtent` over the loaded reads
baseQualitySpan `QualitySpan`	The span of the base qualities drawn, and whether a base carries none. O(bases), so gated on showLegend like the category scan.
bakedColorScale `BakedColorScale \| undefined`	The scale a tag, attribute or mate reference bakes through, read by the per-read bake and the key alike. Undefined for the fields the category table paints.
paintedRefNamePosition `((refName: string) => number \| undefined) \| undefined`	Where a mate's reference sits in this assembly's own chromosome order, for chromosome painting — the same `Assembly.getRefNamePosition` the comparative displays paint by. From the ASSEMBLY, not the reads on screen, so a color never changes with what else is in view. Undefined under every other scheme and until the assembly initializes.
readColorOpts `{ chainMode: boolean; framesChainStrand: boolean; }`	The non-scheme inputs to read classification, with the framing as `framesChainStrand` answered it, so the bake frames exactly where the consensus pass ran and the key words it.
groupOrder `GroupId[]`	Group keys + labels in stacking order; one entry (key '') when ungrouped. Derived from the fetched `rpcDataMap`, not the layout pass, so group identity and order stay stable across relayouts.
notices `string[]`	What the `color`, `facet` and `scales.y` slots say that the display cannot draw as written, for the corner notice, and a facet field no fetched read answers.
showsGroupLabels `boolean`	Whether the stacked section labels and dividers are drawn. Not `isGrouped`: grouping that yields one section still reserves the label offset (`prefersOffset`) and wants its section named and collapsible. Reads the fetched sections, not `facet` — see `hasNamedGroups`.
rawDataByGroup `Map<string, Map<number, WorkerPileupData>>`	Raw (un-laid-out) data regrouped as group key → (region idx → data), insertion-ordered so the first key is the primary group; ungrouped is the single key `''`. Hidden lanes are already gone, like `groupOrder`, so a walk of every entry is a walk of every DRAWN lane. See `buildRawDataByGroup`.
chainAttachment `ChainedByGroup \| undefined`	`rawDataByGroup` with chain identity joined across every region and lane (`attachChainFields`), in chain mode only. The worker knows no chains, so toggling the mode is this getter changing, not a fetch.
chainedByGroup `ReadonlyMap<string, ReadonlyMap<number, ChainedPileupData>>`	The layout's input: `chainAttachment` in chain mode, else the fetched data. `rawDataByGroup` stays chain-free, so the arcs, sashimi, coverage and a split view overlaying this display do not recompute on the toggle.
readIdsByChainName `ReadonlyMap<string, string[]>`	Chain name → the ids of the READS in it; empty outside chain mode. The key is a chain's own identity and the values are read ids, which consumers resolve through `readIdToIndex` / `readIdIndexMap` (hence `highlightedChainReadIds`, `selectedChainReadIds`).
loadedRegionInfos `{ refName: string; start: number; end: number; displayedRegionIndex: number; }[]`	The fetched regions as `{refName,start,end,displayedRegionIndex}`, the shape every per-read region scan takes (`computeArcsByGroup`). Regions whose fetch has not landed are dropped.
displayedRegionInfos `{ refName: string; start: number; end: number; displayedRegionIndex: number; }[]`	The VIEW's displayed regions in the same shape: not "where did reads come from" but "where can a coordinate be drawn". The arc partition (`CrossRegionArc`) keys on this list, since `view.bpToPx` projects through `displayedRegions` (see `ArcRegions`). `displayedRegions` changes on navigation, not on pan, so `arcsByGroup` keeps its fetch invalidation tier.
canonicalRefName `((refName: string) => string) \| undefined`	Normalizer for a refName in the BAM's own spelling (an SA tag's or RNEXT's `chr1`) rather than the assembly-canonical one a fetched read carries (`1`). Undefined when no assembly is resolved, where consumers fall back to identity. Without it a same-chromosome split junction reads as inter-chromosomal.
arcsResult `ArcsByGroupResult`	THE arc resolution: both halves from one pass, read through `arcsByGroup` (arcs inside one region) or `crossRegionArcsByGroup` (arcs joining two). `computeArcsByGroup` owns the whole fan-out because the pooled arc scale (`poolArcScale`) describes the fetch, not a lane. Hidden lanes must stay out: the cross-group scans (`arcsYDomainBp`, `arcLegendCategories`) walk every entry.
arcsByGroup `Map<string, Map<number, ArcsUploadData>>`	Each group's arcs and ticks by loaded region, every arc filed under the one region holding a foot.
crossRegionArcsByGroup `Map<string, CrossRegionArc[]>`	Arcs whose two feet are in different displayed regions, per group. Empty in a single-region view.
arcFeedsByGroup `Map<string, Map<number, ArcBandFeed>>`	The band's marks' input, per group and region (`buildArcBandFeeds`).
modificationThreshold `number`
showModifications `boolean`
mismatchContrastMap `Record<string, string>`	Contrast colors for the mismatch/softclip/per-base letters, off the session palette. SVG export calls `getMismatchContrastMap` with its own palette.
showPerBaseQuality `boolean`
showPerBaseLetter `boolean`
readIdIndexMap `ReadIdIndexMap`
layoutReady `boolean`	Whether a pileup is laid out for an overlay to read — see `readArraysByGroup`.
belowCoverageBands `{ coverageHeight: number; hasArcsBand: boolean; hasSashimiBand: boolean; arcsBandTop: number; sashimiBandTop: number; bottom: number; }`	Geometry of the bands stacked below coverage in arcs-down mode: coverage → paired-end arcs → sashimi. `arcsBandTop`/`sashimiBandTop` are each band's top edge; `bottom` is where the pileup begins (== coverageDisplayHeight).
coverageDisplayHeight `number`
lanes `AlignmentLane[]`	The stacked lanes in stacking order, one `AlignmentLane` per drawn group; ungrouped is the one-lane case. The one place a lane's key resolves to its data.
drawnLanes `AlignmentLane[]`	The lanes laid out, or the one SYNTHETIC no-data lane: `sections` must produce a section before any fetch lands, and a grouped fetch over an empty region partitions to zero lanes. Every collection on it is empty.
sections `SectionsLayout`	All vertical band geometry, one entry per lane; ungrouped is the one-lane call. Runs over `drawnLanes` so a display with no data still has a section. The sticky-coverage-vs-scroll distinction lives downstream in `buildSectionRenders`.
renderSections `LaneSection[]`	Every lane paired with its band geometry in stacking order: the list the overlays, the hit-test pipeline and both renderers walk. The pairing is by INDEX, structural since `computeStackedSections` emits one section per lane in order from `drawnLanes`.
bezierPairSections `{ groupKey: string; topOffset: number; pileupHeight: number; dipReserve: number; pairs: LinkedPair[]; }[]`	The pairs the connector mark draws, placed on each drawn section's pileup band.
connectionColorTypes `Set<number>`	The connection types (LINKED_READ_COLOR_*) drawn in view, by the overlay's curves and by the straight-line pass beside them, so the key lists every connector color on screen. Empty while the legend is hidden so the scan is skipped.
legendMaxWidth `number`	`LegendMixin`'s hook: the split-read rows have to name which kind of read they classify, and that is the tree's longest label.
featureNoun `string`	What one row of this pileup is called, for UI text built from the model alone (the group-label chips). Overridable: LGVSyntenyDisplay draws PAF blocks, so its chips must not offer to "show all reads".
contextMenuHit `ContextMenuHit \| undefined`	Everything the right-click's hit test resolved — the block, the clicked column and whichever mark answered. See `ContextMenuHit`.
contextMenuFeatureId `string \| undefined`	The read id under a right-click, known synchronously unlike `contextMenuFeature`, which lands after an RPC. A menu item that can act from the id alone reads this.
isGrouped `boolean`	True when reads are stacked into >1 group section. Drives the scroll model: ungrouped keeps coverage sticky; grouped scrolls the whole stack as one.
scrollModel `ScrollModel`	The scroll-projection inputs (`sectionScreen.ts`) every overlay needs to map a content-space Y into screen space.
stickyBandHeight `number`	The coverage band held out of the scroll: ungrouped keeps it sticky above the pileup, grouped scrolls the whole stack. Subtracted from both the viewport and the content.
scrollViewportHeight `number`	Ungrouped excludes the sticky coverage band; grouped scrolls the entire display.
scrollContentHeight `number`	The laid-out `sections` less the sticky band, so a hidden pileup or a collapsed group opens no phantom scroll below the coverage band.
growTargetHeight `number`	HeightModeMixin's grow hook: the full laid-out content height (coverage + pileup + arcs), before the `growMaxHeight` cap. Independent of `self.height`: in grow mode `laidOutByGroup` fits to `growMaxHeight` and `featureHeight` is the configured value, so the mixin's `height` can return it without a cycle. With no layout (reads not loaded, or the too-large banner shown) the track keeps its current height.
showOutline `boolean`
visibleLabels `VisibleLabel[]`
selectedChainReadIds `string[]`	Read ids of the selected read's chain, empty outside chain mode.
readCategoryLabel `(c: ReadColorCategory) => string \| undefined`	Names one read color bucket for the hover, with the active scheme's rewording applied — the same `readCategoryLabelOverrides` the legend uses, so the tooltip and its swatch agree.
arcCategoryLabel `(c: ArcCategory) => string \| undefined`	Names one arc color bucket for the hover in the arc key's wording, so the tooltip and the swatch it sends the reader to agree.
readArraysByGroup `ReadonlyMap<string, ReadonlyMap<number, WorkerPileupData>>`	The reads a view overlaying this display may connect — the BreakpointSplitView's curves — by lane and region index, with hidden lanes dropped. Empty while no pileup is laid out, so an overlay draws no read this display does not.
sashimiJunctionSections `{ groupKey: string; sashimiDownKeys: ReadonlySet<string>; junctions: MergedJunction[]; }[]`	The junctions each lane draws, merged and filtered, in stacking order. A gesture owes none of it: it reads loaded data, the on-screen region set and the junction filters, and only the count labels (`sashimiLabels`) read the pan. Not a lane field: a lane feeds the LAYOUT, which the on-screen region set must never reach.
drawsSashimi `boolean`	Whether any lane has a junction to draw. What the view's region table and the count labels wait on, so a track of unspliced reads pays for neither.
sashimiFeedsByGroup `ReadonlyMap<string, ReadonlyMap<number, SashimiBandFeed>>`	The sashimi marks' input, per group and region (`buildSashimiBandFeeds`). In bp, so a pan or zoom rebuilds nothing.
connectorFeedsByGroup `Map<string, Map<number, ConnectorFeed>>`	The connector mark's input, per group and region (`buildConnectorFeeds`): the pairs `bezierPairSections` places, in bp and rows, so a pan or zoom rebuilds nothing.
sourceSections `SectionSource[]`	Per-section upload input in stacking order: each section's laid-out region map with its arc and sashimi feeds, keyed by group. Both renderers pair uploaded section `s` with drawn section `s` by INDEX, so this list and `renderState.sections` both derive from `renderSections` and share its length and order.
sashimiLegendStrands `ReadonlySet<number>`	The junction strands drawn, one key row each. Read off the merged junctions rather than the projected arcs, so a pan does not rebuild the legend.
colorScales `ColorScale[]`	`LegendMixin`'s hook: the read fills, the arc or read-cloud colors, the connection curves and the junction strands, merged and deduped by `getAlignmentsColorScales`. Empty while the legend is hidden, since the category scans are.
fittedFeatureHeight `number`	The read height that makes every uncollapsed group's reads fill the display without scrolling (`fittedReadPitch`). The uncapped row count uses a fixed `maxHeight`-row cap, independent of `featureHeight`, so the fit autorun that writes `featureHeight` cannot feed back into it. Reads `fitTargetHeight`, not the reactive `height` getter — the anti-cycle rule `laidOutByGroup` follows.
sortTag `string \| undefined`	Only the tag NAME goes to the worker, so `rpcProps` re-notifies when the tag changes, not when the sort position or a non-tag type flips.
renderState { scrollTop: number; featureHeight: number; featureSpacing: number; coverageHeight: number; coverageMinDepth: number \| undefined; coverageMaxDepth: number \| undefined; coverageScaleType: ScaleTypeCode; coverageSymlogConstant: number; coverageSnpMinFrequency: number; sashimiArcsHeight: number; showMismatches: boolean; fadeLowFrequencyMismatches: boolean; fadeLowQualityMismatches: boolean; showSoftClipping: boolean; showInterbaseIndicators: boolean; showModifications: boolean; showPerBaseQuality: boolean; showPerBaseLetter: boolean; showOutline: boolean; pileupTopOffset: number; coverageTopOffset: number; sections: SectionRender[]; canvasWidth: number; canvasHeight: number; colors: ColorPalette; chainMode: boolean; showLinkedReadLines: boolean; collapseGroupRows: boolean; readConnectionsLineWidth: number; arcsYDomainBp: number \| undefined; linkRegions: readonly LinkRegion[]; }
linkRegions `readonly LinkRegion[]`	The view's displayed regions as the band's connections place their feet (`viewRegionTable`), and the splice junctions theirs; empty while the band is off and no lane has a junction, so a pan leaves `renderState` alone on a track that draws neither.
sashimiLabels `readonly SashimiLabel[]`	The junction read counts, each at its arc's apex (`sashimiLabels`). The one part of sashimi that reads the pan, and only while the labels are shown; the same empty array otherwise, so the overlay's observer stops.
selectedSashimiHighlight `ArcHighlight \| undefined`	The selected splice junction's ink, for the overlay that outlines it. Reads the pan, and only while a junction is selected.
selectedConnectorHighlight `ArcHighlight \| undefined`	The connectors of the selected read or chain, for the overlay that outlines them. Reads the pan, and only while one is selected.
hoverInk `HighlightRect[]`	The boxes of the hovered read or chain, for the chrome's highlight. Not in `renderState`: the hovered id changes on nearly every mousemove, and routing it through the canvas would repaint the whole pileup.
selectionInk `HighlightRect[]`	The boxes of the selected read, or of every read in the selected chain — the same walk as `hoverInk`, so a click repaints the guide's divs, not the canvas. Not in the SVG export, as no display's selection is.
arcsYDomainBp `number \| undefined`	Floored at 1000bp, so an all-concordant set never divides by near zero.
scoreRulesDrawn `boolean`	Overrides `ScoreScaleMixin`'s: `scales.y.rules` are depths, so they draw on the coverage band.
valueScales `ValueScale[]`	The scales the chrome places the axes from. Coverage rules one band per section, on the right wherever the group label chips take the left edge. The read cloud's insert-size scale rules each section's arc band, captioned TLEN. Each band projects through its section's own scroll; the chrome drops the off-screen ones.
lodTier `LodTier \| undefined`	Overridable hook (default undefined: whatever the adapter picks): the detail tier a fetch issued now asks a tiered adapter for, off the settled zoom. `LGVSyntenyDisplay` resolves it for tiered PIF adapters. In `zoomFetchArgs`, not `rpcProps`, like `perBaseBinBp`.
liveLodTier `LodTier \| undefined`	Overridable hook: the same tier off the LIVE zoom, read by `dataSuperseded` alone — see `livePerBaseBinBp` for the window it covers.
perBaseBinBp `number`	Genomic bp one per-base cell stands for in the worker's extract: the foundation's `settledSubPixelBinBp`, and `1` in every color mode that does not paint a wall of them. Per-base quality and lettering emit an entry per aligned base of EVERY read, so sampling one base per sub-pixel window bounds the extract by the VIEWPORT, not the region. Not an `rpcProps` field — see `zoomFetchArgs`.
livePerBaseBinBp `number`	The same bin off the LIVE zoom, read by `dataSuperseded` alone. The debounced bin is what the held data was fetched under, so it cannot say whether that data is sampled finely enough. Kept out of `zoomFetchArgs` because `FetchVisibleRegions` runs on the leading edge: a live key would refetch at every octave a fast gesture passes.
hoveredFeature `SimpleFeature \| undefined`
dataSuperseded `boolean`	`MultiRegionDisplayMixin`'s supersession hook: the settled per-base bin or detail tier has not moved yet, but the live zoom has left it, so the clear is inevitable and not yet committed. Only the debounce half is here: once the settled bin moves, the stamp stops matching `fetchInputs` and the foundation's `isCacheValid` covers it. A value compare, never a second derivation of `zoomFetchArgs`: restated args would latch this true the day they grow a field, and a latched supersession hangs an export until `awaitSvgReady` times out.
ownGroupState `(string[] \| { [k: string]: number; })[]`	The mixin's hook: the collapses and per-group height overrides `dropGroupState` clears below.
gateEnabled `boolean`	Opt into RegionTooLargeMixin's byte gate: `fetchNeeded` passes `resolvedByteLimit()` to `RenderAlignmentData`, whose first await is the index estimate, so an over-budget region is refused before a read downloads.

97 inherited getters from 12 models

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

From HeightModeMixin: heightMode, fitTargetHeight, growMaxHeight, autoHeight, fitHeightToDisplay, grownHeight, height

From TrackHeightMixin: configuredHeight, allottedHeight, resizing, scrollableHeight

From MultiRegionDisplayMixin: host, canvasWidthPx, settledSubPixelBinBp, canRender, rendersCanvas, trackVisibleRegions, viewportWithinLoadedData, viewportEmpty, fetchSuspended, 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 ScoreScaleMixin: scaleType, scaleZero, domainQuantile, clipQuantile, symlogConstant, manualMinScore, manualMaxScore, valueScaleNotices, autoscaleGroup, scaleTitle, grid, minimalTicks, scoreRules

From ScoreAxisMixin: axisReachesZero, autoscaledDomain, minScoreBound, maxScoreBound, hasManualScoreBounds, axes

From LegendMixin: showLegend, legendTop, legendRight, legendSpec, hasLegendKey

From ColorWritesMixin: writtenColor

From HiddenGroupsMixin: displayHiddenGroupKeys, hiddenGroups, hiddenGroupKeys, groupStateKey

Methods

Member	Description
nonReferenceAt `(column: VariantSortColumn, allele?: VariantAllele \| undefined) => { count: number; depth: number; } \| undefined`	The loaded reads differing from the reference at a variant's sort column, or with `allele` only those carrying it, over the reads spanning it. Undefined until a fetch reaching the column lands.
colorPaletteIn `(theme: JBrowsePalette) => ColorPalette`	The read palette over `theme`, with the category colors `color` sets. SVG export passes its own theme.
legendItems `(palette: ColorPalette) => LegendItem[]`
arcLegendItems `(palette: ColorPalette) => LegendItem[]`	Key for the paired-end arc / read-cloud colors, empty when no overlay is drawn.
groupChipLabel `(label: string) => string`	The text a group's chip shows for its section label
arcFeedsByGroupIn `(colors: ColorPalette) => Map<string, Map<number, ArcBandFeed>>`	`arcFeedsByGroup` colored from `colors`, which the SVG export passes to draw in its own theme.
findFeatureInRpcData `(featureId: string) => ReadHit \| undefined`
laneFor `(key: string) => AlignmentLane \| undefined`	One lane by group key, for the per-key questions a component asks with a `groupKey` in hand. `undefined` for a key that isn't drawn.
connectionLegendItems `(palette: ColorPalette) => LegendItem[]`	Legend swatches for the read connectors.
groupPileupOffset `(groupKey: string) => number`	Content-space Y of a group's pileup relative to the reserved below-coverage height: how far a read's row shifts because its group is stacked below the others. Callers add `coverageDisplayHeight` back. Slightly negative for a lane that drops its arc band (`hasArcs` false).
readIdsSharingChain `(rpcData: ChainedPileupData, index: number) => string[]`	Read ids sharing a chain with the read at `index` in `rpcData`, the read's own included. Empty when the read is in no chain. Shared by hover-highlight and click-select.
readIdsSharingChainWith `(featureId: string) => string[]`	`readIdsSharingChain` from a read id alone, for a caller holding no block — the connector mark, whose arcs carry ids. Empty outside chain mode and for an id no fetched region holds.
getFeatureInfoById `(featureId: string) => { lodMode: LodTier \| undefined; id: string; name: string; start: number; end: number; flags: number; mapq: number; strand: number; refName: string; assemblyName: string; } \| undefined`
readLayoutRecord `(groupKey: string, displayedRegionIndex: number, idx: number) => [number, number, number, number] \| undefined`	Layout rect of one read of `readArraysByGroup`. Y is relative to the pileup's own top (callers add `coverageDisplayHeight`), so a grouped read needs only its section's stacking offset on top of its row. A read past the row cap sits on the cap's overflow row.
connectorFeedsByGroupIn `(colors: ColorPalette) => Map<string, Map<number, ConnectorFeed>>`	`connectorFeedsByGroup` colored from `colors`, for the SVG export's theme.
sashimiFeedsByGroupIn `(colors: ColorPalette) => ReadonlyMap<string, ReadonlyMap<number, SashimiBandFeed>>`	`sashimiFeedsByGroup` colored from `colors`, which the SVG export passes to draw in its own theme.
sourceSectionsIn `(colors: ColorPalette) => SectionSource[]`	`sourceSections` with the connections colored from `colors`, for the SVG export's theme.
sourceSectionsWith `(feeds: ReadonlyMap<string, ReadonlyMap<number, ArcBandFeed>>, sashimiFeeds: ReadonlyMap<string, ReadonlyMap<number, SashimiBandFeed>>, connectorFeeds: ReadonlyMap<string, ReadonlyMap<number, ConnectorFeed>>) => SectionSource[]`	The laid-out sections with each lane's read connections and splice junctions, which join here rather than on the lane: both are colored, and the layout must not read the palette.
sashimiSupportingReadSlots `(junction: LaneJunction) => ReadSlot[]`	The slots of the reads in the junction's lane whose skip gap it is.
colorScalesIn `(theme: JBrowsePalette) => ColorScale[]`	`colorScales` in another theme: the SVG export's, whose theme need not be the session's.
readInk `(ids: readonly string[], strong: boolean) => HighlightRect[]`	The boxes the named reads painted, clipped to their sections. Reading `readIdIndexMap` builds over the whole fetched dataset, so it waits until something is hovered or selected.
slotInk `(slots: readonly ReadSlot[], strong: boolean) => HighlightRect[]`	The boxes the reads in these slots painted, clipped to their sections.
rpcProps `() => { filterBy: ReadFilter; colorBy: ReadColorBy \| undefined; baseLayer: BaseLayer \| undefined; sortTag: string \| undefined; facet: WorkerFacet \| undefined; showSoftClipping: boolean; showCoverage: boolean; }`	Fields that invalidate the fetched data, every one worker-bound. Arc-only fields (`arcColor`, `showInterchrom`, `showLongRange`) are NOT here: `arcsResult` reads them and they need no refetch. Non-tag sort changes and tag coloring (`readFillColors`, baked in `laidOutByGroup`) stay main-thread. Its own views block, after every field it reads, so it reads them off `self`: a subclass override captures the base as a bare function, which would lose a `this`.
zoomFetchArgs `() => { perBaseBinBp: number; lodMode: LodTier \| undefined; }`	`MultiRegionDisplayMixin`'s per-region content axis: the zoom-derived worker arguments, which the fetch spreads into its RPC and the foundation stamps beside every region it loads. Only the per-base bin and the detail tier move it, so a zoom refetches the regions on screen only when one flips; neither is in `rpcProps`. Its own views block, after the getters it reads, like `rpcProps`.
trackMenuItems `() => (MenuItem \| { label: string; icon: OverridableComponent<SvgIconTypeMap<{}, "svg">> & { muiName: string; }; type: "subMenu"; subMenu: (MenuItem \| { label: string; onClick: () => void; })[]; })[]`	Track menu items
contextMenuItems `() => MenuItem[]`

10 inherited methods from 4 models

From BaseDisplay: renderingProps, liftPlot, plotProblems, plotWrites

From MultiRegionDisplayMixin: regionHasData, isCacheValid

From RegionTooLargeMixin: resolvedByteLimit, gateFetchState

From LegendMixin: svgLegendWidth, legendSpecIn

Actions

Member	Description
toggleGroupCollapsed `(key: string) => void`	Collapse/expand a stacked group's pileup (coverage stays visible).
dropGroupState `() => void`	The mixin's hook: the collapses and per-group height overrides, which are keyed by group key.
clearMouseoverState `() => void`
clearHoverUnlessPinned `() => void`	What a cursor leaving a read or connector calls. `setHoverState` refuses writes while the right-click menu pins the hover, so the leave refuses them too. `clearMouseoverState` is the unconditional form, for `closeContextMenu`.
setError `(error?: unknown) => void`
setRpcData `(displayedRegionIndex: number, data: GroupedAlignmentsResult, region: Region) => void`	Stage a region as fetched, with this display's payload shape — so a test stands up a loaded display in one call. Production goes through `ctx.commitRegion`.
clearSelection `() => void`
setBaseLayer `(layer?: BaseLayer \| undefined) => void`	Draw a per-base layer over the reads, or none. The read fill is `colorByField`'s and stays as it is.
setReadFilter `(filterBy: ReadFilter) => void`
setShowSoftClipping `(value: boolean) => void`
setFadeLowQualityMismatches `(value: boolean) => void`
sortAtCenterLine `(type: "basePair" \| "hardclip" \| "insertion" \| "mapq" \| "pairOrientation" \| "softclip" \| "strand" \| "tag", tag?: string \| undefined) => void`
setSort `(sort: SortSetting) => void`	The one writer of `sort`: a whole-window order, or a column sort.
setFacet `(facet?: Facet \| undefined) => void`	Writes the `facet` object; undefined is ungrouped. A tier-1 refetch setting (in `rpcProps`). Resets the Y scroll since the stacked content height changes. `HiddenGroupsMixin`'s key-space reset drops the per-lane state. A grouping named without a domain keeps the current one while the key space holds, so a re-pick is not a reorder.
setCollapseGroupRows `(flag: boolean) => void`	Draw each group as one row, overlap depth shown as tint. Clears the per-group height overrides: an override opts a lane out of the collapse, which means nothing once every lane is a stack again.
toggleGroupExpanded `(key: string) => void`	Expand a fit-to-viewport group to the full `maxHeight` cap, or, if it already carries an override, drop it to return the group to the fit budget. Expanding overflows the viewport, which engages the pileup scroll. Pairs with `groupHeightOverrides`.
resizeGroupHeight `(key: string, dy: number) => void`	Drag a stacked group's pileup band taller/shorter by `dy` px. The override caps the group's rows and pads the band where the rows fall short, so the drag runs in both directions. The accumulation policy lives in the pure `nextGroupHeightOverride`.
setFeatureHeight `(height?: number \| undefined) => void`	Set the per-read pixel size. Grow keeps growing at the new size. Fit derives the size, so a chosen size would be dormant: picking one drops back to fixed.
setMaxHeight `(height?: number \| undefined) => void`
setHeightMode `(mode: "fit" \| "fixed" \| "grow") => void`	The two pieces of transient state a uniform fit/grow contradicts that HeightModeMixin can't know about. The slot write and the scroll reset are its `setHeightMode`, captured as super above.
setFittedHeightPx `(px: number) => void`	Caches the fitted read height; `featureHeight`/`featureSpacing` split it into a body and a derived gap. Written only by the driving autorun.
setShowSashimiArcs `(show: boolean) => void`	Writes this slot alone. The arcs draw only with the coverage band (`showSashimiArcs`), and the menu greys the row out without it rather than turning the band back on behind the user's back.
setShowCoverage `(show: boolean) => void`
setReadConnections `(mode?: "arc" \| "cloud" \| "off" \| undefined) => void`
setReadConnectionsDown `(down: boolean) => void`	Whether the read-connection band hangs below the coverage band.
setShowPileup `(show: boolean) => void`
setCoverageHeight `(height: number) => void`
setCoverageSnpMinFrequency `(fraction: number) => void`
setReadConnectionsHeight `(height: number) => void`
setSashimiArcsHeight `(height: number) => void`
setMinSashimiScore `(score: number) => void`
setSashimiArcsMode `(mode: "auto" \| "down" \| "up") => void`
setShowSashimiLabels `(show: boolean) => void`
setShowNonCanonicalJunctions `(show: boolean) => void`
setReadConnectionsLineWidth `(width: number) => void`
setShowInterchrom `(draw: boolean) => void`
setShowOrdinaryPairs `(show?: boolean \| undefined) => void`
setMinInterchromSupport `(support: number) => void`
setShowLongRange `(draw: boolean) => void`
setArcColorField `(field: "" \| "insertSize" \| "insertSizeAndOrientation" \| "pairOrientation") => void`	Paint the arcs by `field`, `''` following the reads. `arcColor` holds a field and nothing else, so it skips `colorForField`, whose `scale: 'none'` it has no slot for.
setShowMismatches `(show: boolean) => void`
setShowInterbaseIndicators `(show: boolean) => void`
setUnit `(unit: "chain" \| "read") => void`	A new unit restacks the whole pileup, so the scroll resets: the `scrollableHeight` clamp catches only a shorter stack.
setShowBezierConnections `(flag: boolean) => void`	Toggle the paired-read connection overlay. A main-thread tier-2/4 setting, not in `rpcProps`: toggling never refetches.
setHoverState `(state: { overCigarItem: boolean; featureIdUnderMouse: string \| undefined; mouseoverExtraInformation: TooltipPayload \| undefined; hoverCoverageBand?: HoverCoverageBand \| undefined; hoveredArcHighlight?: ArcHighlight \| undefined; hoveredJunction?: LaneJunction \| undefined; highlightedChainReadIds: string[]; }) => void`	The whole hover state in one action, so no branch of the mousemove handler leaves a field stale. Refused while the right-click menu is open, since `openContextMenu` pins the hover to the read the menu acts on. `highlightedChainReadIds` is a chain's reads in chain mode, and outside it the two ends of a hovered connector.
setContextMenuFeature `(feature?: Feature \| undefined) => void`
closeContextMenu `() => void`	Close the right-click menu and release the hover it pinned. `setHoverState` refuses writes while the menu is up, so this is the only place the pin comes off.
selectFeature `(feature: Feature) => void`
startRenderingBackend `(backend: AlignmentsRenderingBackend) => void`
withFeatureById `(featureId: string, onFeat: (feat: Feature) => void) => Promise<void>`	Fetch the feature behind `featureId` and hand it to `onFeat`. For a menu item that needs the whole feature but is offered before one is in hand.
selectFeatureById `(featureId: string) => Promise<void>`
openContextMenu `(info: AlignmentsContextMenuInfo) => void`	Open the right-click menu over a hit. The block, the clicked column and the mark hit arrive as one `ContextMenuHit`, so a consumer cannot read a block without its hit. Resets the read feature and, when the hit carries one, fills it by async RPC, so a repositioned menu cannot inherit the prior read's items. Also clears the hover, then re-pins the highlight box on the menu's read, in that order.
fetchNeeded `(needed: IndexedRegion[]) => Promise<void>`
renderSvg `(opts?: ExportSvgDisplayOptions \| undefined) => Promise<ReactElement<unknown, string \| JSXElementConstructor<any>> \| Iterable<ReactNode> \| AwaitedReactNode>`
clearHoveredFeature `() => void`	Fills `BaseDisplay`'s hover-clear hook, which the fetch foundation's reaction calls on every viewport change. A pan, zoom or internal scroll under a stationary cursor fires no mousemove or mouseleave, so the highlight and tooltip would keep naming the read that was there.