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.

State model factory for LinearAlignmentsDisplay

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',
      pileup: {
        bases: {
          show: true,
          encoding: { color: 'modifications' },
          unmodified: { show: true },
        },
      },
    },
  ],
}

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: { show: true },
    },
  ],
}

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)`

2 inherited properties from 2 models

From ParkedColorMixin: parkedColors

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 a drag set, in px, keyed by group key and dropped with `collapsedGroups`. It caps the lane's rows and pads its band.
expandedGroups `ObservableSet<string>`	Group keys whose chip's "show all" lifted the lane's cap to `pileup.maxLayoutHeight`. Unlike a drag it pads nothing, so the band is as tall as the reads it stacks.
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 draws its vertical hover bar 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 8 models

From ContextMenuMixin: contextMenuInfo

From LegendMixin: dismissedLegendSections

From ScoreScaleMixin: unclippedFenceQuantile

From MultiRegionDisplayMixin: loadedRegions

From FetchMixin: activeSignal, fetchGeneration, reloadCounter, statusWindow, error, statusMessage, statusProgress, fetchCanceled, fetchRotation

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

From RegionTooLargeMixin: forceLoadTrack, byteEstimate, gateMeasuredViewportKey

From TrackHeightMixin: scrollTop, hostHeight

Getters

Member	Description
unit `"chain" \| "read"`
showCoverage `boolean`
coverageHeight `number`
showInterbaseIndicators `boolean`
showCoverageAlleles `boolean`	Whether the coverage band colors its allele segments, `coverage.alleles.show`
coverageMinAlleleFraction `number`
interbaseIndicatorRule `InterbaseIndicatorRule`	`coverage.interbase.filter` as the worker's triangle rule.
showPileup `boolean`
configuredReadHeight `number`	`pileup.mark.height` as configured, independent of the fit squeeze. Consumers that EDIT the size (the "Custom..." height dialog) must start from it, not the fractional fit pitch `featureHeight` resolves to in fit mode, or opening the dialog while compressed would bake the squeeze.
pileupMaxLayoutHeight `number`
showMismatches `boolean`
showSoftClipping `boolean`
showConnectors `boolean`
mismatchOpacityField `"baseQuality" \| undefined`	The field `pileup.mismatches.encoding.opacity` fades by, unset for none: the "Fade low quality mismatches" checkbox.
mismatchQualityOpacity `QualityOpacity`	`pileup.mismatches.encoding.opacity` as mismatch.slang's `qualityFade` reads it.
fadeLowFrequency `boolean`
hasSashimi `boolean`	Whether the display declares the sashimi band, which a synteny block, having no introns, has no use for.
showSashimi `boolean`
sashimiHeight `number`
sashimiPlacement `"auto" \| "down" \| "up"`
effectiveSashimiPlacement `"auto" \| "down" \| "up"`	Where the arcs draw: `sashimi.placement` over the coverage band, and `down`, in a separate strip, while the band is hidden.
showSashimiCounts `boolean`
writtenFilter `FieldPredicate[]`	The `filter` list as written, before the defaults merge in: what a session spec reopens the display with.
filterPredicates `FieldPredicate[]`	The `filter` list the display applies: what is written, merged over the defaults by field.
configProblems `{ level: "error"; slot: string; message: string; }[]`	The `filter` entries the display cannot apply, at the level jbrowse-img fails an export on: an entry the reads ignore draws them unfiltered.
junctionFilter `JunctionFilter`	The splice junctions drawn, off the `junction` fields.
showReadConnections `boolean`
readConnectionsMark `"arc" \| "cloud"`
drawnReadConnections `"arc" \| "cloud" \| "off"`	The mark the read-connection band draws, or 'off' while it is hidden.
readConnectionsHeight `number`
readConnectionsPlacement `"down" \| "up"`
readConnectionsStrokeScale `LinkSizeScale`	The link mark's size scale `readConnections.encoding.strokeWidth` draws.
readConnectionsLineWidth `number`	The width a one-read connection strokes at, which the Line width menu shows.
showOrdinaryPairs `boolean`	Whether the band draws its ordinary pairs: the arcs' concordant ones (`isConcordantPairRead`, whose failure on a paired primary read is the `svSignal` filter field's discordant clause) and the cloud's modal-insert ones. Unset, arcs keep them and the cloud drops them.
connectionFilter `ConnectionFilter`	The connections drawn, off the `connection` and `breakpoint` fields. `breakpoint.reads` counts within one fragment length on both sides of a breakpoint (`clusteredInterchromSupport`), since a mate-pair breakpoint is not localized to a base.
colorSetting `AlignmentsColorSetting`
colorEncoding `string \| FieldColorEncoding \| undefined`	`colorSetting` as it paints, through the one resolver every display's color object goes through.
colorLabels `readonly string[]`	`encoding.color.scale.names` as written, read apart from `colorSetting`, which every color tier keys on, so renaming a key entry re-bakes no read.
colorTitle `string \| undefined`	`encoding.color.legend.title` as written: unset keeps the key's own heading, `''` draws none.
colorKeyTitle `string \| undefined`	The key's heading: `encoding.color.legend.title` as written, else its field preset's while the color paints through the preset, so `encoding.color: "mapq"` keys as "Mapping quality". Unset keeps the key's own heading.
colorKeyDescending `boolean \| undefined`	`encoding.color.legend.descending` as written, else its field preset's while the color paints through the preset, so `encoding.color: "mapq"` keys 30+ first. Read apart from `colorSetting`, so turning the key round re-bakes no read.
pinnedInsertSizeBand `{ lower: number; upper: number; } \| undefined`	The short/long cut points `encoding.color.scale.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.
basesFilter `BasesFilter`	`pileup.bases.filter` over its defaults, which the modifications and bisulfite menus read while another layer draws.
colorField `string \| undefined`	The field the read fill paints by, undefined for the plain fill.
readConnectionsColorField `"insertSize" \| "insertSizeAndOrientation" \| "pairOrientation"`	The field the arcs, the read cloud and the pileup connectors paint: `readConnections.encoding.color`'s own, or the reads' where it names none.
baseLayer `BaseLayer \| undefined`	The per-base layer `pileup.bases` draws; undefined while none is.
bodyColorKind `ColorFieldKind`	What the read body paints as: `colorField`'s kind, or the modification layer's own pale strand tint while the fill is plain.
readPredicates `FieldPredicate[]`	The read fields of `filterPredicates`, which the worker applies.
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.
rpcDataMap `ReadonlyMap<number, GroupedAlignmentsResult>`	Region index → grouped worker result. Ungrouped fetches store one group (key '').
view `LinearGenomeView`
showLinkedReadLines `boolean`	Whether the straight-line pass connects normal read pairs. Chain layout has a separate 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; themed: { colors: 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 completed, so an empty `detectedModifications` means these reads have 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 `configuredReadHeight`, 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 belong to, 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.
collapseSections `boolean`	Whether each group draws as one row, overlap depth shown by the tint layer — the collapse in effect. Reads `canCollapseSections`, not the slot alone: a config default can be ticked where collapsing is inert.
canCollapseSections `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 holds both the gate and the message naming the switch that brings it back. Chain layout takes no `sort`; its rows are chains.
collapseSortBlockedReason `string \| undefined`	Why the collapse leaves no sort to take effect, or `undefined`: every drawn section lays its reads on one row, none opted out by an expand or a drag. A hidden lane or one shown as coverage alone stacks nothing, whatever cap it holds.
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 for that group alone, 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.
expandedGroupKeys `ReadonlySet<string>`	The "show all" lanes in effect, which fit mode ignores as it does `groupHeightOverrides`.
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 `coverage.encoding.y.scale.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 `coverage.encoding.y.scale.constant`, 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 fields painted in the rendered reads (tag values, or mate refNames under chromosome painting). `undefined` for other fields, 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 fields.
declaredReadLabels `DeclaredReadLabels`	`encoding.color.scale.names` 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 `readConnectionsColorField`, 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 field is the one the reads are colored by: a key over one field lists the values 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 `themed`'s sashimi feeds 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 draw 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; sashimiHeight: 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; showSashimi: boolean; sashimiHeight: number; drawnReadConnections: "arc" \| "cloud" \| "off"; readConnectionsHeight: number; readConnectionsDown: boolean; }`	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 and "show all" lanes 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 `pileup.maxLayoutHeight` 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 a per-group 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 a separate computed, so a field 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. No input 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.
connectorFilter `({ e1, e2, c }: LinkedPair) => boolean`	Which pairs the connectors draw under `connectionFilter`. The inter-chromosomal floor comes from the arc band's collection stage, which runs only once a connector crosses chromosomes. The chain layout's own cross-region links read no filter, as its connecting lines do not.
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>; collapseSections: 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 `{ colorField: string \| undefined; bodyColorKind: ColorFieldKind; 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.
linearFieldExtent `NumericExtent \| undefined`	The whole span of a linear color field, a tag or MAPQ, over the loaded reads (`linearFieldExtent`).
baseQualitySpan `QualitySpan`	The span of the base qualities drawn, and whether a base has 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 field and until the assembly initializes.
readColorOpts `{ chainMode: boolean; framesChainStrand: boolean; }`	The inputs to read classification beside the field, 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.
liveNotices `string[]`	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 spelling (an SA tag's or RNEXT's `chr1`) rather than the assembly-canonical one a fetched read has (`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). `resolveArcsByGroup` 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.
arcCollection `ArcCollection`	The collection half of `arcsResult` (`collectArcs`), which the connectors read for the inter-chromosomal floor with the band off, so both marks drop the same connections.
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.
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`
readIdIndex `ReadIdIndex`	Every read's slot by id, and every slot of a read fetched in more than one displayed region (`buildReadIdIndex`).
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 color types (`connectorColorType`) 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`	Whether each read draws its outline: in a chain, where the outline shows which segments are one molecule.
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 field'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.
sashimiLegendStrands `ReadonlySet<number>`	The splice 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. A split junction has no transcript strand.
sashimiLegendSplitClasses `ReadonlySet<ArcSplitCategory>`	The split junction classes drawn, one key row each.
themed `ThemedSources`	The read colors in the session theme and the marks colored from them (`themedIn`).
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 `pileup.maxLayoutHeight`-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`	The worker receives the tag name alone, so `rpcProps` re-notifies when the tag changes, not when the sort position or a non-tag field flips.
renderState { scrollTop: number; featureHeight: number; featureSpacing: number; coverageHeight: number; coverageMinDepth: number \| undefined; coverageMaxDepth: number \| undefined; coverageScaleType: ScaleTypeCode; coverageSymlogConstant: number; coverageMinAlleleFraction: number; showCoverageAlleles: boolean; sashimiHeight: number; showMismatches: boolean; fadeLowFrequencyMismatches: boolean; qualityOpacity: QualityOpacity; showSoftClipping: boolean; showInterbaseIndicators: boolean; showModifications: boolean; showPerBaseQuality: boolean; showPerBaseLetter: boolean; showOutline: boolean; pileupTopOffset: number; coverageTopOffset: number; sections: SectionRender[]; canvasWidth: number; canvasHeight: number; colors: ColorPalette; readConnectionsColorField: "insertSize" \| "insertSizeAndOrientation" \| "pairOrientation"; chainMode: boolean; showLinkedReadLines: boolean; collapseSections: boolean; readConnectionsStrokeScale: LinkSizeScale; 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: `coverage.encoding.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 the one the held data was fetched under, so it cannot show 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.

98 inherited getters from 14 models

From HiddenGroupsMixin: hiddenGroups, hiddenGroupKeys, groupStateKey

From FacetWritesMixin: writtenFacet

From ColorWritesMixin: writtenColor

From ParkedColorMixin: parkedColor

From LegendMixin: showLegend, legendRight, legendSpec, hasLegendKey

From ScoreScaleMixin: scaleType, scaleZero, fenceQuantile, clipFenceQuantile, symlogConstant, manualMinScore, manualMaxScore, autoscaleGroup, scaleTitle, grid, scoreRules

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

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

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

From RenderLifecycleMixin: painted

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

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

From TrackHeightMixin: configuredHeight, allottedHeight, resizing, scrollableHeight

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

Methods

Member	Description
filterNarrowing `() => Reversible`	How `filter` differs from what the track's config declares, as a count of the fields that moved: the "Filter by..." count, and what "Clear all filters" writes back.
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 with it, over the reads spanning it. Undefined until a fetch reaching the column completes.
legendItems `(palette: ColorPalette) => LegendItem[]`
arcLegendItems `(palette: ColorPalette) => LegendItem[]`	Key for the paired-end arc / read-cloud colors, empty when no overlay is drawn.
configProblemsOf `(conf: AnyConfigurationModel) => string[]`	The schema's rules, then what the reads cannot draw as written (`alignmentsConfigProblems`).
groupChipLabel `(label: string) => string`	The text a group's chip shows for its section label
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 have ids. Empty outside chain mode and for an id no fetched region holds.
getFeatureInfoById `(featureId: string) => { lodTier: 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.
sashimiSupportingReadSlots `(junction: LaneJunction) => ReadSlot[]`	The slots of the reads in the junction's lane that support it.
themedIn `(theme: JBrowsePalette) => ThemedSources`	The read palette over `theme`, with the category colors `encoding.color` sets, and the read connections and splice junctions colored from it, each joined to its laid-out section. The SVG export passes the theme it renders with. Each member is its own computed, so while `themed` is observed a member rebuilds only when what it reads changes.
connectorStylerIn `(theme: JBrowsePalette) => ConnectorStyler`	How this display's connectors paint a connection between two reads, in `theme`. The breakpoint split view draws its curves between panels through it, so they agree with the arcs and connectors inside each panel.
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, every region's copy, clipped to their sections. Reading `readIdIndex` 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 `() => { filter: FieldPredicate[]; colorField: string \| undefined; baseLayer: BaseLayer \| undefined; sortTag: string \| undefined; facet: WorkerFacet \| undefined; showSoftClipping: boolean; showCoverage: boolean; interbaseIndicators: InterbaseIndicatorRule; junctions: boolean; }`	Fields that invalidate the fetched data, every one worker-bound. Arc-only fields (`readConnections.encoding.color` and `.filter`) 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. It is defined in a separate 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; lodTier: 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: { label: string; type: "radio"; checked: boolean; keepMenuOpen: boolean \| undefined; onClick: () => void; }[]; } \| { label: string; icon: OverridableComponent<SvgIconTypeMap<{}, "svg">> & { muiName: string; }; type: "subMenu"; subMenu: MenuItem[]; })[]`	Track menu items
contextMenuItems `() => MenuItem[]`

10 inherited methods from 5 models

From ParkedColorMixin: parkedColorOf

From LegendMixin: legendSpecIn

From MultiRegionDisplayMixin: regionHasData, isCacheValid

From RegionTooLargeMixin: resolvedByteLimit, gateFetchState

From BaseDisplay: renderingProps, liftPlot, plotProblems, plotWrites

Actions

Member	Description
setFilterFields `(patch: Readonly<Record<string, readonly FieldPredicate[] \| undefined>>) => void`	Replaces the entries on each field the patch names, `undefined` returning a field to its defaults; every other field keeps what was written.
setShowCoverage `(show: boolean) => void`
setShowInterbaseIndicators `(show: boolean) => void`
setShowCoverageAlleles `(show: boolean) => void`	Turns the coverage band's allele colors on or off, `coverage.alleles.show`
setCoverageMinAlleleFraction `(fraction: number) => void`
setShowPileup `(show: boolean) => void`
setShowMismatches `(show: boolean) => void`
setShowSoftClipping `(value: boolean) => void`
setShowConnectors `(flag: boolean) => void`	A main-thread tier-2/4 setting, not in `rpcProps`: toggling never refetches.
setMismatchOpacityField `(field?: "baseQuality" \| undefined) => void`	Writes `field` alone, so a written domain and range survive the fade being turned off and on.
setShowSashimi `(show: boolean) => void`	Writes `sashimi.show` alone. Without the coverage band the arcs draw in a separate strip (`effectiveSashimiPlacement`).
setSashimiPlacement `(placement: "auto" \| "down" \| "up") => void`
setShowSashimiCounts `(show: boolean) => void`
setJunctionFilter `(patch: JunctionFilterPatch) => void`
setDrawnReadConnections `(mode: "arc" \| "cloud" \| "off") => void`	What the "Read arcs" and "Read cloud" checkboxes write: 'off' hides the band and keeps its mark for the way back.
setReadConnectionsPlacement `(placement: "down" \| "up") => void`
setReadConnectionsLineWidth `(width?: number \| undefined) => void`	Stroke a one-read connection `width` px, keeping the written field, scale type and range ratio, or a constant width; undefined returns to the default 1 px.
setReadConnectionsColorField `(field?: "insertSize" \| "insertSizeAndOrientation" \| "pairOrientation" \| undefined) => void`	Paint the connections by `field`; unset follows the reads.
setShowOrdinaryPairs `(show?: boolean \| undefined) => void`
setConnectionFilter `(patch: Partial<ConnectionFilter>) => void`
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, both of which use group keys.
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`
openSolidColorDialog `() => void`	The picker Color by's Solid color... opens, on the theme's plain read fill until a constant is written.
setBases `({ show, field, unmodified, filter }: BasesPatch) => void`	Writes the `pileup.bases` members the patch names, as one action so a layer and its filter refetch once. The read fill is `colorByField`'s and stays as it is.
sortAtCenterLine `(field: ColumnSortField) => void`
setSort `(sort: SortSetting) => void`	The one writer of `sort`: a whole-window order, or a column sort.
setCollapseSections `(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`	Lift a group's cap to `pileup.maxLayoutHeight` without padding its band, or, if a drag or an earlier expand already sized it, return the group to the fit budget. Expanding overflows the viewport, which engages the pileup scroll.
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 is in the pure `nextGroupHeightOverride`.
setReadHeight `(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.
setPileupMaxLayoutHeight `(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.
setCoverageHeight `(height: number) => void`
setReadConnectionsHeight `(height: number) => void`
setSashimiHeight `(height: number) => 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.
setHoverState `(state: { overCigarItem: boolean; featureIdUnderMouse: string \| undefined; mouseoverExtraInformation: TooltipPayload \| undefined; hoverCoverageBand?: HoverCoverageBand; hoveredArcHighlight?: ArcHighlight; hoveredJunction?: LaneJunction; 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 has 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.