react-msaview 7.0.0 → 8.0.0

package/dist/model.d.ts

@@ -1,24 +1,23 @@
+import type { ColumnStats } from './columnStats.ts';
+import type { ScrollZoomAxis } from './constants.ts';
 import type { HierarchyNode } from './hierarchy.ts';
 import type { ExportSvgOptions } from './renderToSvg.tsx';
-import type { Annotation, Arc, BasicTrack, ResidueMappingProblem, ColumnTrackSpec, DomainBand, Highlight, NodeWithIds, NodeWithIdsAndLength, ResidueMapping, ResolvedHighlight, RowResidue, StructureResidue, UnshareableData } from './types.ts';
+import type { Annotation, Arc, BasicTrack, Cell, Clade, ResidueMappingProblem, ColumnTrackSpec, DomainBand, Encoding, Highlight, Legend, NodeWithIds, NodeWithIdsAndLength, Region, ResidueMapping, ResolvedClade, ResolvedEncoding, ResolvedHighlight, ResolvedRowPanel, RowPanelSpec, RowResidue, StructureResidue, TrackKind, UnshareableData, Viewport } from './types.ts';
 import type { FileLocation as FileLocationType } from '@jbrowse/core/util/types';
 import type { Instance } from '@jbrowse/mobx-state-tree';
 import type { InterProScanResults } from 'msa-parsers';
+export declare const defaultTrackHeights: Partial<Record<TrackKind, number>>;
 /**
  * The snapshot properties reset() carries across a return to the import form:
  * display preferences and layout, nothing derived from the loaded file.
  *
- * reset() applies a default snapshot filtered to this list, so the list is the
- * whole decision: a property left off it resets to its default, a visible and
- * benign failure. The previous shape — a hand-maintained list of things to
- * CLEAR — failed in the dangerous direction: a forgotten property silently
- * carried the previous file's state into the next one, and because node ids
- * are path-derived (node-0-0-1), a stale `collapsed` or `showOnly` id matched
- * a real node in the new tree and folded it. Downstream composed properties
- * (e.g. the jbrowse plugin's) are not on the list, so they reset too.
+ * reset() applies a default snapshot filtered to this list, so any property
+ * left off it resets, including downstream composed ones (e.g. the jbrowse
+ * plugin's). Node ids are path-derived (node-0-0-1), so a carried-over
+ * `collapsed` or `showOnly` id would match a real node in the next tree and
+ * fold it.
  *
- * Exported for modelReset.test.ts, which checks that everything off this list
- * matches a freshly created model after reset().
+ * Exported for modelReset.test.ts.
  */
 export declare const preservedOnReset: Set<string>;
 /**
@@ -41,7 +40,7 @@ export declare const preservedOnReset: Set<string>;
  * root.view.setData({ msa: '>seq1\nACGT\n>seq2\nACGT' })
  * ```
  */
-declare function stateModelFactory(): import("@jbrowse/mobx-state-tree").IModelType<Omit<Omit<Omit<{}, "autoTreeAreaWidth" | "drawLabels" | "drawNodeBubbles" | "drawTree" | "labelsAlignRight" | "showBranchLen" | "treeAreaWidth" | "treeWidth"> & {
+declare function stateModelFactory(): import("@jbrowse/mobx-state-tree").IModelType<Omit<Omit<Omit<{}, "autoTreeAreaWidth" | "drawLabels" | "drawNodeBubbles" | "drawNodeLabels" | "drawTree" | "labelsAlignRight" | "overviewHeight" | "showBranchLen" | "showTreeOverview" | "treeAreaWidth" | "treeWidth"> & {
     drawLabels: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").ISimpleType<boolean>, [undefined]>;
     labelsAlignRight: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").ISimpleType<boolean>, [undefined]>;
     treeAreaWidth: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").ISimpleType<number>, [undefined]>;
@@ -49,13 +48,16 @@ declare function stateModelFactory(): import("@jbrowse/mobx-state-tree").IModelT
     showBranchLen: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").ISimpleType<boolean>, [undefined]>;
     drawTree: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").ISimpleType<boolean>, [undefined]>;
     drawNodeBubbles: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").ISimpleType<boolean>, [undefined]>;
+    drawNodeLabels: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").ISimpleType<boolean>, [undefined]>;
+    showTreeOverview: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").ISimpleType<boolean>, [undefined]>;
+    overviewHeight: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").ISimpleType<number>, [undefined]>;
     autoTreeAreaWidth: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").ISimpleType<boolean>, [undefined]>;
 }, "bgColor" | "colorSchemeName" | "msaFormat" | "showColumnStats"> & {
     bgColor: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").ISimpleType<boolean>, [undefined]>;
     colorSchemeName: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").ISimpleType<string>, [undefined]>;
     showColumnStats: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").ISimpleType<boolean>, [undefined]>;
     msaFormat: import("@jbrowse/mobx-state-tree").IMaybe<import("@jbrowse/mobx-state-tree").ISimpleType<import("msa-parsers").MSAFormat>>;
-}, "allowedGappyness" | "colWidth" | "collapsed" | "columnTracks" | "currentAlignment" | "data" | "drawMsaLetters" | "gffFilehandle" | "height" | "hideGaps" | "highlightColumns" | "highlights" | "id" | "msaFilehandle" | "relativeTo" | "residueMappings" | "rowHeight" | "scrollX" | "scrollY" | "scrollZoom" | "showDomainLegend" | "showDomains" | "showOnly" | "subFeatureRows" | "treeFilehandle" | "treeMetadataFilehandle" | "turnedOffFeatures" | "turnedOffTracks" | "type"> & {
+}, "allowedGappyness" | "clades" | "colWidth" | "collapsed" | "columnTracks" | "currentAlignment" | "data" | "drawMsaLetters" | "encodings" | "gffFilehandle" | "height" | "hideGaps" | "highlightColumns" | "highlights" | "id" | "msaFilehandle" | "relativeTo" | "residueMappings" | "rowHeight" | "rowPanels" | "scrollX" | "scrollY" | "scrollZoom" | "scrollZoomAxis" | "showDomainLegend" | "showDomains" | "showOnly" | "subFeatureRows" | "trackHeights" | "treeFilehandle" | "treeMetadataFilehandle" | "turnedOffFeatures" | "turnedOffTracks" | "type"> & {
     /**
      * #property
      * id of view, randomly generated if not provided
@@ -68,10 +70,8 @@ declare function stateModelFactory(): import("@jbrowse/mobx-state-tree").IModelT
     /**
      * #property
      * whether the domain legend is expanded. The legend floats over the
-     * top-right of the alignment, so on a tall panel it covers real
-     * residues -- persisting the state is what lets a reader collapse it
-     * and keep it collapsed, and what lets a session or a figure open with
-     * it already out of the way.
+     * top-right of the alignment and covers residues, so a session or
+     * figure can open with it collapsed.
      */
     showDomainLegend: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").ISimpleType<boolean>, [undefined]>;
     /**
@@ -90,7 +90,7 @@ declare function stateModelFactory(): import("@jbrowse/mobx-state-tree").IModelT
      * #property
      * hardcoded view type
      */
-    type: import("@jbrowse/mobx-state-tree").ISimpleType<"MsaView">;
+    type: import("@jbrowse/mobx-state-tree").ILiteralType<"MsaView">;
     /**
      * #property
      */
@@ -100,6 +100,11 @@ declare function stateModelFactory(): import("@jbrowse/mobx-state-tree").IModelT
      * zoom in/out on plain mouse-wheel without holding ctrl
      */
     scrollZoom: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").ISimpleType<boolean>, [undefined]>;
+    /**
+     * #property
+     * which cell dimensions a wheel zoom scales, while `scrollZoom` is on
+     */
+    scrollZoomAxis: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").ISimpleType<"both" | "horizontal" | "vertical">, [undefined]>;
     /**
      * #property
      * height of the div containing the view, px
@@ -543,18 +548,25 @@ declare function stateModelFactory(): import("@jbrowse/mobx-state-tree").IModelT
     turnedOffTracks: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").IMapType<import("@jbrowse/mobx-state-tree").ISimpleType<boolean>>, [undefined]>;
     /**
      * #property
-     * tracks supplied as data rather than computed from the alignment:
-     * per-column values drawn as bars, or a per-column string drawn as a
-     * text track. See docs/layers.md
+     * the height of every track one divider resizes, keyed by `heightKey`:
+     * the `kind` for the computed tracks, `own:<id>` for a data track. A
+     * key is absent until the user drags that divider, and
+     * `defaultTrackHeights` answers for it until then, so an untouched
+     * viewer adds nothing to the shared URL.
+     */
+    trackHeights: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").IMapType<import("@jbrowse/mobx-state-tree").ISimpleType<number>>, [undefined]>;
+    /**
+     * #property
+     * tracks supplied as data: per-column values drawn as bars, or a
+     * per-column string drawn as a text track. See docs/layers.md
      */
     columnTracks: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").IArrayType<import("@jbrowse/mobx-state-tree").IType<ColumnTrackSpec, ColumnTrackSpec, ColumnTrackSpec>>, [undefined]>;
     /**
      * #property
-     * which residue of which structure each row's residues are, as data.
-     * The viewer cannot infer this -- matching a row to a structure by
-     * sequence equality fails for a tagged construct, a truncation or a
-     * subsequence row, and fails in the direction that looks like it
-     * worked -- so it arrives computed. See docs/layers.md
+     * row-to-structure residue correspondence, computed outside the viewer
+     * (e.g. from SIFTS). Matching by sequence equality places a tagged
+     * construct, a truncation or a subsequence row on the wrong residue.
+     * See docs/layers.md
      */
     residueMappings: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").IArrayType<import("@jbrowse/mobx-state-tree").IType<ResidueMapping, ResidueMapping, ResidueMapping>>, [undefined]>;
     /**
@@ -578,10 +590,9 @@ declare function stateModelFactory(): import("@jbrowse/mobx-state-tree").IModelT
     /**
      * #property
      * the user's explicit hide choices per annotation accession, keyed by
-     * accession with the value meaning "off", the same shape as
-     * `turnedOffTracks`. An accession the user has never touched is absent
-     * and drawn, so a file of two hundred domain types adds nothing to the
-     * shared URL until someone filters one out
+     * accession with the value meaning "off", like `turnedOffTracks`. An
+     * untouched accession is absent and drawn, so the shared URL grows
+     * only with the user's filters
      */
     turnedOffFeatures: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").IMapType<import("@jbrowse/mobx-state-tree").ISimpleType<boolean>>, [undefined]>;
     /**
@@ -602,9 +613,34 @@ declare function stateModelFactory(): import("@jbrowse/mobx-state-tree").IModelT
      * labeled highlights in 1-based inclusive coordinates: a column span
      * `{start, end}`, a residue span `{row, start, end}` of a named row,
      * or a row set `{rows}`, each with an optional `label` and `color`.
-     * Persists in the snapshot, so a computed answer travels in the URL.
+     * Persists in the snapshot and the URL.
      */
     highlights: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").IArrayType<import("@jbrowse/mobx-state-tree").IType<Highlight, Highlight, Highlight>>, [undefined]>;
+    /**
+     * #property
+     * clades of the tree with a mark drawn over them. `mrca` names tips
+     * whose common ancestor is the clade, or `range` its first and last
+     * tip in display order, and `tips` is the leaf count the producer
+     * measured. `mark` is `highlight`, `bracket`, `collapse` or `focus`.
+     * See docs/layers.md
+     */
+    clades: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").IArrayType<import("@jbrowse/mobx-state-tree").IType<Clade, Clade, Clade>>, [undefined]>;
+    /**
+     * #property
+     * what the viewer's own marks read from `rowData`:
+     * `{channel, field, scale?}` per channel, where `channel` is
+     * `tipLabel` or `rowTint`. See docs/layers.md
+     */
+    encodings: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").IArrayType<import("@jbrowse/mobx-state-tree").IType<Encoding, Encoding, Encoding>>, [undefined]>;
+    /**
+     * #property
+     * panels drawn between the tree and the alignment:
+     * `{kind: "strip", field, scale?, width?, header?}` colors one cell
+     * per row from a `rowData` field, and
+     * `{kind: "features", x, encoding?, transform?, width?, header?}`
+     * draws the spans the GFF carries. See docs/layers.md
+     */
+    rowPanels: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").IArrayType<import("@jbrowse/mobx-state-tree").IType<RowPanelSpec, RowPanelSpec, RowPanelSpec>>, [undefined]>;
 }, {
     queueOfDialogs: [import("@jbrowse/core/util").DialogComponentType, any][];
 } & {
@@ -621,6 +657,9 @@ declare function stateModelFactory(): import("@jbrowse/mobx-state-tree").IModelT
     setAutoTreeAreaWidth(arg: boolean): void;
     setShowBranchLen(arg: boolean): void;
     setDrawNodeBubbles(arg: boolean): void;
+    setDrawNodeLabels(arg: boolean): void;
+    setShowTreeOverview(arg: boolean): void;
+    setOverviewHeight(n: number): void;
     setDrawLabels(arg: boolean): void;
 } & {
     setColorSchemeName(name: string): void;
@@ -632,6 +671,12 @@ declare function stateModelFactory(): import("@jbrowse/mobx-state-tree").IModelT
      * #volatile
      */
     headerHeight: number;
+    /**
+     * #volatile
+     * leaves the toolbar out, for a host drawing its own controls. Kept out
+     * of the snapshot so a link opened in the full app shows the toolbar.
+     */
+    hideHeader: boolean;
     /**
      * #volatile
      */
@@ -641,9 +686,7 @@ declare function stateModelFactory(): import("@jbrowse/mobx-state-tree").IModelT
     } | undefined;
     /**
      * #volatile
-     * high resolution scale factor, helps make canvas look better on hi-dpi
-     * screens. derived from the device pixel ratio so canvases are crisp on
-     * retina/4k displays and not needlessly oversized on standard ones
+     * canvas scale factor, from the device pixel ratio
      */
     highResScaleFactor: number;
     /**
@@ -703,40 +746,14 @@ declare function stateModelFactory(): import("@jbrowse/mobx-state-tree").IModelT
     highlightedColumns: number[] | undefined;
     /**
      * #volatile
-     * transient highlights keyed by who asked for them. One slot cannot hold
-     * two sources -- a structure viewer's hover and a genome view's hover
-     * both want to point at a column, and with one slot whoever clears last
-     * erases the other's. Keyed by owner, each source adds and removes only
-     * its own. Not persisted: a hover is not part of the document.
+     * transient highlights keyed by owner, so a structure viewer's hover and
+     * a genome view's hover each clear only their own. Not persisted.
      */
     transientHighlights: Record<string, Highlight[]>;
     /**
      * #volatile
      */
     minimapHeight: number;
-    /**
-     * #volatile
-     */
-    conservationTrackHeight: number;
-    /**
-     * #volatile
-     * heights of individual `columnTracks`, by track id. A data track is
-     * resized on its own: the shared per-kind heights below belong to the
-     * tracks the viewer computes, and dragging a data track's handle used to
-     * resize those instead.
-     */
-    columnTrackHeights: Record<string, number>;
-    /**
-     * #volatile
-     * taller than the conservation track by default: the logo spends its
-     * height on stacked glyphs, and a 40px stack of four residues leaves each
-     * one too short to identify
-     */
-    sequenceLogoTrackHeight: number;
-    /**
-     * #volatile
-     */
-    arcTrackHeight: number;
     /**
      * #volatile
      */
@@ -747,33 +764,28 @@ declare function stateModelFactory(): import("@jbrowse/mobx-state-tree").IModelT
     error: unknown;
     /**
      * #volatile
-     * load problems the view carried on through: an optional layer that did
-     * not arrive, an overlay that did not parse. `error` is the other kind --
-     * it replaces the view, which is right for the alignment and wrong for a
-     * decorative file
+     * non-fatal load problems: an optional layer that failed to load, an
+     * overlay that failed to parse. `error` replaces the view and is for the
+     * alignment itself
      */
     warnings: string[];
     /**
      * #volatile
-     * bumped by reset(). The React error boundary above the view keeps its
-     * caught error until it is remounted, so "Return to import form" did
-     * nothing after a render error until this became its key
+     * bumped by reset(). The error boundary above the view uses it as its key,
+     * since the boundary keeps its caught error until remounted
      */
     resetCount: number;
     /**
      * #volatile
-     * set by a host that restores the loaded documents by its own means --
-     * a jbrowse session that holds them, a page that refetches them on load.
-     * `unshareableData` then reports nothing, since what it warns about is a
-     * link that opens empty, and under such a host the link does not
+     * set by a host that restores the loaded documents itself, such as a
+     * jbrowse session or a page that refetches them. `unshareableData` then
+     * reports nothing
      */
     hostCarriesData: boolean;
     /**
      * #volatile
-     * overlay annotations drawn on the alignment, whatever their source.
-     * Every source -- InterProScan, GFF, a user upload -- converts to this
-     * flat list before it reaches the model, so nothing downstream of here
-     * knows which one it came from
+     * overlay annotations drawn on the alignment. InterProScan JSON, GFF and
+     * user uploads all convert to this flat list
      */
     annotations: Annotation[];
 } & {
@@ -806,8 +818,8 @@ declare function stateModelFactory(): import("@jbrowse/mobx-state-tree").IModelT
     setWidth(arg: number): void;
     /**
      * #action
-     * high-res scale factor, tracks the device pixel ratio so canvases stay
-     * crisp when the window moves between monitors or the browser zooms
+     * update the canvas scale factor when the device pixel ratio changes
+     * (moving between monitors, browser zoom)
      */
     setHighResScaleFactor(arg: number): void;
     /**
@@ -822,8 +834,8 @@ declare function stateModelFactory(): import("@jbrowse/mobx-state-tree").IModelT
     setError(error?: unknown): void;
     /**
      * #action
-     * report something the view survived: a layer that failed to load, a
-     * file that failed to parse
+     * record a non-fatal load problem: a layer that failed to load, a file
+     * that failed to parse
      */
     addWarning(warning: string): void;
     /**
@@ -833,25 +845,25 @@ declare function stateModelFactory(): import("@jbrowse/mobx-state-tree").IModelT
     /**
      * #action
      * declare that this host restores the loaded documents itself, which
-     * takes down the "Not in the link" warning. See `hostCarriesData`
+     * hides the "Not in the link" warning. See `hostCarriesData`
      */
     setHostCarriesData(arg: boolean): void;
     /**
      * #action
      * set mouse position (row, column) in the MSA
      *
-     * PUBLIC API: a host drives this (and reads the `mouseCol` volatile) to
-     * sync the alignment's hover with a view of its own -- a genome view, a
-     * 3D structure. Keep the name and signature stable.
+     * Public API: a host calls this (and reads `mouseCol`) to sync hover with
+     * its own view, such as a genome view or 3D structure. Keep the name and
+     * signature stable.
      */
     setMousePos(col?: number, row?: number): void;
     /**
      * #action
      * set highlighted columns
      *
-     * PUBLIC API: jbrowse-plugin-msaview calls this from its
-     * afterCreateAutoruns to highlight alignment columns, and MSAViewer
-     * passes its `highlightColumns` prop through it. Not dead code.
+     * Public API: jbrowse-plugin-msaview calls this from its
+     * afterCreateAutoruns, and MSAViewer passes its `highlightColumns` prop
+     * through it.
      */
     setHighlightedColumns(columns?: number[]): void;
     /**
@@ -860,15 +872,18 @@ declare function stateModelFactory(): import("@jbrowse/mobx-state-tree").IModelT
     setHighlights(highlights: Highlight[]): void;
     /**
      * #action
-     * show `highlights` on behalf of `owner`, replacing whatever that owner
-     * showed before and leaving every other owner's alone. The object is
-     * replaced rather than mutated so one assignment is the observable
-     * change.
+     * replace the clades the viewer marks (see docs/layers.md)
+     */
+    setClades(clades: Clade[]): void;
+    /**
+     * #action
+     * show `highlights` for `owner`, replacing that owner's previous ones and
+     * leaving other owners' in place
      */
     applyHighlight(owner: string, highlights: Highlight[]): void;
     /**
      * #action
-     * drop what `owner` was showing, leaving every other owner's in place
+     * remove `owner`'s highlights, leaving other owners' in place
      */
     clearHighlight(owner: string): void;
     /**
@@ -902,10 +917,9 @@ declare function stateModelFactory(): import("@jbrowse/mobx-state-tree").IModelT
     setColWidth(n: number): void;
     /**
      * #action
-     * switch to another alignment of a multi-alignment file (Stockholm). The
-     * new alignment has its own rows and its own tree, so everything naming
-     * the old one's -- the collapsed node ids, the subtree in focus, the
-     * reference row, the scroll position -- goes with it
+     * switch to another alignment of a multi-alignment file (Stockholm).
+     * Clears the collapsed node ids, the subtree in focus, the reference row
+     * and the scroll position, which all refer to the previous alignment
      */
     setCurrentAlignment(n: number): void;
     /**
@@ -960,11 +974,10 @@ declare function stateModelFactory(): import("@jbrowse/mobx-state-tree").IModelT
     setTreeMetadata(result: string): void;
     /**
      * #action
-     * keep the GFF text the way the alignment and the tree are kept, rather
-     * than only its parsed annotations. The annotations are volatile, so a
-     * file opened from disk used to leave no trace in the snapshot at all --
-     * not the text, and not the filehandle, which is cleared once a blob is
-     * read. An autorun parses this back into annotations.
+     * store the GFF text in the snapshot like the alignment and tree. The
+     * parsed annotations are volatile and a blob filehandle is cleared once
+     * read, so the text is the only persisted copy. An autorun parses it
+     * into annotations.
      */
     setGFF(result: string): void;
 } & {
@@ -983,16 +996,14 @@ declare function stateModelFactory(): import("@jbrowse/mobx-state-tree").IModelT
     readonly actuallyShowDomains: boolean;
     /**
      * #getter
-     * whether this host brings the loaded documents back by means the
-     * snapshot cannot see, which is what decides whether `unshareableData`
-     * has anything to warn about.
+     * whether the host restores the loaded documents outside the snapshot.
+     * When true, `unshareableData` is empty.
      *
-     * A simple host flips the `hostCarriesData` volatile. A host whose
-     * answer depends on how the view was opened overrides this getter in a
-     * `.views` block of its own composed model -- jbrowse-plugin-msaview's
-     * indexed-location views refetch from a URL the session holds, while its
-     * data-store views really are absent from a link someone pastes
-     * elsewhere. `unshareableData` reads it off `self`, so an override wins.
+     * A simple host sets `hostCarriesData`. A host where this depends on how
+     * the view was opened overrides the getter in its own composed model's
+     * `.views` block; jbrowse-plugin-msaview's indexed-location views refetch
+     * from a URL the session holds, while its data-store views do not.
+     * `unshareableData` reads it off `self`, so an override takes effect.
      */
     readonly hostRestoresData: boolean;
     readonly viewInitialized: boolean;
@@ -1031,33 +1042,40 @@ declare function stateModelFactory(): import("@jbrowse/mobx-state-tree").IModelT
     readonly noDomains: boolean;
     /**
      * #getter
-     * the loaded documents this view's own snapshot cannot carry, largest
-     * first. A file opened from disk or pasted in becomes inline text, and
-     * DataModel drops an inline document past `maxInlineSnapshotBytes`
-     * rather than put megabytes of sequence into a session or a URL.
+     * loaded documents left out of the snapshot, largest first. A file opened
+     * from disk or pasted in becomes inline text, and DataModel drops an
+     * inline document past `maxInlineSnapshotBytes`.
      *
-     * Dropping it is right. Dropping it silently is what makes a copied link
-     * open an empty viewer, so the header says so and the standalone app
-     * stops rewriting the address bar while this is non-empty. A document
-     * fetched from a URL never appears here whatever its size: the snapshot
-     * keeps the filehandle and refetches through it.
+     * The header lists these, and the standalone app stops rewriting the
+     * address bar while the list is non-empty, so a copied link does not
+     * open an empty viewer unannounced. A document fetched from a URL never
+     * appears here, since the snapshot keeps its filehandle.
      *
-     * Nothing is unshareable when the host restores the data by its own
-     * means (see `hostRestoresData`) -- inside a session that reloads these
-     * documents from somewhere the snapshot does not show, the warning is
-     * simply wrong.
+     * Empty when `hostRestoresData` is true.
      */
     readonly unshareableData: UnshareableData[];
     menuItems(): never[];
     /**
      * #getter
-     * extra per-row attributes, keyed by row name. Parsed defensively: the
-     * source is a user-supplied document (treeMetadataFilehandle, or a
-     * session snapshot), and this computed is read by labelWidthMap on every
-     * layout, so a malformed file would otherwise throw out of rendering and
-     * take the whole view down over a decorative field.
+     * the row table: extra fields per row, keyed by row name, which the
+     * `encodings` channels read. It is stored as the JSON string
+     * `data.treeMetadata`, the name that travels in existing links, so the
+     * inline size limit and `treeMetadataFilehandle` cover it. labelWidthMap
+     * reads it on every layout, so a malformed user-supplied file returns {}
+     * instead of throwing out of rendering.
+     */
+    readonly rowData: Record<string, Record<string, string> | undefined>;
+    /**
+     * #method
+     * one row's fields, the single reader of the row table
+     */
+    rowDataOf(name: string): Record<string, string> | undefined;
+    /**
+     * #getter
+     * the field names the row table carries, sorted, for a producer or a UI
+     * choosing one to encode
      */
-    readonly treeMetadata: Record<string, Record<string, string> | undefined>;
+    readonly rowFields: string[];
     /**
      * #getter
      */
@@ -1080,6 +1098,22 @@ declare function stateModelFactory(): import("@jbrowse/mobx-state-tree").IModelT
      * #getter
      */
     readonly rowNamesSet: Map<string, number>;
+    /**
+     * #getter
+     * `clades` resolved to the rows each one covers. The tip names resolve
+     * against `tree` rather than `root`, so a clade whose ancestor the user
+     * collapsed keeps its rows. One leaf pass over the tree serves every
+     * clade. A `range` record names no node, so `collapse` and `focus`, which
+     * need one, drop it.
+     */
+    readonly resolvedClades: ResolvedClade[];
+    /**
+     * #getter
+     * the pixel column reserved at the right of the tree area for the bracket
+     * mark, which the tip labels and the tree itself stay clear of. Zero
+     * where no clade draws a bar or a label.
+     */
+    readonly cladeGutterWidth: number;
     /**
      * #getter
      */
@@ -1099,11 +1133,70 @@ declare function stateModelFactory(): import("@jbrowse/mobx-state-tree").IModelT
     readonly root: HierarchyNode<NodeWithIds>;
     /**
      * #getter
-     * widget width minus the tree area gives the space for the MSA
+     * height of the band the tree overview draws in, zero when it is off
+     */
+    readonly treeOverviewHeight: number;
+    /**
+     * #getter
+     * the whole tree laid out for the overview, or undefined when the
+     * overview is off. The focus is left out, so the focused subtree draws
+     * inside the whole tree, and the collapsed clades are folded, since
+     * those are rows the view no longer has. `x` is in tip-index space and
+     * `len` is a fraction of the root-to-tip length, so one layout serves
+     * any band size.
+     */
+    readonly treeOverviewLayout: {
+        root: HierarchyNode<NodeWithIds>;
+        numTips: number;
+        maxDepthToLeaf: number;
+        showBranchLen: boolean;
+    } | undefined;
+    /**
+     * #getter
+     * the `clades` highlights in the overview's own row space, which the
+     * focus does not narrow
+     */
+    readonly treeOverviewClades: ResolvedClade[];
+    /**
+     * #getter
+     * the inclusive tip rows the focused subtree covers in the overview,
+     * which is the box drawn on it. undefined with no focus
+     */
+    readonly treeOverviewFocusRows: [number, number] | undefined;
+    /**
+     * #method
+     * the subtree a point `y` pixels down the tree overview picks: the
+     * deepest one whose tip range covers every row under that pixel, with
+     * the rows it covers. A pixel stands for several tips on a large tree,
+     * which is what keeps the pick off the individual tips. undefined when
+     * the overview is off or the point picks the whole tree.
+     */
+    treeOverviewHit(y: number): {
+        id: string;
+        rows: [number, number];
+    } | undefined;
+    /**
+     * #getter
+     * the pixel column the row panels occupy between the tree and the
+     * alignment, the sum of each record's width
+     */
+    readonly rowPanelsWidth: number;
+    /**
+     * #getter
+     * height of the band the row panel headers draw in, which is zero with
+     * no row panels and leaves the top area as it was
+     */
+    readonly rowPanelsHeaderHeight: 0 | 56;
+    /**
+     * #getter
+     * widget width minus the tree area and the row panels gives the space
+     * for the MSA
      */
     readonly msaAreaWidth: number;
     /**
      * #getter
+     * the right edge the tip labels end at, which is the tree area less the
+     * margin and the bracket gutter
      */
     readonly treeAreaWidthMinusMargin: number;
     /**
@@ -1124,29 +1217,22 @@ declare function stateModelFactory(): import("@jbrowse/mobx-state-tree").IModelT
     readonly rows: [string, string][];
     /**
      * #getter
-     * number of rows the alignment occupies on screen. This is the leaf count,
-     * not `rows.length`: a tree leaf with no matching MSA row still takes up a
-     * row of vertical space (drawn blank), so row hit-testing and fit-to-height
-     * must count it.
+     * number of rows on screen: the leaf count, which includes tree leaves
+     * with no matching MSA row (drawn blank), unlike `rows.length`.
      */
     readonly numRows: number;
     /**
      * #method
      * index of the global column holding each ungapped sequence position of a
-     * row, so seqPos -> column is a lookup rather than a scan. The domain
-     * overlay resolves thousands of these per redraw.
-     *
-     * Built per row, on the row asked for: the first lookup used to index
-     * every row in the alignment. The cache is keyed on the parse the rows
-     * came from, so a new alignment brings a new one.
+     * row. The domain overlay resolves thousands of these per redraw. Built
+     * lazily per row and cached on the parse.
      */
     seqPosIndex(rowName: string): Int32Array | undefined;
     /**
      * #getter
-     * every sequence the alignment holds, keyed by row name, whatever the
-     * tree currently shows. `rows` is the rows on screen; this is the rows
-     * that exist, and every lookup about a named row goes through it --
-     * collapsing a clade hides rows, it does not delete their sequence
+     * every sequence in the alignment, keyed by row name, including rows a
+     * collapsed clade hides. `rows` holds only the rows on screen; lookups
+     * by row name use this
      */
     readonly rowMap: Map<string, string>;
     /**
@@ -1229,17 +1315,14 @@ declare function stateModelFactory(): import("@jbrowse/mobx-state-tree").IModelT
     readonly rootToTipLength: number;
     /**
      * #getter
-     * x-position of the farthest tip in a phylogram, px. The layout scales
-     * the longest root-to-tip path onto treeWidth, so that is where it lands
-     * -- and 0 for a tree carrying no lengths at all, which draws as a
-     * cladogram instead
+     * x-position of the farthest tip in a phylogram, px: treeWidth, or 0 for
+     * a tree with no branch lengths (drawn as a cladogram)
      */
     readonly maxBranchLength: number;
     /**
      * #getter
-     * pixels per unit of branch length in the current phylogram layout, and 0
-     * in cladogram mode, where the x-positions carry no length at all. The
-     * scale bar over the tree is drawn from it.
+     * pixels per unit of branch length in the phylogram layout, 0 in
+     * cladogram mode. The tree's scale bar uses it.
      */
     readonly pxPerBranchLength: number;
     /**
@@ -1292,9 +1375,8 @@ declare function stateModelFactory(): import("@jbrowse/mobx-state-tree").IModelT
     readonly seqConsensus: string | undefined;
     /**
      * #getter
-     * the base pairs of the consensus secondary structure, as arcs. The WUSS
-     * string is collapsed through the hidden columns before it is parsed, so
-     * the pairs land in the same visible column space the text track does
+     * the base pairs of the consensus secondary structure, as arcs, in
+     * visible column space (hidden columns are removed before parsing)
      */
     readonly secondaryStructureArcs: Arc[] | undefined;
     /**
@@ -1312,24 +1394,28 @@ declare function stateModelFactory(): import("@jbrowse/mobx-state-tree").IModelT
         arcs?: Arc[];
     }>;
     /**
-     * #getter
+     * #method
+     * the height a track draws at: what the user dragged its divider to,
+     * then the height its snapshot asked for, then its kind's default. Only
+     * a text track falls through to rowHeight, and `??` short-circuits
+     * before reading it, so vertical zoom does not rebuild the other tracks
      */
-    readonly columnTrackModels: BasicTrack[];
+    trackHeight(kind: TrackKind, heightKey?: string, given?: number): number;
     /**
      * #getter
      */
+    readonly columnTrackModels: BasicTrack[];
     /**
      * #getter
-     * the consensus secondary structure as a track, when there is one. Its
-     * own getter so the object keeps its identity across a zoom: the canvas
-     * redraws on the track it is handed changing, and rebuilding these
-     * alongside everything else made every zoom frame redraw every track
+     * the consensus secondary structure as a track, when there is one. A
+     * separate getter keeps the object stable across zoom, so its canvas
+     * does not redraw
      */
     readonly basePairTrackModels: BasicTrack[];
     /**
      * #getter
-     * the tracks computed from the alignment itself, which depend on their
-     * own heights and on the alphabet -- and on nothing zoom changes
+     * the tracks computed from the alignment; they depend on their heights
+     * and the alphabet, not on zoom
      */
     readonly computedTrackModels: BasicTrack[];
     readonly tracks: BasicTrack[];
@@ -1355,10 +1441,10 @@ declare function stateModelFactory(): import("@jbrowse/mobx-state-tree").IModelT
      * Convert a visible column to a row-specific sequence position (0-based).
      * Returns undefined if the position is a gap in the sequence.
      *
-     * PUBLIC API: this and the sibling coordinate converters
-     * (visibleColToGlobalCol, seqPosToVisibleCol, globalColToVisibleCol,
-     * seqPosToGlobalCol) are how a host translates between alignment columns
-     * and a row's residue positions across gaps. Keep them stable.
+     * Public API, like the sibling converters (visibleColToGlobalCol,
+     * seqPosToVisibleCol, globalColToVisibleCol, seqPosToGlobalCol) hosts
+     * use to translate between columns and residue positions. Keep them
+     * stable.
      *
      * @param rowName - The name of the row
      * @param visibleCol - The visible column index
@@ -1387,10 +1473,9 @@ declare function stateModelFactory(): import("@jbrowse/mobx-state-tree").IModelT
     globalColToVisibleCol(globalCol: number): number | undefined;
     /**
      * #method
-     * Convert a visible column index (what a mouse handler reports) back to a
-     * column of the full alignment. Hidden columns shift everything to their
-     * right, so a host that holds per-column data of its own has to make this
-     * hop before indexing it.
+     * Convert a visible column index (what a mouse handler reports) to a
+     * column of the full alignment. A host indexing its own per-column data
+     * needs this when columns are hidden.
      *
      * @param visibleCol - The visible column index
      * @returns The global column index in the full MSA
@@ -1399,8 +1484,7 @@ declare function stateModelFactory(): import("@jbrowse/mobx-state-tree").IModelT
     /**
      * #method
      * Convert a sequence position (ungapped) to a global column index.
-     * Returns undefined for a row the alignment does not have -- answering
-     * anyway is how a mistyped or stale row name came to highlight column 0.
+     * Returns undefined for a row name the alignment does not have.
      *
      * @param rowName - The name of the row
      * @param seqPos - The sequence position (0-based, ungapped)
@@ -1417,27 +1501,34 @@ declare function stateModelFactory(): import("@jbrowse/mobx-state-tree").IModelT
      * @returns The visible column index, or undefined if the column is hidden
      */
     seqPosToVisibleCol(rowName: string, seqPos: number): number | undefined;
+    /**
+     * #method
+     * the visible columns a span covers, in highlight coordinates: `start`
+     * and `end` are 1-based residues of `row`, or columns of the file
+     * without it. A fractional position, as a zoom gesture reports one,
+     * widens to the whole residue or column it falls in. A span entirely on
+     * hidden columns, or naming a row the alignment lacks, gives undefined.
+     */
+    visibleSpan({ row, start: rawStart, end: rawEnd }: Region): {
+        startCol: number;
+        endCol: number;
+    } | undefined;
     /**
      * #getter
-     * every reason a mapping is being ignored, so a host can say which. A
-     * mapping outlives the alignment it was computed for; when the two no
-     * longer agree the lookups have to refuse, and refusing invisibly is how
-     * "there is no structure here" gets confused with "this data is stale".
+     * why each ignored residue mapping is ignored, so a host can tell a
+     * missing structure from a mapping made against a different alignment.
      */
     readonly residueMappingProblems: ResidueMappingProblem[];
     /**
      * #getter
-     * the mappings that still fit the loaded alignment. A row-level problem
-     * takes the whole mapping out; a single malformed segment takes only
-     * itself, since the rest of the mapping is still a claim about residues
-     * that exist.
+     * the mappings that fit the loaded alignment. A row-level problem drops
+     * the whole mapping; a malformed segment drops only that segment.
      */
     readonly usableResidueMappings: ResidueMapping[];
     /**
      * #getter
-     * the structures the loaded alignment has usable mappings onto. A row can
-     * have several -- an experimental entry and a predicted model, say -- so
-     * a host that means a particular one has to name it.
+     * the structures with usable mappings. A row can map onto several, such
+     * as an experimental entry and a predicted model.
      */
     readonly mappedStructures: {
         row: string;
@@ -1445,18 +1536,12 @@ declare function stateModelFactory(): import("@jbrowse/mobx-state-tree").IModelT
     }[];
     /**
      * #method
-     * The structure residue a row residue is, or undefined. Refusing is the
-     * point: the guess this replaces answered every query, with a wrong
-     * residue when it did not know.
-     *
-     * It also refuses when the answer is not unique. A row commonly maps onto
-     * several structures -- an experimental entry and two predicted models --
-     * and returning whichever came first would be the same class of wrong,
-     * quieter. Name one with `structureId`, or use `mappedStructures` to see
-     * what there is.
+     * The structure residue for a row residue. Returns undefined when no
+     * segment covers `seqPos`, or when the row maps onto several structures
+     * and `structureId` does not pick one (see `mappedStructures`).
      *
-     * Positions are 1-based, as `residueMappings` and `highlights` are --
-     * note that the column helpers above take 0-based ones.
+     * Positions are 1-based, like `residueMappings` and `highlights`; the
+     * column helpers above are 0-based.
      *
      * @param rowName - The alignment row
      * @param seqPos - Residue of that row, 1-based
@@ -1465,10 +1550,10 @@ declare function stateModelFactory(): import("@jbrowse/mobx-state-tree").IModelT
     structureResidue(rowName: string, seqPos: number, structureId?: string): StructureResidue | undefined;
     /**
      * #method
-     * The row residue a structure residue is, the same lookup backwards, and
-     * refusing on the same terms. `asymId` picks between mappings onto the
-     * same entry, which a homodimer -- two rows, two chains, one id -- always
-     * needs; without it such a lookup is ambiguous and gets nothing.
+     * The row residue for a structure residue; the inverse of
+     * `structureResidue`, returning undefined in the same cases. `asymId`
+     * picks a chain when several mappings share an entry id, as in a
+     * homodimer.
      *
      * @param structureId - The structure's id, as the mapping names it
      * @param position - Residue of that structure, 1-based label_seq_id
@@ -1478,12 +1563,26 @@ declare function stateModelFactory(): import("@jbrowse/mobx-state-tree").IModelT
 } & {
     /**
      * #getter
-     * the vertical space the alignment rows actually get: the widget height
-     * less everything stacked above and below them -- the header, the tracks,
-     * and the minimap when the columns overflow. Every consumer wants this
-     * same subtraction, so there is one of it: blocksY, maxScrollY, the
-     * vertical scrollbar and fitVertically all read it, and a second getter
-     * that forgot the tracks is what put the last rows out of reach.
+     * the branch-length scale bar over the tree, undefined in cladogram mode
+     * or when the tree area is too narrow for one
+     */
+    readonly treeScaleBar: {
+        step: number;
+        px: number;
+        label: string;
+    } | undefined;
+    /**
+     * #getter
+     * the band across the top: the minimap over the alignment, the row panel
+     * headers, and the tree overview stacked on the scale bar, as tall as the
+     * tallest of the three
+     */
+    readonly topBandHeight: number;
+    /**
+     * #getter
+     * the vertical space for alignment rows: the widget height less the
+     * header, the top band and the tracks. Shared by blocksY, maxScrollY, the
+     * vertical scrollbar and fitVertically.
      */
     readonly msaAreaHeight: number;
     /**
@@ -1492,8 +1591,8 @@ declare function stateModelFactory(): import("@jbrowse/mobx-state-tree").IModelT
      */
     readonly totalTrackAreaHeight: number;
     /**
-     * one representative annotation per accession, which is what the legend,
-     * the filter dialog and the palettes key off
+     * one representative annotation per accession, for the legend, the
+     * filter dialog and the palettes
      */
     readonly annotationTypes: Map<string, Annotation>;
     readonly filteredAnnotations: Annotation[];
@@ -1531,10 +1630,16 @@ declare function stateModelFactory(): import("@jbrowse/mobx-state-tree").IModelT
     readonly maxScrollX: number;
     /**
      * #getter
-     * most-negative allowed scrollY, keeping the last row in view rather than
-     * letting the whole alignment scroll off the top.
+     * most-negative allowed scrollY, which keeps the last row in view
      */
     readonly maxScrollY: number;
+    /**
+     * #getter
+     * axis a wheel zoom scales, for ctrl+wheel as much as for scroll-zoom.
+     * With scroll-zoom off the toolbar shows no axis, so ctrl+wheel takes
+     * both.
+     */
+    readonly wheelZoomAxis: ScrollZoomAxis;
 } & {
     /**
      * #action
@@ -1544,6 +1649,10 @@ declare function stateModelFactory(): import("@jbrowse/mobx-state-tree").IModelT
      * #action
      */
     setScrollZoom(arg: boolean): void;
+    /**
+     * #action
+     */
+    setScrollZoomAxis(arg: ScrollZoomAxis): void;
     /**
      * #action
      * set hovered tree node and its descendants
@@ -1552,18 +1661,16 @@ declare function stateModelFactory(): import("@jbrowse/mobx-state-tree").IModelT
     /**
      * #action
      * Calculate a neighbor joining tree from the current MSA using BLOSUM62
-     * distances. Refuses above `maxNeighborJoiningRows`: the join loop is
-     * cubic and runs on the main thread, so 800 rows is a ten-second freeze
-     * with no progress and no cancel, and a tree that size wants a tool built
-     * for it anyway.
+     * distances. Throws above `maxNeighborJoiningRows`: the join loop is
+     * cubic and runs on the main thread, and 800 rows freeze the tab for ten
+     * seconds with no cancel.
      */
     calculateNeighborJoiningTreeFromMSA(): void;
     /**
      * #action
-     * swap in a different tree over the same alignment. Node ids are derived
-     * from the path (node-0-0-1), so a `collapsed` or `showOnly` id held over
-     * from the old tree matches a real node in the new one and folds whatever
-     * happens to sit there -- the ids go with the tree they name.
+     * swap in a different tree over the same alignment. Clears `collapsed`
+     * and `showOnly`, since path-derived node ids (node-0-0-1) from the old
+     * tree would match unrelated nodes in the new one.
      */
     replaceTree(newick: string): void;
     /**
@@ -1599,13 +1706,14 @@ declare function stateModelFactory(): import("@jbrowse/mobx-state-tree").IModelT
      * #action
      * Smoothly zoom by a continuous scaleFactor. The column under the cursor
      * (offsetX/offsetY, px relative to the MSA area) stays anchored
-     * horizontally. Vertically the anchor is biased toward the top: when the
-     * alignment nearly fits the viewport, snap to y=0 rather than pinning a
-     * random row under the cursor, with the bias fading out as the alignment
-     * grows taller than the viewport (where cursor-anchoring is useful).
-     * Drives wheel/trackpad-pinch zoom.
+     * horizontally. Vertically the anchor is biased toward y=0 when the
+     * alignment nearly fits the viewport, fading to cursor-anchoring as the
+     * alignment grows taller than the viewport.
+     * Drives wheel/trackpad-pinch zoom. `axis` holds one cell dimension
+     * fixed; the held axis still re-anchors its scroll offset, since the
+     * other one can change how much of the alignment fits.
      */
-    zoomToPos(scaleFactor: number, offsetX: number, offsetY: number): void;
+    zoomToPos(scaleFactor: number, offsetX: number, offsetY: number, axis?: ScrollZoomAxis): void;
     /**
      * #action
      */
@@ -1617,13 +1725,11 @@ declare function stateModelFactory(): import("@jbrowse/mobx-state-tree").IModelT
     setScrollY(n: number): void;
     /**
      * #action
-     * Set the overlay annotations (an empty list clears them). Every source
-     * funnels through here after its own adapter has flattened it:
-     * InterProScan, GFF, user uploads, NCBI CDD.
+     * Set the overlay annotations (an empty list clears them). InterProScan,
+     * GFF, user uploads and NCBI CDD all arrive here as Annotation[].
      *
-     * It does not touch `showDomains`. Loading used to force the overlay on,
-     * and since a restored snapshot loads its GFF again on the way in, a link
-     * shared with the overlay hidden reopened with it drawn.
+     * Leaves `showDomains` alone, because a restored snapshot reloads its
+     * GFF and must keep a hidden overlay hidden.
      */
     setAnnotations(annotations: Annotation[]): void;
     /**
@@ -1646,6 +1752,22 @@ declare function stateModelFactory(): import("@jbrowse/mobx-state-tree").IModelT
      * #action
      */
     setColumnTracks(tracks: ColumnTrackSpec[]): void;
+    /**
+     * #action
+     * replace the row table, which the model keeps as the JSON string
+     * `data.treeMetadata` (see docs/layers.md)
+     */
+    setRowData(rowData: Record<string, Record<string, string>>): void;
+    /**
+     * #action
+     * replace what the viewer's marks read from the row table
+     */
+    setEncodings(encodings: Encoding[]): void;
+    /**
+     * #action
+     * replace the panels drawn between the tree and the alignment
+     */
+    setRowPanels(panels: RowPanelSpec[]): void;
     /**
      * #action
      * replace the alignment<->structure correspondence (see docs/layers.md)
@@ -1669,16 +1791,39 @@ declare function stateModelFactory(): import("@jbrowse/mobx-state-tree").IModelT
     readonly verticalScrollbarWidth: 0 | 20;
     /**
      * #getter
-     * width of the alignment canvas itself: the msa area less the vertical
-     * scrollbar sitting in it. Not usable from showHorizontalScrollbar, which
-     * feeds msaAreaHeight -> showVerticalScrollbar and would close a cycle
+     * width of the alignment canvas: the msa area less the vertical
+     * scrollbar. showHorizontalScrollbar must not read it, since that feeds
+     * msaAreaHeight -> showVerticalScrollbar and would form a cycle
      */
     readonly msaCanvasWidth: number;
+    /**
+     * #method
+     * the cell at a visible column and row index, in the coordinates a host
+     * writes highlights in
+     */
+    cellAt(visibleCol: number, rowIndex?: number): Cell;
+    /**
+     * #getter
+     * the cell under the pointer. Public API: MSAViewer's onCellHover
+     * reports it.
+     */
+    readonly hoveredCell: Cell | undefined;
+    /**
+     * #getter
+     * the cell a click pinned. Public API: MSAViewer's onCellClick reports it.
+     */
+    readonly clickedCell: Cell | undefined;
+    /**
+     * #getter
+     * the columns on screen. Public API: MSAViewer's onViewportChange reports
+     * it.
+     */
+    readonly viewport: Viewport | undefined;
     /**
      * #getter
      * ordinal segment types (exons etc.), ordered by sequence position so
-     * exon-1..exon-14 read left-to-right; colored by alternating shade and
-     * labeled by number rather than each getting a distinct hue + legend row
+     * exon-1..exon-14 run left-to-right; colored by alternating shade and
+     * labeled by number, with no legend row
      */
     readonly segmentDomainTypes: Annotation[];
     /**
@@ -1693,6 +1838,29 @@ declare function stateModelFactory(): import("@jbrowse/mobx-state-tree").IModelT
     readonly strokePalette: {
         [k: string]: string;
     };
+    /**
+     * #getter
+     * the encoding coloring the overlay's spans, undefined when none does,
+     * which leaves each span the color its accession takes in `fillPalette`
+     */
+    readonly featureFillEncoding: ResolvedEncoding | undefined;
+    /**
+     * #getter
+     * the fill and outline of every feature's span: its own GFF `color=`
+     * first, then the `featureFill` scale, then the accession palette.
+     * Computed once per change of the features, the encodings or the palette
+     */
+    readonly featureColors: Map<Annotation, {
+        fill: string;
+        stroke: string;
+    }>;
+    /**
+     * #getter
+     * the text the `featureLabel` channel draws inside each span, undefined
+     * when no encoding names the channel. A data channel, so it draws
+     * whether or not the residue letters do
+     */
+    readonly featureLabels: Map<Annotation, string> | undefined;
     /**
      * #getter
      * accession -> number drawn on each segment band: the trailing number of
@@ -1702,20 +1870,41 @@ declare function stateModelFactory(): import("@jbrowse/mobx-state-tree").IModelT
     /**
      * #getter
      * the domain types currently drawn on the alignment (filtered-on), shared
-     * by the on-screen legend and the SVG export legend. Ordinal segments
-     * (exons) are excluded — they read as a numbered gene model, not a color
-     * key — so this is the categorical types ordered by sequence position
+     * by the on-screen legend and the SVG export legend: the categorical types
+     * ordered by sequence position. Ordinal segments (exons) are numbered on
+     * the band instead
      */
     readonly visibleDomainTypes: Annotation[];
+    /**
+     * #getter
+     * the categorical color keys drawn for this view, shared by the on-screen
+     * legend overlay and the SVG export's reserved column. The domain overlay
+     * produces the first, listing the `featureFill` scale where an encoding
+     * names one. Every field a row-table encoding or a row panel reads
+     * produces one more, so two channels over one field, or two strips over
+     * it, list that field once. A strip's `legend` names the title it lists
+     * under, so strips over eight fields with one set of colors list one
+     * legend between them
+     */
+    readonly legends: Legend[];
+    /**
+     * #getter
+     * whether the overlay marks each domain with a bar under its row instead
+     * of filling the row behind the letters. Letter-color mode hands the
+     * background to the color scheme, so a filled box would paint over it and
+     * leave the setting with nothing to show. Sub-row layout already stacks
+     * the boxes clear of the letters, and with the letters too small to draw
+     * the filled box is the only thing left to read.
+     */
+    readonly domainUnderline: boolean;
     /**
      * #getter
      * every filtered-on annotation resolved to the visible column span it is
      * drawn across, keyed by row name. Each row is ordered longest-first so a
-     * short domain nested inside a long one draws on top of it rather than
-     * under it. Resolving these once here rather than inside each canvas
-     * block removes a per-feature, per-block sequence position conversion
-     * from every redraw, and gives the letter renderer the band colors it
-     * needs to keep residues readable on top of the boxes.
+     * nested short domain draws on top, and each band carries the lane the
+     * sub-row layout puts it in. Resolved once here instead of per canvas
+     * block per redraw; the letter renderer also reads the band colors to
+     * pick legible letter colors.
      */
     readonly domainBands: Map<string, DomainBand[]>;
     /**
@@ -1739,15 +1928,14 @@ declare function stateModelFactory(): import("@jbrowse/mobx-state-tree").IModelT
      * #getter
      * row indices highlighted by the current tree hover (a hovered internal
      * node highlights every tip below it). Shared by the tree and MSA overlay
-     * canvases so they cannot disagree, and resolved through the memoized
-     * name->index map rather than rebuilding a lookup on each mouse move.
+     * canvases, via the memoized name->index map.
      */
     readonly hoveredRowIndices: number[];
     /**
      * #getter
      * contiguous runs of `highlightedColumns`, so a run of highlighted columns
-     * draws as one bordered band. Computed here because the overlay canvas
-     * redraws on every mouse move while the highlight itself rarely changes.
+     * draws as one bordered band. Memoized because the overlay canvas redraws
+     * on every mouse move.
      */
     readonly highlightedColumnRuns: {
         start: number;
@@ -1761,24 +1949,20 @@ declare function stateModelFactory(): import("@jbrowse/mobx-state-tree").IModelT
      * is dropped. Row names that match no row are ignored.
      */
     readonly resolvedHighlights: ResolvedHighlight[];
+    /**
+     * #method
+     * per-column summary statistics: consensus residue and its identity
+     * fraction, both conservation scores, gap fraction, and the sorted non-gap
+     * residue distribution. undefined past the end of the alignment or for an
+     * all-gap column.
+     */
+    columnStatsAt(col: number): ColumnStats | undefined;
     /**
      * #getter
-     * per-column summary statistics for the hovered column: consensus residue
-     * and its identity fraction, conservation score, gap fraction, and the
-     * sorted non-gap residue distribution. undefined when nothing is hovered.
+     * `columnStatsAt` for the hovered column, undefined when nothing is
+     * hovered
      */
-    readonly mouseOverColumnStats: {
-        col: number;
-        total: number;
-        gaps: number;
-        gapFraction: number;
-        conservation: number;
-        propertyConservation: number | undefined;
-        consensusLetter: string;
-        consensusCount: number;
-        consensusFraction: number;
-        distribution: [string, number][];
-    } | undefined;
+    readonly mouseOverColumnStats: ColumnStats | undefined;
     /**
      * #method
      */
@@ -1788,35 +1972,84 @@ declare function stateModelFactory(): import("@jbrowse/mobx-state-tree").IModelT
             accession?: string;
             dbxref?: string;
         } | undefined;
-        treeMetadata: Record<string, string> | undefined;
+        rowData: Record<string, string> | undefined;
     };
-} & {
     /**
-     * #action
+     * #getter
+     * each encoding with its scale resolved against the values its field
+     * takes: a feature channel reads them across the features drawn, every
+     * other channel across the row table. Resolved once per change of that
+     * table or the encodings, never per row per frame.
      */
-    setHeaderHeight(arg: number): void;
+    readonly resolvedEncodings: ResolvedEncoding[];
+    /**
+     * #getter
+     * each row panel with its scale resolved against the values its field
+     * takes across the row table, giving the color per row name, the pixel
+     * column it draws in, and the entries its legend lists. Resolved once
+     * per change of that table or the panels, never per block per frame.
+     */
+    readonly resolvedRowPanels: ResolvedRowPanel[];
+    /**
+     * #getter
+     * the shift an `align` transform gives each row, keyed by the feature
+     * name it aligns on: the offset putting the first feature of that name
+     * at zero. A row carrying no such feature is absent, and keeps its own
+     * origin.
+     */
+    readonly featureAlignShifts: Map<string, Map<string, number>>;
+    /**
+     * #getter
+     * the color the `tipLabel` channel gives each row, by row name. Undefined
+     * when no encoding names the channel, which leaves the labels the theme's
+     * text color.
+     */
+    readonly tipLabelColors: Map<string, string> | undefined;
+    /**
+     * #getter
+     * the wash the `rowTint` channel draws over each row, indexed by row, or
+     * undefined when no encoding names the channel. The overlay draws these,
+     * so a tint stays out of the raster tile cache and its keys.
+     */
+    readonly rowTints: (string | undefined)[] | undefined;
+    /**
+     * #getter
+     * the color the `branch` channel gives each tree edge, by the node id at
+     * the edge's far end, or undefined when no encoding names the channel. A
+     * node takes the field value its tips agree on, so a clade of one value
+     * colors down from where it splits off, and a node whose tips disagree or
+     * whose value has no color is absent and draws in the default color.
+     *
+     * The pass runs over the whole tree, never `root`, so a collapsed or
+     * focused clade keeps the color the full tree gives it.
+     */
+    readonly branchColors: Map<string, string> | undefined;
+} & {
     /**
      * #action
      */
-    setConservationTrackHeight(arg: number): void;
+    setHeaderHeight(arg: number): void;
     /**
      * #action
      */
-    setColumnTrackHeight(id: string, height: number): void;
+    setHideHeader(arg: boolean): void;
     /**
      * #action
+     * focus the subtree a click `y` pixels down the tree overview lands on.
+     * A click inside the box already drawn there clears the focus, the way
+     * clicking the focused branch again does.
      */
-    setSequenceLogoTrackHeight(arg: number): void;
+    treeOverviewClick(y: number): void;
     /**
      * #action
+     * resize every track sharing a `heightKey`; see `trackHeights`
      */
-    setArcTrackHeight(arg: number): void;
+    setTrackHeight(heightKey: string, height: number): void;
     /**
      * #action
-     * Return to the import form: every property off `preservedOnReset`
-     * (data, filehandles, collapsed/showOnly, zoom, scroll, ...) goes back
-     * to its default, then the file-derived volatiles applySnapshot cannot
-     * reach are cleared by hand.
+     * Return to the import form: reset every property not in
+     * `preservedOnReset` to its default, then clear the file-derived
+     * volatiles applySnapshot does not touch.
      */
     reset(): void;
     /**
@@ -1825,8 +2058,8 @@ declare function stateModelFactory(): import("@jbrowse/mobx-state-tree").IModelT
     exportSVG(opts: ExportSvgOptions): Promise<void>;
     /**
      * #action
-     * draw this annotation type, or stop drawing it. Only the "stop" is
-     * recorded -- see `turnedOffFeatures`
+     * show or hide an annotation type. Only hidden types are recorded; see
+     * `turnedOffFeatures`
      */
     setFilter(accession: string, shown: boolean): void;
     /**
@@ -1837,6 +2070,13 @@ declare function stateModelFactory(): import("@jbrowse/mobx-state-tree").IModelT
      * #action
      */
     fitVertically(): void;
+    /**
+     * #action
+     * zoom and scroll so a span fills the alignment's width, in highlight
+     * coordinates (see visibleSpan). Does nothing before the viewer knows
+     * its width, or for a span that resolves to no visible column.
+     */
+    zoomToRegion(region: Region): void;
     /**
      * #action
      */
@@ -1854,6 +2094,9 @@ declare function stateModelFactory(): import("@jbrowse/mobx-state-tree").IModelT
     showBranchLen: boolean;
     drawTree: boolean;
     drawNodeBubbles: boolean;
+    drawNodeLabels: boolean;
+    showTreeOverview: boolean;
+    overviewHeight: number;
     autoTreeAreaWidth: boolean;
     columnTracks: ColumnTrackSpec[];
     id: string;
@@ -1865,6 +2108,7 @@ declare function stateModelFactory(): import("@jbrowse/mobx-state-tree").IModelT
     type: "MsaView";
     drawMsaLetters: boolean;
     scrollZoom: boolean;
+    scrollZoomAxis: "both" | "horizontal" | "vertical";
     height: number;
     rowHeight: number;
     scrollY: number;
@@ -1954,11 +2198,15 @@ declare function stateModelFactory(): import("@jbrowse/mobx-state-tree").IModelT
     collapsed: string[];
     showOnly: string | undefined;
     turnedOffTracks: import("mobx").IKeyValueMap<boolean>;
+    trackHeights: import("mobx").IKeyValueMap<number>;
     residueMappings: ResidueMapping[];
     turnedOffFeatures: import("mobx").IKeyValueMap<boolean>;
     relativeTo: string | undefined;
     highlightColumns: number[] | undefined;
     highlights: Highlight[];
+    clades: Clade[];
+    encodings: Encoding[];
+    rowPanels: RowPanelSpec[];
     data: {
         tree?: string | undefined;
         msa?: string | undefined;
@@ -1977,6 +2225,9 @@ declare function stateModelFactory(): import("@jbrowse/mobx-state-tree").IModelT
     showBranchLen: boolean;
     drawTree: boolean;
     drawNodeBubbles: boolean;
+    drawNodeLabels: boolean;
+    showTreeOverview: boolean;
+    overviewHeight: number;
     autoTreeAreaWidth: boolean;
     columnTracks?: undefined;
     id: string;
@@ -1988,6 +2239,7 @@ declare function stateModelFactory(): import("@jbrowse/mobx-state-tree").IModelT
     type: "MsaView";
     drawMsaLetters: boolean;
     scrollZoom: boolean;
+    scrollZoomAxis: "both" | "horizontal" | "vertical";
     height: number;
     rowHeight: number;
     scrollY: number;
@@ -2077,11 +2329,15 @@ declare function stateModelFactory(): import("@jbrowse/mobx-state-tree").IModelT
     collapsed: string[];
     showOnly: string | undefined;
     turnedOffTracks: import("mobx").IKeyValueMap<boolean>;
+    trackHeights: import("mobx").IKeyValueMap<number>;
     residueMappings: ResidueMapping[];
     turnedOffFeatures: import("mobx").IKeyValueMap<boolean>;
     relativeTo: string | undefined;
     highlightColumns: number[] | undefined;
     highlights: Highlight[];
+    clades: Clade[];
+    encodings: Encoding[];
+    rowPanels: RowPanelSpec[];
     data: {
         tree?: string | undefined;
         msa?: string | undefined;