type: types.literal('LinearManhattanDisplay') | | LinearManhattanDisplay |
| **configuration**configuration: ConfigurationReference(configSchema) | | LinearManhattanDisplay |
| **indexSnp**indexSnp: types.maybe(types.string) | The index SNP the LD join reads r² to: a SNP id or a 1-based `chr:bp`. It follows the highest-scoring loaded SNP until the user pins one. | LinearManhattanDisplay |
| **indexSnpPinned**indexSnpPinned: types.stripDefault(types.boolean, false) | True once the user pins an index SNP by right-clicking a point. | LinearManhattanDisplay |
| **id**id: ElementId | | [BaseDisplay](../basedisplay#property-id) |
| **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](../treesidebarmixin#property-runclustering) |
| **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](../treesidebarmixin#property-clusterregion) |
| **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](../treesidebarmixin#property-sortrowsby) |
## Volatiles
| Member | Description | Defined by |
| --- | --- | --- |
| **sourceListing**plotFields: undefined as PlotFields | undefined | | [LinearMarkDisplay](../linearmarkdisplay#volatile-plotfields) |
| **plotFieldsError**plotFieldsError: undefined as unknown | | [LinearMarkDisplay](../linearmarkdisplay#volatile-plotfieldserror) |
| **plotDefaultChecked**plotDefaultChecked: false | | [LinearMarkDisplay](../linearmarkdisplay#volatile-plotdefaultchecked) |
| **plotFieldsPromise**plotFieldsPromise: undefined as Promise<PlotFields> | undefined | | [LinearMarkDisplay](../linearmarkdisplay#volatile-plotfieldspromise) |
| **plotScanned**plotScanned: [] as Region[] | | [LinearMarkDisplay](../linearmarkdisplay#volatile-plotscanned) |
| **detailsRotation**coarseTier: regionDataMap<P>('coarseTier') | The coarse payload by `displayedRegionIndex`, over the regions the last read was issued for. Cleared on chromosome navigation. | [CoarseTierMixin](../coarsetiermixin#volatile-coarsetier) |
| **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](../coarsetiermixin#volatile-coarsetierread) |
| **coarseTierLoading**coarseTierLoading: false | | [CoarseTierMixin](../coarsetiermixin#volatile-coarsetierloading) |
| **unclippedQuantile**unclippedQuantile: undefined as number | undefined | | [ScoreScaleMixin](../scorescalemixin#volatile-unclippedquantile) |
| **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](../legendmixin#volatile-dismissedlegendsections) |
| contextMenuInfo: undefined as Info | undefined | | [ContextMenuMixin](../contextmenumixin#volatile-contextmenuinfo) |
| **storedHoveredFeature**storedHoveredFeature: undefined as T | undefined | | [StoredHoverMixin](../storedhovermixin#volatile-storedhoveredfeature) |
| hiddenGroups: observable.set<string>() | Group keys the user hid from the stack. | [HiddenGroupsMixin](../hiddengroupsmixin#volatile-hiddengroups) |
| **error**error: undefined as unknown | | [BaseDisplay](../basedisplay#volatile-error) |
| **statusMessage**statusMessage: undefined as string | undefined | | [BaseDisplay](../basedisplay#volatile-statusmessage) |
| **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](../basedisplay#volatile-statusprogress) |
| **scrollTop**scrollTop: 0 | | [TrackHeightMixin](../trackheightmixin#volatile-scrolltop) |
| **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`.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](../regiontoolargemixin#volatile-forceloadtrack) |
| **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](../regiontoolargemixin#volatile-byteestimate) |
| **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](../regiontoolargemixin#volatile-gatemeasuredviewportkey) |
| **canvasDrawn**canvasDrawn: false | flips true on first paint; read by test selectors to detect render | [RenderLifecycleMixin](../renderlifecyclemixin#volatile-canvasdrawn) |
| **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](../renderlifecyclemixin#volatile-paintcount) |
| **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` and narrowed with `as B` inside the autoruns. Don't "fix" the cast. | [RenderLifecycleMixin](../renderlifecyclemixin#volatile-currentrenderingbackend) |
| **renderTick**renderTick: 0 | counter the render autorun observes; bumped to force a re-render | [RenderLifecycleMixin](../renderlifecyclemixin#volatile-rendertick) |
| **autorunsInstalled**autorunsInstalled: false | guards attachRenderingBackend so the autorun pair spawns once per instance | [RenderLifecycleMixin](../renderlifecyclemixin#volatile-autorunsinstalled) |
| **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](../renderlifecyclemixin#volatile-rendererror) |
| **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.activeSignal: undefined as AbortSignal | undefined | signal of the in-flight fetch, or undefined when idle | [FetchMixin](../fetchmixin#volatile-activesignal) |
| **fetchGeneration**fetchGeneration: 0 | bumps at every fetch end; autoruns read it to re-evaluate, and it doubles as the staleness epoch inside runFetch | [FetchMixin](../fetchmixin#volatile-fetchgeneration) |
| **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](../fetchmixin#volatile-reloadcounter) |
| **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](../fetchmixin#volatile-statuswindow) |
| **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](../fetchmixin#volatile-fetchcanceled) |
| **fetchRotation**hoveredTreeNode: undefined as HoveredTreeNode | undefined | | [TreeSidebarMixin](../treesidebarmixin#volatile-hoveredtreenode) |
| **treeCanvas**treeCanvas: null as HTMLCanvasElement | null | | [TreeSidebarMixin](../treesidebarmixin#volatile-treecanvas) |
| **mouseoverCanvas**mouseoverCanvas: null as HTMLCanvasElement | null | | [TreeSidebarMixin](../treesidebarmixin#volatile-mouseovercanvas) |
## Getters
| Member | Description | Defined by |
| --- | --- | --- |
| **gateEnabled**boolean | No byte gate: a Manhattan plot's case is a genome-wide view of summary statistics, which a region budget would refuse. | LinearManhattanDisplay |
| **ldAdapterConfig**Record<string, unknown> | undefined | The `ldAdapter` on the track's `GWASAdapter`, or undefined for none. Read off the live track, since `self.adapterConfig` is a snapshot, which leaves out a slot at its default. | LinearManhattanDisplay |
| **hasLdData**boolean | | LinearManhattanDisplay |
| **joinsLd**boolean | Whether a fetch joins r² to the index: a mark's encoding names `ld` or `ld_role`, and the adapter has an LD file to read them from. Without one, a mark reads `ld` off the features like any other field. | LinearManhattanDisplay |
| UnionNode<…>[] | The steps every mark runs before its own: the display's, then the facet's. | LinearManhattanDisplay |
| **ldColorable**boolean | Whether "Color by LD to index SNP" has a point mark to colour. | LinearManhattanDisplay |
| **ldMarkIndexes**number[] | The marks drawing at this zoom that name an LD field and plot each SNP's own `y` at its own position, whose points the top hit reads. | LinearManhattanDisplay |
| **topSnp**string | undefined | The highest-scoring loaded SNP of the LD marks as a 1-based `chr:bp`, the index the join follows while none is pinned.{ ld: string; } | undefined | The index the fetch joins r² to, a fetch input, so adopting or pinning one refetches. None before the first load names a top hit. | LinearManhattanDisplay |
| **dataSuperseded**boolean | The loaded data was joined under an index other than the top hit, so adopting it will clear the data and refetch: `MultiRegionDisplayMixin`'s supersession hook, and the auto-pick's trigger. | LinearManhattanDisplay |
| **conf**boolean | the track label sits above the plot so the y-axis stays on the edge | [LinearMarkDisplay](../linearmarkdisplay#getter-prefersoffset) |
| **markTypes**("bar" | "line" | "link" | "point" | "rule" | "span" | "text")[] | The declared marks' types, in draw order. | [LinearMarkDisplay](../linearmarkdisplay#getter-marktypes) |
| **facet**FacetSetting | undefined | The `facet` object as written, or undefined while unfaceted. | [LinearMarkDisplay](../linearmarkdisplay#getter-facet) |
| **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](../linearmarkdisplay#getter-groupkeyspace) |
| **markEntries**MarkEntry[] | Each mark's type and zoom range, what the mark list is built from. | [LinearMarkDisplay](../linearmarkdisplay#getter-markentries) |
| **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](../linearmarkdisplay#getter-textmarkentries) |
| **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](../linearmarkdisplay#getter-markview) |
| **densityMarkIndex**number | The mark the density sidecar stands in for, or -1. | [LinearMarkDisplay](../linearmarkdisplay#getter-densitymarkindex) |
| **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](../linearmarkdisplay#getter-marksizes) |
| **markRowProportions**number[] | Each mark's `rowProportion`, which a span alone reads. | [LinearMarkDisplay](../linearmarkdisplay#getter-markrowproportions) |
| **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](../linearmarkdisplay#getter-rowproportion) |
| **hasLinkMark**boolean | Whether any mark is a link, whose feet place through the view's regions rather than the block's own range. | [LinearMarkDisplay](../linearmarkdisplay#getter-haslinkmark) |
| **pointSize**number | The size the Point size menu shows: the first point mark's, or the default where no mark is a point. | [LinearMarkDisplay](../linearmarkdisplay#getter-pointsize) |
| **encodings**MarkEncoding[] | The declared marks' encodings, as the worker takes them. | [LinearMarkDisplay](../linearmarkdisplay#getter-encodings) |
| **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](../linearmarkdisplay#getter-marksteplists) |
| **markChannels**StepChannels[] | The channels each mark's steps fill where its encoding leaves them unwritten. | [LinearMarkDisplay](../linearmarkdisplay#getter-markchannels) |
| **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](../linearmarkdisplay#getter-markcolors) |
| **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](../linearmarkdisplay#getter-facetsteps) |
| **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](../linearmarkdisplay#getter-layerrequests) |
| **origin**number | | [LinearMarkDisplay](../linearmarkdisplay#getter-origin) |
| **minWidthPx**number | | [LinearMarkDisplay](../linearmarkdisplay#getter-minwidthpx) |
| **configuredFilters**() => string[] | the `filter` slot | [LinearMarkDisplay](../linearmarkdisplay#getter-configuredfilters) |
| **baseFilters**() => string[] | What the track's config declares for `filter`, which "Clear all filters" returns to. | [LinearMarkDisplay](../linearmarkdisplay#getter-basefilters) |
| **rowsField**string | `rows.field` as written: the field each value of which takes a row. | [LinearMarkDisplay](../linearmarkdisplay#getter-rowsfield) |
| **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](../linearmarkdisplay#getter-drawsrows) |
| **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](../linearmarkdisplay#getter-drawskeyedrows) |
| **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](../linearmarkdisplay#getter-splitfield) |
| **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](../linearmarkdisplay#getter-rowcolorfields) |
| **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](../linearmarkdisplay#getter-coarsetiermode) |
| **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](../linearmarkdisplay#getter-densitypayloads) |
| **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](../linearmarkdisplay#getter-featurepayloads) |
| **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](../linearmarkdisplay#getter-rowlisting) |
| **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](../linearmarkdisplay#getter-adaptersources) |
| **guideTreeNewick**string | undefined | `TreeSidebarMixin`'s hook: the guide tree the adapter lists over the rows, a MAF's species tree. | [LinearMarkDisplay](../linearmarkdisplay#getter-guidetreenewick) |
| **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](../linearmarkdisplay#getter-discoveredrows) |
| **sources**RowSource[] | The rows drawn, top to bottom: the arrangement narrowed to the focus. | [LinearMarkDisplay](../linearmarkdisplay#getter-sources) |
| **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](../linearmarkdisplay#getter-rowkeys) |
| **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](../linearmarkdisplay#getter-facetlayout) |
| **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](../linearmarkdisplay#getter-rpcdatamap) |
| **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](../linearmarkdisplay#getter-rowtable) |
| **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](../linearmarkdisplay#getter-drawnkeys) |
| **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](../linearmarkdisplay#getter-scaledatamap) |
| **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](../linearmarkdisplay#getter-marklist) |
| **hasPointMark**boolean | Whether a point mark draws at the view's zoom, for the Point size menu. | [LinearMarkDisplay](../linearmarkdisplay#getter-haspointmark) |
| **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](../linearmarkdisplay#getter-drawingmarkindices) |
| **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](../linearmarkdisplay#getter-autoscalerange) |
| **domain**[number, number] | undefined | | [LinearMarkDisplay](../linearmarkdisplay#getter-domain) |
| **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](../linearmarkdisplay#getter-valueinsetpx) |
| **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](../linearmarkdisplay#getter-valuescales) |
| **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](../linearmarkdisplay#getter-rowcount) |
| **nrow**number | `rowCount`, under the name `useRowVirtualScroll`'s shift+wheel resize divides the plot by. | [LinearMarkDisplay](../linearmarkdisplay#getter-nrow) |
| **autoRowHeight**number | `RowHeightMixin`'s hook: the plot split between the rows. | [LinearMarkDisplay](../linearmarkdisplay#getter-autorowheight) |
| **rowsHeaderHeight**number | `TreeSidebarMixin`'s hook: the plot's top inset. | [LinearMarkDisplay](../linearmarkdisplay#getter-rowsheaderheight) |
| **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](../linearmarkdisplay#getter-plotbox) |
| **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](../linearmarkdisplay#getter-paintscales) |
| **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](../linearmarkdisplay#getter-sizescales) |
| **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](../linearmarkdisplay#getter-linkregions) |
| **renderState**MarkRenderState | geometry and scale for the plot canvas, the same box the hit test measures in | [LinearMarkDisplay](../linearmarkdisplay#getter-renderstate) |
| **highlightedHit**MarkHitInfo | undefined | The mark the hover or the open context menu is on, or undefined. | [LinearMarkDisplay](../linearmarkdisplay#getter-highlightedhit) |
| **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](../linearmarkdisplay#getter-highlightstyle) |
| **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](../linearmarkdisplay#getter-hoverink) |
| **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](../linearmarkdisplay#getter-configproblems) |
| **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](../linearmarkdisplay#getter-datanotices) |
| SharedKey[] | The shape keys whose unlisted values collide on one shape, each with the domain Pin distinct shapes writes. | [LinearMarkDisplay](../linearmarkdisplay#getter-sharedkeys) |
| **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](../linearmarkdisplay#getter-cornernotices) |
| **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](../linearmarkdisplay#getter-notices) |
| **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](../linearmarkdisplay#getter-densitystandinnotice) |
| **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](../linearmarkdisplay#getter-skippedfeatures) |
| **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](../linearmarkdisplay#getter-legendsections) |
| **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](../linearmarkdisplay#getter-colorscales) |
| **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](../linearmarkdisplay#getter-effectiverowheight) |
| **scrollContentHeight**number | `TrackHeightMixin`'s hook: the rows under `rows`, taller than the plot wherever a pinned `rowHeight` asks for more than it holds. | [LinearMarkDisplay](../linearmarkdisplay#getter-scrollcontentheight) |
| **scrollViewportHeight**number | `TrackHeightMixin`'s hook: the plot the rows scroll behind. | [LinearMarkDisplay](../linearmarkdisplay#getter-scrollviewportheight) |
| **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](../linearmarkdisplay#getter-valuemarkindex) |
| **hierarchy**ClusterHierarchyNode | undefined | The dendrogram positioned against the rows drawn, or undefined where it no longer names them. | [LinearMarkDisplay](../linearmarkdisplay#getter-hierarchy) |
| **spatialIndex**TreeSpatialIndex | undefined | | [LinearMarkDisplay](../linearmarkdisplay#getter-spatialindex) |
| SvgSidebarProps | undefined | | [LinearMarkDisplay](../linearmarkdisplay#getter-svgsidebar) |
| **plotScanLocus**string | undefined | The window the held field scan read, for the dialog to name. | [LinearMarkDisplay](../linearmarkdisplay#getter-plotscanlocus) |
| **coarseAdapterSlot**string | | [DensityTierMixin](../densitytiermixin#getter-coarseadapterslot) |
| **densityTierMode**"auto" | "density" | "features" | The `densityTier` slot's value. | [DensityTierMixin](../densitytiermixin#getter-densitytiermode) |
| **densityTierThresholdBpPerPx**number | | [DensityTierMixin](../densitytiermixin#getter-densitytierthresholdbpperpx) |
| **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](../densitytiermixin#getter-coarsetierpastthreshold) |
| **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](../densitytiermixin#getter-coarsereadkey) |
| **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](../coarsetiermixin#getter-coarsetiergated) |
| **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](../coarsetiermixin#getter-coarsetierhassomewheretodraw) |
| **coarseSourceConfig**unknown | The coarse source's config, read off the live track config so a re-pointed adapter follows. | [CoarseTierMixin](../coarsetiermixin#getter-coarsesourceconfig) |
| **hasCoarseSource**boolean | | [CoarseTierMixin](../coarsetiermixin#getter-hascoarsesource) |
| **coarseTierActive**boolean | Whether the coarse tier stands in for the detail right now. | [CoarseTierMixin](../coarsetiermixin#getter-coarsetieractive) |
| **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`.boolean | The byte gate is measuring the coarse read rather than the detail fetch, so its verdict is about the tier on screen. | [CoarseTierMixin](../coarsetiermixin#getter-gatemeasurescoarse) |
| **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](../coarsetiermixin#getter-bytegateadapterpath) |
| **gateRefusesDetail**boolean | The gate's refusal is about the detail fetch, so that fetch owes the re-measure the gate releases through. | [CoarseTierMixin](../coarsetiermixin#getter-gaterefusesdetail) |
| **coarseTierIssueKey**boolean | `MultiRegionDisplayMixin`'s hook, from `resolveFetchSuspended` over `coarseTierStandsIn`. | [CoarseTierMixin](../coarsetiermixin#getter-fetchsuspended) |
| **displayPhase**DisplayPhase | The foundation's phase with the too-large banner swapped for the tier — see `coarseTierDisplayPhase`. | [CoarseTierMixin](../coarsetiermixin#getter-displayphase) |
| **svgReady**boolean | The export gate under the same swap — see `coarseTierSvgReady`. | [CoarseTierMixin](../coarsetiermixin#getter-svgready) |
| **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](../coarsetiermixin#getter-drawswhentoolarge) |
| **scaleType**string | | [ScoreScaleMixin](../scorescalemixin#getter-scaletype) |
| **scaleZero**boolean | `scales.y.zero`: whether an autoscaled linear or symlog axis reaches 0. | [ScoreScaleMixin](../scorescalemixin#getter-scalezero) |
| **domainQuantile**number | `scales.y.domainQuantile`: what an unpinned end follows, 1 the extremes and below it that quantile of each sign. | [ScoreScaleMixin](../scorescalemixin#getter-domainquantile) |
| **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](../scorescalemixin#getter-clipquantile) |
| **symlogConstant**number | Raw slot; `0` means "derive from the domain". Resolve it with `resolveSymlogConstant` once the domain is known. | [ScoreScaleMixin](../scorescalemixin#getter-symlogconstant) |
| **manualMinScore**number | undefined | The lower bound the config pins, `undefined` where it pins none. | [ScoreScaleMixin](../scorescalemixin#getter-manualminscore) |
| **manualMaxScore**number | undefined | The upper bound the config pins, `undefined` where it pins none. | [ScoreScaleMixin](../scorescalemixin#getter-manualmaxscore) |
| **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](../scorescalemixin#getter-valuescalenotices) |
| **autoscaleGroup**string | undefined | `scales.y.autoscaleGroup`, `undefined` while it names none. | [ScoreScaleMixin](../scorescalemixin#getter-autoscalegroup) |
| **scaleTitle**string | `scales.y.title`, `''` while unset | [ScoreScaleMixin](../scorescalemixin#getter-scaletitle) |
| **grid**boolean | `scales.y.grid` | [ScoreScaleMixin](../scorescalemixin#getter-grid) |
| **minimalTicks**boolean | `scales.y.minimalTicks` | [ScoreScaleMixin](../scorescalemixin#getter-minimalticks) |
| **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](../scorescalemixin#getter-scorerulesdrawn) |
| **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](../scorescalemixin#getter-scorerules) |
| **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).boolean | Overridable: whether the autoscaled domain reaches 0, `scaleZero` unless the display maps its score to something with no axis. | [ScoreAxisMixin](../scoreaxismixin#getter-axisreacheszero) |
| **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](../scoreaxismixin#getter-autoscaleddomain) |
| **minScoreBound**number | undefined | Resolved lower bound; `undefined` means autoscale this end. | [ScoreAxisMixin](../scoreaxismixin#getter-minscorebound) |
| **maxScoreBound**number | undefined | Resolved upper bound; `undefined` means autoscale this end. | [ScoreAxisMixin](../scoreaxismixin#getter-maxscorebound) |
| **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](../scoreaxismixin#getter-hasmanualscorebounds) |
| **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](../scoreaxismixin#getter-axes) |
| **showLegend**boolean | Whether the legend is drawn. | [LegendMixin](../legendmixin#getter-showlegend) |
| **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](../legendmixin#getter-legendtop) |
| **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](../legendmixin#getter-legendright) |
| **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](../legendmixin#getter-legendspec) |
| **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](../legendmixin#getter-haslegendkey) |
| **hoveredFeature**T | undefined | | [StoredHoverMixin](../storedhovermixin#getter-hoveredfeature) |
| 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](../hiddengroupsmixin#getter-displayhiddengroupkeys) |
| **ownGroupState**unknown | Overridable hook: the per-group state a display keeps beyond the hidden sections, as a plain value. None by default; alignments answers its collapses and height overrides, the state its `dropGroupState` clears. | [HiddenGroupsMixin](../hiddengroupsmixin#getter-owngroupstate) |
| 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](../hiddengroupsmixin#getter-hiddengroupkeys) |
| **groupStateKey**unknown | All the per-group state as a plain, comparable value: the hidden sections, sorted, beside `ownGroupState`. A live figure keys on it, since the state is volatile and in no snapshot; a Set would serialize as `{}`. | [HiddenGroupsMixin](../hiddengroupsmixin#getter-groupstatekey) |
| **parentTrack**AbstractTrackModel | | [BaseDisplay](../basedisplay#getter-parenttrack) |
| **RenderingComponent**FC<…> | | [BaseDisplay](../basedisplay#getter-renderingcomponent) |
| **DisplayBlurb**Record<string, unknown> | | [BaseDisplay](../basedisplay#getter-adapterconfig) |
| **isMinimized**boolean | Returns true if the parent track is minimized. Used to skip expensive operations like autoruns when track is not visible. | [BaseDisplay](../basedisplay#getter-isminimized) |
| **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".{ 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.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](../basedisplay#getter-plotkeys) |
| **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](../basedisplay#getter-plot) |
| **plotExamples**readonly PlotExample[] | The worked examples this display type declares, which "Edit plot..." offers as buttons. | [BaseDisplay](../basedisplay#getter-plotexamples) |
| **configDocsUrl**string | This display type's page in the config reference, which lists every setting it takes. | [BaseDisplay](../basedisplay#getter-configdocsurl) |
| **height**number | | [TrackHeightMixin](../trackheightmixin#getter-height) |
| **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).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](../trackheightmixin#getter-scrollableheight) |
| **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](../multiregiondisplaymixin#getter-host) |
| **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.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](../multiregiondisplaymixin#getter-settledsubpixelbinbp) |
| **canRender**boolean | Overrides `RenderLifecycleMixin`'s default-true hook with the LGV precondition both foundations share — see `foundationCanRender`. | [MultiRegionDisplayMixin](../multiregiondisplaymixin#getter-canrender) |
| **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](../multiregiondisplaymixin#getter-renderscanvas) |
| **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](../multiregiondisplaymixin#getter-trackvisibleregions) |
| **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.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](../multiregiondisplaymixin#getter-viewportempty) |
| **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](../multiregiondisplaymixin#getter-layoutready) |
| **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](../multiregiondisplaymixin#getter-renderblocks) |
| **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](../multiregiondisplaymixin#getter-fetchinputs) |
| **regionPayloads**ReadonlyMap<number, unknown> | The store's payloads, keyed by `displayedRegionIndex`. A display narrows this once — `get rpcDataMap() { return self.regionPayloads as ReadonlyMapboolean | 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](../multiregiondisplaymixin#getter-hasregiondata) |
| **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.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.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](../multiregiondisplaymixin#getter-phaseviewportcurrent) |
| **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](../multiregiondisplaymixin#getter-paintinert) |
| **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](../multiregiondisplaymixin#getter-paintsuperseded) |
| **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](../regiontoolargemixin#getter-bytegateadapterconfig) |
| **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](../regiontoolargemixin#getter-configuredfetchsizelimit) |
| **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](../regiontoolargemixin#getter-densitytoolarge) |
| **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](../regiontoolargemixin#getter-adapterfetchsizelimit) |
| **configForceLoad**boolean | The declarative `forceLoad` slot. | [RegionTooLargeMixin](../regiontoolargemixin#getter-configforceload) |
| **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](../regiontoolargemixin#getter-gateviewportspanbp) |
| **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.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](../regiontoolargemixin#getter-aboveforceloadfloor) |
| **gateExempt**boolean | Nothing may gate on either axis: the `forceLoad` slot or the button. | [RegionTooLargeMixin](../regiontoolargemixin#getter-gateexempt) |
| **estimatedFetchBytes**number | undefined | The stored estimate's bytes; undefined when nothing has been measured. | [RegionTooLargeMixin](../regiontoolargemixin#getter-estimatedfetchbytes) |
| **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](../regiontoolargemixin#getter-gatemeasurementstale) |
| **gateByteLimit**number | The byte budget: the adapter's limit, else the display's, doubled below `AUTO_FORCE_LOAD_BP`. Read only through `resolvedByteLimit()`. | [RegionTooLargeMixin](../regiontoolargemixin#getter-gatebytelimit) |
| **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](../regiontoolargemixin#getter-gateactive) |
| **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](../regiontoolargemixin#getter-densitygateactive) |
| **tooLargeStatus**RegionTooLargeStatus | The verdict and its banner text, from the stored estimate against `resolvedByteLimit()` and the density axis when it may act. | [RegionTooLargeMixin](../regiontoolargemixin#getter-toolargestatus) |
| **regionTooLarge**boolean | | [RegionTooLargeMixin](../regiontoolargemixin#getter-regiontoolarge) |
| **regionTooLargeReason**string | Banner text for the axis that tripped; empty when not too large. | [RegionTooLargeMixin](../regiontoolargemixin#getter-regiontoolargereason) |
| **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](../regiontoolargemixin#getter-zoomcanreleasegate) |
| **gateSkipsMeasuredViewport**boolean | The skip both fetch skeletons apply: the banner is up and its measurement already describes the viewport on screen. | [RegionTooLargeMixin](../regiontoolargemixin#getter-gateskipsmeasuredviewport) |
| **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.boolean | true while a fetch is active | [FetchMixin](../fetchmixin#getter-isloading) |
| **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](../fetchmixin#getter-isloadingorcanceled) |
| **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.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.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.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.boolean | Whether the dendrogram sidebar is drawn. | [TreeSidebarMixin](../treesidebarmixin#getter-showtree) |
| **showBranchLength**boolean | Whether tree nodes are positioned by branch length (dendrogram) or evenly by topology (cladogram). | [TreeSidebarMixin](../treesidebarmixin#getter-showbranchlength) |
| **showRowLabels**boolean | Whether each row's name is drawn over the left of the plot. | [TreeSidebarMixin](../treesidebarmixin#getter-showrowlabels) |
| **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](../treesidebarmixin#getter-treeareawidth) |
| **rowDomain**string[] | The row order, `rows.domain`: the rows it names lead, in its order, and the rest follow as `unlistedRowsSort` says. | [TreeSidebarMixin](../treesidebarmixin#getter-rowdomain) |
| **rowLabels**Readonly<Record<string, string>> | The labels drawn in place of row names, `rows.labels`, by name. | [TreeSidebarMixin](../treesidebarmixin#getter-rowlabels) |
| **rowTreeProvenance**ClusterProvenance | undefined | What `rowTree` was computed from, the locus and the settings; undefined for a tree that arrived as data. | [TreeSidebarMixin](../treesidebarmixin#getter-rowtreeprovenance) |
| **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](../treesidebarmixin#getter-rowfocus) |
| **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](../treesidebarmixin#getter-rowcolorsetting) |
| **baseRowColor**RowColorSetting | The `rowColor` object this display's base declares, which a reset returns to and "is this the reader's" compares against. | [TreeSidebarMixin](../treesidebarmixin#getter-baserowcolor) |
| **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](../treesidebarmixin#getter-baserowdomain) |
| **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](../treesidebarmixin#getter-rowalias) |
| **unlistedRowsSort**UnlistedRowsSort | Overridable hook: where the rows `rowOrder` does not list go, in the order they arrived by default. | [TreeSidebarMixin](../treesidebarmixin#getter-unlistedrowssort) |
| **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](../treesidebarmixin#getter-rowbanding) |
| **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](../treesidebarmixin#getter-rowfocuslineheight) |
| **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](../treesidebarmixin#getter-rowstopoffset) |
| **guideTree**HierarchyNode<NewickNode> | undefined | `guideTreeNewick` parsed and rotated towards `rows.domain`; undefined while the display supplies none. | [TreeSidebarMixin](../treesidebarmixin#getter-guidetree) |
| **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](../treesidebarmixin#getter-guidetreehonoursdomain) |
| **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](../treesidebarmixin#getter-rowtree) |
| **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](../treesidebarmixin#getter-roworder) |
| **expandedRows**S[] | `discoveredRows` through `expandRows`: the rows at the granularity drawn, before any arrangement. | [TreeSidebarMixin](../treesidebarmixin#getter-expandedrows) |
| boolean | Overridable hook: whether the rows share one panel, so nothing but colour tells them apart. False by default. | [TreeSidebarMixin](../treesidebarmixin#getter-sharespanel) |
| **rowColorPaintsMarks**boolean | Overridable hook: whether a row's colour paints its data marks, which holds while nothing else colours them. True by default. | [TreeSidebarMixin](../treesidebarmixin#getter-rowcolorpaintsmarks) |
| **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](../treesidebarmixin#getter-rownoun) |
| **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](../treesidebarmixin#getter-internalrowfields) |
| **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](../treesidebarmixin#getter-rowbandingnotices) |
| **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](../treesidebarmixin#getter-rowpalettedeals) |
| **rowColorDealRows**readonly S[] | The rows the palette deals over: `expandedRows` in the base arrangement, so no reorder, focus or relabel recolours a row. | [TreeSidebarMixin](../treesidebarmixin#getter-rowcolordealrows) |
| **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](../treesidebarmixin#getter-rowstylingiscustom) |
| **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](../treesidebarmixin#getter-rowcolorchoice) |
| **rowColorAttribute**string | The attribute the rows are coloured by, or '' by `name`. | [TreeSidebarMixin](../treesidebarmixin#getter-rowcolorattribute) |
| **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](../treesidebarmixin#getter-dealtrowcolors) |
| **rowColorAttributesOffered**readonly string[] | The attributes a reader can colour the rows by: `rowColorFields`, and the current one where the rows lack it, so it still shows as chosen. | [TreeSidebarMixin](../treesidebarmixin#getter-rowcolorattributesoffered) |
| **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](../treesidebarmixin#getter-resolvedrowcolors) |
| **rowArrangementIsCustom**boolean | Whether the arrangement differs from what the config declares — what "Reset row order" is offered on. | [TreeSidebarMixin](../treesidebarmixin#getter-rowarrangementiscustom) |
| **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](../treesidebarmixin#getter-editablesources) |
| **rowColorKeyInputs**RowColorKeyInputs | What the row colour key and its focus read of the colours. | [TreeSidebarMixin](../treesidebarmixin#getter-rowcolorkeyinputs) |
| **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](../treesidebarmixin#getter-rowcolorscales) |
| **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](../treesidebarmixin#getter-clusterablesources) |
| **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](../treesidebarmixin#getter-parsedtree) |
| **root**HierarchyNode<NewickNode> | undefined | The parsed tree narrowed to the focus. | [TreeSidebarMixin](../treesidebarmixin#getter-root) |
| **bandedRows**{ rows: S[]; bands: RowBand[]; } | `bandedSources` and `rowBands`, from one pass over the rows. | [TreeSidebarMixin](../treesidebarmixin#getter-bandedrows) |
| **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](../treesidebarmixin#getter-bandedsources) |
| **rowBands**readonly RowBand[] | Each band's value, label and the rows it spans in `bandedSources`; none while nothing bands. | [TreeSidebarMixin](../treesidebarmixin#getter-rowbands) |
| **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](../treesidebarmixin#getter-clusterpartition) |
| **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](../treesidebarmixin#getter-treelessbandcount) |
| **treeHasBranchLengths**boolean | Whether the tree carries merge heights, so a dendrogram layout differs from the cladogram; gates the "Tree branch lengths" toggle. | [TreeSidebarMixin](../treesidebarmixin#getter-treehasbranchlengths) |
| **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](../rowheightmixin#getter-rowheight) |
## Methods
| Member | Description | Defined by |
| --- | --- | --- |
| **resolveAdapterOptions**() => MenuItem[] | | LinearManhattanDisplay |
| () => MenuItem[] | | LinearManhattanDisplay |
| **rpcProps**(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](../linearmarkdisplay#method-plotproblems) |
| **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](../linearmarkdisplay#method-liftmarkplot) |
| **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](../legendmixin#method-svglegendwidth) |
| **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](../legendmixin#method-colorscalesin) |
| **legendSpecIn**(palette: JBrowsePalette) => LegendSpec | `legendSpec` in the SVG export's theme. | [LegendMixin](../legendmixin#method-legendspecin) |
| **renderingProps**(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](../basedisplay#method-liftplot) |
| **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](../basedisplay#method-plotwrites) |
| **regionHasData**(displayedRegionIndex: number) => boolean | Overridable hook: whether the display can draw what this region is marked loaded over, at the zoom the view has.(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](../multiregiondisplaymixin#method-iscachevalid) |
| **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](../regiontoolargemixin#method-resolvedbytelimit) |
| **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](../regiontoolargemixin#method-gatefetchstate) |
| **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](../treesidebarmixin#method-expandrows) |
| (text?: ExportTextStyle | undefined) => number | Px the SVG export reserves left of the track for `svgSidebar`, measured in the export's text. | [TreeSidebarMixin](../treesidebarmixin#method-svgsidebarwidth) |
| **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](../treesidebarmixin#method-rowband) |
| **dealtRowColorsFor**(choice: string) => RowColorSetting | The `rowColor` object `choice` starts from (`startingRowColor`): the current object's where it shows that choice, else the config's. | [TreeSidebarMixin](../treesidebarmixin#method-rowcolorfor) |
| **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](../treesidebarmixin#method-roworderwilldroptree) |
## Actions
| Member | Description | Defined by |
| --- | --- | --- |
| **setIndexSnp**(snp?: string | undefined) => void | | LinearManhattanDisplay |
| **setLdColoring**(on: boolean) => void | Colour each point by its r² to the index SNP, the index a pink diamond over them, or take that colouring off, leaving every other member and mark of the plot as it was (`withLd`, `withoutLd`). | LinearManhattanDisplay |
| **colorByLdToHit**(hit: { refName: string; start: number; }) => void | Right-click "Color by LD to this SNP": colour by r² to the clicked point and pin it as the index, in one action so the fetch inputs settle once. | LinearManhattanDisplay |
| **useTopHitAsIndex**() => void | Release a pinned index back to following the top hit. | LinearManhattanDisplay |
| **setSourceListing**(read: AdapterRead<RowSourceListing | undefined>) => void | | [LinearMarkDisplay](../linearmarkdisplay#action-setsourcelisting) |
| **setRowProportion**(n: number) => void | Write every span mark's `rowProportion`. | [LinearMarkDisplay](../linearmarkdisplay#action-setrowproportion) |
| **setFitToHeight**() => void | Fit the rows to the plot. The `height` getter is the slot itself, so nothing needs seeding on the way in. | [LinearMarkDisplay](../linearmarkdisplay#action-setfittoheight) |
| **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](../linearmarkdisplay#action-selectfeature) |
| **setRpcData**(idx: number, data: EncodedLayersResult, region: Region) => void | Stage a region as fetched, with this display's payload layout. | [LinearMarkDisplay](../linearmarkdisplay#action-setrpcdata) |
| **setFacetDomain**(domain: string[]) => void | The Sections menu's reorder lands on the declaration. | [LinearMarkDisplay](../linearmarkdisplay#action-setfacetdomain) |
| **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](../linearmarkdisplay#action-setfacetfield) |
| **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](../linearmarkdisplay#action-splitbyplotrows) |
| **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](../linearmarkdisplay#action-sortrowsbyvalueat) |
| **setFilter**(filters?: string[] | undefined) => void | Write the `filter` slot; undefined returns it to what the track's config declares. | [LinearMarkDisplay](../linearmarkdisplay#action-setfilter) |
| **setPlotFields**(fields?: PlotFields | undefined, error?: unknown) => void | | [LinearMarkDisplay](../linearmarkdisplay#action-setplotfields) |
| **setPlotDefaultChecked**() => void | | [LinearMarkDisplay](../linearmarkdisplay#action-setplotdefaultchecked) |
| **setPlotFieldsPromise**() => 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](../linearmarkdisplay#action-ensureplotfields) |
| **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](../linearmarkdisplay#action-openplotdialog) |
| **setPointSize**(val?: number | undefined) => void | Write every point mark's `encoding.size` number; undefined returns each to the default. | [LinearMarkDisplay](../linearmarkdisplay#action-setpointsize) |
| **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](../linearmarkdisplay#action-pindistinctshapes) |
| **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](../linearmarkdisplay#action-openmarkplotdialog) |
| **openPlotForm**(draft: Plot) => void | The text box's "Back to form", opened on its draft. | [LinearMarkDisplay](../linearmarkdisplay#action-openplotform) |
| **fetchNeeded**(needed: IndexedRegion[]) => Promise<void> | | [LinearMarkDisplay](../linearmarkdisplay#action-fetchneeded) |
| **startRenderingBackend**(backend: MarkRenderingBackend) => void | identity encode — the stored payload is what the backend uploads | [LinearMarkDisplay](../linearmarkdisplay#action-startrenderingbackend) |
| **renderSvg**(entries: CoarseTierEntry<P>[], read: CoarseTierRead) => void | | [CoarseTierMixin](../coarsetiermixin#action-setcoarsetier) |
| **clearCoarseTier**() => void | | [CoarseTierMixin](../coarsetiermixin#action-clearcoarsetier) |
| **setCoarseTierLoading**(loading: boolean) => void | | [CoarseTierMixin](../coarsetiermixin#action-setcoarsetierloading) |
| **setScaleType**(scaleType: string) => void | | [ScoreScaleMixin](../scorescalemixin#action-setscaletype) |
| **setScaleZero**(zero: boolean) => void | | [ScoreScaleMixin](../scorescalemixin#action-setscalezero) |
| **setDomainQuantile**(quantile: number) => void | | [ScoreScaleMixin](../scorescalemixin#action-setdomainquantile) |
| **setMinScore**(val?: number | undefined) => void | | [ScoreScaleMixin](../scorescalemixin#action-setminscore) |
| **setMaxScore**(val?: number | undefined) => void | | [ScoreScaleMixin](../scorescalemixin#action-setmaxscore) |
| **setAutoscaleGroup**(group?: string | undefined) => void | | [ScoreScaleMixin](../scorescalemixin#action-setautoscalegroup) |
| **setGrid**(grid: boolean) => void | | [ScoreScaleMixin](../scorescalemixin#action-setgrid) |
| **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](../scorescalemixin#action-setscorerules) |
| **setShowLegend**(arg: boolean) => void | Writes the slot, and showing the legend again restores the sections closed inside it. | [LegendMixin](../legendmixin#action-setshowlegend) |
| **dismissLegendSection**(id: string) => void | Close one section of the legend, leaving the others up. | [LegendMixin](../legendmixin#action-dismisslegendsection) |
| (info: Info) => void | | [ContextMenuMixin](../contextmenumixin#action-opencontextmenu) |
| () => void | | [ContextMenuMixin](../contextmenumixin#action-closecontextmenu) |
| **setHoveredFeature**(hit?: T | undefined) => void | | [StoredHoverMixin](../storedhovermixin#action-sethoveredfeature) |
| **clearHoveredFeature**() => void | | [StoredHoverMixin](../storedhovermixin#action-clearhoveredfeature) |
| **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](../hiddengroupsmixin#action-hidegroup) |
| **showAllGroups**() => void | | [HiddenGroupsMixin](../hiddengroupsmixin#action-showallgroups) |
| **dropGroupState**() => void | Forget every hidden section. | [HiddenGroupsMixin](../hiddengroupsmixin#action-dropgroupstate) |
| **setStatusMessage**(status?: RpcStatus | undefined) => void | | [BaseDisplay](../basedisplay#action-setstatusmessage) |
| **setError**(error?: unknown) => void | | [BaseDisplay](../basedisplay#action-seterror) |
| **reload**() => void | base display reload does nothing, see specialized displays for details | [BaseDisplay](../basedisplay#action-reload) |
| **applyDisplaySettings**(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](../basedisplay#action-applyplot) |
| **setScrollTop**(scrollTop: number) => void | | [TrackHeightMixin](../trackheightmixin#action-setscrolltop) |
| **setHeight**(displayHeight: number) => number | | [TrackHeightMixin](../trackheightmixin#action-setheight) |
| **resizeHeight**(distance: number) => number | | [TrackHeightMixin](../trackheightmixin#action-resizeheight) |
| **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](../trackheightmixin#action-expandtocontentheight) |
| **setLoadedRegion**(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.(displayedRegionIndex: number) => void | Forget one region — for a display pruning what has scrolled off screen. | [MultiRegionDisplayMixin](../multiregiondisplaymixin#action-droploadedregion) |
| **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](../multiregiondisplaymixin#action-cleardisplayspecificdata) |
| **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.() => 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](../multiregiondisplaymixin#action-clearallrpcdata) |
| **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](../multiregiondisplaymixin#action-invalidatesettings) |
| **fetchRegions**() => void | installs the fetch-lifecycle autoruns (DisplayedRegionsChange, FetchVisibleRegions, SettingsInvalidate, ClearBlockingStateOnViewportChange) | [MultiRegionDisplayMixin](../multiregiondisplaymixin#action-afterattach) |
| **clearByteEstimate**() => void | Drops the estimate and the viewport stamp. `forceLoadTrack` survives: it is a track-wide approval. | [RegionTooLargeMixin](../regiontoolargemixin#action-clearbyteestimate) |
| **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](../regiontoolargemixin#action-cleargatemeasurements) |
| **setForceLoadTrack**(flag: boolean) => void | | [RegionTooLargeMixin](../regiontoolargemixin#action-setforceloadtrack) |
| **commitFetchBytes**() => void | The banner's button: exempt the track on both axes and refetch. | [RegionTooLargeMixin](../regiontoolargemixin#action-forceload) |
| **markCanvasDrawn**() => void | | [RenderLifecycleMixin](../renderlifecyclemixin#action-markcanvasdrawn) |
| **resetCanvasDrawn**() => void | | [RenderLifecycleMixin](../renderlifecyclemixin#action-resetcanvasdrawn) |
| **stopRenderingBackend**() => void | | [RenderLifecycleMixin](../renderlifecyclemixin#action-stoprenderingbackend) |
| **renderNow**() => void | | [RenderLifecycleMixin](../renderlifecyclemixin#action-rendernow) |
| **setOffScreen**(offScreen: boolean) => void | | [RenderLifecycleMixin](../renderlifecyclemixin#action-setoffscreen) |
| **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](../renderlifecyclemixin#action-setrendererror) |
| **attachRenderingBackend**() => 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](../fetchmixin#action-stopactivefetch) |
| **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.() => 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](../fetchmixin#action-cancelfetch) |
| **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](../fetchmixin#action-cancelfetchbyuser) |
| **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](../fetchmixin#action-beforedestroy) |
| **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](../fetchmixin#action-beginfetch) |
| **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](../fetchmixin#action-endfetch) |
| **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.(arg: boolean) => void | | [TreeSidebarMixin](../treesidebarmixin#action-setshowtree) |
| **setShowBranchLength**(arg: boolean) => void | | [TreeSidebarMixin](../treesidebarmixin#action-setshowbranchlength) |
| **setShowRowLabels**(arg: boolean) => void | | [TreeSidebarMixin](../treesidebarmixin#action-setshowrowlabels) |
| **setTreeAreaWidth**(width: number) => void | | [TreeSidebarMixin](../treesidebarmixin#action-settreeareawidth) |
| **setRunClustering**(arg?: boolean | undefined) => void | | [TreeSidebarMixin](../treesidebarmixin#action-setrunclustering) |
| **setClusterRegion**(arg?: string | undefined) => void | | [TreeSidebarMixin](../treesidebarmixin#action-setclusterregion) |
| **setSortRowsBy**(arg?: RowSortSpec | undefined) => void | Trigger (or clear) a one-shot declarative row sort; consumed and reset by `setupRowSortAutorun`. | [TreeSidebarMixin](../treesidebarmixin#action-setsortrowsby) |
| **setHoveredTreeNode**(node?: HoveredTreeNode | undefined) => void | | [TreeSidebarMixin](../treesidebarmixin#action-sethoveredtreenode) |
| **setTreeCanvasRef**(ref: HTMLCanvasElement | null) => void | | [TreeSidebarMixin](../treesidebarmixin#action-settreecanvasref) |
| **setMouseoverCanvasRef**(ref: HTMLCanvasElement | null) => void | | [TreeSidebarMixin](../treesidebarmixin#action-setmouseovercanvasref) |
| **setRowOrder**(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](../treesidebarmixin#action-setrowlabels) |
| **setRowFocus**(names?: readonly string[] | undefined) => void | Narrow the display to `names`, or show every row again. | [TreeSidebarMixin](../treesidebarmixin#action-setrowfocus) |
| **applyRowEdits**() => 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 choice, which stays. | [TreeSidebarMixin](../treesidebarmixin#action-resetrowarrangement) |
| **setRowColorChoice**(choice: string) => void | Colour the rows by `choice`, as a menu picks it: '' for None, `name` for Each row, or an attribute, starting from `rowColorFor`. A pick of the current choice writes nothing. | [TreeSidebarMixin](../treesidebarmixin#action-setrowcolorchoice) |
| **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](../treesidebarmixin#action-focuslegendentry) |
| **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](../rowheightmixin#action-setrowheight) |