type: types.literal('LinearSyntenyDisplay') | | LinearSyntenyDisplay |
| **configuration**configuration: ConfigurationReference(configSchema) | | LinearSyntenyDisplay |
| **id**id: ElementId | | [BaseDisplay](../basedisplay#property-id) |
## Volatiles
| Member | Description | Defined by |
| --- | --- | --- |
| **featureData**featureData: undefined as SyntenyFeatureData | undefined | | LinearSyntenyDisplay |
| **instanceData**instanceData: undefined as SyntenyGeometry | undefined | Raw GPU-instance geometry produced by the RPC. The view observes this on every display and uploads it to the shared backend keyed by `displayKey`. Clearing it (undefined) triggers backend eviction. | LinearSyntenyDisplay |
| **hoveredInstanceIdx**hoveredInstanceIdx: -1 | Index into `instanceData` of the GPU instance the pointer is over, or -1. The INSTANCE, not the feature, even though the tooltip and the highlight are both about the feature: a CIGAR-detailed ribbon is a base block plus a tile per indel, and the operator under the cursor is readable from nothing else (`getCigarOpAtInstance`). `getFeature` translates to the feature. Same choice `DotplotDisplay` makes, where the stored index is `hoveredSegmentIdx`. | LinearSyntenyDisplay |
| **clickedInstanceIdx**clickedInstanceIdx: -1 | Clicked twin of `hoveredInstanceIdx` — the instance whose feature stays highlighted after the pointer leaves it. | LinearSyntenyDisplay |
| contextMenuAnchor: undefined as ClickCoord | undefined | | LinearSyntenyDisplay |
| **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) |
| **assembliesSwapped**assembliesSwapped: false | Set once at view load by a refName-comparison check, independent of the per-render fetch, so it never re-fires or misfires on zoom. Surfaces through each display's `warnings`. | [ComparativeFetchMixin](../comparativefetchmixin#volatile-assembliesswapped) |
| **loadedFetchKey**loadedFetchKey: undefined as string | undefined | `currentFetchKey` as it stood when the held data was committed — the loaded half of the freshness compare. Written only by `commitFetchResult`, so a display cannot stamp data it did not fetch, and cleared by `reload` for the overlay's sake rather than the refetch's (the skeleton's reload epoch is what overrides its gate). The data itself stays display-owned: arc keeps stale arcs on screen under the loading overlay, HiC the stale matrix, synteny the stale ribbons. | [KeyedFetchMixin](../keyedfetchmixin#volatile-loadedfetchkey) |
| **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 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 `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**lodTierInfo: undefined as LodTierInfo | undefined | | [LodTierInfoMixin](../lodtierinfomixin#volatile-lodtierinfo) |
## Getters
| Member | Description | Defined by |
| --- | --- | --- |
| **parentHelper**LevelDuck | The level (row gap) this display's track sits on. Found by predicate rather than by hop count — see isSyntenyLevel. | LinearSyntenyDisplay |
| **level**number | Index of the level (row gap) this display draws in: between `view.views[level]` and `view.views[level + 1]`. | LinearSyntenyDisplay |
| **displayKey**number | Stable backend key under the view-shared backend. | LinearSyntenyDisplay |
| **height**number | | LinearSyntenyDisplay |
| **numFeats**number | | LinearSyntenyDisplay |
| **culledRibbonMates**CulledRibbonMates | undefined | Every alignment this display drew geometry for, placed on both axes, so either strip can mark the ones the band is currently culling — the facing end is on a contig that row displays and has scrolled off, which no fetch-time tally can answer. ONE PER ROW, because culling is symmetric: an alignment can be undrawable with its query end off screen and its target end in plain sight, and marking it on the query axis puts it at an x the layout rejects. See `culledRibbonMates`.number | Mean on-screen width (px, axis 0) of this display's alignment blocks with every already-wide block counted as `FADE_WIDE_BLOCK_PX`, or 0 until a fetch lands and both views connect. The fade only affects sub-pixel ribbons (perpW < 1), so a capped mean well under 1 means the view is dominated by thin ribbons — exactly what width-proportional fade declutters, and `LinearSyntenyView.fadeThinAlignments` decides 'auto' off the narrowest of these.number | Which CIGAR indel ops are actually painted in the current geometry. The worker only emits an indel instance for an op wide enough to draw (sub-pixel indels are dropped), so a set bit means a visible-width op of that kind is on screen. The legend keys its indel chips off this rather than the coarse "file has any CIGAR" flag, so whole-genome zoom (every indel sub-pixel) shows no dead insertion/deletion swatch. | LinearSyntenyDisplay |
| **warnings**ComparativeWarning[] | Warnings surfaced in the view header. Flags a likely reversed assembly row order, detected once at view load (only when the two assemblies have distinct chromosome names). | LinearSyntenyDisplay |
| **fetchLanded**boolean | `ComparativeFetchMixin`'s hook: a fetch has completed (data is present, even if it mapped zero features). Not `numFeats > 0` — an empty-but-finished fetch has landed, otherwise an empty result spins the loading overlay forever. | LinearSyntenyDisplay |
| **fetchInert**boolean | Overrides `FetchMixin`'s default-false hook with the two states where this display's fetch autorun deliberately never runs: minimized, or a level whose two rows aren't both showing regions. A display in one of them draws nothing (`renderParams` is undefined for exactly the same pair) and has no data coming, so anything waiting on data has to treat it as terminal rather than wait forever. One getter because four places answer it — the autorun's own gate, the loading overlay, the SVG export, and (through the mixin) `displaysSettled`. | LinearSyntenyDisplay |
| **regionSignature**string | Contents, order and orientation of both connected views' displayed regions — the inputs the worker's cumBp index is built from, so a change in any of them makes held features stale. Its own getter, not inlined into `currentFetchKey`: this is O(total regions) (a whole-genome view of a scaffold-heavy assembly runs to thousands), while `currentFetchKey`'s other deps flip on every pan past the buffer and every zoom bucket. Split out, MobX memoizes it against `displayedRegions` alone instead of rebuilding the whole string per zoom step. | LinearSyntenyDisplay |
| **viewSignature**string | `KeyedFetchMixin`'s hook, this display's half of `currentFetchKey`: the fetch-input signature (region set/order, snapped fetch window, zoom bucket, CIGAR draw options, LOD tier) for the view's current state — the same tracked deps the fetch autorun refetches on. The mixin appends the settings and adapter axes. Reactive: flips the instant any of them changes. Before both connected views are ready it collapses to a degenerate signature (empty region sig, no fetch-window/zoom keys) that no connected fetch can produce — a real fetch requires non-empty displayedRegions — so `dataCurrent` reads false until a real fetch lands. Non-nullable so it mirrors dotplot's. | LinearSyntenyDisplay |
| **displayPhase**DisplayStatusPhase | The display's own mutually-exclusive state, the way every LGV display publishes one — so `AppReadyMarker` counts this display's fetch, and the app stops reporting itself ready over a ribbon that is still working. Ranked by `comparativeDisplayPhase`, off the shared canvas's `surfaceReadiness` and this display's own fetch state.ParentViewDuck | The LinearSyntenyView this display's level sits in. Duck-typed, and that is the load-bearing part: this getter is the last edge of the view -> level -> display -> view cycle, and naming the view's model here is what made `levels` an `IAnyModelType` and every read off a level `any`. `parentViewDuck.ts` carries the rest, including why ADR-055's interface form does not substitute on a four-node loop. | LinearSyntenyDisplay |
| **effectiveDrawCurves**boolean | Whether this level draws bezier ribbons: the promotable `drawCurves` slot resolved through the display-type cascade — this track's configured value, the session-wide default the settings menu's pin writes, then `promotedBase` (straight). The view settings checkbox writes the slot too, on every level at once (`setDrawCurves`), so there is no view tier over this. | LinearSyntenyDisplay |
| **effectiveDrawLocationMarkers**boolean | Whether this level continues the query row's ruler through its ribbons. Resolved exactly as `effectiveDrawCurves` above. | LinearSyntenyDisplay |
| **computedColors**Uint32Array<ArrayBuffer> | undefined | Main-thread-computed per-instance colors. Recomputes whenever colorBy, featureData, or instanceData descriptors change — this is the gpuProps half of the rpcProps/gpuProps split. colorBy changes flow through here without touching the RPC.string | The band this display paints into — see `bandGroundColor`. Read here as well as on the level because the location ticks are packed into the color lane, which is this display's, and the SVG export draws through `renderSvg` without a level to ask. | LinearSyntenyDisplay |
| **paintedChromosomeOrder**readonly string[] | undefined | The chromosome order the chromosome-painting modes color by: the refNames of whichever of this level's two assemblies `effectiveColorBy` resolved to, in the assembly's own order. Undefined for every other mode, and while the assembly is still loading — the color function falls back to its hash there.string | | LinearSyntenyDisplay |
| **trackColor**string | This track's slot in the view's palette, used by `colorBy: 'track'`. Assigned by the view, not locally: pinning a color on one track shifts which automatic slots its siblings can take. | LinearSyntenyDisplay |
| **colorByMode**SyntenyColorBy | The mode this track renders with, before the per-level 'reference' remap: its own override if the user set one, else the view-wide mode. This is the user-facing answer — menus and the legend title read it, so a uniform 'reference' view reports 'reference' rather than the query/target each level resolved it to. | LinearSyntenyDisplay |
| **effectiveColorBy**SyntenyColorBy | `colorByMode` resolved for this specific level, for the renderer. 'reference' is a stacked-view mode that colors every level by the shared anchor assembly's chromosome names; each level maps it to 'query' or 'target' depending on which of its two assemblies is the anchor, so the coloring stays consistent across levels. Every other mode passes through.string[] | undefined | The hovered ribbon's tooltip, as lines, or undefined when nothing is hovered. Lines rather than an HTML string — see `getTooltipLines`, and `DotplotDisplay.tooltipLines` for the twin. | LinearSyntenyDisplay |
| **connectedViews**{…} | undefined | The two adjacent genome views this level draws between, or undefined until both are initialized with regions. A level draws between an adjacent pair, so both render and fetch depend only on those two views, not the whole stack. Single source of truth for that gate. | LinearSyntenyDisplay |
| **bpPerPxBucketKey**string | undefined | Stable key over the log2 zoom bucket of both connected views. The fetch autorun tracks this (a computed compares its string output) instead of raw bpPerPx, so it only refetches when zoom crosses a doubling rather than on every settled zoom within a bucket. | LinearSyntenyDisplay |
| **lodTier**LodTier | The detail tier this level's fetch asks the adapter for, resolved here on the main thread so it can enter `currentFetchKey`.boolean | True while the served tier is the coarse one and the zoom is finer than the fold's `--coarse` bound, which only a pinned "Alignment blocks only" reaches. A walk through a coarse CIGAR is within that bound of the alignment's real path, and the bound is sub-pixel at or past it and visible below it, so the follow reports a placement walked there as approximate. | LinearSyntenyDisplay |
| **fetchRegions**Region[] | The query axis's (v0) fetch window, and the regions the fetch actually sends: the visible content blocks expanded by the shared pan buffer and snapped outward to a buffer-sized grid, so a pan within the buffer neither refetches nor exposes an unfetched strip. The worker emits geometry for exactly this window, so the two cannot disagree. The target axis is not scoped — the fetch is one-dimensional (query regions in, every mate out) — so its window is `targetWindowRegions`. | LinearSyntenyDisplay |
| **targetWindowRegions**Region[] | The target axis's (v1) snapped window: what the LOWER row can pan across before the fetch key rolls over, in the key and sent to the worker either way, because `buildSyntenyGeometry` emits detail for it exactly as it does for the query window. What the bidirectional setting decides is only whether the worker also QUERIES it, recovering the alignments anchored there whose query end is on a contig the row above is not displaying.string | undefined | Stable key over the *snapped* fetch window of both connected views. The fetch autorun tracks this (through `currentFetchKey`) so a scroll/zoom that moves either snapped window refetches, while a sub-buffer pan (identical snapped windows) does not — a MobX computed only notifies when its string output changes. Built from the same `fetchRegions` the worker is handed, so the key can't describe a window the fetch didn't use. | LinearSyntenyDisplay |
| **renderParams**{…} | undefined | Per-track render params consumed by the view's aggregator. yTop is 0 here: the level's canvas is the band, and only the multiway display stacks tracks within one. | LinearSyntenyDisplay |
| **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) |
| **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.boolean | Overridable hook: the display holds something an SVG export can draw. Defaults to `fetchLanded`; the dotplot answers with its instance geometry rather than its `geometry` computed, because `svgReady` is polled outside any reactive context and a `geometry` read there recolors every segment per poll. | [ComparativeFetchMixin](../comparativefetchmixin#getter-hasdrawable) |
| **loading**boolean | First load, nothing on screen yet: drives the full striped overlay. Deliberately not `&& isLoading`, which would blink the overlay off during the pre-fetch debounce gap. Excludes `error` so error UI and loading UI never show at once, and `fetchInert` so a display that will never fetch rests instead of spinning on data that is not coming. | [ComparativeFetchMixin](../comparativefetchmixin#getter-loading) |
| **refetching**boolean | A fetch is running over a stale plot still on screen (zoom, reorder, pan past the buffer): drives a corner indicator rather than the full overlay, so a viewport change does not mask what is drawn. | [ComparativeFetchMixin](../comparativefetchmixin#getter-refetching) |
| **svgReady**boolean | Off-screen SVG export gate, the shared `computeSvgReady` policy every display runs. Neither comparative display has a `regionTooLarge` state (LOD gates the fetch, not region size). `fetchInert` is the extra terminal, so an export cannot hang on data the autorun will never fetch, and `fetchCanceled` is terminal for the same reason: durable until Retry, and an export presses nothing. The data half waits out an in-flight same-key retry (`!refetching`) and a stale plot (`dataCurrent`). | [ComparativeFetchMixin](../comparativefetchmixin#getter-svgready) |
| **dataSuperseded**boolean | Overridable hook (default false): the held data answers the key, but this display knows it is not what the screen will settle on — a dependent fetch of its own is still out, or a fetch input it writes itself has moved. The same hook `MultiRegionDisplayMixin` declares, for the same reason: the key compare is structurally blind to anything the display fetches outside its primary fetch, and an export sampling `svgReady` in that window paints the half-filled frame.string | undefined | Key of the fetch the current view, settings and adapter call for — the display's `viewSignature` plus the serialized `rpcProps()` axis plus the adapter config. The fetch skeleton's freshness key: captured at issue, compared against the stamp above, and written to it at commit. | [KeyedFetchMixin](../keyedfetchmixin#getter-currentfetchkey) |
| **dataCurrent**boolean | The shared freshness answer every foundation gives: data has been committed (`loadedFetchKey` is only ever written beside it), it was fetched for the current view and settings, and the display is not about to supersede it itself. 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. **What the fetch autorun gates on is the same compare inside `installFetch`**, not this getter — the skeleton owns it so a reload can override it. This one is for the readers outside the fetch, the export gate above all. The per-region twin is `isCacheValid`: what decides a refetch, and deliberately not the whole freshness answer. | [KeyedFetchMixin](../keyedfetchmixin#getter-datacurrent) |
| **isLoading**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 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 `computeLoadingTerm`: 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 says 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.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.string | The adapter axis of the same key, watched by the same two readers as `rpcPropsCacheKey`: `SettingsInvalidate` per-region and the global family's `currentFetchKey`. A track re-pointed in the config editor is a different fetch, and until 2026-09 only the comparative family said so. | [FetchMixin](../fetchmixin#getter-adapterconfigkey) |
## Methods
| Member | Description | Defined by |
| --- | --- | --- |
| **getFeature**(index: number) => FeatPos | undefined | The parent feature under an INSTANCE index (what the pick engine and the hover/click state carry). Without instanceData the two spaces coincide. Deliberately not `instanceFeatureIdx[index] ?? index`: an out-of-range instance index reads `undefined` there, and falling back to the raw index would silently return a different feature rather than nothing. | LinearSyntenyDisplay |
| **renderingProps**() => MenuItem[] | | [BaseDisplay](../basedisplay#method-trackmenuitems) |
## Actions
| Member | Description | Defined by |
| --- | --- | --- |
| **setRpcData**(idx: number) => void | Point the hover at one GPU instance, or -1 for none. The level's `setHoveredFeature` is what calls this, from a pick hit. | LinearSyntenyDisplay |
| **setClickedInstanceIdx**(idx: number) => void | | LinearSyntenyDisplay |
| (anchor: ClickCoord) => void | | LinearSyntenyDisplay |
| () => void | | LinearSyntenyDisplay |
| **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) |
| **applyDisplaySettings**(arg: boolean) => void | | [ComparativeFetchMixin](../comparativefetchmixin#action-setassembliesswapped) |
| **commitFetchResult**(commit: () => void, key: string) => void | The commit half of a keyed fetch: run the display's own store in the same transaction as the key stamp, so no observer can see fresh data under a stale key or the reverse. Being the only writer of `loadedFetchKey` is what makes `dataCurrent` derivable — a display cannot commit without stamping. | [KeyedFetchMixin](../keyedfetchmixin#action-commitfetchresult) |
| **stopActiveFetch**() => void | Abort the in-flight fetch (if any) and retire its slot. The shared preamble of both cancel paths; the difference between them is only what they do to `fetchCanceled` / `fetchGeneration` afterward. | [FetchMixin](../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) |
| **beginFetch**(stopToken: StopToken) => void | The `onBegin` half of a fetch's bookkeeping: publish the in-flight token (`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. The stop token itself is released by the rotation's own `end()`, one layer down. | [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.(info: LodTierInfo | undefined) => void | | [LodTierInfoMixin](../lodtierinfomixin#action-setlodtierinfo) |