LinearCanvasBaseDisplay

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

Shared GPU-accelerated feature display base for canvas-rendered tracks.

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
configuration `configuration: ConfigurationReference(configSchema)`
pinnedFeatureIds `pinnedFeatureIds: types.stripDefault(types.array(types.string), [])`	Feature ids the user pinned to the top of the layout via the feature right-click menu.
soloFeatureIds `soloFeatureIds: types.stripDefault(types.array(types.string), [])`	"Show only these features": the collected set the user builds by ctrl+clicking features (or via the right-click menu).
soloApplied `soloApplied: types.stripDefault(types.boolean, false)`	Whether the collected soloFeatureIds set is actually isolating the view (worker drops non-members).
hiddenFeatureIds `hiddenFeatureIds: types.stripDefault(types.array(types.string), [])`	"Hide this feature" exclusion set (inverse of solo): the worker drops these from layout/drawing.
expandedGeneIds `expandedGeneIds: types.stripDefault(types.array(types.string), [])`	Genes the user opened from the isoform badge on their own label: these draw every isoform whatever `geneGlyphMode` or the fit ladder's isoform rung would otherwise collapse them to.
featureHighlights `featureHighlights: types.stripDefault( types.array(FeatureHighlightModel), [], )`	Declarative feature highlights, typically seeded by a text search (highlight the gene you searched for).

2 inherited properties from one model

From BaseDisplay: id, type

Volatiles

Member	Description
featureIdUnderMouse `string \| undefined`
subfeatureIdUnderMouse `string \| undefined`
mouseoverExtraInformation `string[] \| undefined`	the hover tooltip's rows, each rendered as its own element — see hoverTooltipRows for why this is a list and not one HTML string
sequenceHoverPosition `SequenceHoverPosition \| undefined`	genomic base currently hovered in a feature sequence dialog opened from this display, read by the LGV crosshair overlay
onScreenIdsMemo `(next: ReadonlySet<string>) => ReadonlySet<string>`
incrementalLayout `(rpcDataMap: ReadonlyMap<number, LayoutRegionData>, inputs: LayoutInputs) => Map<number, FeatureDataResult>`
incrementalLayoutLabelsOnly `(rpcDataMap: ReadonlyMap<number, LayoutRegionData>, inputs: LayoutInputs) => Map<number, FeatureDataResult>`
incrementalLayoutBodiesOnly `(rpcDataMap: ReadonlyMap<number, LayoutRegionData>, inputs: LayoutInputs) => Map<number, FeatureDataResult>`
incrementalLayoutDecimated `(rpcDataMap: ReadonlyMap<number, LayoutRegionData>, inputs: LayoutInputs) => Map<number, FeatureDataResult>`
incrementalLayoutIsoforms `(rpcDataMap: ReadonlyMap<number, LayoutRegionData>, inputs: LayoutInputs) => Map<number, FeatureDataResult>`
incrementalLayoutThinned `(rpcDataMap: ReadonlyMap<number, LayoutRegionData>, inputs: LayoutInputs) => Map<number, FeatureDataResult>`
incrementalLayoutBare `(rpcDataMap: ReadonlyMap<number, LayoutRegionData>, inputs: LayoutInputs) => Map<number, FeatureDataResult>`
packHeightsIsoforms `(rpcDataMap: ReadonlyMap<number, LayoutRegionData>, inputs: PackKnobFreeInputs) => Map<string, PackedBottoms>`
packHeightsThinned `(rpcDataMap: ReadonlyMap<number, LayoutRegionData>, inputs: PackKnobFreeInputs) => Map<string, PackedBottoms>`
packHeightsDecimated `(rpcDataMap: ReadonlyMap<number, LayoutRegionData>, inputs: PackKnobFreeInputs) => Map<string, PackedBottoms>`
morphFromTops `Map<string, number> \| undefined`
morphProgress `number`
morphStartMs `number`
morphFromMaxY `number`

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 LegendMixin: dismissedLegendSections

From CanvasFeatureGateMixin: densityStatsPerRegion

From ContextMenuMixin: contextMenuInfo

Getters

Member	Description
rpcDataMap `ReadonlyMap<number, LoadedFeatureData>`	The fetched features, keyed by displayedRegionIndex — the foundation's per-region store, narrowed.
conf `ConfigNodeProps<…> & ConfigNodeActions & ConfigNodeBrand<ConfigurationSchemaType<…>>`	the config typed off the concrete schema; `ConfigurationReference` erases `self.configuration` to `any`, so direct reads route through this to stay typed (same move as `BaseAdapter<CONF>`).
colorSetting `ColorSetting`	The `color` object as written, its `value` and `field` raw: either may be a `jexl:` expression over a feature, which has none here.
workerColor `WorkerColor`	The two members the worker reads, the rest being the main thread's.
colorEncoding `string \| FieldColorEncoding \| undefined`	`colorSetting` as it paints, through the one resolver every display's color object goes through: `color.value`, or a field through its scale, `score` a ramp and any other field categorical while `scale` is unset.
colorField `string \| undefined`	The field the color paints by, through any scale, or undefined while `color.value` paints.
categoricalColorField `CategoricalField \| undefined`	The color channel's field while it paints through a categorical scale, which a facet on the same field shares.
paintedColorField `CategoricalField \| undefined`	The field the color channel paints through a categorical or threshold scale, a threshold's values filed under their bins.
identityKeyEntries `{ value: string; label: string; color: string; }[]`	The rows an identity scale's key names, empty under any other scale.
colorKeyTitle `string \| undefined`	The key's heading: the color's `title`, or its field's preset's, else the field.
colorValueExtent `[number, number]`	The smallest and largest number the loaded regions' values of the painting field hold, which a ramp's open ends follow.
colorValueGaps `{ missing: boolean; notNumber: boolean; }`	Whether a loaded feature holds no value in the painting field, or text that is no number, which a ramp's key lists beside its bar.
colorRamp `{ domain: [number, number]; lut: Uint8Array<ArrayBufferLike>; midNorm: number; colorOf: (value: number) => number; } \| undefined`	The ramp a linear or log color paints through, over the loaded values where an end is left open.
paintColorValue `((value: string) => string) \| undefined`	The color a field value paints, while a field paints. A ramp paints a value-less feature the no-value grey, as the categorical and threshold scales do.
fieldPalette `{ field: string; paint: (value: string) => string; tableOf(values: readonly string[], withTints: boolean): Uint32Array<ArrayBuffer>; } \| undefined`	`paintColorValue` with each value's packed colors held for every region and re-encode that asks, while the scale stands.
colorNotices `string[]`	What the `color` object's slots say together that it cannot paint as written.
notices `string[]`	The corner notice's lines: `colorNotices`, which a display with more to say extends.
showOutline `boolean`
outlineColor `string \| undefined`	The outline's color as written, undefined taking the theme's.
featureColor `string`
solidColor `string \| undefined`	The constant `color.value` holds, painting or kept beside a field; undefined where it holds none or a `jexl:` expression.
colorByMode `"attribute" \| "default" \| "solid" \| "strand"`	The Color by radio that is ticked: a field, else a constant, else the track's own color.
colorByAttribute `string`
geneGlyphNotice `GeneGlyphNotice \| undefined`	Overridable hook (default absent): the isoform-collapse control the shared canvas body draws in its bottom-right chip stack, or nothing when the display has no gene glyphs.
facet `FacetSetting \| undefined`	The `facet` object as written, or undefined while ungrouped.
hiddenGroupFeatureIds `ReadonlySet<string> \| undefined`	The features of the sections the user hid, which sit unplaced by choice and so count as nothing the track failed to show.
layoutReady `boolean`	Whether features can be laid out: data is fetched, in-bounds, the view is measured.
onScreenFeatureIds `ReadonlySet<string> \| undefined`	The features whose bp span touches the viewport, less any in a hidden section, as one Set for as long as the membership holds.
labelDensityPerPx `number`	Features per pixel of what is actually ON SCREEN — the density the `auto` label modes gate on (ADR-093).
onScreenWidthPx `number`
geneLabelDensityPerPx `number \| undefined`	On-screen gene features per pixel, which `auto` holds to the same threshold so gene names outlast a crowd of other features. Undefined with no gene on screen.
renderState `{ scrollY: number; canvasWidth: number; canvasHeight: number; outlineColor: number; hideChevrons: boolean; }`
displayDirectionalChevrons `boolean`	Overridable hook (default on): whether intron lines carry chevrons. Drawn from the render state, not baked by the worker, so the toggle refetches nothing.
labelScrollBucket `number`
displayMode `"collapsed" \| "compact" \| "normal" \| "superCompact"`
groupKeySpace `string`	`HiddenGroupsMixin`'s hook: a section key means nothing outside the field that issued it, so moving the field drops what was hidden.
effectiveSubfeatureLabels `"below" \| "none" \| "overlay"`	Overridable hook (default none): the subfeature-label mode the worker bakes.
labelFontSize `number`
showLabelsMode `"auto" \| "description" \| "name" \| "nameAndDescription" \| "none"`
labelVisibility `{ showLabels: boolean; geneNamesOnly: boolean; showDescriptions: boolean; }`	Which labels the `showLabels` mode shows at the on-screen feature density: names, descriptions, and whether only gene names survive.
showLabels `boolean`
geneNamesOnly `boolean`	`auto` past the name threshold, with the gene features alone still under it: gene names stay and every other name goes.
showDescriptions `boolean`
effectiveShowDescriptions `boolean`
selectedFeatureId `string \| undefined`
colorByCDS `boolean`
showAminoAcids `boolean`
reversedRegions `Set<number>`
pinnedFeatureIdSet `ReadonlySet<string>`
expandedGeneIdSet `ReadonlySet<string>`
soloFeatureIdSet `ReadonlySet<string>`
hiddenFeatureCount `number`
soloFeatureCount `number`
pinnedFeatureCount `number`
canonicalFeatureHighlights `FeatureHighlight[]`
resolvedHighlights `ResolvedHighlights`
highlightedFeatureIdSet `ReadonlySet<string>`
layoutPinnedFeatureIdSet `ReadonlySet<string>`
featureHighlightCount `number`
layoutInputs `{ bpPerPx: number; reversedRegions: Set<number>; displayMode: "collapsed" \| "compact" \| "normal" \| "superCompact"; pinnedFeatureIds: ReadonlySet<string>; expandedGeneIds: ReadonlySet<string>; facet: FacetSetting \| undefined; hiddenGroupKeys: ReadonlySet<string>; geneNamesOnly: boolean; }`	Layout inputs shared by the base layout and every fit rung, `expandedGeneIds` included: a rung inheriting them without the exemption re-collapses the gene the user just opened.
fitMeasureFeatureIds `ReadonlySet<string> \| undefined`	The features the ladder measures its rungs and its isoform solve against: the on-screen set in `fit` and `fixed`, undefined in `grow` (which measures the whole stack).
canonicalTranscripts `CanonicalTranscripts`	the tags the worker ranks a gene's isoforms by, which the sequence panel reads to open on the isoform this display draws first
showsEveryIsoform `boolean`	Overridable hook (default false): the display's transcript setting names every isoform, so the fit ladder's `isoforms` rung may not trim — the surplus scrolls instead.
effectiveGeneGlyphMode `"all" \| "auto" \| "longestCoding"`	Overridable hook (default all): the gene-glyph mode the worker collapses under.
reservesBelowLabelRows `boolean`	Whether the settings reserve `below` subfeature-label rows, which is what earns the fit ladder its `bare` rung — with nothing reserved the rung would repack an identical stack.
fullReservation `LabelReservation`	What the `full` rung reserves: the names and descriptions the settings ask for.
labelsReservation `LabelReservation`	The `labels` and `decimated` rungs' reservation: names kept, descriptions dropped.
isoformsReservation `LabelReservation`	The `isoforms` rung's reservation: the `labels` rung's when fitting to the display, else the `full` rung's.
decimatedBaseInputs `LabelRoomFactorFreeInputs`	The `decimated` rung's layout inputs minus the whitespace factor.
decimatedHeightProbe `(labelRoomFactor: number, geneLabelRoomFactor?: number \| undefined) => number`	Measures the `decimated` rung's stack height at any whitespace factor, against the features the ladder measures its rungs with — so the factor the solve picks is judged on the same stack the rung is then kept or rejected on.
isoformsBaseInputs `IsoformCountFreeInputs`	The `isoforms` rung's layout inputs minus the count itself, typed without it so the solve's shared preparation provably cannot depend on it.
isoformsHeightProbe `(maxIsoforms: number) => number`	Measures the `isoforms` rung's stack height at any isoform count, against the features the ladder measures its rungs with.
maxIsoformsOnScreen `number`	The most isoforms any trimmable gene ON SCREEN has — the top of the solve's bracket, and the count above which a trim can take nothing away.
fitIsoformCount `number \| undefined`	The isoform count the `isoforms` rung commits at: the largest whose names-kept stack fits `fitTargetHeight`, so the most transcripts are kept without giving up a name.
fitIsoformsSolved `Map<number, FeatureDataResult>`	The `isoforms` stack: every gene trimmed to `fitIsoformCount` transcripts, names intact.
thinnedBaseInputs `LabelRoomFactorFreeInputs`	The `thinned` rung's layout inputs minus the body scale: every name, no descriptions, the `isoforms` rung's count.
fitLabeledBodyFloor `number`	The smallest body scale the labelled rungs may pack at: the tallest body stays `LABELED_BODY_TO_FONT_RATIO` of the label font, and the shortest stays drawn.
fitBodyScale `number \| undefined`	The body scale the `thinned` rung commits at: the largest whose stack, every name kept, fits `fitTargetHeight`, or undefined when even the floor overflows.
fitThinnedSolved `Map<number, FeatureDataResult>`	The `thinned` stack: every name at its font size over bodies shortened to `fitBodyScale`.
baseLaidOutDataMap `Map<number, FeatureDataResult>`	Full reservation (names + descriptions): rendered at fit stage `full` and in non-fit modes, and the first stack `fitStage` probes.
fitLabelsOnlyLayout `Map<number, FeatureDataResult>`	Names reserved, descriptions dropped — the `labels` stage's stack.
fitDecimatedFactors `LabelRoomFactors \| undefined`	The whitespace factors the `decimated` rung commits at: the smallest whose packed stack fits `fitTargetHeight`, so the most names are kept.
fitDecimatedSolved `Map<number, FeatureDataResult>`	The `decimated` stack: names kept only on features with at least their tier's `fitDecimatedFactors ×` their label width in neighbour whitespace (plus pinned/highlighted, always).
fitDecimatedBodyScale `number \| undefined`	The body scale the `decimated` rung commits at: with the names `fitDecimatedFactors` kept, the bodies grow back into whatever height the dropped names freed.
fitBodiesOnlyLayout `Map<number, FeatureDataResult>`
fitBareLayout `Map<number, FeatureDataResult>`	The `bare` stack: `bodies` with the `below` subfeature-label rows spent at zero height, so the last reduction before a squeeze gives back rows whose text the squeeze was about to hide anyway.
fitSmallestBoxPx `number`	The shortest box the layout draws on screen, read off the layout rather than the `featureHeight` slot, a per-feature jexl callback that throws with no feature in scope.
fitMinScale `number`	Floor on the fit squeeze: the smallest vertical scale that still leaves every drawn box at least `MIN_FIT_BOX_PX` tall.
fitStage `FitStage`	The resolved fit outcome — which reservation `level` survived, its unscaled `layout`, and the vertical `scale` to fill the track — bundled so the three can never disagree.
fitScale `number`	Uniform vertical scale for fit mode; below 1 only while the stack is squeezed to fit.
laidOutDataMap `ReadonlyMap<number, FeatureDataResult>`	What every consumer (hit test, GPU upload, React render) reads: the resolved fit layout, cloned and scaled only when squeezed.
groupSections `FeatureGroupSection[]`	The stacked sections in stacking order, each with the chip row the packer reserved above it, read off the same rows the glyphs paint; empty while ungrouped.
showsGroupLabels `boolean`	Whether the section chips and dividers draw: a grouping is set and the layout produced a section for it.
prefersOffset `boolean`	A grouped track puts its track label above the plot, where it cannot cover the first section's chip. Reads the setting, not the sections, so the label does not jump when data lands.
renderedShowDescriptions `boolean`	Descriptions are painted where the kept rung reserved room for them.
renderedShowLabels `boolean`	Names are painted where the kept rung reserved row height + overhang for them.
renderedShowSubfeatureLabels `boolean`	A subfeature label (a transcript name under its gene) is worker-baked and its row is reserved in the pack, so it survives every rung that kept those rows and goes only where the kept rung spent them at zero.
renderedLabelFontSize `number`	The size the kept rung priced its labels at, and so the size they draw at.
fitDrops `FitDrops`	What the ladder took from the labels the settings reserved, and how far it squeezed — the one derivation both user-facing notes read.
fitNote `string \| undefined`	The track-sizing control's account of what fit mode gave up, or undefined when nothing.
labelsFitHint `string \| undefined`	The note on the selected "Labels" radio while the ladder is not honouring it (see `inertLabelHint`).
morphEased `number`
animating `boolean`	a row morph is in flight, which the chrome publishes for the capture waits
renderDataMap `ReadonlyMap<number, FeatureDataResult>`
settledMaxY `number`
maxY `number`
scrollExtentMaxY `number`
hasOverflow `boolean`
truncatedFeatureCount `number`
contentHeight `number`
scrollContentHeight `number`
scrollViewportHeight `number`
growTargetHeight `number`
featureIdIndex `Map<string, FlatbushItem>`
subfeatureIdIndex `Map<string, SubfeatureInfo>`
hoveredFeature `FlatbushItem \| undefined`
hoveredSubfeature `SubfeatureInfo \| undefined`
hoverBoxFeature `FlatbushItem \| undefined`	The feature the hover box frames: the open context menu's target while one is open, so the box always agrees with what the menu acts on, else the feature under the cursor.
hoverBoxSubfeature `SubfeatureInfo \| undefined`	The transcript the hover box frames instead of its gene, by the rule of `hoverBoxFeature`.
regionInstanceIndexes `ReadonlyMap<number, RegionInstanceIndex>`	Feature and subfeature ids to the primitives they painted, per laid-out region. Deliberately held by no autorun: nothing builds it until a hover or a selection asks which instances to light.
hoverInk `HighlightRect[]`	What the chrome lights under the pointer: the open context menu's target while one is open, else the hovered subfeature, else the hovered feature — one box per region over its glyph and its labels.
selectionInk `HighlightRect[]`	The session's selected feature, boxed the same way.
pinnedInk `HighlightRect[]`	Every feature the user pinned — a search hit, a right-click highlight, the `highlight=` URL param — boxed the same way. The one highlight list the SVG export draws.
soloInk `HighlightRect[]`	The features collected for a solo, boxed the same way, while the solo is still pending. Empty once it applies, since the view then shows only these.
flatbushIndexes `Map<number, FlatbushRegionIndexes>`
derivedColorScales `ColorScale[]`	The key the color channel's scale derives from what the worker painted, less the values only a hidden section painted, in the sections' order where the facet reads the same field. An identity scale's key is its `domain` colors whole, once anything is drawn.
colorScales `ColorScale[]`	`LegendMixin`'s hook: the key the color channel's scale derives.

85 inherited getters from 11 models

From BaseDisplay: parentTrack, RenderingComponent, DisplayBlurb, adapterConfig, isMinimized, featureNoun, featureWidgetType, 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, dataSuperseded, renderBlocks, fetchInputs, regionPayloads, hasRegionData, staleSettingsDrawn, dataCurrent, loadedAssembly, phaseViewportCurrent, svgReady, paintInert, paintSuperseded, displayPhase

From RegionTooLargeMixin: gateEnabled, 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 LegendMixin: showLegend, legendTop, legendRight, legendSpec, hasLegendKey

From ColorWritesMixin: writtenColor

From CanvasFeatureGateMixin: visibleFeatureDensityPerPx, maxFeatureDensity

From HiddenGroupsMixin: displayHiddenGroupKeys, ownGroupState, hiddenGroups, hiddenGroupKeys, groupStateKey

Methods

Member	Description
configuredFilters `() => string[]`	The filters the `filter` config slot holds.
baseFilters `() => string[]`	What the track's config declares for `filter`, which "Clear all filters" returns to.
rampColorScales `(id: string) => ColorScale[]`	The key a ramp paints, under the caller's scale `id`: the bar over its domain, and a row apiece for the values the ramp has no color for. Both displays composing this built it from the same three getters, so the derivation is here rather than twice over.
renderStateIn `(palette: JBrowsePalette) => { scrollY: number; canvasWidth: number; canvasHeight: number; outlineColor: number; hideChevrons: boolean; }`	`renderState` in another palette: the SVG export's, whose theme need not be the session's.
rpcProps `() => { displayConfig: {…}; colorByCDS: boolean; soloFeatureIds: (IMSTArray<…> & IStateTreeNode<…>) \| undefined; hiddenFeatureIds: (IMSTArray<…> & IStateTreeNode<…>) \| undefined; }`
gpuProps `() => { colorTable: Uint32Array<ArrayBuffer>; fieldPalette: { field: string; paint: (value: string) => string; tableOf(values: readonly string[], withTints: boolean): Uint32Array<ArrayBuffer>; } \| undefined; }`	What the main-thread encode needs beyond a region's own data: the packed color for every theme class the worker emitted, off `session.palette`, and the color field's scale, so a theme toggle or a recolor re-encodes what is loaded instead of refetching it.
fitLayoutAt `(memo: (rpcDataMap: ReadonlyMap<number, LayoutRegionData>, inputs: LayoutInputs) => Map<number, FeatureDataResult>, reserved: LabelReservation) => Map<number, FeatureDataResult>`	One fit-escalation candidate: the stack packed with the given label reservation, via that config's own memo instance so each keeps stable references across renders.
decimatedLayoutInputs `(factors: LabelRoomFactors) => LayoutInputs`	Layout inputs for the `decimated` rung at one pair of whitespace factors.
solveLabelRoomFactors `(trackHeight: number) => LabelRoomFactors \| undefined`	The whitespace factors the `decimated` rung commits at: gene names first, then the rest, each the smallest whose packed stack fits `trackHeight` (smallest = most names kept), or undefined when even the most aggressive decimation overflows.
bodyScaleHeightProbe `(cache: (rpcDataMap: ReadonlyMap<number, LayoutRegionData>, inputs: PackKnobFreeInputs) => Map<string, PackedBottoms>, inputs: LabelRoomFactorFreeInputs, factors?: LabelRoomFactors \| undefined) => (bodyScale: number) => number`	Measures a labelled stack's height at any body scale. Each scale is its own prep, since the pack reads body heights from it.
floatingLabels `(palette: JBrowsePalette) => FloatingLabel[]`	The labels the floating label layer draws over the canvas, as records in the display's own px, for a host that shows the canvas but not this display's DOM: a ring of the circular view. The isoform badge is a control, not a label, and stays out.
searchFeatureByID `(id: string) => readonly [number, number, number, number] \| undefined`
renderSvg `(opts?: ExportSvgDisplayOptions \| undefined) => Promise<ReactElement<unknown, string \| JSXElementConstructor<any>> \| Iterable<ReactNode> \| AwaitedReactNode>`
featureNarrowings `() => Reversibles`	Everything this display is doing to narrow what the user sees, each declared once, so the "Filter by... (n)" count, its undo rows and "Clear all filters" cannot disagree; a method, not a getter, because a getter cannot be super-captured.
featureMarks `() => Reversibles`	Reversible state that MARKS features rather than hiding them — the highlight boxes and the pins holding features at the top of the layout.
zoomFetchArgs `() => { geneGlyphMode: "all" \| "auto" \| "longestCoding"; peptides: boolean; expandedGeneIds: (IMSTArray<ISimpleType<string>> & IStateTreeNode<IOptionalIType<IArrayType<ISimpleType<string>>, [...]>>) \| undefined; }`	The worker's zoom-dependent decisions, resolved: the RPC spreads this object and the foundation stamps it beside each region, so a track with the overlay off and a fixed mode never refetches on zoom. `expandedGeneIds` only under `longestCoding`, the one mode the worker collapses in.
groupByPlot `(field: string \| undefined, colorByGroup: boolean) => Plot`	The Group by dialog's choice of field as plot settings, which its Apply writes and its Edit plot button shows: the facet, keeping its domain while the field is the one already set; a color by the field when ticked, left alone while it already paints through any scale; and unticked over a categorical color that was the facet's own, that field parked under `scale: 'none'`. Both colors keep a written constant for the way back, as Color by does.
scanGroupByCandidates `(opts: GroupByScanOptions) => Promise<RegionTooLargeResult \| GroupByCandidate[]>`	The attributes the features in view carry and the sections each would make, for the Group by dialog: the render fetch's download over the visible blocks, under the same admission and byte budget.
plotProblems `(draft: Plot) => string[]`	The base display's problems, then a `jexl:` color or filter that does not compile.
showSubmenuCheckboxItems `() => MenuItem[]`
showSubmenuRadioGroups `() => MenuItem[]`
showSubmenuMenuItems `() => MenuItem[]`	Flattened "Show..." submenu: all checkbox toggles first, then the radio groups (each under its own subHeader).
contextMenuItems `() => MenuItem[]`	The feature right-click menu (open details, zoom to, get sequence, highlight scopes, pin/solo/hide, copy).
colorBySubMenuItems `() => MenuItem[]`	The "Color by..." radio choices (solid/strand/attribute).
colorMenuItems `() => MenuItem[]`	Color-related track menu entries: a single "Color by..." entry whose radios pick the track's own color or a field, and whose "Solid color..." item opens the solid+UTR color picker.
featureHeightMenuItems `() => MenuItem[]`	One "Feature height" menu with two independent radio groups: the size presets and, under a "Track sizing" subheader, how the track responds when there are more features than fit.
trackMenuItems `() => MenuItem[]`

11 inherited methods from 5 models

From BaseDisplay: renderingProps, liftPlot, plotWrites

From MultiRegionDisplayMixin: regionHasData, isCacheValid

From RegionTooLargeMixin: resolvedByteLimit, gateFetchState

From LegendMixin: svgLegendWidth, colorScalesIn, legendSpecIn

From CanvasFeatureGateMixin: observedMaxDensity

Actions

Member	Description
beginYMorph `(fromTops: Map<string, number>, fromMaxY: number) => void`
setMorphProgress `(t: number) => void`
advanceAnimation `(nowMs: number) => void`	the chrome's frame clock
endAnimation `() => void`
setRpcData `(displayedRegionIndex: number, data: FeatureDataResult, region: Region) => void`	Stage a region as fetched — the store's raw write with this display's payload shape, so a test stands up a loaded display in one call.
startRenderingBackend `(backend: CanvasFeatureRenderingBackend) => void`
togglePinnedFeature `(featureId: string) => void`
clearPinnedFeatures `() => void`
toggleExpandedGene `(featureId: string) => void`	Open or re-collapse one gene's isoforms, from the badge on its own label.
clearExpandedGenes `() => void`	Re-collapse every gene opened from a badge.
toggleSoloFeature `(featureId: string) => void`
applySolo `() => void`
soloFeature `(featureId: string) => void`
clearSolo `() => void`
hideFeature `(featureId: string) => void`
showAllHidden `() => void`
setHover `(featureId: string \| undefined, subfeatureId: string \| undefined, tooltip: string[] \| undefined) => void`
clearHover `() => void`
setFeatureHighlights `(highlights: FeatureHighlight[]) => void`
setSearchHighlight `(highlight: FeatureHighlight) => void`	A text search's highlight replaces the previous search's and leaves the right-click ones, which carry a `featureId`, alone.
addFeatureHighlightForItem `(target: HighlightTarget, refName: string) => void`
removeFeatureHighlightsForId `(featureId: string) => void`
clearFeatureHighlights `() => void`
openContextMenu `(info: FeatureContextMenuInfo) => void`	Drops the hover first, so its tooltip does not sit under the menu; the highlight box stays on the target through `hoverBoxFeature`.
openFeatureDetails `(fetch: () => Promise<Feature \| undefined>, parentFeature?: ParentFeatureSummary \| undefined) => void`	Open the feature-details widget on what `fetch` resolves to, with the adapter's header metadata beside it; a lookup that resolves to nothing is reported as a miss.
selectFeature `(feature: Feature) => void`	Open the feature-details widget on a feature already in hand.
clearSelection `() => void`
setShowLabels `(value: "auto" \| "description" \| "name" \| "nameAndDescription" \| "none") => void`
setFilter `(filters?: string[] \| undefined) => void`	Write the `filter` slot (already-`jexl:`-prefixed expressions); undefined returns it to what the track's config declares.
setShowOutline `(value: boolean) => void`
setSequenceHoverPosition `(pos: SequenceHoverPosition \| undefined) => void`
openFilterDialog `() => void`
setDisplayMode `(value: "collapsed" \| "compact" \| "normal" \| "superCompact") => void`
setFacet `(facet?: { field: string; domain?: readonly string[] \| undefined; } \| undefined) => void`	Writes the `facet` object, an unnamed domain as empty, keeping the hidden sections while the field holds; undefined is ungrouped. The stack starts over from the top.
openSetColorDialog `() => void`
fetchFullFeature `(featureId: string, displayedRegionIndex: number, opts?: { signal?: AbortSignal \| undefined; statusCallback?: StatusCallback \| undefined; }) => Promise<SimpleFeature \| undefined>`
selectFeatureById `(featureId: string, subfeatureInfo: SubfeatureInfo \| undefined, displayedRegionIndex: number) => void`
reload `() => void`	Clears the loaded regions and fetches straight away, rather than waiting out `FetchVisibleRegions`' 600ms debounce as the rest of the family does — Retry and Force load are both clicks, and this is the display the user is most often clicking on.
fetchNeeded `(needed: IndexedRegion[]) => void`
openPlotDialog `(seed?: Plot \| undefined) => void`	"Edit plot...", seeded with a draft a dialog has not applied.
applyGroupBy `(field: string \| undefined, colorByGroup: boolean) => void`	What the Group by dialog applies: `groupByPlot`, the draft its Edit plot button shows. The stack starts over from the top.
openColorByAttributeDialog `() => void`
clearHoveredFeature `() => void`	Fills `BaseDisplay`'s hover-clear hook, which the fetch foundation's reaction calls on every viewport change.
openGroupByDialog `() => void`
pickDefaultColor `() => void`	Color by's Default: no field and no solid color, so the track's own color paints, a `jexl:` expression included.
pickSolidColor `() => void`	Color by's Solid color...: paints the constant kept beside a field, where there is one, and opens the picker.