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 |
| **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) |
| **error**error: undefined as unknown | last non-abort fetch error, or undefined | [FetchMixin](../fetchmixin#volatile-error) |
| **statusMessage**statusMessage: undefined as string | undefined | work-in-progress status string | [FetchMixin](../fetchmixin#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 | [FetchMixin](../fetchmixin#volatile-statusprogress) |
| **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 | Overridable hook (default false): a fetch has completed and data is present, even if it mapped zero features. Not a feature-count test — an empty-but-finished fetch has landed, or an empty plot spins its overlay forever. Each display answers off its own payload field, which survives a `reload()` where `loadedFetchKey` does not: that is what keeps a retry on the corner chip rather than the full overlay.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 |
| **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 |
| **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 |
| **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 |
| **viewSignature**string | undefined | Overridable hook, the one freshness input a display supplies: the signature of what the current *view* calls for — its block set (`blockKeySignature`) plus any view-derived fetch tier, like HiC's binsize; both comparative views' region sets, zoom buckets and LOD tier. `undefined` means "not computable yet" (view unmeasured, a prerequisite header still in flight) and holds the fetch off.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): 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 `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) |
## Actions
| Member | Description | Defined by |
| --- | --- | --- |
| **setAssembliesSwapped**(arg: boolean) => void | | ComparativeFetchMixin |
| **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) |
| **reload**() => void | `FetchMixin.reload` (error, cancel, counter — the shared skeleton's reload epoch is what makes that bump override the freshness gate, even against a fetch that commits mid-reload, so nothing here has to remember to invalidate for the retry's sake) plus this layer's one addition, for the export gate rather than the refetch: dropping the loaded key sends `dataCurrent` false, so an export started after the click waits for the refetch instead of capturing what the retry is about to replace. The data itself survives, staying on screen under that overlay. A subclass whose reload needs extra teardown can override and chain. | [KeyedFetchMixin](../keyedfetchmixin#action-reload) |
| **setError**(error?: unknown) => void | | [FetchMixin](../fetchmixin#action-seterror) |
| **setStatusMessage**(status?: RpcStatus | undefined) => void | Unthrottled: a display writing a phase label by hand must see every write land. The high-frequency RPC stream is thinned one level up, by the streams `self.statusWindow` hands out — and aggregated across them, which a write by hand is not. | [FetchMixin](../fetchmixin#action-setstatusmessage) |
| **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.