features: undefined as Feature[] | undefined | | ArcFetchModel |
| **hoveredArcFeature**hoveredArcFeature: undefined as Feature | undefined | Named apart from the `hoveredFeature` getter it fills: `BaseDisplay` declares that hook as a computed and MST refuses a volatile over one. | ArcFetchModel |
| **hoveredArcKey**hoveredArcKey: undefined as string | undefined | Which ARC of that feature, since one feature can lay out as several: `pairKey` keys on endpoints, so a BND record with two ALTs survives dedupe as two arcs sharing one `Feature`. The tooltip looks the caption up by this, not by the feature. | ArcFetchModel |
| **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`, 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 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 `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) |
| **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) |
| **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 | | ArcFetchModel |
| **hoveredFeature**Feature | undefined | Fills `BaseDisplay`'s cross-display hover hook, which the view reads to publish `session.hovered`. | ArcFetchModel |
| **minScore**number | arcs whose feature scores below this are not drawn; 0 (the default) draws every arc, as does any feature carrying no score | ArcFetchModel |
| **scoreRange**ScoreRange | undefined | the score span the filter slider is laid out over, `undefined` when the loaded features give it nothing to filter on | ArcFetchModel |
| **canvasWidth**number | The box the arcs are laid out in: the on-screen canvas and the export's clip rect have to be one number, or a bezier that legitimately bows outside the viewport is clipped on one path and not the other. Same name and same reason as the LD display's, over `totalWidthPx` because arcs span the whole scrolled content rather than the content width alone.string | undefined | Arc's half of `GlobalFetchMixin`'s freshness compare: the static-block set is the whole staleness axis (there is no `loadedRegions` spatial map — every feature is fetched into one array), so panning or zooming past a block boundary refetches and a scroll inside the loaded blocks does not. | ArcFetchModel |
| **displayPhase**DisplayStatusPhase | Narrows the foundation's `displayPhase` to the backend-free variant. Arc composes the render lifecycle with the rest of the foundation but never calls `attachRenderingBackend` — it paints its own Canvas2D on screen, and JSX `boolean | Arc's first-paint signal, overriding `RenderLifecycleMixin`'s `painted`: nothing ever flips `canvasDrawn` here, because arc attaches no rendering backend, so the data arriving is the signal — or `paintInert`, the two states (a failed fetch, an empty viewport) in which no data ever will. Stays true across a refetch so `data-display-drawn` and the loading anti-flash don't churn on pan; the stricter, staleness-aware `svgReady` is the export gate.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) |
| **staticBlockSignature**string | undefined | The static-block set as a signature, or `undefined` before the view is measured — the building block every `viewSignature` in this family starts from. Arc and multi-way synteny are exactly this; HiC appends its resolution. Declared here so the initialized gate is spelled once. | [GlobalFetchMixin](../globalfetchmixin#getter-staticblocksignature) |
| **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. The fetch skeleton's freshness key: captured at issue, compared against the stamp below, and written to it at commit. | [GlobalFetchMixin](../globalfetchmixin#getter-fetchsignature) |
| **signatureCurrent**boolean | The freshness compare: 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 it and the fetch autorun refetches. **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, through `dataCurrent` below. The per-region twin is `isCacheValid`: what decides a refetch, and deliberately not the whole freshness answer. | [GlobalFetchMixin](../globalfetchmixin#getter-signaturecurrent) |
| **dataSuperseded**boolean | Overridable hook (default false): the held data answers the signature, 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 signature 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.boolean | The shared freshness answer every foundation gives (`dataCurrent`): the fetch gate above, minus the display's own supersession. What the export gate reads; never what the fetch gate reads. | [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) |
| **densityGateEnabled**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 | 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; 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 **and the settings it would be taken under**. 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, so the stamp names the settings the worker actually counted under.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 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 (`ClearByteEstimateOnNavOrTierSwap`) 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 | `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) |
| **rendersCanvas**boolean | Overridable hook (default true): whether this display paints a canvas in its **current** configuration, as opposed to a deliberate static placeholder (LD with the triangle off, sequence past base resolution — both render a message where the ` | [RenderLifecycleMixin](../renderlifecyclemixin#getter-renderscanvas) |
| **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 by the per-region fetch plan: the display is drawing something in the features' place and wants no fetch while it does. `DensityTierMixin` says it while the band is up and the gate is not blocking, so a track forced to `density` never downloads the features it will not draw, while a refused viewport keeps its measurement pass and the gate can still release.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.() => MenuItem[] | The "Filter by score" row, or nothing when the data has no score span to filter on — rather than a slider whose ends mean the same thing. Each display spreads it into its own `trackMenuItems`. | ArcFetchModel |
| **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) |
## Actions
| Member | Description | Defined by |
| --- | --- | --- |
| **setFeatures**(f: Feature[]) => void | The shared commit stamps the signature these were fetched for (`GlobalFetchMixin.commitFetchResult`) in the same transaction. | ArcFetchModel |
| **setHoveredFeature**() => void | Fills `BaseDisplay`'s hover-clear hook, which the fetch foundation's reaction calls on every viewport change: the arcs move under a stationary cursor with no mouseleave to drop the hover. | ArcFetchModel |
| **setMinScore**(score: number) => void | | ArcFetchModel |
| **renderSvg**(commit: () => void, signature: string) => void | The commit half of this family's fetch: 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) |
| **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 family's one addition, for the overlay rather than the refetch: dropping the loaded signature sends `dataCurrent` false, so the refetch shows as loading rather than as a display claiming fresh data. The data itself survives, staying on screen under that overlay. A subclass whose reload needs extra teardown can override and chain. | [GlobalFetchMixin](../globalfetchmixin#action-reload) |
| **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**(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.