configuration: ConfigurationReference(configSchema) | | SharedLDModel |
| **jexlFiltersSetting**jexlFiltersSetting: types.maybe(types.array(types.string)) | Runtime "General JEXL filters..." override, already `jexl:`-prefixed. When set (even to an empty list) it replaces the `jexlFilters` config slot; when undefined the config default applies. The two-tier contract every display with this row implements — see `JexlFilterModel`. | SharedLDModel |
| **id**id: ElementId | | [BaseDisplay](../basedisplay#property-id) |
| **type**type: types.string | | [BaseDisplay](../basedisplay#property-type) |
## Volatiles
| Member | Description | Defined by |
| --- | --- | --- |
| **rpcData**rpcData: null as LDDataResult | null | | SharedLDModel |
| **focalSnpLocus**focalSnpLocus: undefined as string | undefined | Locus (`refName:start`) of the focal SNP whose LD row+column is emphasized, or undefined. Keyed by locus rather than array index so the selection survives a re-fetch that reorders SNPs. | SharedLDModel |
| **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) |
| **loadedFetchSignature**loadedFetchSignature: undefined as string | undefined | `fetchSignature` as it stood when the held data was committed — the loaded half of this family's freshness compare. Written only by `commitFetchResult` and cleared only by `reload`, so a display cannot stamp data it did not fetch or forget to invalidate on retry; the data itself stays display-owned (arc keeps stale arcs on screen under the loading overlay, HiC keeps the stale matrix). | [GlobalFetchMixin](../globalfetchmixin#volatile-loadedfetchsignature) |
| **forceLoadTrack**forceLoadTrack: false | The force-load button's track-wide approval. Volatile so it never reaches a saved session; the `forceLoad` config slot is the durable form. | [RegionTooLargeMixin](../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 string | undefined | The viewport key the gate last asked the adapter about, on either axis. 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) |
| **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) |
| **activeStopToken**activeStopToken: undefined as StopToken | undefined | stop token of the in-flight fetch, or undefined when idle | [FetchMixin](../fetchmixin#volatile-activestoptoken) |
| **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 both LGV fetch foundations compose, the same argument that put `fetchInert` below; the comparative family carries its own on `SyntenyFetchStateMixin` (ADR-054). | [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 `createStopTokenRotation` 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**boolean | | SharedLDModel |
| **minorAlleleFrequencyFilter**number | | SharedLDModel |
| **lengthCutoffFilter**number | | SharedLDModel |
| **lineZoneHeight**number | | SharedLDModel |
| **ldMetric**"dprime" | "r2" | | SharedLDModel |
| **showLDTriangle**boolean | | SharedLDModel |
| **squashToHeight**boolean | | SharedLDModel |
| **hweFilterThreshold**number | | SharedLDModel |
| **callRateFilter**number | | SharedLDModel |
| **maxVariantSeparation**number | | SharedLDModel |
| **showVerticalGuides**boolean | | SharedLDModel |
| **showLabels**boolean | | SharedLDModel |
| **tickHeight**number | | SharedLDModel |
| **useGenomicPositions**boolean | | SharedLDModel |
| **signedLD**boolean | | SharedLDModel |
| **configuredLDMethod**"auto" | "composite" | "phased" | Which estimator the `ldMethod` config slot ASKS for. Named apart from `ldMethod` below, which is what the RPC actually ran — they differ whenever the request cannot be honoured ('phased' on unphased data) and whenever 'auto' resolves. | SharedLDModel |
| **snps**LDSnp[] | The loaded matrix's SNPs, in the order they are drawn along the column axis (the worker puts them in screen order — see `RenderLDDataRPC/reversedRegions.ts`). Empty until data arrives. | SharedLDModel |
| **cellWidth**number | Fetch-time width of one column in the un-rotated frame (`uniformW`). Read through `columnX`, which rescales it to the live viewport. | SharedLDModel |
| **filterStats**FilterStats | undefined | | SharedLDModel |
| **viewSignature**string | undefined | LD's half of `GlobalFetchMixin`'s freshness compare: the dynamic-block set. LD's SNP set is viewport-defined (the index-mode triangle spans the visible blocks), so a pan refetches — but worker output is genomic, so the stale triangle draws at its own position under the live transform while the refetch runs. The settings axis — what keeps `svgReady` from capturing a matrix computed under the filters the user just changed — rides in through the `rpcPropsCacheKey` half the mixin appends. | SharedLDModel |
| **rendersCanvas**boolean | Override of the `GlobalFetchMixin` hook that gates the initial pre-first-paint loading scrim (`rendersCanvas && !canvasDrawn`). With the triangle toggled off, `LDDisplayComponent` renders an EmptyState ("Enable LD triangle…") instead of a canvas, so `canvasDrawn` never flips. Returning false here keeps the scrim from sitting permanently over that placeholder. This is the *only* override of the hook — do not remove it as dead-looking single-use code: without it the LD track shows a stuck loading spinner whenever the triangle is disabled. If the EmptyState is ever moved outside `DisplayChrome`, revisit together. | SharedLDModel |
| **fetchInert**boolean | With the triangle off the display shows an EmptyState and its `prepare` declines forever, so nothing is loading and nothing ever will. Both readers need that: the scrim would otherwise park over the placeholder — permanently, once a cancel has been clicked, since `fetchCanceled` is durable — and `awaitSvgReady` is an unbounded `when`, so one such track hangs the whole view's SVG export.boolean | True when this display reads LD out of a file (PLINK, ldmat) rather than computing it from a VCF's genotypes — which decides the fetch path, whether the filter menus mean anything, and whether the byte gate has a `getFeatures` to measure with. | SharedLDModel |
| **effectiveLdMetric**LDMetric | Metric the loaded data actually represents. A pre-computed file with no D' column downgrades a 'dprime' request to 'r2', so the legend and the metric radios read this rather than the raw requested `ldMetric`. | SharedLDModel |
| **effectiveSignedLD**boolean | Whether the loaded values actually carry a sign. Reads the packed matrix rather than the slot for the same reason as `effectiveLdMetric`: a pre-computed file states magnitudes and cannot honor the request, so a track configured `signedLD: true` against one would otherwise get a legend reading -1..1 and a tooltip calling r² "R" over 0..1 values. The cells already follow the data (the ramp is built from `rpcData`). | SharedLDModel |
| **effectiveUseGenomicPositions**boolean | Whether the loaded matrix was actually laid out at genomic positions. The worker falls back to uniform cells when the viewport holds more than one region (SNPs from the later ones would collapse onto the first's coordinates), so the raw slot can say yes while what is on screen is index-laid-out. Every consumer that branches on the layout — the hit test, the zone height, the connectors-vs-labels choice — reads this, not the slot, or it describes a matrix that isn't there. Same requested-vs-loaded split as `effectiveLdMetric`; `rpcProps` still sends the slot, which is the request. | SharedLDModel |
| **dprimeAvailable**boolean | Whether the D' metric can be shown — false only for a pre-computed file lacking a DP column, which disables the D' option. | SharedLDModel |
| **ldMethod**LDMethod | undefined | How the loaded LD values were derived: 'phased' (exact haplotypic), 'composite' (Weir estimate from unphased genotypes), or 'precomputed' (read from a PLINK/ldmat file). Undefined until data loads. This is what RAN, which is not always what `configuredLDMethod` asked for. | SharedLDModel |
| **loadedLDWindow**number | undefined | The pair-separation window the LOADED matrix was computed at, in variants, or undefined when it covers the whole triangle. Read off the result rather than off `maxVariantSeparation`, for the same reason `ldMethod` is: the slot is a request, and `resolveBand` clamps it to `n - 1`, at which point there is no window to report.number | Array index of the focal SNP in the current `snps`, or -1 if none is selected or the locus is no longer present after a re-fetch. | SharedLDModel |
| **gateEnabled**boolean | Opt into RegionTooLargeMixin's derived byte gate (byte axis only, no density axis). On for every adapter, including the pre-computed ones (PlinkLD*), which serve no features at all: `RenderLDData` measures the genotype adapter it is about to read and skips those entirely, so they report no bytes — "unmeasurable", the same answer a BigWig gives — and an unmeasurable estimate keeps the byte axis out of the verdict without anything here having to know which adapter it has.number | Pixel height of the SVG zone above the canvas (variant labels + lines). The hit-test subtracts this from mouseY before reversing the render transform. | SharedLDModel |
| **ldCanvasHeight**number | Effective height for the LD canvas (total height minus the zone the variant lines occupy above the matrix). | SharedLDModel |
| **canvasWidth**number | The box the triangle is drawn in. One pair for all three of the canvas element's CSS size, the backing store the rendering backends resize to, and the SVG export's paint layer — they have to be the same number or the drawn matrix is stretched against the box it sits in, and they were previously derived independently on either side of that boundary. `totalWidthPxWithoutBorders` is the rounded content width, so this is the drawn width even when the genome doesn't fill the viewport. | SharedLDModel |
| **canvasHeight**number | Height of that box: the triangle's natural apex height (half its width), or the display's own height when squashed to fit. | SharedLDModel |
| **yScalar**number | Per-frame yScalar squash factor. When squashToHeight is on, squashes the natural (canvasWidth/2) triangle into ldCanvasHeight. Lives on the main thread so resize doesn't trigger a worker re-fetch. | SharedLDModel |
| **renderState**LDRenderState | Per-frame render state for the GPU backend. Read by the upload/render autorun — every change to any tracked observable (view.bpPerPx, view.offsetPx, model.squashToHeight, rpcData contents, …) re-fires it. | SharedLDModel |
| **viewTransform**{ viewScale: number; viewOffsetX: number; } | The per-frame map from the payload's pre-rotation data space (origin-relative bp / √2) to canvas px, shared by the render state, the hit test, the overlays and the SVG export so none of them can disagree. Pure live-view arithmetic; the one payload-derived term, `originBp`, folds the payload's own axis anchor back in — in double precision — so a stale triangle draws at its genomic position while a refetch runs. | SharedLDModel |
| **connectorLineCoords**ConnectorCoord[] | The connector lines tying each matrix column to its SNP's genomic position, in viewport pixels, plus the label the hover tooltip and `VariantLabels` show. Only meaningful in index mode (genomic-positions mode already draws columns at their genomic x). | SharedLDModel |
| **triangleTransform**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) |
| **hoveredFeature**unknown | Overridable hook (default `undefined`): what the pointer is currently over, for readers **outside** the display. `LinearGenomeViewContainer` publishes it to `session.hovered`, the view-wide "what is the user pointing at" channel a plugin can subscribe to.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; } | Overridable hook: which widget `openFeatureWidget` opens for one of this display's features. The default is the generic one, which is what a display drawing plain features wants and what the canvas base spelled out by hand.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 | Overridable hook: how far this display's content can scroll past its viewport, in px. `Infinity` (the default) means "this display doesn't scroll internally" — `setScrollTop` then never clamps and the re-clamp autorun below is inert, so a non-scrolling display pays nothing and, crucially, never evaluates a getter that would read view geometry.RegionHost | The hosting view as the `RegionHost` contract — see `containingHost` for the cast it owns, why the name is `host` and not `view`, and why both foundations still declare the name over one body. | [GlobalFetchMixin](../globalfetchmixin#getter-host) |
| **viewportEmpty**boolean | No content block is on screen, so this display has nothing to fetch and nothing to paint — see `viewportEmpty.ts` for the one viewport that reaches it, how narrow that is, and why the state still has to be terminal rather than a permanent scrim. Both foundations declare it over that one expression, the same way they each declare `host` and `paintInert`. | [GlobalFetchMixin](../globalfetchmixin#getter-viewportempty) |
| **canRender**boolean | Overrides `RenderLifecycleMixin`'s default-true hook with the LGV precondition both foundations share — see `foundationCanRender`. | [GlobalFetchMixin](../globalfetchmixin#getter-canrender) |
| **fetchSignature**string | undefined | Signature of the fetch the current view and settings call for — the display's `viewSignature` plus the serialized `rpcProps()` axis. What `runGlobalFetch` gates on, captures at issue, and stamps at commit. | [GlobalFetchMixin](../globalfetchmixin#getter-fetchsignature) |
| **dataCurrent**boolean | The shared freshness answer, now derived rather than a hook: data has been committed (`loadedFetchSignature` is only ever written beside it) and it was fetched for the current view and settings. A pan inside the loaded blocks stays current; a block entering, a tier step, a settings change or a `reload()` moves one side of the compare and refetches. | [GlobalFetchMixin](../globalfetchmixin#getter-datacurrent) |
| **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. | [GlobalFetchMixin](../globalfetchmixin#getter-paintinert) |
| **svgReady**boolean | Policy single-sourced in `computeSvgReady`; this family supplies only the freshness half, which `foundationSvgReady` reads as `dataCurrent` or the vacuous currency of `viewportEmpty`. Note it requires the dataset to actually be current, NOT merely "not currently fetching": the fetch trigger is a debounced `afterAttach` autorun, so at export time `isLoading` can still be false with no data yet — a `displayPhase !== 'loading'` test would then capture an empty render. Never gates on `canvasDrawn`, which an off-screen export never sets. Off-screen renderers gate on it via `awaitSvgReady(model)`. | [GlobalFetchMixin](../globalfetchmixin#getter-svgready) |
| **displayPhase**DisplayPhase | The display's mutually-exclusive visual state, mapped in `foundationDisplayPhase` — every foundation calls it and supplies only its staleness argument, so a term added to `computeLoadingTerm` reaches all of them without being wired twice.boolean | Whether the density axis applies. `CanvasFeatureGateMixin` contributes `true` beside its measurement; byte-only displays leave it. | [RegionTooLargeMixin](../regiontoolargemixin#getter-densitygateenabled) |
| **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 | The display's `fetchSizeLimit` slot, from `regionTooLargeConfigSchemaFields`. | [RegionTooLargeMixin](../regiontoolargemixin#getter-configuredfetchsizelimit) |
| **densityTooLarge**boolean | The density axis's verdict; canvas overrides it. | [RegionTooLargeMixin](../regiontoolargemixin#getter-densitytoolarge) |
| **byteGateAdapterPath**string[] | Where on the track config the measured adapter sits. A tiered display overrides this one hook (MAF: `['adapter', 'summaryAdapter']` while `showSummary`), and both the measurement and the budget follow it. | [RegionTooLargeMixin](../regiontoolargemixin#getter-bytegateadapterpath) |
| **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) |
| **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. Undefined until the view is measured, and the mixin's only read of the view. Captured before the fetch's round trip, never at commit. | [RegionTooLargeMixin](../regiontoolargemixin#getter-gateviewport) |
| **byteGateAdapterKey**string | Which tier the estimate is about, as a comparable string. | [RegionTooLargeMixin](../regiontoolargemixin#getter-bytegateadapterkey) |
| **aboveForceLoadFloor**boolean | Whether the span on screen is at or above `AUTO_FORCE_LOAD_BP`, the one comparison against that constant. False on an unmeasured view. | [RegionTooLargeMixin](../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 is about a viewport the user has since left. True before any measurement. | [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 | `gateActive` plus the density axis's own terms: the axis is on, and the span is above the floor. | [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 saying otherwise is a lie that never resolves.boolean | true while a fetch is active | [FetchMixin](../fetchmixin#getter-isloading) |
| **isLoadingOrCanceled**boolean | `isLoading` widened to cover a user-canceled load. **This, not `isLoading`, is what a `displayPhase` loading term wants.** `cancelFetchByUser` clears the stop token synchronously, so `isLoading` goes false the instant the user clicks Cancel — and the loading overlay that unmounts on it is carrying the Retry button, which is the only way back: the state is deliberately durable, so no autorun restarts the fetch on its own. A bare `isLoading` therefore reads as `ready` over a display that is stopped, empty and offering nothing.boolean | Overridable hook (default false), read only by the dev-only retry 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.string | The RPC cache key both fetch foundations invalidate on: this display's `rpcProps()` payload serialized to a string. `serializeRpcProps` owns the why, including the silently-dead-axis corollary.boolean | Whether the legend is drawn. Resolved through the promotable-slot tiers (`resolveConf`): an explicit track value customizes it either way, otherwise it follows the session-wide default for this display type, falling back to the slot's `promotedBase`. | [LegendMixin](../legendmixin#getter-showlegend) |
| **showLegendDisplayTypeDefault**Pin | The "make the current legend visibility the default for all tracks" control. Symmetric, so it promotes whichever value the track currently shows. `showLegendCheckboxItem` takes this as its `pin`. | [LegendMixin](../legendmixin#getter-showlegenddisplaytypedefault) |
## Methods
| Member | Description | Defined by |
| --- | --- | --- |
| **configuredFilters**() => string[] | What the `jexlFilters` config slot alone declares, `jexl:`-prefixed. Prefixing on read is what makes a config-declared filter work at all — the slot stores them unprefixed (deferred evaluation) and `stringToJexlExpression` throws on anything else, so before this an admin following the slot's own documented convention got a worker exception. | SharedLDModel |
| **activeFilters**() => string[] | The filters actually applied, `jexl:`-prefixed: the runtime override when set, otherwise the config tier. In its own block after `configuredFilters` so it reaches it through `self`, the arrangement `LinearBasicDisplay` uses for the same pair. | SharedLDModel |
| **rpcProps**() => LDRpcProps | | SharedLDModel |
| **columnX**(column: number) => number | Viewport x of a position on the matrix's column axis, in fractional column indices: 0 is the triangle's left corner, `i + 0.5` the apex of column i, `i + 1` the boundary between columns i and i+1. The index-mode connector lines anchor through this.(refName: string, coord: number) => number | undefined | Viewport x of one locus, through the same `genomicViewportX` the connector lines use. The crosshair ticks and the view's vertical guides go through this rather than measuring off `contentBlocks[0]`: that block's own left edge is only x=0 while the content reaches the viewport edge, and a SNP in any *later* block isn't measured against its own region at all. Undefined when the locus has no on-screen x, which the caller drops rather than pinning to 0. | SharedLDModel |
| **cellToScreen**(x: number, y: number) => { x: number; y: number; } | Forward transform of the LD matrix (`triangleDataToScreen`), paired with `hitTest` below (its exact inverse): pre-rotation cell coordinates to canvas-relative pixels. The overlays that decorate individual cells — the hover crosshair, the focal-SNP band — place themselves through this, so they land on the cells the shader drew and move with the same rescale during the debounce+RPC window. | SharedLDModel |
| **screenToCell**(mouseX: number, mouseY: number) => { x: number; y: number; } | The exact inverse of `cellToScreen` (`triangleScreenToData`), split out of `hitTest` so the pair is checkable as an **identity** rather than only through the cell it lands in — `overlayCoords.test.ts` asserts coordinates, which is what catches a dropped term. | SharedLDModel |
| **hitTest**(mouseX: number, mouseY: number) => LDFlatbushItem | undefined | Takes mouse coords (canvas-relative) and returns the LD cell under the cursor, or undefined: `screenToCell` above, then the boundary walk. Mirrors plugins/hic's `hitTest` so both contact maps keep the forward and inverse transforms paired on the model. | SharedLDModel |
| **svgLegendWidth**() => number | How much room the SVG export's container reserves to the right of the plot for this display's legend (it maxes this across tracks), via the shared helper — see `gradientSvgLegendWidth` for why it reserves on the setting alone. | SharedLDModel |
| () => MenuItem[] | | SharedLDModel |
| **renderSvg**(opts: ExportSvgDisplayOptions) => Promise<ReactNode> | | SharedLDModel |
| **renderingProps**() => 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) |
## Actions
| Member | Description | Defined by |
| --- | --- | --- |
| **setRpcData**(data: LDDataResult) => void | `runGlobalFetch` stamps the signature this was fetched for (`GlobalFetchMixin.commitFetchResult`) in the same transaction. | SharedLDModel |
| **setFocalSnp**(snp: LDSnp | undefined) => void | | SharedLDModel |
| **setLineZoneHeight**(n: number) => void | | SharedLDModel |
| **setMafFilter**(arg: number) => void | | SharedLDModel |
| **setLDMetric**(metric: LDMetric) => void | | SharedLDModel |
| **setShowLDTriangle**(show: boolean) => void | | SharedLDModel |
| **setSquashToHeight**(value: boolean) => void | | SharedLDModel |
| **setHweFilter**(threshold: number) => void | | SharedLDModel |
| **setCallRateFilter**(threshold: number) => void | | SharedLDModel |
| **setShowVerticalGuides**(show: boolean) => void | | SharedLDModel |
| **setShowLabels**(show: boolean) => void | | SharedLDModel |
| **setUseGenomicPositions**(value: boolean) => void | | SharedLDModel |
| **setSignedLD**(value: boolean) => void | | SharedLDModel |
| **setJexlFilters**(filters?: string[] | undefined) => void | | SharedLDModel |
| **startRenderingBackend**(backend: LDRenderingBackend) => void | Starts the upload/render autorun. No upload-diffing helper here on purpose: matrix and color ramp both derive from the one `rpcData` object, so the upload autorun's whole dependency set is that field and it can't re-fire without both genuinely being stale. (HiC needs `createGlobalUploadSync` because its palette is a config slot with an input independent of the RPC result.) | SharedLDModel |
| **setStatusMessage**(status?: RpcStatus | undefined) => void | | [BaseDisplay](../basedisplay#action-setstatusmessage) |
| **setError**(error?: unknown) => void | | [BaseDisplay](../basedisplay#action-seterror) |
| **clearHoveredFeature**() => void | Overridable hook (default no-op): drop whatever `hoveredFeature` reports. The writing twin of that getter, and what `installClearHoverOnViewportChange` calls.() => void | base display reload does nothing, see specialized displays for details | [BaseDisplay](../basedisplay#action-reload) |
| **setScrollTop**(scrollTop: number) => void | Clamped into `[0, scrollableHeight]`, so no caller has to remember the bound. Unbounded for a display that leaves `scrollableHeight` at its `Infinity` default. | [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 exactly the content it is currently hiding, so a display scrolled over a taller stack ends up showing all of it. The track's resize handle runs this on a double click.(commit: () => void, signature: string) => void | The commit half of `runGlobalFetch`: run the display's own store in the same transaction as the signature stamp, so no observer can see fresh data under a stale signature or the reverse. Being the only writer of `loadedFetchSignature` is what makes `dataCurrent` derivable — a display cannot commit without stamping. | [GlobalFetchMixin](../globalfetchmixin#action-commitfetchresult) |
| **setByteEstimate**() => void | Drops the estimate and the viewport stamp. `forceLoadTrack` survives: it is a track-wide approval. | [RegionTooLargeMixin](../regiontoolargemixin#action-clearbyteestimate) |
| **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) |
| **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 | Release an in-flight fetch's stop token 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) |
| **endFetch**(current: boolean, stopToken: StopToken) => 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: whoever superseded it — a newer `begin`, or `cancel` — already released this token. | [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 stopToken to forward to the RPC and an isStale() check to short-circuit commits once the user has moved on.(arg: boolean) => void | | [LegendMixin](../legendmixin#action-setshowlegend) |