LinearMarkDisplay

Auto-generated @jbrowse/mobx-state-tree API for the current JBrowse release — see pluggable elements 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.

Members a composed model contributes are listed here too, so these tables are the whole surface.

Properties

Member	Description	Defined by
type `type: types.literal('LinearMarkDisplay')`		LinearMarkDisplay
configuration `configuration: ConfigurationReference(configSchema)`		LinearMarkDisplay
id `id: ElementId`		BaseDisplay
runClustering `runClustering: types.maybe(types.boolean)`	Transient declarative launch spec, the same idea as `LinearGenomeView`'s `init`: a session or config sets this true and the real clustering RPC runs once automatically, with no dialog, as soon as the display reports itself ready. `setupRunClusteringAutorun` clears it afterwards, so a saved session never re-triggers.	TreeSidebarMixin
clusterRegion `clusterRegion: types.maybe(types.string)`	Where that run reads from, as a locstring (whitespace-separated for several). Clustering is region-scoped, so naming the locus lets a session cluster on the signal and then show it against its context. Cleared with `runClustering`, since it is that flag's argument.	TreeSidebarMixin
sortRowsBy `sortRowsBy: types.maybe(types.frozen<RowSortSpec>())`	Transient declarative launch spec, the same idea as `runClustering`: set `{refName, pos}` to order the rows once by the value each carries at that genomic column — the session-expressible form of the right-click "Sort rows by ... here". `setupRowSortAutorun` applies it once the region containing it has loaded and then clears it, so the resulting order persists but a saved session never re-sorts.	TreeSidebarMixin

Volatiles

Member	Description	Defined by
sourceListing `sourceListing: undefined as \| AdapterRead<RowSourceListing \| undefined> \| undefined`	The latest `MarkGetRowSources` answer, stamped with the adapter config it answers.	LinearMarkDisplay
plotFields `plotFields: undefined as PlotFields \| undefined`		LinearMarkDisplay
plotFieldsError `plotFieldsError: undefined as unknown`		LinearMarkDisplay
plotDefaultChecked `plotDefaultChecked: false`		LinearMarkDisplay
plotFieldsPromise `plotFieldsPromise: undefined as Promise<PlotFields> \| undefined`		LinearMarkDisplay
plotScanned `plotScanned: [] as Region[]`		LinearMarkDisplay
detailsRotation `detailsRotation: createAbortRotation(self, { statusWindow: self.statusWindow, })`		LinearMarkDisplay
plotScanRotation `plotScanRotation: createAbortRotation(self, { statusWindow: self.statusWindow, })`		LinearMarkDisplay
coarseTier `coarseTier: regionDataMap<P>('coarseTier')`	The coarse payload by `displayedRegionIndex`, over the regions the last read was issued for. Cleared on chromosome navigation.	CoarseTierMixin
coarseTierRead `coarseTierRead: undefined as CoarseTierRead \| undefined`	What the held payloads were read over — the buffered regions and the read key — so a pan or a zoom inside them re-reads nothing. Undefined until a read lands.	CoarseTierMixin
coarseTierLoading `coarseTierLoading: false`		CoarseTierMixin
unclippedQuantile `unclippedQuantile: undefined as number \| undefined`		ScoreScaleMixin
dismissedLegendSections `dismissedLegendSections: [] as string[]`	Ids of the scales whose section the reader closed on its own; cleared when the whole legend is shown again. Volatile where `showLegend` is config: which sections a reader collapsed in one sitting is not how the track is configured.	LegendMixin
contextMenuInfo `contextMenuInfo: undefined as Info \| undefined`		ContextMenuMixin
storedHoveredFeature `storedHoveredFeature: undefined as T \| undefined`		StoredHoverMixin
hiddenGroups `hiddenGroups: observable.set<string>()`	Group keys the user hid from the stack.	HiddenGroupsMixin
error `error: undefined as unknown`		BaseDisplay
statusMessage `statusMessage: undefined as string \| undefined`		BaseDisplay
statusProgress `statusProgress: undefined as number \| undefined`	determinate progress fraction [0,1] for the current status, or undefined when the in-flight phase is indeterminate. Set alongside `statusMessage` by `setStatusMessage`; a display that never shows a bar simply leaves it undefined.	BaseDisplay
scrollTop `scrollTop: 0`		TrackHeightMixin
loadedRegions `loadedRegions: regionDataMap<LoadedRegion>('loadedRegions')`	The per-region store, keyed by `displayedRegionIndex`: what a fetch asked for (the span), what it was issued under (`fetchInputs`) and what it brought back (`payload`), written as one record by `ctx.commitRegion`. A display's own `rpcDataMap` was the payload column of this map held separately, and every hook that existed to keep the two in step — `clearDisplaySpecificData`, a `regionHasData` that answered `rpcDataMap.has(idx)`, a hand-rolled prune — was that separation's cost. A display reads the payload back through `regionPayloads`.	MultiRegionDisplayMixin
forceLoadTrack `forceLoadTrack: false`	The force-load button's track-wide approval. Volatile so it never reaches a saved session; the `forceLoad` config slot is the durable form.	RegionTooLargeMixin
byteEstimate `byteEstimate: undefined as ByteEstimate \| undefined`	The last byte measurement: bytes, the span they were taken at, and whether zooming has been shown not to shrink them. Survives `clearAllRpcData`; dropped on chromosome navigation and on a tier swap.	RegionTooLargeMixin
gateMeasuredViewportKey `gateMeasuredViewportKey: undefined as unknown`	The `gateViewport` key the gate last asked the adapter about, on either axis — the viewport AND the settings it asked under. Separate from `byteEstimate` because a density refusal measures no bytes.	RegionTooLargeMixin
canvasDrawn `canvasDrawn: false`	flips true on first paint; read by test selectors to detect render	RenderLifecycleMixin
paintCount `paintCount: 0`	bumped after every frame the backend painted, so a consumer that reads this display's canvas — the circular view's ring, which copies the strip into a texture — knows when the pixels moved	RenderLifecycleMixin
currentRenderingBackend `currentRenderingBackend: undefined`	current backend reference, updated on context-loss recovery. Typed `unknown` (not generic `B`) on purpose: this mixin is composed by every display via a non-generic factory, so the per-display backend type `B` isn't known here — it's supplied at `attachRenderingBackend<B>` and narrowed with `as B` inside the autoruns. Don't "fix" the cast.	RenderLifecycleMixin
renderTick `renderTick: 0`	counter the render autorun observes; bumped to force a re-render	RenderLifecycleMixin
autorunsInstalled `autorunsInstalled: false`	guards attachRenderingBackend so the autorun pair spawns once per instance	RenderLifecycleMixin
renderError `renderError: undefined`	the render-backend (GPU/Canvas2D init or context-loss) error, or undefined. Single source of truth for the render-error terminal state: `useRenderingBackend` writes it from the canvas-init mechanism so the model — not React-local hook state — owns every terminal state. Read by `displayPhase` (whose `renderError` term outranks `loading`, suppressing the scrim) and by `DisplayChrome` (shows the retry overlay).	RenderLifecycleMixin
offScreen `offScreen: false`	the display's canvas has scrolled out of the page, so the render autorun skips pan and zoom redraws, still draws new data, and hands its GPU targets back after every tick. Written by `useRenderingBackend`, which watches the canvas element itself — false everywhere `IntersectionObserver` is absent, which is every unit test and every non-browser host. A whole view that scrolls away is already unmounted (`useViewVisibility`) and a minimized track never mounts, so what this covers is the track below the fold of a view that IS mounted: the display list is not windowed, and each of those tracks holds a full-height multisampled target.	RenderLifecycleMixin
activeSignal `activeSignal: undefined as AbortSignal \| undefined`	signal of the in-flight fetch, or undefined when idle	FetchMixin
fetchGeneration `fetchGeneration: 0`	bumps at every fetch end; autoruns read it to re-evaluate, and it doubles as the staleness epoch inside runFetch	FetchMixin
reloadCounter `reloadCounter: 0`	Bumped by `reload()` and read unconditionally by the fetch autoruns, so a user retry re-runs the body even where nothing else moved — after an error every other fetch input is unchanged. It is also the half that survives a `reload()` override that forgets to invalidate, which is the dead Retry button `makeRetryContractCheck` reports. Declared here because this is the one mixin every fetch foundation composes, the same argument that put `fetchInert` below; the comparative family carried its own until ADR-105.	FetchMixin
statusWindow `statusWindow: createStatusWindow(writeStatus(self))`	This display's status field, and the only thing that writes it: one throttle window, one slot per concurrent operation, so N parallel per-region fetches thin to one stream between them rather than N and a second operation cannot end the first one's label (ADR-081). Lent whole to `createAbortRotation` by a display that also runs a bare-autorun fetch — see `StatusReporter`.	FetchMixin
fetchCanceled `fetchCanceled: false`	true after the user explicitly cancels a load (the loading overlay's cancel button → `cancelFetchByUser`). A durable, blocking state — unlike `cancelFetch`, it does not retrigger the fetch autoruns — so the load stays stopped until the user retries (`reload`) or the viewport changes. Any new fetch clears it (`runFetch` resets it at the start).	FetchMixin
fetchRotation `fetchRotation: createAbortRotation(self, { statusWindow: self.statusWindow, })`	The latest-wins machine this mixin is a wrapper around, and not a second one: `createAbortRotation` owns abort rotation, the `isCurrent` guard, the status slot and the supersede-versus-end rule (ADR-080, ADR-081), for every fetch in the codebase that has one. `runFetch` adds the observable bookkeeping a display needs on top — `isLoading`, `error`, `fetchGeneration`, `fetchCanceled` — and nothing else. It was two implementations of that machine until 2026-08-20, which is how they came to disagree about whether a completed fetch releases its signal. A display's primary fetch is this wrapper; a second concurrent fetch on the same node holds a rotation of its own, which is why the primitive is the thing that exists and this is the thing built on it (ADR-054 §1, the one section ADR-105 keeps). It is lent this display's `statusWindow`, so the fetch takes a slot on the one field rather than opening a second window over it — the whole point of `StatusReporter`.	FetchMixin
hoveredTreeNode `hoveredTreeNode: undefined as HoveredTreeNode \| undefined`		TreeSidebarMixin
treeCanvas `treeCanvas: null as HTMLCanvasElement \| null`		TreeSidebarMixin
mouseoverCanvas `mouseoverCanvas: null as HTMLCanvasElement \| null`		TreeSidebarMixin

Getters

Member	Description	Defined by
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, and the density tier draws in place of the refused region.	LinearMarkDisplay
conf `ConfigNodeProps<…> & ConfigNodeActions & ConfigNodeBrand<ConfigurationSchemaType<…>>`	the config typed off the concrete schema	LinearMarkDisplay
prefersOffset `boolean`	the track label sits above the plot so the y-axis stays on the edge	LinearMarkDisplay
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.	LinearMarkDisplay
markTypes `("bar" \| "line" \| "link" \| "point" \| "rule" \| "span" \| "text")[]`	The declared marks' types, in draw order.	LinearMarkDisplay
facet `FacetSetting \| undefined`	The `facet` object as written, or undefined while unfaceted.	LinearMarkDisplay
groupKeySpace `string`	`HiddenGroupsMixin`'s hook: a section key means nothing outside the facet that issued it, so moving the field drops what was hidden.	LinearMarkDisplay
markEntries `MarkEntry[]`	Each mark's type and zoom range, what the mark list is built from.	LinearMarkDisplay
textMarkEntries `TextMarkEntry[]`	Each mark as the text layer places it: the entry with whether it names a `y` and whether its colour is written, a constant or a scale. Its own getter so a slot only a label reads never remakes the mark list.	LinearMarkDisplay
markView `MarkView`	The marks at the view's zoom: whether each draws, inside its `minBpPerPx`..`maxBpPerPx` range where 0 is no bound, and the first drawing mark the density sidecar stands in for, -1 where none does.	LinearMarkDisplay
densityMarkIndex `number`	The mark the density sidecar stands in for, or -1.	LinearMarkDisplay
markSizes `number[]`	Each mark's `encoding.size` number in px, its type's default where none is written, which a bar or span leaves unread.	LinearMarkDisplay
markRowProportions `number[]`	Each mark's `rowProportion`, which a span alone reads.	LinearMarkDisplay
rowProportion `number \| undefined`	The proportion the Row height dialog shows: the first span's, or undefined where no mark is a span, so the dialog asks for none.	LinearMarkDisplay
hasLinkMark `boolean`	Whether any mark is a link, whose feet place through the view's regions rather than the block's own range.	LinearMarkDisplay
pointSize `number`	The size the Point size menu shows: the first point mark's, or the default where no mark is a point.	LinearMarkDisplay
encodings `MarkEncoding[]`	The declared marks' encodings, as the worker takes them.	LinearMarkDisplay
markStepLists `UnionNode<…>[][]`	The steps that run before each mark's encode, in order: the display's, the facet's, then the mark's own.	LinearMarkDisplay
markChannels `StepChannels[]`	The channels each mark's steps fill where its encoding leaves them unwritten.	LinearMarkDisplay
markColors `ColorSource[]`	Where each mark's colour comes from (`markColor.ts`), read from the config alone, so editing a colour recolours the loaded regions rather than fetching them again.	LinearMarkDisplay
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.	LinearMarkDisplay
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.	LinearMarkDisplay
origin `number`		LinearMarkDisplay
minWidthPx `number`		LinearMarkDisplay
configuredFilters `() => string[]`	the `filter` slot	LinearMarkDisplay
baseFilters `() => string[]`	What the track's config declares for `filter`, which "Clear all filters" returns to.	LinearMarkDisplay
rowsField `string`	`rows.field` as written: the field each value of which takes a row.	LinearMarkDisplay
drawsRows `boolean`	Whether the display draws one row per value: a `rows` field and no `facet`, which draws in its place until bands of rows land.	LinearMarkDisplay
drawsKeyedRows `boolean`	Whether each `row` lane holds a key the row table places: under `rows`, except while the density sidecar stands in, whose bins count every row's features and draw as one band.	LinearMarkDisplay
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`.	LinearMarkDisplay
rowColorFields `readonly string[]`	`TreeSidebarMixin`'s hook: none, since a row is a value of the rows field and carries no attribute of its own.	LinearMarkDisplay
coarseTierMode `CoarseTierMode`	`CoarseTierMixin`'s hook, narrowed: with no mark declaring the sidecar there is nothing to draw the bins as, so the tier neither reads nor stands in and the banner is the answer it always was.	LinearMarkDisplay
densityPayloads `ReadonlyMap<number, MarkRegionData>`	The tier's bins as this display's own payload: the density mark's layer built from the sidecar's intervals, every other mark empty. Keyed off `coarseTier`, which moves once per read.	LinearMarkDisplay
featurePayloads `ReadonlyMap<number, MarkRegionData>`	The layers as they came back, keyed by displayedRegionIndex: the foundation's per-region store, or the density tier's bins where the gate refused the features and a mark declared the sidecar. One map, so the domain, the legend, the hover, the highlight and the SVG export read the tier through the paths they already had.	LinearMarkDisplay
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 none, one that lists another field, and until the current adapter config's listing lands.	LinearMarkDisplay
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.	LinearMarkDisplay
guideTreeNewick `string \| undefined`	`TreeSidebarMixin`'s hook: the guide tree the adapter lists over the rows, a MAF's species tree.	LinearMarkDisplay
discoveredRows `RowSource[]`	`TreeSidebarMixin`'s hook: every row the adapter lists over the rows' field, in its order and with its label and colour, so a source with nothing in the loaded regions keeps its row; then the other values the worker split the loaded regions on, in the order the field's sections stack.	LinearMarkDisplay
sources `RowSource[]`	The rows drawn, top to bottom: the arrangement narrowed to the focus.	LinearMarkDisplay
rowKeys `RowKeys`	The key each value of `rows.field` holds across every loaded region, assigned at the value's first arrival and never moved; a new field is a new key space.	LinearMarkDisplay
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.	LinearMarkDisplay
rpcDataMap `ReadonlyMap<number, MarkRegionData>`	The layers the display draws. Under a facet every region's rows are offset onto the one layout, so a chip and the band beside it agree whichever region a span came from; under `rows` every row is a key the row table places, so a reorder or a focus moves no instance. A region is offset or keyed again only when it, the facet's layout or the key space moves, which is what the upload re-packs.	LinearMarkDisplay
rowTable `RowTable \| undefined`	Under `rows`, the table every mark places a key through: its slot in the rows' order, hidden where the focus leaves it out. Rebuilt on a reorder, a focus or a new value, which uploads one small texture and no instance bytes. Undefined wherever the lanes are not keys.	LinearMarkDisplay
drawnKeys `Uint8Array<ArrayBufferLike> \| undefined`	1 at each key the row table draws, undefined while every key a loaded region carries is drawn: a focus moves it, a reorder does not.	LinearMarkDisplay
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 hides leaves them as it leaves the plot.	LinearMarkDisplay
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.	LinearMarkDisplay
hasPointMark `boolean`	Whether a point mark draws at the view's zoom, for the Point size menu.	LinearMarkDisplay
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.	LinearMarkDisplay
autoscaleRange `[number, number] \| undefined`	[min, max] over the `y` of every mark drawing at this zoom, through the autoscale mode `scales.y` names, widened to every rule the scale declares and to the origin whenever a bar mark draws, or undefined before any valued mark loads	LinearMarkDisplay
domain `[number, number] \| undefined`		LinearMarkDisplay
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.	LinearMarkDisplay
valueScales `ValueScale[]`	The one y scale the chrome draws the axis from — `scales.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.	LinearMarkDisplay
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 carries, plus one	LinearMarkDisplay
nrow `number`	`rowCount`, under the name `useRowVirtualScroll`'s shift+wheel resize divides the plot by.	LinearMarkDisplay
autoRowHeight `number`	`RowHeightMixin`'s hook: the plot split between the rows.	LinearMarkDisplay
rowsHeaderHeight `number`	`TreeSidebarMixin`'s hook: the plot's top inset.	LinearMarkDisplay
plotBox `{ yTop: number; plotHeight: number; }`	The plot canvas's box: the axis inset, less the focus chip's line at its top, so the canvas starts where the rows do.	LinearMarkDisplay
paintScales `(MarkColorScale \| undefined)[]`	The colour scale each mark paints through where its colour 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 colour 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.	LinearMarkDisplay
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 colour ramp's domain is, so a hidden section leaves the stroke widths the way it leaves the key.	LinearMarkDisplay
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.	LinearMarkDisplay
renderState `MarkRenderState`	geometry and scale for the plot canvas, the same box the hit test measures in	LinearMarkDisplay
highlightedHit `MarkHitInfo \| undefined`	The mark the hover or the open context menu is on, or undefined.	LinearMarkDisplay
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 colour scale's; a shade over anything else.	LinearMarkDisplay
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.	LinearMarkDisplay
configProblems `MarkProblem[]`	What the declared marks say that the display cannot draw as written, reported where a load would once have refused the track.	LinearMarkDisplay
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.	LinearMarkDisplay
sharedKeys `SharedKey[]`	The shape keys whose unlisted values collide on one shape, each with the domain Pin distinct shapes writes.	LinearMarkDisplay
cornerNotices `string[]`	The config problems as lines, `dataNotices`, and the keys whose values collide: what the corner's problems notice lists. The skipped count has a chip of its own.	LinearMarkDisplay
notices `string[]`	`cornerNotices` and a mark whose every loaded feature was skipped, which a mistyped field is, as lines an agent's settle report carries: a display with any of them still draws, so nothing else reaches a caller that cannot see the corner.	LinearMarkDisplay
densityStandInNotice `string \| undefined`	The corner notice while the sidecar stands in, naming what is drawn and how many marks are not: past the budget the banner is gone, and nothing else on screen says the bars are the sidecar's.	LinearMarkDisplay
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.	LinearMarkDisplay
legendSections `MarkLegendSection[]`	the colour keys the loaded regions carry, one per scale the marks drawing at the view's zoom resolve through, each headed with its channel's `title`	LinearMarkDisplay
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 colour key	LinearMarkDisplay
effectiveRowHeight `number`	The px each row is drawn in, the band every shape gets: `RowHeightMixin`'s under `rows`, pinned or fit. Elsewhere the bands fit the plot whatever `rowHeight` holds, since a facet's rows and the density sidecar's one band have no scroll to reach past the plot's foot.	LinearMarkDisplay
scrollContentHeight `number`	`TrackHeightMixin`'s hook: the rows under `rows`, taller than the plot wherever a pinned `rowHeight` asks for more than it holds.	LinearMarkDisplay
scrollViewportHeight `number`	`TrackHeightMixin`'s hook: the plot the rows scroll behind.	LinearMarkDisplay
valueMarkIndex `number`	The first mark drawing at this zoom that stands at a value: what a row's value at a column is read from, and what clustering compares. -1 where none does.	LinearMarkDisplay
hierarchy `ClusterHierarchyNode \| undefined`	The dendrogram positioned against the rows drawn, or undefined where it no longer names them.	LinearMarkDisplay
spatialIndex `TreeSpatialIndex \| undefined`		LinearMarkDisplay
svgSidebar `SvgSidebarProps \| undefined`		LinearMarkDisplay
plotScanLocus `string \| undefined`	The window the held field scan read, for the dialog to name.	LinearMarkDisplay
coarseAdapterSlot `string`		DensityTierMixin
densityTierMode `"auto" \| "density" \| "features"`	The `densityTier` slot's value.	DensityTierMixin
densityTierThresholdBpPerPx `number`		DensityTierMixin
coarseTierPastThreshold `boolean`	`auto` also swaps from the `densityTierBpPerPx` slot outward, where a track asks for the band before the region is too large to fetch.	DensityTierMixin
coarseReadKey `string`	The bins are read at the view's bp/px, so a real zoom re-reads at the level the sidecar keeps for it and a small one reuses what is held.	DensityTierMixin
coarseTierGated `boolean`	Overridable hook (default false): the coarse read is a feature download the byte gate has to measure. The gate then measures the coarse adapter while the tier is up, its refusal is the banner, the detail fetch stands down outright since the coarse read is the measurement pass, and the swap is by threshold alone — the verdict is about whichever tier is up, so it cannot also pick the tier. A read bounded by construction (bins per screen pixel) leaves this off.	CoarseTierMixin
coarseTierHasSomewhereToDraw `boolean`	Overridable hook (default true): the display has somewhere to put the tier. Alignments fills it with `showCoverage`. The measured view is not this hook but the tier's own term below, since every display drawing one needs the geometry the draw is mapped through.	CoarseTierMixin
coarseSourceConfig `unknown`	The coarse source's config, read off the live track config so a re-pointed adapter follows.	CoarseTierMixin
hasCoarseSource `boolean`		CoarseTierMixin
coarseTierActive `boolean`	Whether the coarse tier stands in for the detail right now.	CoarseTierMixin
coarseTierStandsIn `boolean`	Whether the tier is standing in for the detail on screen right now: the tier's verdict, a measured view, and the display's own `coarseTierHasSomewhereToDraw`. Not a hook any more. It was one, and the three displays that filled it wrote two spellings of the same conjunction between them — which is how alignments came to be the one that never checked the view. A display with a place-to-draw term states that term alone now.	CoarseTierMixin
gateMeasuresCoarse `boolean`	The byte gate is measuring the coarse read rather than the detail fetch, so its verdict is about the tier on screen.	CoarseTierMixin
byteGateAdapterPath `ByteGateAdapterPath`	`RegionTooLargeMixin`'s hook: measure the adapter of the fetch that is about to run, so the estimate and the budget describe one file.	CoarseTierMixin
gateRefusesDetail `boolean`	The gate's refusal is about the detail fetch, so that fetch owes the re-measure the gate releases through.	CoarseTierMixin
coarseTierIssueKey `{ adapter: (Record<string, unknown> & { type: string; }) \| undefined; read: unknown; }`	The whole key a read is held under: the coarse adapter and the display's own term.	CoarseTierMixin
fetchSuspended `boolean`	`MultiRegionDisplayMixin`'s hook, from `resolveFetchSuspended` over `coarseTierStandsIn`.	CoarseTierMixin
displayPhase `DisplayPhase`	The foundation's phase with the too-large banner swapped for the tier — see `coarseTierDisplayPhase`.	CoarseTierMixin
svgReady `boolean`	The export gate under the same swap — see `coarseTierSvgReady`.	CoarseTierMixin
drawsWhenTooLarge `boolean`	`renderDisplaySvg`'s hook: the export paints the tier in place of the too-large note, the same swap the chrome makes on screen — unless the note is about the coarse read itself.	CoarseTierMixin
scaleType `string`		ScoreScaleMixin
scaleZero `boolean`	`scales.y.zero`: whether an autoscaled linear or symlog axis reaches 0.	ScoreScaleMixin
domainQuantile `number`	`scales.y.domainQuantile`: what an unpinned end follows, 1 the extremes and below it that quantile of each sign.	ScoreScaleMixin
clipQuantile `number`	The quantile "Clip extreme outliers" fences at: the one an untick this session wrote over, else the scale's own default where that is below 1, else 0.99.	ScoreScaleMixin
symlogConstant `number`	Raw slot; `0` means "derive from the domain". Resolve it with `resolveSymlogConstant` once the domain is known.	ScoreScaleMixin
manualMinScore `number \| undefined`	The lower bound the config pins, `undefined` where it pins none.	ScoreScaleMixin
manualMaxScore `number \| undefined`	The upper bound the config pins, `undefined` where it pins none.	ScoreScaleMixin
valueScaleNotices `string[]`	What `scales.y`'s ends say together that the axis cannot draw as written, as corner-notice lines, by the rule a colour ramp's ends answer to. The mark display reports them through its rule list.	ScoreScaleMixin
autoscaleGroup `string \| undefined`	`scales.y.autoscaleGroup`, `undefined` while it names none.	ScoreScaleMixin
scaleTitle `string`	`scales.y.title`, `''` while unset	ScoreScaleMixin
grid `boolean`	`scales.y.grid`	ScoreScaleMixin
minimalTicks `boolean`	`scales.y.minimalTicks`	ScoreScaleMixin
scoreRulesDrawn `boolean`	Whether this display draws `scales.y.rules`, which is whether the Y axis panel offers Include 0 and the reference lines: a scale it places y through rules a band for them to cross, which a density plot's colour-mapped rows and a colour ramp do not.	ScoreScaleMixin
scoreRules `ValueScaleRule[]`	`scales.y.rules`, read off the live nodes: a snapshot strips a slot at its default, and a rule at 0 is one.	ScoreScaleMixin
defaultScoreDomain `[number \| undefined, number \| undefined]`	Overridable hook: what each end of the domain falls back to where the config leaves its bound unset. `[undefined, undefined]` — the default — means autoscale both ends, which is right for a track whose scores have no absolute meaning (a bigwig's units are its own). A display whose scores are bounded by construction overrides it, so the axis stops being a function of what happens to be on screen: GC content is a fraction, so 0 and 1 are its real limits and mean the same thing at every locus. Autoscaled, the same GC value drew at different heights depending on where the user had panned, and the track could not be read across loci. A hook rather than a config default because the answer can depend on the data — the wiggle display reads the bounds its adapter declares, a GC content track's [0, 1] — and rather than each display re-resolving the sentinels, which is the one thing that must not be duplicated: config bounds still win, precisely because they are checked before this is consulted.	ScoreAxisMixin
axisReachesZero `boolean`	Overridable: whether the autoscaled domain reaches 0, `scaleZero` unless the display maps its score to something with no axis.	ScoreAxisMixin
autoscaledDomain `[number, number] \| undefined`	The domain an autoscaled axis draws: `autoscaleRange`, widened to every range its `autoscaleGroup` holds, nice-rounded inside this display's own bounds. Each member unions the others' own ranges and never their domains, so a pinned end stays the display's that pinned it. `undefined` while this display has nothing of its own to scale.	ScoreAxisMixin
minScoreBound `number \| undefined`	Resolved lower bound; `undefined` means autoscale this end.	ScoreAxisMixin
maxScoreBound `number \| undefined`	Resolved upper bound; `undefined` means autoscale this end.	ScoreAxisMixin
hasManualScoreBounds `boolean`	Whether the user has pinned either end, which is a different question from whether either end resolved to a number: `defaultScoreDomain` fills the unset ends in, so a GC content track answers yes to the second with nothing configured. The score menu asks this one — it captions the min/max row with the range in force, and a caption off the resolved pair named a range on every freshly opened GC content track.	ScoreAxisMixin
axes `YAxis[]`	The axes, one per declared scale whose domain resolved: where each tick lands in the band's own pixel space, through `computeYTicks` unless the scale brought its own ladder, and where each of the scale's `rules` inside the domain lands in that same box, through the scale type the renderer places its values by.	ScoreAxisMixin
showLegend `boolean`	Whether the legend is drawn.	LegendMixin
legendTop `number`	Overridable hook (default 0): px the on-screen key is pushed down from its own inset. A display that already draws a control of its own in that corner — Hi-C's resolution box — answers that control's height; the chrome adds its own axis captions on top. The export draws no controls, so it does not read this.	LegendMixin
legendRight `number`	Overridable hook (default 0): px the on-screen key is pushed left from its own inset, for a display that draws a column of text down its right edge — the multi-way lanes' scales. Not read by the export.	LegendMixin
legendSpec `LegendSpec`	The key, derived from `colorScales` less the sections the reader dismissed. `DisplayChrome` renders it on screen and `renderDisplaySvg` flattens it for the export, so the two describe one set of colors.	LegendMixin
hasLegendKey `boolean`	Whether the display has a key at all. The "Show legend" row is offered only when it does. Overridable for a display whose key is only waiting for data: a scale that stays empty until a region lands must not remove the toggle in the meantime.	LegendMixin
hoveredFeature `T \| undefined`		StoredHoverMixin
displayHiddenGroupKeys `ReadonlySet<string>`	Overridable hook: lanes the DISPLAY hides on its own behalf, as opposed to the ones the user hid from a chip. Empty by default; LGVSyntenyDisplay hides the self-alignment lane of an all-vs-all track through it.	HiddenGroupsMixin
hiddenGroupKeys `ReadonlySet<string>`	Every key the stack drops: what the user hid and what the display hides for itself. A fresh Set per change rather than the observable set itself, so a layout memo comparing its inputs by identity sees a hide.	HiddenGroupsMixin
parentTrack `AbstractTrackModel`		BaseDisplay
RenderingComponent `FC<…>`		BaseDisplay
DisplayBlurb `FC<{ model: ModelInstanceTypeProps<{ id: IOptionalIType<ISimpleType<string>, [undefined]>; type: ISimpleType<string>; }> & { ...; } & { ...; } & IStateTreeNode<...>; }> \| null`		BaseDisplay
adapterConfig `Record<string, unknown>`		BaseDisplay
isMinimized `boolean`	Returns true if the parent track is minimized. Used to skip expensive operations like autoruns when track is not visible.	BaseDisplay
featureNoun `string`	Overridable hook (default `'feature'`): the SINGULAR word for one of the things this display draws, as a menu row or a chip says it — "Hide this read", "Showing 3 variants". Declared here for the same reason as `hoveredFeature` above: it is read across the display boundary, by chrome that has no idea which display it is drawing for (`SoloSelectionChip`, alignments' group-label overlay), and a name only the base declares is a name every such consumer can rely on. Two displays declared it independently and one of those declarations WAS this default. A control keeps the generic word; content takes this one. "Variant height" reads as a different setting from "Feature height" when it is the same one, so the shared menus stay on "feature" however the display answers here, and the noun varies where it names what the user is looking at — "Showing 3 variants", "Hide this read". A display drawing something the generic word already fits is right to leave this alone. Distinct from the per-hit noun a context menu takes off the clicked item's own `type` ("mRNA", "gene"); that names one annotation, this names what the track holds. The hit noun falls back to this.	BaseDisplay
featureWidgetType `{ type: string; id: string; }`	The widget `openFeatureWidget` opens for one of this display's features. Displays may override it. The default is the generic feature widget, for displays drawing plain features. Displays whose features are a specific kind (a read, a variant, a synteny block) override it, including the `id`: two displays naming one id share the drawer panel, which suits two displays showing the same kind of feature.	BaseDisplay
plotKeys `string[]`	The grammar settings this display's config declares, by slot name (`PLOT_VOCABULARY`): what "Edit plot..." edits. Empty on a display with none, which then offers no editor.	BaseDisplay
plot `Plot`	Those settings as declared, defaults left off and a shorthand written as a config file writes it. An agent edits a `structuredClone` of it, checks it with `plotProblems` and hands it to `applyPlot`.	BaseDisplay
plotExamples `readonly PlotExample[]`	The worked examples this display type declares, which "Edit plot..." offers as buttons.	BaseDisplay
configDocsUrl `string`	This display type's page in the config reference, which lists every setting it takes.	BaseDisplay
height `number`		TrackHeightMixin
resizing `boolean`	True for the duration of a height drag on this track, whichever handle is running it. A display whose row geometry is a function of the track height restretches every row per animation frame, and can use this to sit an expensive per-frame layer out of the drag (MAF's dense per-base letter overlay is a Canvas2D pass that scales with rows x columns). The flag itself is the track's (`BaseTrackModel`), so the view brackets a drag without needing the active display to have opted into this mixin. This getter reads it so that a display that did opt in has `self.resizing`.	TrackHeightMixin
scrollableHeight `number`	How far the content scrolls. A sub-pixel overflow is 0: a fit mode that divides the viewport across n rows multiplies back to a few ULPs over it, and an extent of 1e-14px still draws a scrollbar and holds the wheel away from the page.	TrackHeightMixin
host `RegionHost`	The containing LinearGenomeView, typed once for every display in this family — see `containingHost` for the cast it owns and why both foundations still declare the name.	MultiRegionDisplayMixin
canvasWidthPx `number`	The CSS width of this display's on-screen canvas, in px — and the `canvasWidth` its `renderState` must carry, since the two have to agree or the bp→px mapping is scaled against a box it doesn't fill. `trackWidthPx`, not `view.width`: `TrackRenderingContainer` insets the rendering component by the 2px track outline under `contain: strict`, so a `view.width`-wide canvas overhangs its own container and the browser clips the overhang away. It renders almost identically, which is why MAF drifted onto `view.width` uncaught. A getter rather than a note on each display, because the choice was being made by copying a neighbour out of four plausible view getters — `width` (the viewport), this one, and `totalWidthPx` / `totalWidthPxWithoutBorders` (the content width, which the global family's heatmaps legitimately want: a different question, not a different answer). `no-restricted-syntax` bans the underlying read everywhere but this line, since a second spelling agrees until it doesn't. SVG export is the one exception: the export shell has no outline, so `renderSvg` overrides `canvasWidth` with the shell's own width (see `LgvSvgBodyProps`).	MultiRegionDisplayMixin
settledSubPixelBinBp `number`	Genomic bp one cell of a per-base pass stands for at the settled zoom: `subPixelBinBp` off the host's debounced `coarseBpPerPx`, and 1 until the view initializes. A per-base encode or fetch reads this rather than the live zoom so a wheel tick does not redo every region.	MultiRegionDisplayMixin
canRender `boolean`	Overrides `RenderLifecycleMixin`'s default-true hook with the LGV precondition both foundations share — see `foundationCanRender`.	MultiRegionDisplayMixin
rendersCanvas `boolean`	Fills `RenderLifecycleMixin`'s hook off `fetchInert`, as `GlobalFetchMixin` does: a display that will never fetch here shows a placeholder where its canvas would be.	MultiRegionDisplayMixin
trackVisibleRegions `VisibleRegion[]`	The visible blocks on the track's own assemblies, the ones this display fetches and is judged against. A view of several genomes leaves a single-genome track's other regions blank.	MultiRegionDisplayMixin
viewportWithinLoadedData `boolean`	true when every visible block lies within an already-fetched region — i.e. the viewport shows data we actually loaded, not the stale fringe left after a zoom-out/pan. Drives the loading overlay through the pre-refetch debounce. Spatial only, and it stays that way. Whether the data held for a block is still what a fetch would bring back is `isCacheValid`, which `dataCurrent` conjoins for the export gate. The scrim reads this getter and `dataSuperseded`, never `isCacheValid`: a phase that went `loading` on a moved `fetchInputs` would raise the overlay into every zoom.	MultiRegionDisplayMixin
viewportEmpty `boolean`	No content block is on screen, so this display has nothing to fetch and nothing to paint — see `viewportEmpty.ts` for the one viewport that reaches it, how narrow that is, and why the state still has to be terminal rather than a permanent scrim. Both foundations declare it over that one expression, the same way they each declare `host` and `paintInert`.	MultiRegionDisplayMixin
layoutReady `boolean`	Overridable hook (default false): whether a searchable feature layout currently exists. Any display defining a feature-lookup method (`searchFeatureByID`) must override it, so callers can tell "laid out, but off-display" from "no layout exists yet" — a distinction only the display can make. See `agent-docs/reference/DISPLAY_KIT.md` §"Four readiness axes".	MultiRegionDisplayMixin
dataSuperseded `boolean`	Overridable hook (default false): the held data is loaded and covers the viewport, but a fetch input has moved past it, so the data is about to be refetched. A display says so here rather than overriding `dataCurrent`, for the reason `FetchMixin.fetchInert` is a hook: an override has to restate the freshness terms and then misses the next one added. Both answers a display gives about being finished read it — the export gate through `dataCurrent`, the loading scrim through `displayPhase`. The export gate is the sharper case: `awaitSvgReady` samples freshness once, and an export that samples it inside this window renders the data that is about to be replaced. GWAS's LD auto-index is that case: adopting the top hit as the index SNP is an `rpcProps` change, so the very load that produced the top hit is what it invalidates — and `SettingsInvalidate` lands a tick after the write, so until it does not even `staleSettingsDrawn` has seen it. The window is NOT invisible on screen, which this used to say while `displayPhase` took a spatial-only argument: alignments' per-base wall spends the debounce plus the RPC painting a 1 px stripe every 8 px, with nothing in the key having moved yet. The input need not have settled yet. Alignments counts the debounce window ahead of its per-base bin, where the bin the data was fetched under has not moved and the clear is inevitable rather than committed. That is the half of the window an export lands in, since a reader zooms and then reaches for the menu. What may NOT go in is a change that could still be taken back: this fails hung, not stale. So state the live-vs-settled half as a value compare and leave the stamp alone. The settled half — the stamp a fetch committed under against the `zoomFetchArgs` a fetch now would send — is the foundation's already, through the `isCacheValid` term in `dataCurrent`, and an override restating it buys nothing: a second derivation misses the field the args gain next, latches this true, and every export of the display then waits out `awaitSvgReady`'s backstop instead of failing.	MultiRegionDisplayMixin
renderBlocks `RenderBlock[]`	Shared cached view for every LGV-based GPU display. A single displayedRegion may produce multiple render blocks (shared GPU buffer, different scissor clips on screen). Plugins that want to suppress rendering in certain states (e.g. no domain yet) can override this getter to return [] — the autorun lifecycle will then issue an empty-blocks render that clears the canvas.	MultiRegionDisplayMixin
fetchInputs `FetchInputs`	What a fetch issued right now would stamp on a region: the settings tier (`FetchMixin.settingsFetchInputs`, the tier `staleSettingsDrawn` compares alone) and the zoom tier (the display's `zoomFetchArgs()` object). `fetchRegions` captures it before the RPC goes out and stamps it beside the loaded region; `isCacheValid` compares against it.	MultiRegionDisplayMixin
regionPayloads `ReadonlyMap<number, unknown>`	The store's payloads, keyed by `displayedRegionIndex`. A display narrows this once — `get rpcDataMap() { return self.regionPayloads as ReadonlyMap<number, MyResult> }` — and every reader it already had goes on reading a map. MST makes a `.views()` getter a computed, so the Map is built once per store change and handed back by reference after that — which is what keeps `installUpload`'s diff a reference compare per key and a frame that changed no data free of it. While something observes it: MobX suspends an unobserved computed and rebuilds on every read, so a display whose only reader is a pointer handler needs the keep-alive canvas and Manhattan both install (`agent-docs/reference/DISPLAY_KIT.md` §"A hit test's index needs an observer"). The render lifecycle's upload autorun is that reader for every display that draws.	MultiRegionDisplayMixin
hasRegionData `boolean`	A fetch has landed: at least one region's payload is in the store. The render callback's first-paint gate reads this, so an empty frame before any data cannot flip `canvasDrawn`; an empty but loaded region counts, and paints its empty frame.	MultiRegionDisplayMixin
staleSettingsDrawn `boolean`	A visible block's held data was fetched under a settings or adapter key that has since moved: drawn, and wrong for the current settings, until the refetch `isCacheValid` already owes lands. The loading scrim's third staleness term, beside spatial coverage and `dataSuperseded` — the one that used to come from `SettingsInvalidate` emptying the coverage map, and the reason it no longer has to. False on a zoom by construction: it compares the stamp's `settings` tier alone, so a moved zoom tier raises no scrim. That is the whole distance from the declined fold, which compared the whole key and put the overlay 250 ms into every zoom.	MultiRegionDisplayMixin
dataCurrent `boolean`	This family's answer to the shared freshness question every display foundation must answer (`dataCurrent`): the held data corresponds to what is on screen right now. Four terms — spatial coverage of every visible block, `loadedRegions.size` to rule out the vacuously-true empty viewport, `isCacheValid` per block, and the display's own `dataSuperseded`. Regions stream in one at a time, so a multi-region/whole-genome export waits on this getter to be complete; waiting on the first datum to arrive would export a partial set. `isCacheValid` belongs here and not in the scrim. Coverage answers "is the data here", never "is it what a fetch now would bring back", so a zoom that moves `fetchInputs` leaves every held region covered and stale at once — and an export sampling `svgReady` across that window painted bins the worker computed for the previous zoom. `displayPhase` takes `dataSuperseded` but NOT this term: folding a moved `fetchInputs` into the phase raises the loading scrim into every zoom, which is the trade this does not take. The term cannot latch, and the reason is structural rather than a case list: a block reaches `fetchNeeded` unless `planRegionFetch` finds it ungated, covered AND cache-valid, and it reads that last term tracked. The `&&` short-circuits ahead of it drop its observables only where the block is fetched anyway, so the key move that closes this gate is the same read, in the same dependency set, that wakes the refetch reopening it.	MultiRegionDisplayMixin
loadedAssembly `(ModelInstanceTypeProps<…> & { error: unknown; loadingP: Promise<…> \| undefined; ... 10 more ...; refNameMismatches: Map<…>; } & ... 13 more ... & IStateTreeNode<...>) \| undefined`	The assembly the data in hand came from, once it can answer about refNames — `undefined` before that. Read off the first LOADED region rather than the view's displayed ones, and defined here for that reason: a display holding fetched data is asking about the assembly THAT data is on, and the view's regions can already have moved on. The `initialized` gate is why this returns the assembly rather than its name. `getCanonicalRefName2` and `refNameToIndex` answer WRONGLY rather than throwing before the aliases land — identity, and a miss — so a caller that skips the gate gets a plausible answer and no signal. Returning `undefined` until the aliases load forces the caller to write its fallback.	MultiRegionDisplayMixin
phaseViewportCurrent `boolean`	The loading scrim's staleness argument: what is drawn answers for what is on screen. Spatial coverage, `dataSuperseded` and `staleSettingsDrawn`; NOT `isCacheValid`, which is `dataCurrent`'s and would scrim every zoom. `displayPhase` reads it, and so does a stand-in phase (`coarseTierDisplayPhase`) — one predicate, so a term added here reaches both.	MultiRegionDisplayMixin
paintInert `boolean`	Fills `RenderLifecycleMixin`'s `paintInert` hook — see there for why a failed fetch has to read as finished to the consumers outside the display, and `foundationPaintInert` for the second such state and why both fetch families answer it through one function. Overridable, as the hook is: a display with a third inert state of its own says so here.	MultiRegionDisplayMixin
paintSuperseded `boolean`	Fills `RenderLifecycleMixin`'s hook with `staleSettingsDrawn`, so `painted` — and `data-display-drawn` through it — reads pending over a canvas painted under the previous settings until the refetch lands. `clearAllRpcData` used to reset `canvasDrawn` for the same effect; the hook says it without blanking anything.	MultiRegionDisplayMixin
byteGateAdapterConfig `Record<string, unknown>`	The adapter config the gate measures — the one at `byteGateAdapterPath`. Overridable for a display whose adapter config is synthesized rather than read off the track.	RegionTooLargeMixin
configuredFetchSizeLimit `number \| undefined`	The display's `fetchSizeLimit` slot, from `regionTooLargeConfigSchemaFields`. `number \| undefined`, because `getConf` answers `undefined` for a slot a composing display's schema never declared and typing it `number` hid the whole failure — `resolveByteLimit` falls back closed, and says why.	RegionTooLargeMixin
densityTooLarge `boolean`	The density axis's verdict, and the whole of that axis's opt-in: `CanvasFeatureGateMixin` overrides it beside the measurement that fills it, and a byte-only display leaves it false.	RegionTooLargeMixin
adapterFetchSizeLimit `number \| undefined`	The measured adapter's own `fetchSizeLimit` slot, read off the live track config rather than the `adapterConfig` snapshot, which omits slots at their default.	RegionTooLargeMixin
configForceLoad `boolean`	The declarative `forceLoad` slot.	RegionTooLargeMixin
gateViewportSpanBp `number \| undefined`	The span on screen, or undefined until the view is measured: the half of gateViewport the budget questions need. Split off because the identity half joins a string over `view.visibleRegions`, which rebuilds every gesture frame, and `aboveForceLoadFloor` sits under `regionTooLarge` — every gated display rebuilt it per frame to ask whether the span was 20 kb.	RegionTooLargeMixin
gateViewport `GateViewport \| undefined`	What a measurement taken now would be about: the span on screen, and a key for the stretch of genome it covers and the settings it would be taken under. Undefined until the view is measured, and with gateViewportSpanBp the mixin's only read of the view. Captured before the fetch's round trip, never at commit, so the stamp names the settings the worker actually counted under. The settings term is `settingsFetchInputs`, the axis every family invalidates data on. It belongs in the measurement because the worker's density probe counts ADMITTED features (`densityGate`'s `admit`), so a filter admitting almost nothing is a different measurement of the same viewport — and while staleness was viewport-only, the main thread never went back to ask. The byte axis is an index read no `rpcProps` field can move; the rule is one rule rather than one per axis.	RegionTooLargeMixin
aboveForceLoadFloor `boolean`	Whether the span on screen is at or above `AUTO_FORCE_LOAD_BP`, the one comparison against that constant. False on an unmeasured view.	RegionTooLargeMixin
gateExempt `boolean`	Nothing may gate on either axis: the `forceLoad` slot or the button.	RegionTooLargeMixin
estimatedFetchBytes `number \| undefined`	The stored estimate's bytes; undefined when nothing has been measured.	RegionTooLargeMixin
gateMeasurementStale `boolean`	Whether the last measurement still describes what a fetch issued now would ask: the viewport on screen, under the settings on screen. True before any measurement. The triple's third term, the adapter tier, is not here — a tier swap drops the measurement outright (`ClearGateMeasurementsOnNavOrTierSwap`) rather than marking it stale.	RegionTooLargeMixin
gateByteLimit `number`	The byte budget: the adapter's limit, else the display's, doubled below `AUTO_FORCE_LOAD_BP`. Read only through `resolvedByteLimit()`.	RegionTooLargeMixin
gateActive `boolean`	Whether the gate may act right now, on any axis: opted in, not exempt, view measured. The view is read last, so an ungated display never touches it.	RegionTooLargeMixin
densityGateActive `boolean`	Whether the density axis may act: `gateActive`, and the span is above the floor — the one axis the floor applies to. Whether it has anything to say is `densityTooLarge`.	RegionTooLargeMixin
tooLargeStatus `RegionTooLargeStatus`	The verdict and its banner text, from the stored estimate against `resolvedByteLimit()` and the density axis when it may act.	RegionTooLargeMixin
regionTooLarge `boolean`		RegionTooLargeMixin
regionTooLargeReason `string`	Banner text for the axis that tripped; empty when not too large.	RegionTooLargeMixin
zoomCanReleaseGate `boolean`	Whether "zoom in to see features" is honest advice. Density always releases on zoom; bytes only if the last zoom-in moved the estimate.	RegionTooLargeMixin
gateSkipsMeasuredViewport `boolean`	The skip both fetch skeletons apply: the banner is up and its measurement already describes the viewport on screen.	RegionTooLargeMixin
painted `boolean`	The first-paint answer every consumer outside the display should read, `canvasDrawn` being only the raw flag: a display that is deliberately not painting a canvas has finished, and reporting it unfinished leaves every waiter on it waiting forever. The two `rendersCanvas: false` states each had three of their four consumers wired by hand — the loading scrim (`rendersCanvas` / `fetchInert`) and the SVG export (`fetchInert`) — while the fourth, `data-display-drawn`, went on publishing `"false"` forever off the raw flag. That attribute is what `PENDING_DISPLAYS` (`@jbrowse/browser-test-utils`) selects on, so a zoomed-out reference sequence track made every capture wait on the page run to its full timeout, and that wait swallows its own timeout without reporting it. `fetchInert` on the comparative side has the same problem: the forgotten reader is the one outside the display, so the display has to publish one name for it. `paintInert` is the third term and the same argument once more, for the state where a display would paint a canvas and never gets to — a fetch that failed before first paint. `paintSuperseded` is the fourth, and the one that subtracts: a canvas painted from data a settings change has made wrong is drawn and not finished. See both hooks.	RenderLifecycleMixin
isLoading `boolean`	true while a fetch is active	FetchMixin
isLoadingOrCanceled `boolean`	`isLoading` widened to cover a user-canceled load: what a hover gate wants, since neither state has a frame on screen that a hit describes. Not a phase input — `computeActivityPhase` reads the two apart, because a cancel is finished (`canceled`) where a fetch is not (`loading`).	FetchMixin
fetchInert `boolean`	Overridable hook (default false): the states where this display deliberately never fetches, so it holds no data and none is coming. Sequence sets it past base resolution ("Zoom in to see sequence"); LD sets it with the triangle toggled off. One hook has three readers. A display that gains such a state declares it once, which covers the reader it would otherwise forget, always the one outside the display: - the phase (`computeActivityPhase`), which otherwise parks a scrim over the placeholder, or a canceled overlay once Cancel is clicked; - the SVG export (`computeSvgReady`'s `extraTerminal`), whose `awaitSvgReady` is an unbounded `when`, so one such display hangs the whole view's export; - the retry contract check (`makeRetryContractCheck`), which would otherwise report a dead Retry on a display correctly declining to load anything. `fetchInert` replaces three hooks: `loadingSuppressed`, `svgReadyExtraTerminal` on each of the two foundations, and `fetchInert` on the comparative family, which had already collapsed them. Both LGV displays that override it returned one expression for all three, and the global family hard-coded one of the three to `false` for a while, so LD could express only half its state. All three fetch families declare it here since the comparative one composed this mixin (ADR-105), so the retry check reads one field everywhere. ADR-082. A hook rather than a `displayPhase` override, because overriding the getter means restating the whole loading condition. Sequence held a verbatim copy of the other terms that way, and a copy misses any term added to the condition later. `fetchInert` lives here because this is the one mixin all three display foundations compose. Same argument, one level down, that put `rendersCanvas` on `RenderLifecycleMixin` beside `canvasDrawn`.	FetchMixin
awaitingPrerequisite `boolean`	Overridable hook (default false), read only by the retry contract check (`makeRetryContractCheck`): "this run declined because a prerequisite fetch in another autorun has not landed, and its arrival wakes this one again". It defers the retry verdict to that later run rather than waiving it, so a display cannot spend its retry on a decline it called preliminary. Two displays set it, one per fetch foundation, so it lives beside `fetchInert` rather than on either: HiC's contacts fetch declines until `CoreGetInfo` lands, and `MultiSampleVariantBaseModel`'s `fetchNeeded` declines until `sourcesBase` does. Both have a `reload()` that wakes the prerequisite's autorun as well as their own. It has to be strictly narrower than the gate it explains. One that restates the gate's negation makes every decline a deferred one. No run is then ever judged, which exempts the display from the check. HiC does this deliberately, because its gate and its prerequisite are one condition; what covers its retry instead is `LinearHicDisplay/infoFetchFailure.test.ts`. Not for a display deliberately not fetching at all — that is `fetchInert` above, which the loading scrim and the export read too.	FetchMixin
awaitingDependentData `boolean`	Overridable hook (default false), read by `computeActivityPhase`: a load this display depends on beyond its primary fetch has not landed for the first time, so the frame the primary fetch calls current is still missing something. Multi-way synteny sets it until its lane genes and lane links first arrive, so an export or a capture never lands between the ortholog fetch and the gene models that fill the lanes. A hook rather than a `displayPhase` override, for the reason `fetchInert` is one: that display carried the override, restating the foundation's two arguments verbatim to append one term, and a copy like that misses any term added to the foundation later. Not `dataSuperseded`, which holds the export through every later refetch too: a display saying this wants the scrim on the first landing only, since later lane fetches redraw over lanes already on screen.	FetchMixin
settingsFetchInputs `unknown`	The settings axis every fetch family invalidates on: this display's `rpcProps()` payload and its adapter config, as one value compared structurally. The per-region family watches it from `SettingsInvalidate` and stamps it on each region, the keyed families fold it into `currentFetchKey`, and the byte gate measures under it — one getter, so no two can come to invalidate on different axes. `undefined` inside the payload is a real state and a class instance compares by its own fields, which a serialized key could not say; `makeSettingsFetchInputs` has why.	FetchMixin
showTree `boolean`	Whether the dendrogram sidebar is drawn.	TreeSidebarMixin
showBranchLength `boolean`	Whether tree nodes are positioned by branch length (dendrogram) or evenly by topology (cladogram).	TreeSidebarMixin
showRowLabels `boolean`	Whether each row's name is drawn over the left of the plot.	TreeSidebarMixin
treeAreaWidth `number`	Width in px of the sidebar the dendrogram draws in. On the config rather than the display snapshot for the same reason `height` is: the config node outlives the display instance, so a dragged width survives unticking and reticking the track.	TreeSidebarMixin
rowDomain `string[]`	The row order, `rows.domain`: the rows it names lead, in its order, and the rest follow as `unlistedRowsSort` says.	TreeSidebarMixin
rowLabels `Readonly<Record<string, string>>`	The labels drawn in place of row names, `rows.labels`, by name.	TreeSidebarMixin
rowTreeProvenance `ClusterProvenance \| undefined`	What `rowTree` was computed from, the locus and the settings; undefined for a tree that arrived as data.	TreeSidebarMixin
rowFocus `readonly string[] \| undefined`	The row names a focus narrows the display to, `rows.kept` — a clade picked off the tree or a key row's rows — or undefined while every row shows.	TreeSidebarMixin
rowColorSetting `RowColorSetting`	The `rowColor` object: the row attribute whose values take colours, `name` where it names none, and the values given a colour of their own.	TreeSidebarMixin
baseRowColor `RowColorSetting`	The `rowColor` object this display's base declares, which a reset returns to and "is this the reader's" compares against.	TreeSidebarMixin
baseRowDomain `readonly string[]`	The `rows.domain` this display's base declares: the base arrangement a row palette deals over, so no reorder recolours a row.	TreeSidebarMixin
rowAlias `RowAlias \| undefined`	Overridable hook: the name a row also answers to, for a display whose rows stand for something named by another name (a variant display's haplotype rows, each answering to its sample). An order, a label, a colour and a focus written against the alias reach every row answering to it. None by default.	TreeSidebarMixin
unlistedRowsSort `UnlistedRowsSort`	Overridable hook: where the rows `rowOrder` does not list go, in the order they arrived by default.	TreeSidebarMixin
rowBanding `RowBanding \| undefined`	Overridable hook: the attribute the rows stack in bands by and the bands listed first, or undefined, the default, for no bands.	TreeSidebarMixin
rowFocusLineHeight `number`	The line the "Showing N rows" chip takes above the first row while `rows.kept` narrows the rows, 0 while every row shows.	TreeSidebarMixin
rowsTopOffset `number`	Where the rows start in the display's box: under the display's own `rowsHeaderHeight` and the focus chip's line. Every row painter, hit test, label, tree and export places the rows from here.	TreeSidebarMixin
guideTree `HierarchyNode<NewickNode> \| undefined`	`guideTreeNewick` parsed and rotated towards `rows.domain`; undefined while the display supplies none.	TreeSidebarMixin
guideTreeHonoursDomain `boolean`	Whether the rotated guide tree lists `rows.domain`'s names in `rows.domain`'s order, which holds exactly when some rotation of it does.	TreeSidebarMixin
rowTree `string \| undefined`	The tree the rows are arranged by, as newick: `rows.tree`, else the guide tree while `guideTreeHonoursDomain`. A reorder no rotation produces hides the guide tree, and a reset brings it back.	TreeSidebarMixin
rowOrder `readonly string[]`	Overridable hook: the names the rows are placed by, `rows.domain` by default; MAF leads with a drawn tree's leaves.	TreeSidebarMixin
rowColorPairs `ReadonlyMap<string, string>`	The colour a reader set on each named row: the `rowColor` pairs while it paints by `name`, and none while it paints by another field.	TreeSidebarMixin
rowStylingIsCustom `boolean`	Whether `rowColor` gives its field's values colours the config does not, so "Reset row order" is offered for a recolour too: whether `rowColorResetTarget` has anything to write. What the rows are coloured by is no arrangement, so picking it is never custom.	TreeSidebarMixin
expandedRows `S[]`	`discoveredRows` through `expandRows`: the rows at the granularity drawn, before any arrangement.	TreeSidebarMixin
sharesPanel `boolean`	Overridable hook: whether the rows share one panel, so nothing but colour tells them apart. False by default.	TreeSidebarMixin
rowColorPaintsMarks `boolean`	Overridable hook: whether a row's colour paints its data marks, which holds while nothing else colours them. True by default.	TreeSidebarMixin
rowNoun `string`	Overridable hook: what one row is called, which titles the row colour key where it lists the rows by name in a shared panel. "Row" by default, which only a display of its own that shares a panel would show; a wiggle overlay's rows are subtracks.	TreeSidebarMixin
internalRowFields `readonly string[]`	Overridable hook: the row fields that are a display's own plumbing, which the arrangement dialog never lists as a column.	TreeSidebarMixin
rowBandingNotices `string[]`	A line for the corner notice when rows have arrived and none carries the field `rowBanding` bands by, which then bands nothing. Each display spreads it into its `notices`.	TreeSidebarMixin
rowPaletteDeals `boolean`	Whether the palette deals each row a colour by name: only where the rows share one panel and their colour paints the marks.	TreeSidebarMixin
rowColorDealRows `readonly S[]`	The rows the palette deals over: `expandedRows` in the base arrangement, so no reorder, focus or relabel recolours a row.	TreeSidebarMixin
rowColorChoice `string`	What the rows are coloured by, as the arrangement dialog and a menu offer it: '' for none dealt, `name` for a palette colour each, or an attribute.	TreeSidebarMixin
rowColorAttribute `string`	The attribute the rows are coloured by, or '' by `name`.	TreeSidebarMixin
dealtRowColors `ReadonlyMap<string, string>`	The colour each value of the config's `rowColor` field takes, listed pairs first and then in the order dealt.	TreeSidebarMixin
resolvedRowColors `ReadonlyMap<string, string>`	Each row's colour, by name: its `rowColor` entry, else its own `color`, else the palette's where `rowPaletteDeals`. The one answer every display paints a row's colour from.	TreeSidebarMixin
rowArrangementIsCustom `boolean`	Whether the arrangement differs from what the config declares — what "Reset row order" is offered on.	TreeSidebarMixin
editableSources `S[]`	The rows in the reader's arrangement, each with its resolved `rowColor`, and with no focus or band: the list the arrangement dialog edits, so a submit writes back only what the reader chose. `expandedRows` itself while nothing is arranged or coloured.	TreeSidebarMixin
rowColorKeyInputs `RowColorKeyInputs`	What the row colour key and its focus read of the colours.	TreeSidebarMixin
rowColorScales `CategoricalScale[]`	The row colour key, which every display spreads into its `colorScales`: one scale titled by the `rowColor` field, or none where it has no entries. Its entries (`rowColorKeyEntries`) show where the labels cannot name the colours: by an attribute, or by name in a shared panel. By name on stacked rows the labels are the key.	TreeSidebarMixin
clusterableSources `S[]`	Overridable hook: `editableSources` narrowed to the focus, the rows a clustering run clusters, and deliberately not the display's decorated `sources`, whose palette and band a run has no business writing back. MAF applies a focus as given on a track that discovers its species.	TreeSidebarMixin
parsedTree `HierarchyNode<NewickNode> \| undefined`	`rowTree` parsed. A run rotated its tree in the same write as the order it produced; a tree that arrived as data rotates towards `rows.domain` here, and the guide tree is `guideTree`'s parse.	TreeSidebarMixin
root `HierarchyNode<NewickNode> \| undefined`	The parsed tree narrowed to the focus.	TreeSidebarMixin
bandedRows `{ rows: S[]; bands: RowBand[]; }`	`bandedSources` and `rowBands`, from one pass over the rows.	TreeSidebarMixin
bandedSources `S[]`	`clusterableSources` stacked in bands by `rowBanding`, each band's rows in their arranged order: the rows each display paints its palette over. `clusterableSources` itself while nothing bands.	TreeSidebarMixin
rowBands `readonly RowBand[]`	Each band's value, label and the rows it spans in `bandedSources`; none while nothing bands.	TreeSidebarMixin
clusterPartition `string[][] \| undefined`	The names of the rows a clustering run clusters, by band, so each band clusters apart and the run writes one forest; undefined while fewer than two bands stack.	TreeSidebarMixin
treelessBandCount `number`	How many bands the tree draws no dendrogram for, because it holds no clade whose leaves are that band's rows in order; 0 with no tree or no bands.	TreeSidebarMixin
treeHasBranchLengths `boolean`	Whether the tree carries merge heights, so a dendrogram layout differs from the cladogram; gates the "Tree branch lengths" toggle.	TreeSidebarMixin
rowHeight `number`	Raw per-row height setting: `0` is fit-to-display-height, any positive value is a fixed px height. The resolved value is `effectiveRowHeight` — consumers read that, never this. On the config rather than the display snapshot for the same reason `height` is: the config node outlives the display instance, so a fixed height survives unticking and reticking the track.	RowHeightMixin

Methods

Member	Description	Defined by
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.	LinearMarkDisplay
rpcProps `() => { layers: LayerRequest[]; transform: TransformStep[]; facet?: FacetSpec \| undefined; opts?: object \| undefined; }`	the fetch inputs SettingsInvalidate watches: each mark's encoding and lanes, and the filters as transform steps, all evaluated in the worker, and the `adapterOptions` each region resolves	LinearMarkDisplay
plotProblems `(plot: Plot) => string[]`	What a draft plot would report once applied, as the lines `notices` carries, without touching the display; one a config file would refuse throws the refusal.	LinearMarkDisplay
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. Nothing on this display is touched.	LinearMarkDisplay
trackMenuItems `() => MenuItem[]`		LinearMarkDisplay
contextMenuItems `() => MenuItem[]`		LinearMarkDisplay
svgLegendWidth `() => number`	Overridable hook (default 0): the width the LGV export reserves beside the plot for this legend. A display whose plot fills its band — the contact matrix, the LD triangle — answers `svgLegendGutterWidth(self)` so the key does not cover it.	LegendMixin
colorScalesIn `(_palette: JBrowsePalette) => ColorScale[]`	Overridable hook (default `colorScales`): the scales in another theme, the SVG export's, which need not be the session's. Only a display whose key takes colors from the theme answers it.	LegendMixin
legendSpecIn `(palette: JBrowsePalette) => LegendSpec`	`legendSpec` in the SVG export's theme.	LegendMixin
renderingProps `() => { displayModel: ModelInstanceTypeProps<{ id: IOptionalIType<…>; type: ISimpleType<string>; }> & { ...; } & { ...; } & { ...; } & IStateTreeNode<...>; }`	props passed to the renderer's React "Rendering" component. these are client-side only and never sent to the worker. includes displayModel and callbacks	BaseDisplay
liftPlot `(draft: Plot) => AnyConfigurationModel`	A draft as the config would hold it, merged over `plot`, throwing what a config file would be refused for. Nothing on the display changes.	BaseDisplay
plotWrites `(draft: Plot) => Record<string, unknown>`	What applying a draft would write, by setting: the lifted value where it differs from `plot`, `null` where it resets one. Throws a refusal.	BaseDisplay
regionHasData `(displayedRegionIndex: number) => boolean`	Overridable hook: whether the display can draw what this region is marked loaded over, at the zoom the view has. The default answers off the store — an entry a fetch committed carries what it stored — and off the payload's `zoomRange` where the adapter declared one (`BaseFeatureDataAdapter.getZoomRange`): a BigWig tier answers a band of zooms, and the region reads as stale when the view leaves it. A payload carrying no range answers at every zoom. What survives an override is the question the store cannot answer: which of several held payloads answers. MAF caches a summary tier and a detail tier side by side under one `displayedRegionIndex`, so crossing the threshold inside an already-loaded region changes which map has to answer. The multi-row display's override survives for the auto-partition reconciliation (`regionHasPinnedData`). A view, not an action, so the reads it makes register as dependencies of `FetchVisibleRegions`.	MultiRegionDisplayMixin
isCacheValid `(displayedRegionIndex: number) => boolean`	Whether the data held for a region still answers the current view. Not a hook a display fills: a display states its rule as `zoomFetchArgs` (what a fetch now would send the worker) and `regionHasData` (does what the last one stored still answer), and this compares the whole input set against the one the region was fetched under.	MultiRegionDisplayMixin
resolvedByteLimit `() => number \| undefined`	The budget the worker enforces and the banner compares against — the one spelling of that pair. Undefined when the gate may not act.	RegionTooLargeMixin
gateFetchState `() => GateFetchState`	The gate as it stands for a fetch about to be issued. Calling it is the capture, which is why it is a method.	RegionTooLargeMixin
expandRows `(rows: S[]) => S[]`	Overridable hook: the discovered rows as the rows drawn, the rows themselves by default; a variant display's phased mode expands each sample to its haplotypes.	TreeSidebarMixin
svgSidebarWidth `(text?: ExportTextStyle \| undefined) => number`	Px the SVG export reserves left of the track for `svgSidebar`, measured in the export's text.	TreeSidebarMixin
rowBand `(row: S) => string`	Overridable hook: the band a row stacks in while `rowBanding` is set, by default its value of the banding attribute, '' for none.	TreeSidebarMixin
rowColorsFor `(setting: Partial<RowColorSetting>) => ReadonlyMap<string, string>`	The colour each value takes under `setting` (`dealtValueColors`), which the arrangement dialog shows before it writes the setting.	TreeSidebarMixin
rowOrderWillDropTree `(next: readonly { name: string; }[]) => boolean`	Whether the arrangement dialog's submit of `next` drops the tree: an order that moves no row is not written, so it drops nothing, and the guide tree drops only for an order no rotation of it lists.	TreeSidebarMixin

Actions

Member	Description	Defined by
setSourceListing `(read: AdapterRead<RowSourceListing \| undefined>) => void`		LinearMarkDisplay
setRowProportion `(n: number) => void`	Write every span mark's `rowProportion`.	LinearMarkDisplay
setFitToHeight `() => void`	Fit the rows to the plot. The `height` getter is the slot itself, so nothing needs seeding on the way in.	LinearMarkDisplay
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`. A bin of the density sidecar opens nothing, its region holding no request — the read-back is the download the gate refused.	LinearMarkDisplay
setRpcData `(idx: number, data: EncodedLayersResult, region: Region) => void`	Stage a region as fetched, with this display's payload layout.	LinearMarkDisplay
setFacetDomain `(domain: string[]) => void`	The Sections menu's reorder lands on the declaration.	LinearMarkDisplay
setFacetField `(field: string) => void`	A field's own bands, in their sorted order: the outgoing field's domain goes with it, and the facet's steps stay.	LinearMarkDisplay
splitByPlotRows `(fields: PlotFields) => void`	A row per source where the adapter lists several and nothing splits the features yet: one value per row is the row axis, and a facet is for bands holding more than one row.	LinearMarkDisplay
sortRowsByValueAt `(refName: string, pos: number) => boolean`	Order the rows by the value each stands at over (refName, pos), highest first, off the loaded regions with no refetch; false where no loaded region covers the column.	LinearMarkDisplay
setFilter `(filters?: string[] \| undefined) => void`	Write the `filter` slot; undefined returns it to what the track's config declares.	LinearMarkDisplay
setPlotFields `(fields?: PlotFields \| undefined, error?: unknown) => void`		LinearMarkDisplay
setPlotDefaultChecked `() => void`		LinearMarkDisplay
setPlotFieldsPromise `(promise?: Promise<PlotFields> \| undefined, scanned?: Region[]) => void`		LinearMarkDisplay
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.	LinearMarkDisplay
openPlotDialog `(seed?: Plot \| 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.	LinearMarkDisplay
setPointSize `(val?: number \| undefined) => void`	Write every point mark's `encoding.size` number; undefined returns each to the default.	LinearMarkDisplay
pinDistinctShapes `() => void`	The categorical analogue of the min/max dialog's "Use current range": every value a colliding shape key lists goes into the shape's `domain`, in key order after what it already lists, so each takes a shape of its own.	LinearMarkDisplay
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.	LinearMarkDisplay
openPlotForm `(draft: Plot) => void`	The text box's "Back to form", opened on its draft.	LinearMarkDisplay
fetchNeeded `(needed: IndexedRegion[]) => Promise<void>`		LinearMarkDisplay
startRenderingBackend `(backend: MarkRenderingBackend) => void`	identity encode — the stored payload is what the backend uploads	LinearMarkDisplay
renderSvg `(opts?: ExportSvgDisplayOptions \| undefined) => Promise<ReactElement<unknown, string \| JSXElementConstructor<any>> \| Iterable<...> \| AwaitedReactNode>`		LinearMarkDisplay
fetchCoarseTier `(read: CoarseTierRead, ctx: FetchContext) => Promise<CoarseTierResult<FeatureDensity>>`		DensityTierMixin
setCoarseTier `(entries: CoarseTierEntry<P>[], read: CoarseTierRead) => void`		CoarseTierMixin
clearCoarseTier `() => void`		CoarseTierMixin
setCoarseTierLoading `(loading: boolean) => void`		CoarseTierMixin
setScaleType `(scaleType: string) => void`		ScoreScaleMixin
setScaleZero `(zero: boolean) => void`		ScoreScaleMixin
setDomainQuantile `(quantile: number) => void`		ScoreScaleMixin
setMinScore `(val?: number \| undefined) => void`		ScoreScaleMixin
setMaxScore `(val?: number \| undefined) => void`		ScoreScaleMixin
setAutoscaleGroup `(group?: string \| undefined) => void`		ScoreScaleMixin
setGrid `(grid: boolean) => void`		ScoreScaleMixin
setScoreRules `(rules: (number \| ValueScaleRule)[]) => void`	Replaces `scales.y.rules` whole, each entry in a form the config takes: a number, or `{ value, color, label }`.	ScoreScaleMixin
setShowLegend `(arg: boolean) => void`	Writes the slot, and showing the legend again restores the sections closed inside it.	LegendMixin
dismissLegendSection `(id: string) => void`	Close one section of the legend, leaving the others up.	LegendMixin
openContextMenu `(info: Info) => void`		ContextMenuMixin
closeContextMenu `() => void`		ContextMenuMixin
setHoveredFeature `(hit?: T \| undefined) => void`		StoredHoverMixin
clearHoveredFeature `() => void`		StoredHoverMixin
hideGroup `(key: string) => void`	Drop a section from the stack. Reversed by `showAllGroups`, which the "Show..." menu offers while anything is hidden, since a hidden section draws no chip of its own to come back from.	HiddenGroupsMixin
showAllGroups `() => void`		HiddenGroupsMixin
dropGroupState `() => void`	Forget every hidden section.	HiddenGroupsMixin
setStatusMessage `(status?: RpcStatus \| undefined) => void`		BaseDisplay
setError `(error?: unknown) => void`		BaseDisplay
reload `() => void`	base display reload does nothing, see specialized displays for details	BaseDisplay
applyDisplaySettings `(settings: Record<string, unknown>, options?: { allowSetters?: boolean \| undefined; } \| undefined) => { applied: string[]; unapplied: UnappliedSetting[]; failed: { ...; }[]; }`	Apply a set of display settings to the live display, and report which were applied. Each key runs through the display config schema's `preProcessSnapshot` (shorthand expansions and legacy-key migrations, as `showTrackGeneric` applies to a session spec's inline track keys), then writes the matching config slot. A key naming a sub-schema (`facet`, `color`) replaces the whole object, its string shorthand lifted by that schema, and `null` clears it. Keys that are not slots come back in `unapplied` as `{ key, reason }`, so a caller can tell a misspelling from a key that has an action instead of a slot. `allowSetters` also routes a non-slot key to a single-argument action named `set<Key>`. It is off by default because session specs, share links and embeds pass untyped JSON here, and a default fallback would let them call internal setters (`setError`, `setScrollTop`, ...) and call multi-argument setters with one argument. A caller that wants a specific action can call it directly. A key whose write threw is reported in `failed`. Only `failed` means the caller passed a bad value. `unapplied` needs the caller's own context to read: `showTrackGeneric` spreads the same settings into the display's snapshot, so a declared prop (`resolution`) has already landed by the time it reports here, while the restyle path spreads nothing and every entry there did nothing. A per-key error does not abort the remaining keys. A caller mid-`showTrack` has already pushed the track, and one rejected value should not leave it half-configured.	BaseDisplay
applyPlot `(draft: Plot) => void`	Write a draft over `plot`: each setting it changes is replaced whole, so a member left out of an object goes back to its default, and `null` resets the setting. A draft the schema refuses, or naming a setting outside the plot, throws before anything is written.	BaseDisplay
setScrollTop `(scrollTop: number) => void`		TrackHeightMixin
setHeight `(displayHeight: number) => number`		TrackHeightMixin
resizeHeight `(distance: number) => number`		TrackHeightMixin
expandToContentHeight `() => number`	Grow the track by the content it is hiding, for the resize handle's double click. Goes through `resizeHeight` so grow mode's override leaves grow first.	TrackHeightMixin
setLoadedRegion `(displayedRegionIndex: number, region: Region, payload: {} \| undefined, fetchInputs?: FetchInputs) => void`	The raw write behind `ctx.commitRegion`, and not what a fetch should call. A display naming its span itself is the bug this family spent a release fixing, and the context gives a fetch no way to express it — see RegionFetchContext. Direct callers are tests staging an already-loaded display. The payload is named on every call, `undefined` included: this write replaces the whole record, so a re-stamp that left it off dropped the data a test had staged one line earlier, and the failure surfaced as a reader throwing three layers away. A test stages a claim with nothing behind it by saying so. An action so callers after an async boundary stay in MST strict mode. Stamps the region with the fetch key its data came back under. `fetchRegions` passes the key it captured before issuing the RPC; the default reads it now, which is right for a caller holding the region already and wrong for anything resuming after an await, where the viewport may have moved under the fetch.	MultiRegionDisplayMixin
evictRegionStore `(keep: ReadonlySet<number>) => void`	The store's bound. Drops the entries a fetch can no longer be about: an index outside the view's buffered viewport, once the store is over `MAX_STORED_REGIONS`, oldest first. One rule for every display, where canvas hand-rolled `pruneRpcDataMapToVisible` (prune to the buffer on every fetch) and every other display had no bound at all beyond `displayedRegions.length`. That count is the contig count, so a fragmented assembly was effectively unbounded. The cap lets a pan back onto a recently-visited region draw immediately, which the prune-to-buffer rule did not.	MultiRegionDisplayMixin
dropLoadedRegion `(displayedRegionIndex: number) => void`	Forget one region — for a display pruning what has scrolled off screen.	MultiRegionDisplayMixin
clearDisplaySpecificData `() => void`	Overridable hook (no-op base): drop what this display holds beside the store — a second store of its own, a verdict about the viewport that was just dropped. Called by `clearAllRpcData`, which runs on a displayed-regions change, on a viewport move past an error or a cancel, and on `reload()`.	MultiRegionDisplayMixin
clearSettingsBakedData `() => void`	Overridable hook (no-op base): drop what this display holds that is wrong under a changed setting rather than merely stale — a payload whose shape the setting decides. Called by `invalidateSettings`, where `clearDisplaySpecificData` is deliberately not: bins, reads and features fetched under the previous setting draw honestly under the scrim `staleSettingsDrawn` raises until the refetch lands, the way canvas has kept its features since ADR-006 and every display does since 2026-09. The variant matrix overrides it, for a structural reason: it holds one payload for every visible region and the row set is a setting, so there is no per-region replacement to wait for.	MultiRegionDisplayMixin
clearAllRpcData `() => void`	full reset: cancels fetch, clears error, loadedRegions, display-specific data, and the canvas-drawn flag. The too-large gate is derived (a pure function of the cached estimate × viewport), so it needs no explicit clear here — the fetch autorun re-measures at the new viewport and the verdict follows.	MultiRegionDisplayMixin
invalidateSettings `() => void`	`SettingsInvalidate`'s reset: the half of `clearAllRpcData` a settings change still needs now that the settings and adapter axes are in `fetchInputs`. The in-flight fetch is superseded now rather than when its payload lands stamped stale, a blocking error or cancel is cleared so the plan is not `blocked`, and the display drops its settings-baked data. `loadedRegions` and the canvas-drawn flag stay: every held region already reads `!isCacheValid`, so the plan refetches it, and until that lands the data stays on screen under the scrim `staleSettingsDrawn` raises.	MultiRegionDisplayMixin
fetchRegions `(needed: IndexedRegion[], work: (ctx: RegionFetchContext) => Promise<void>) => Promise<void>`	Run a per-region fetch. The work callback calls `ctx.commitRegion` as it stores each region's payload, which is what marks it loaded — see RegionFetchContext for why this function no longer does that itself. Its only callers are the three helpers in `fetchEachRegion.ts`, which make that call for every display in the family; a display reaching past them owns both `ctx.isStale()` guards and the commit by hand, and none does. The fetch key is captured here, at issue, and carried into every commit — never re-read after the await. `ctx.isStale()` trips on a newer fetch or a cancel, not on a viewport that moved under a fetch that is still current, so a key read at commit time would stamp this data with a zoom it was not fetched at.	MultiRegionDisplayMixin
afterAttach `() => void`	installs the fetch-lifecycle autoruns (DisplayedRegionsChange, FetchVisibleRegions, SettingsInvalidate, ClearBlockingStateOnViewportChange)	MultiRegionDisplayMixin
clearByteEstimate `() => void`	Drops the estimate and the viewport stamp. `forceLoadTrack` survives: it is a track-wide approval.	RegionTooLargeMixin
clearGateMeasurements `() => void`	Overridable hook (no-op base): drop what the other axis measured, on the trigger that invalidates this one. The two used to clear on different triggers, so re-pointing an adapter dropped the bytes and left `densityTooLarge` speaking for the previous file.	RegionTooLargeMixin
setForceLoadTrack `(flag: boolean) => void`		RegionTooLargeMixin
commitFetchBytes `(perRegionBytes: (number \| undefined)[], issued: GateFetchState, partial?: boolean) => void`	The byte axis of a finished fetch: the per-region max against the `gateFetchState()` captured at issue. An empty batch, or an ungated display, commits nothing. Reached through `openGateCommit`, the only production caller, which owns the capture, the commit-at-most-once rule and the pairing with `partial`. A test staging a measurement by hand calls this directly.	RegionTooLargeMixin
forceLoad `() => void`	The banner's button: exempt the track on both axes and refetch.	RegionTooLargeMixin
markCanvasDrawn `() => void`		RenderLifecycleMixin
resetCanvasDrawn `() => void`		RenderLifecycleMixin
stopRenderingBackend `() => void`		RenderLifecycleMixin
renderNow `() => void`		RenderLifecycleMixin
setOffScreen `(offScreen: boolean) => void`		RenderLifecycleMixin
setRenderError `(error: unknown) => void`	set/clear the render-backend error. Called by `useRenderingBackend`: with the error when the canvas factory rejects (or context-loss re-init fails), and with `undefined` on successful (re)init and on retry.	RenderLifecycleMixin
attachRenderingBackend `<B>(backend: B, setup: () => RenderingBackendCallbacks<B>) => void`	attach a GPU/Canvas2D backend and install the upload + render autorun pair. Idempotent: re-calling swaps the backend and does not run `setup` again, so the callbacks and everything they close over are the first call's.	RenderLifecycleMixin
stopActiveFetch `() => void`	Abort the in-flight fetch (if any) and retire its slot. The shared preamble of both cancel paths; the difference between them is only what they do to `fetchCanceled` / `fetchGeneration` afterward.	FetchMixin
openStatusStream `(isCurrent: () => boolean) => StatusStream`	Open one operation's slot on the display's status field: an RPC `statusCallback` throttled through the display-wide window and guarded so a callback that fires after the node is torn down (RPCs resolve their status stream asynchronously) is a safe no-op, plus the `clear` that retires the slot when the operation ends. Every operation on the display opens one, and the two come back together because an operation that never retires keeps reporting status for a phase that is over. The viewport fetch (`runFetch`), the clustering run and a lent `createAbortRotation` are three of them on one field; before ADR-081 each blanked the field outright and the last one to finish overwrote the status of the other two. `isCurrent` is required and has no "node is alive" default, because a live node is not enough: a superseded fetch is on a live node, and its late status repainting the overlay of the fetch that replaced it is the failure this guards. `runFetch` passes `!isStale()`, and every display gets that through `ctx.statusCallback` unasked; a caller outside a fetch (the clustering autorun) passes its own run's flag. Defaulting to `isAlive` made the loose answer the easy one and five displays took it. `runFetch`'s own slot is opened by the rotation; this is for an operation outside any fetch, the tree sidebar's clustering run.	FetchMixin
cancelFetch `() => void`	cancel any in-flight fetch and bump fetchGeneration (always bumps, so callers can retrigger fetch autoruns even when nothing was in flight). This is the internal reset `clearAllRpcData` runs — it clears any user-cancel flag so the retrigger actually re-fetches.	FetchMixin
cancelFetchByUser `() => void`	User-initiated cancel from the loading overlay. Stops the in-flight fetch and lands in a durable `fetchCanceled` state. Unlike `cancelFetch`, it does NOT bump fetchGeneration — so the fetch autoruns don't immediately restart the load. The user retries via `reload` (the overlay's retry button), or it clears on the next viewport change.	FetchMixin
beforeDestroy `() => void`	Abort an in-flight fetch on teardown. Without this, a display destroyed mid-fetch (track/view closed while loading) never signals the worker to abort the now-useless work, and its in-flight HTTP reads keep downloading. MST auto-chains lifecycle hooks, so a composing display can still define its own beforeDestroy.	FetchMixin
beginFetch `(signal: AbortSignal) => void`	The `onBegin` half of a fetch's bookkeeping: publish the in-flight signal (`isLoading`) and clear the durable user-cancel — a load starting is the single clear point that covers every retrigger path (reload, viewport change, settings invalidate). An action of its own for the same reason `endFetch` is: `installFetch`'s lifecycle callbacks run outside any MST flow this mixin owns.	FetchMixin
endFetch `(current: boolean) => void`	The `finally` half of `runFetch`'s bookkeeping, an action of its own because `runFetchOnce`'s `finally` resumes on a microtask the flow does not own — a direct volatile write there is outside the action context, which is the one thing hoisting the sequence into a shared function costs. The stale branch is a superseded fetch, which must not clear the loading flag the run that replaced it just set.	FetchMixin
runFetch `(work: (ctx: FetchContext) => Promise<void>) => Promise<void>`	Run a cancel-safe fetch (cancels any prior). The work callback gets a FetchContext with a signal to forward to the RPC and an isStale() check to short-circuit commits once the user has moved on. The MST-flow wrapper over the shared `runFetchOnce` sequence, and only the wrapper: the begin/clear/run/commit/error/end order, and the rules that keep a superseded run from writing back, are the same function every other fetch in the tree runs. What this adds is the observable bookkeeping a display needs — `isLoading` through `activeSignal`, `fetchGeneration`, the user-cancel clear — and the flow itself, which is an action, so `work`'s synchronous prefix runs untracked wherever a fetch autorun calls this.	FetchMixin
setShowTree `(arg: boolean) => void`		TreeSidebarMixin
setShowBranchLength `(arg: boolean) => void`		TreeSidebarMixin
setShowRowLabels `(arg: boolean) => void`		TreeSidebarMixin
setTreeAreaWidth `(width: number) => void`		TreeSidebarMixin
setRunClustering `(arg?: boolean \| undefined) => void`		TreeSidebarMixin
setClusterRegion `(arg?: string \| undefined) => void`		TreeSidebarMixin
setSortRowsBy `(arg?: RowSortSpec \| undefined) => void`	Trigger (or clear) a one-shot declarative row sort; consumed and reset by `setupRowSortAutorun`.	TreeSidebarMixin
setHoveredTreeNode `(node?: HoveredTreeNode \| undefined) => void`		TreeSidebarMixin
setTreeCanvasRef `(ref: HTMLCanvasElement \| null) => void`		TreeSidebarMixin
setMouseoverCanvasRef `(ref: HTMLCanvasElement \| null) => void`		TreeSidebarMixin
setRowOrder `(rows: readonly { name: string; }[], run?: ClusterRun \| undefined) => void`	Arrange the rows in `rows`' order, ahead of any name the current order carries that `rows` does not. A clustering run passes its result, and the tree and its provenance land with the order; any other reorder that moves a row drops the tree, which no longer describes it.	TreeSidebarMixin
setRowLabels `(labels: Readonly<Record<string, string>>) => void`	The labels drawn in place of row names, whole: a row the map does not name shows the name it arrived with.	TreeSidebarMixin
setRowFocus `(names?: readonly string[] \| undefined) => void`	Narrow the display to `names`, or show every row again.	TreeSidebarMixin
applyRowEdits `(rows: readonly S[], rowColor?: Partial<RowColorSetting> \| undefined) => void`	The arrangement dialog's submit: the rows in their new order, each carrying the label and colour the reader left on it, and the `rowColor` object the dialog shows, the config's own when omitted, as the dialog omits it where the reader left the colours alone. The labels go to `rows` by the rule `rowEdits` states, and the order to `rows.domain` unless it moves no row, so a submit that changes nothing writes nothing. The rows' colours are read only under an object painting by `name`, whose pairs they become; any other object is written as the dialog shows it, so a colour set on one row never stands for its attribute's value.	TreeSidebarMixin
resetRowArrangement `() => void`	Return every arrangement member — order, labels, tree, provenance and focus — to what the config declares, leaving `rows.field`, and the `rowColor` colours to `rowColorResetTarget`: the config's for the field the rows are coloured by, which stays.	TreeSidebarMixin
focusLegendEntry `(scaleId: string, value: string) => void`	`LegendHost`'s hook: a click on a row colour key entry narrows the rows to those it lists. Every other scale's entries name colours, not rows, and stay inert.	TreeSidebarMixin
setRowHeight `(n: number) => void`	Pin a px row height. `0` is the fit sentinel, but enter fit mode through `setFitToHeight` instead — displays whose `height` getter is content-derived have to re-seed the slot on the way in, and that is what the action is for.	RowHeightMixin

LinearMarkDisplay

Properties#

Volatiles#

Getters#

Methods#

Actions#

Properties

Volatiles

Getters

Methods

Actions