LinearMarkDisplay

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

A display declared in config: a list of marks, each with an encoding from feature fields to channels, drawn in order over one score axis from one worker fetch per region.

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 `types.literal('LinearMarkDisplay')`
configuration `ConfigurationReference(configSchema)`
hiddenCategories `types.frozen< readonly HiddenCategory[] \| undefined >()`	The categories the key's rows hide, each a value of the field a categorical color reads or a color an identity key lists: session state the Categories menu toggles, applied where the colors resolve, so a toggle refetches nothing. Kept across a field change and live again when the field comes back.

4 inherited properties from 2 models

From TreeSidebarMixin: runClustering, clusterRegion, sortRowsBy

From BaseDisplay: id

Volatiles

Member	Description
sourceListing `AdapterRead<RowSourceListing \| null> \| undefined`	The latest `MarkGetRowSources` answer, stamped with the adapter config it answers; null where the adapter lists none or the read failed.
plotFields `PlotFields \| undefined`
plotFieldsError `unknown`
plotDefaultChecked `boolean`
plotFieldsPromise `Promise<PlotFields> \| undefined`
plotScanned `Region[]`
detailsRotation `{ begin(): ActiveFetch; cancel: () => void; dispose(): void; }`
plotScanRotation `{ begin(): ActiveFetch; cancel: () => void; dispose(): void; }`

28 inherited volatiles from 10 models

From StoredHoverMixin: storedHoveredFeature

From ContextMenuMixin: contextMenuInfo

From LegendMixin: dismissedLegendSections

From ScoreScaleMixin: unclippedFenceQuantile

From TreeSidebarMixin: hoveredTreeNode, treeCanvas, mouseoverCanvas

From MultiRegionDisplayMixin: loadedRegions

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

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

From RegionTooLargeMixin: forceLoadTrack, byteEstimate, gateMeasuredViewportKey

From TrackHeightMixin: scrollTop, hostHeight

Getters

Member	Description
gateEnabled `boolean`	Opt into the byte gate: `CoreGetEncodedLayers` measures the index before it downloads, so an over-budget region is refused before a feature is read.
conf `LinearMarkDisplayConfig`	the config typed off the concrete schema
prefersOffset `boolean`	the track label sits above the plot so the y-axis stays on the edge
adapterOptions `object \| undefined`	Overridable hook: what every region's fetch hands the adapter beside the region and the zoom, or undefined for nothing. A fetch input, so a change refetches; `resolveAdapterOptions` places it on each region. Manhattan's LD join is one.
menusOfferPlotFields `boolean`	Overridable hook: whether the track menu offers the scanned fields, so a declared plot still scans, and rescans while it holds none.
joinedPlotFields `JoinedPlotFields`	Overridable hook: the fields `adapterOptions` has the adapter write onto a feature, which Edit plot offers beside the ones a scan of the file found. Manhattan's LD join writes two.
jexlFunctions `{ [k: string]: Signature; }`	What each function a formula may call returns, so Edit plot offers a formula's field as numeric or categorical by what it answers.
configuredFilters `() => string[]`	The `jexl:` expressions the `filter` list holds.
baseFilters `() => string[]`	The expressions the track's config declares, which "Clear all filters" returns to.
markTypes `("bar" \| "line" \| "link" \| "point" \| "rect" \| "rule" \| "text")[]`	The declared marks' types, in draw order.
declaredFacet `FacetSetting \| undefined`	The `facet` object as written, or undefined while unfaceted.
rowGroups `RowGroup[]`	The `rows.groups` entries, each slot filled in.
rowAttributeFields `readonly string[]`	The fields a row has besides its name, which a facet bands the rows by: `group` where `rows.groups` declares groups. Config alone, so whether a facet bands or splits is known before a feature loads.
markSizes `number[]`	Each mark's px, a point's `encoding.size` or a stroked mark's `encoding.strokeWidth` number, its type's default where none is written, and 0 for a bar, span or text, which draw none.
markRowProportions `number[]`	Each mark's `mark.height.band`, which a span alone reads.
rowProportion `number \| undefined`	The proportion the Row height dialog shows: the first sized span's, or undefined where no span has a height, so the dialog asks for none.
hasLinkMark `boolean`	Whether any mark is a link, whose feet place through the view's regions rather than the block's own range.
pointSize `number`	The size the Point size menu shows: the first point mark's, or the default where no mark is a point.
sharedSteps `MarkTransformConfig[]`	The steps every mark runs before its own `transform`: the display's, then the facet's.
origin `number`
filterSteps `TransformStep[]`	The `filter` list as the worker's steps: each expression its own step, and the field tests one step of predicates.
rowsField `string`	`rows.field` as written: the field each value of which takes a row.
showRowSeparators `boolean`	Whether a line runs between rows, `rows.axis.grid`.
bandsRows `boolean`	Whether the facet stacks the rows in bands: `rows` drawn and the facet on a row attribute.
markStepLists `MarkTransformConfig[][]`	The steps that run before each mark's encode, in order: the display's, the facet's, then the mark's own.
markChannels `StepChannels[]`	The channels each mark's steps fill where its encoding leaves them unwritten.
facet `FacetSetting \| undefined`	The facet the worker splits the features into sections by: `declaredFacet`, unless it bands the rows, which are split by `rows` alone and banded here.
markEntries `MarkEntry[]`	Each mark's type and zoom range, what the mark list is built from.
markColors `ColorSource[]`	Where each mark's color comes from (`markColor.ts`), read from the config alone, so editing a color recolors the loaded regions rather than fetching them again.
facetSteps `TransformStep[]`	The facet's own steps as the worker takes them, run over each section before any mark's; with no field to split on they run over the one section there is, after the display's own steps.
layerRequests `LayerRequest[]`	The worker request, one layer per mark: its encoding and the lanes its type reads. Every mark is sent, the one outside its zoom range included, so the worker encodes a layer the view will not draw: measured at 280 ns a feature, 28 ms per 100,000, for the excluded half of the default multiscale pair (`encodeFeatures.bench.ts`, the pair table), against a parse in the hundreds of milliseconds. An empty slot for it would make the zoom a fetch input and refetch the pair on every crossing, so there is none (ADR-112). Its `auto` bin resolves at the bound it next draws at, so a zoom outside its range refetches nothing.
groupKeySpace `string`	`HiddenGroupsMixin`'s hook: a section key means nothing outside the facet that issued it, so moving the field drops what was hidden.
textMarkEntries `TextMarkEntry[]`	Each mark as the text layer places it: the entry with whether it names a `y` and whether its color is written, a constant or a scale. Its own getter so a slot only a label reads never remakes the mark list.
markView `MarkView`	The marks at the view's zoom: whether each draws, inside its `minBpPerPx`..`maxBpPerPx` range where 0 is no bound.
encodings `MarkEncoding[]`	The declared marks' encodings, as the worker takes them.
markList `DisplayMark[]`	The mark list the marks declare — one `defineMark` per config entry with a shape, reading `layers[markIndex]`, off outside its zoom range. A text mark has no shape and is the text layer's, so the list is shorter than `marks` where one is declared. Recomputed only when the entries move, so the component can key its backend factory on it.
drawsRows `boolean`	Whether the display draws one row per value: a `rows` field and no `facet` splitting the features, which draws in the rows' place.
rowGroupMatchers `CompiledRowGroup[]`	The `rows.groups` entries whose `match` compiles.
rowBanding `RowBanding \| undefined`	`TreeSidebarMixin`'s hook: the facet's bands where it bands the rows, its `sort` first and then the `rows.groups` groups in the order they are declared.
drawnRowStep `RowStep`	The `rows.step` the drawn rows take: `rows.step` while the display draws rows, else fit, since a facet's bands have no scroll to reach past the plot's foot.
splitField `string \| undefined`	The field the worker splits the features on: the facet's, else the rows'. One split serves both, so `rows` sends it as `facet`.
drawingMarkIndices `number[]`	Every mark drawing at this zoom, in list order: what folds into the y domain and what the plot's inset and row count are read from.
featurePayloads `ReadonlyMap<number, MarkRegionData>`	The layers as they came back, keyed by displayedRegionIndex: the foundation's per-region store.
adapterListing `RowSourceListing \| undefined`	The adapter's row listing for the current adapter config, until which it is undefined, as for an adapter that lists none.
rowListingSettled `boolean`	The current adapter config's row listing has landed or failed, or this display draws no rows from one.
dataSuperseded `boolean`	True until the row listing settles, since the listing adds rows to the ones the features name and reorders them.
rowListing `RowSourceListing \| undefined`	The adapter's row listing where it names the rows drawn: its field is `rows.field`, or the key a `flatten` in the shared steps wrote over its field. Undefined for an adapter that lists no rows, for one that lists another field, and until the listing for the current adapter config arrives.
adapterSources `ListedRowSource[] \| undefined`	The sources the adapter lists whatever a region holds, a multi-BigWig's files or a MAF's species, in the adapter's order.
guideTreeNewick `string \| undefined`	`TreeSidebarMixin`'s hook: the guide tree the adapter lists over the rows, a MAF's species tree.
discoveredRows `RowSource[]`	`TreeSidebarMixin`'s hook: every row the adapter lists over the rows' field, in its order and with its label and color, so a source with nothing in the loaded regions keeps its row; then the other values the worker split the loaded regions on that have an instance on screen, in the order the field's sections stack. The fetch reaches past the screen on each side, and a row it met only there would stand empty.
rowKeySpace `RowKeySpace`	The key each row holds across every loaded region, assigned at its first arrival and never moved, and the name it is keyed by: under `rows` its section's value, under a facet that value and the row's depth in it. A new split field, or a switch between `rows` and a facet, is a new key space.
facetLayout `FacetLayout`	The sections drawn over every loaded region, in the domain's order and less the hidden ones, and where each key's rows start; under `rows`, one row per value in the rows' order, which no chip names.
rpcDataMap `ReadonlyMap<number, MarkRegionData>`	The layers the display draws. Under a facet or `rows` every row is a key the row table places, so a chip and the band beside it agree whichever region a span came from, and a reorder, a focus, a hidden section or a deeper section moves no instance. A region is keyed again only when it or the key space moves, which is what the upload re-packs.
rowKeys `RowKeys`	`rowKeySpace`'s keys.
rowTable `RowTable \| undefined`	The table every mark places a key through: under `rows` its slot in the rows' order, hidden where the focus leaves it out; under a facet its section's first row plus its depth, hidden with its section. Rebuilt on a reorder, a focus, a hidden or deeper section or a new row, which uploads one small texture and no instance bytes. Undefined while nothing splits the features.
drawnKeys `Uint8Array<ArrayBufferLike> \| undefined`	1 at each key the row table draws, undefined while every key a loaded region has is drawn: a focus or a hidden section moves it, a reorder does not.
scaleDataMap `ReadonlyMap<number, MarkRegionData>`	`rpcDataMap` with each layer's key and extents over the instances the row table draws, its lanes shared: what the legend, the axis and the size scales read, so a row the focus or a hidden section hides leaves them as it leaves the plot.
statsInView `VisibleStats<RegionLayer, ScoreStats> \| undefined`	The `y` stats of every mark drawing at this zoom, or undefined before any valued mark loads
keyWindows `{ regionIndex: number; refName: string; start: number; end: number; }[]`	The bp each displayed region shows once a pan settles, which the key lists what is present in. Compared by value, so a pan that settles where it was rebuilds no key.
valueInsetPx `number`	The px the y scale stands in from both ends of its band, one number for the axis and every mark: room for the largest glyph or half the thickest rule where only those draw, and none beside a bar, whose top edge is its datum and wants the plot box itself. A text mark labels what is drawn and moves nothing.
rowCount `number`	bands a span stacks into: the facet's rows, one per row drawn under `rows`, or else the highest `row` any loaded layer has, plus one
rowsHeaderHeight `number`	`TreeSidebarMixin`'s hook: the plot's top inset.
plotBox `{ yTop: number; plotHeight: number; }`	The plot canvas's box: the axis inset, less the sidebar's lines above the rows at its top, so the canvas starts where the rows do.
sizeScales `(LinkSizeScale \| undefined)[]`	Each link mark's size scale: its declared ends, the open ones the least and greatest the regions draw, so a value strokes at one width in every region; undefined for a mark whose size names no field. Over the drawn layers, as the color ramp's domain is, so a hidden section leaves the stroke widths the way it leaves the key.
linkRegions `readonly LinkRegion[]`	The view's displayed regions as a link's feet place through them (`viewRegionTable`). Empty where no mark is a link, reading nothing per frame.
autoscaleRange `[number, number] \| undefined`	[min, max] over the `y` of every mark drawing at this zoom, through the fence `encoding.y.scale` names, widened to every rule the scale declares and to the origin whenever a bar mark draws, or undefined before any valued mark loads
valuesInView `[number, number] \| undefined`	The least and greatest `y` drawing in view, unfenced.
nrow `number`	`rowCount`, under the name `useRowVirtualScroll`'s shift+wheel resize divides the plot by.
autoRowHeight `number`	`RowHeightMixin`'s hook: the plot split between the rows. Rows under `rows` fill the plot, a fraction of a px each where they must, as every row display's do; a facet's packed rows keep whole px while each can have one.
legendSections `MarkLegendSection[]`	the color keys for the loaded regions, one per scale the marks drawing at the view's zoom resolve through, each headed with its channel's `title`; a categorical or shape key lists the values on screen, a ramp's domain stays over every loaded region
domain `[number, number] \| undefined`
effectiveRowHeight `number`	The px each row is drawn in, the band every shape gets: `drawnRowStep` resolved, pinned or fit.
paintScales `(MarkColorScale \| undefined)[]`	The color scale each mark paints through where its color is quantitative: a ramp over the domain the legend already unioned across the regions, its middle stop a value, or a threshold's cuts and the packed color of each interval. Both ride uniforms, so a pan that widens a domain or an edit that moves a cut uploads no instance bytes and no table.
colorScales `ColorScale[]`	`LegendMixin`'s hook: the keys as color scales, so the chrome and the export draw the legend off the tables the worker resolved, then the row color key
sidebarPanel `SvgSidebarProps \| undefined`	The dendrogram, band strip and row labels at the display's left, which the axis sits past on screen and the export parks left of the figure; none while the rows are not drawn.
valueScales `ValueScale[]`	The one y scale the chrome draws the axis from — `encoding.y` resolved: its type, its domain autoscaled where it pins nothing, its title as the caption and its rules. Every mark reads the same pair.
renderState `MarkRenderState`	geometry and scale for the plot canvas, the same box the hit test measures in
svgSidebar `SvgSidebarProps \| undefined`
hasPointMark `boolean`	Whether a point mark draws at the view's zoom, for the Point size menu.
highlightedHit `MarkHitInfo \| undefined`	The mark the hover or the open context menu is on, or undefined.
highlightStyle `HighlightStyle`	A ring around a point or a rule, since a wash over 4 px of ink is invisible and every hue may be the color scale's; a shade over anything else.
hoverInk `HighlightRect[]`	The box the hovered instance painted, for the chrome's highlight; the context menu's hit stands in while a menu is open. In the chrome's px, so the plot's inset is added to the canvas box. A ring wraps the ink a fixed margin out, round a point and along a rule's whole length, and floors at 6 px, so a tiny point stays findable.
configProblems `MarkProblem[]`	The rule list over the live config, with each problem's level and slot: jbrowse-img fails an export on an error and warns on the rest.
dataNotices `string[]`	What the adapter said about the loaded regions that the plot cannot show — an index SNP no LD record names — each once, for the corner notice, and each `filter` field no loaded feature carries.
displayNotices `string[]`	Overridable hook: notices a display derives from its state and the view, beside the adapter's. Manhattan's reports when the LD index SNP is out of reach of the screen.
rowColorNotices `string[]`	A color over the rows' field whose written `range` names a color a row's own replaces (`withRowColors`), one line per color object.
sharedKeys `SharedKey[]`	The shape keys whose unlisted values collide on one shape, each with the domain Pin distinct shapes writes.
cornerNotices `string[]`	The config's lines, `dataNotices`, and the keys whose values collide: what the corner's problems notice lists. The skipped count appears in a separate chip.
liveNotices `string[]`	`dataNotices`, the colliding keys, and a mark whose every loaded feature was skipped, which a mistyped field is: a display with any of them still draws, so an agent's settle report lists them for a caller that cannot see the corner.
skippedFeatures `SkippedFeatures`	What the worker left out of the loaded regions — a feature whose position or `y` read as missing or not a number — for the corner notice, naming the field a binned position came from.
scrollContentHeight `number`	`TrackHeightMixin`'s hook: the rows under `rows`, taller than the plot wherever a px `rows.step` asks for more than it holds.
scrollViewportHeight `number`	`TrackHeightMixin`'s hook: the plot the rows scroll behind.
rowCompare `RowCompare \| undefined`	The mark clustering and "Sort rows by ... here" read at this zoom, and what of its instances they compare (`rowCompareOf`).
rowCompareLabel `string`	What a sort or a cluster caption names the compared thing.
activeHiddenCategories `readonly HiddenCategory[]`	The hidden categories a color drawn now reads, so a hide kept across a field change counts only once its field is back.
autoClusterReady `boolean`	Two or more clusterable rows once the row listing settles, and a mark to compare them on.
plotScanWindow `Region[]`	The window a field scan reads now (`plotScanRegions`), the same array while a pan stays inside its grid step
plotScanLocus `string \| undefined`	The windows the held field scan read, for the dialog to name: one window's locus, or how many sampled the span they lie across.

140 inherited getters from 14 models

From FacetWritesMixin: writtenFacet

From HiddenGroupsMixin: hiddenGroups, ownGroupState, hiddenGroupKeys, groupStateKey

From StoredHoverMixin: hoveredFeature

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

From ScoreScaleMixin: scaleType, scaleZero, fenceQuantile, clipFenceQuantile, symlogConstant, domainMin, domainMax, autoscaleGroup, scaleTitle, grid, showAxis, scoreRulesDrawn, scoreRules, axisGuide

From ScoreAxisMixin: defaultScoreDomain, axisReachesZero, resolvedDomainMin, resolvedDomainMax, autoscaledDomain, pinsDomain, axes

From RowHeightMixin: rowStep

From TreeSidebarMixin: showTree, showBranchLength, showRowLabels, treeAreaWidth, rowsListedUpFront, baseRowColorChannel, rowSort, rowLabels, storedRowTree, rowTreeProvenance, rowFocus, rowFilter, rowColorChannel, rowColorPins, rowAnnotationChannels, baseRowColorSetting, finerTreeHint, internalRowFields, rowColorFields, baseRowFilter, rowBandingNotices, rowColorIsCustom, rowColorChoice, rowColorFieldsOffered, rowArrangementIsCustom, rotatableRowTree, rowsContentHeight, hierarchy, rowSidebarProps, sidebarBounds, awaitingDependentData, spatialIndex, clusterPartition, treelessBandCount, rowNarrowingClears, rowNarrowingNotices, rowNarrowingHint, treeOnFinerRows, treeHasBranchLengths

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

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

From RenderLifecycleMixin: painted

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

From TrackHeightMixin: configuredHeight, allottedHeight, height, resizing, scrollableHeight

From BaseDisplay: parentTrack, selectedFeatureId, RenderingComponent, DisplayBlurb, adapterConfig, isMinimized, featureNoun, featureWidgetType, plotKeys, plot, configNotices, notices, plotExamples, configDocsUrl

Methods

Member	Description
resolveAdapterOptions `(options: object, _region: Region, _signal: AbortSignal) => Promise<object \| undefined>`	Overridable hook: `adapterOptions` as one region's fetch sends them as `CoreGetEncodedLayers`'s `opts`, resolved on the main thread, where the assembly's aliases are; undefined sends none.
defaultPlotOf `(fields: PlotFields) => DefaultPlot \| undefined`	Overridable hook: what the display draws with nothing declared, off the scanned fields, or undefined where they decide nothing and the plot dialog opens instead.
expandRows `(rows: RowSource[]) => RowSource[]`	`TreeSidebarMixin`'s hook: each row tagged with the group of the first `rows.groups` entry its name matches.
plotRequest `() => { layers: LayerRequest[]; transform: TransformStep[]; facet?: FacetSpec \| undefined; }`	The plot as the worker reads it: each mark's encoding and lanes, and the filters as transform steps. Every field and expression the plot names is in it, and `adapterOptions` is not, so a display may derive its options from what the plot reads.
canonicalRefName `(assemblyName: string, refName: string) => string`	A refName as the assembly it is on names it, which a link's far foot is matched to the view's regions by.
rpcProps `() => { layers: LayerRequest[]; transform: TransformStep[]; facet?: FacetSpec; opts?: object; }`	the fetch inputs SettingsInvalidate watches: `plotRequest`, all of it evaluated in the worker, and the `adapterOptions` each region resolves
floatingLabels `(palette: JBrowsePalette) => FloatingLabel[]`	The text marks' labels as records in the display's own px, for a host that shows the plot canvas but not the text layer over it: a ring of the circular view. Placed and culled as on screen.
configProblemsOf `(conf: AnyConfigurationModel) => string[]`	The rule list over a config, as lines. It replaces the schema's rules rather than adding to them, since it checks the colors and `encoding.y` itself.
liftMarkPlot `(plot: Plot) => MarkPlotSettings`	A draft as the rule list reads it, merged over `plot` and lifted by the config schema, throwing what a config file would be refused for. It changes no state on this display.
exportedFeatures `(features: Feature[]) => Feature[]`	The exported features this display draws: those a mark drawing at this zoom reaches through the worker's steps, in a section or row shown, outside the categories the key hides.
trackMenuItems `() => MenuItem[]`
contextMenuItems `() => MenuItem[]`

17 inherited methods from 5 models

From LegendMixin: colorScalesIn, legendSpecIn

From TreeSidebarMixin: rowFoundAtSomeLoci, svgSidebarWidth, unreadFilterFieldNotice, rowColorFor, orderDropsRowTree, rowOrderWillDropTree, rowAnnotationNotices

From MultiRegionDisplayMixin: regionHasData, isCacheValid

From RegionTooLargeMixin: gateFetchState, resolvedByteLimit

From BaseDisplay: renderingProps, liftPlot, plotProblems, plotWrites

Actions

Member	Description
setSourceListing `(read: AdapterRead<RowSourceListing \| null>) => void`
setRowProportion `(n: number) => void`	Write every sized span's `mark.height.band`; a band-0 span stays the line it draws.
toggleCategory `(field: string, values: readonly string[]) => void`	Hide a key row's categories, or show them all again where any is hidden: `field` the color's, `''` under an identity color.
showAllCategories `() => void`
selectFeature `(hit: MarkHitInfo) => void`	Open the feature widget on the read, the bin or the run a hit drew, inside its facet section, through `selectEncodedFeature`.
setRpcData `(idx: number, data: EncodedLayersResult, region: Region) => void`	Stage a region as fetched, with this display's payload layout.
setShowRowSeparators `(show: boolean) => void`
applyDefaultPlot `(plot: DefaultPlot) => void`	Write a default plot: its marks, its axis, a row per value of its `rows` field where nothing splits the features yet, and its color where the display states none.
sortRowsByValueAt `(refName: string, pos: number) => boolean`	Order the rows by what `rowCompare` reads over (refName, pos), off the loaded regions with no refetch: values and ramped numbers highest first, a span's categories in blocks of one category, the largest on screen first and then in the categories' order, and covered rows before bare ones; false where no loaded region covers the column.
setFilter `(filters?: string[] \| undefined) => void`	Write the `filter` list's expressions; undefined returns them to what the track's config declares.
setPlotFields `(fields?: PlotFields \| undefined, error?: unknown) => void`
setPlotDefaultChecked `() => void`
setPlotFieldsPromise `(promise?: Promise<PlotFields> \| undefined, scanned?: Region[]) => void`
ensurePlotFields `() => Promise<PlotFields>`	Scan the features for the fields a plot can read. A scan that found a numeric field answers for the display's life; one that found none answers only for the window it read, and a failed one for nothing. A scan a newer one aborted answers with the newer one's fields.
openPlotDialog `(seed?: Plot \| undefined, seedOptions?: PlotWriteOptions \| undefined) => void`	Open the plot as text, over the same settings the controls write. `seed` overlays a setting the caller has in hand but has not applied.
setPointSize `(val?: number \| undefined) => void`	Write every point mark's `encoding.size` number; undefined returns each to the default.
pinDistinctShapes `() => void`	The ordinal analogue of the min/max dialog's "Use current range": every value a colliding shape key lists goes into the shape's `scale.domain`, in key order after what it already lists, so each takes a separate shape.
openMarkPlotDialog `(seed?: Plot \| undefined) => void`	Open the plot as controls: every mark, the channels its type reads, and what the rules say under each. The field scan runs behind it, as it does for the field dialog.
openPlotForm `(draft: Plot) => void`	The text box's "Back to form", opened on its draft.
fetchNeeded `(needed: IndexedRegion[]) => Promise<void>`	Fetch each needed region widened to the edges of the widest bin a shared step or a mark drawing at this zoom cuts, so no bin a drawn mark plots is cut at the fetch edge.
startRenderingBackend `(backend: MarkRenderingBackend) => void`	identity encode — the backend uploads the stored payload
decideDefaultPlot `() => Promise<void>`	Scan the current window, and write the default plot off it where the window holds features and nothing has been declared meanwhile. A failed scan is the error of a display with nothing to draw; a declared plot draws on, and the next window scans again.
renderSvg `(opts?: ExportSvgDisplayOptions \| undefined) => Promise<ReactElement<unknown, string \| JSXElementConstructor<any>> \| Iterable<ReactNode> \| AwaitedReactNode>`