jbrowse-plugin-msaview 5.4.0 → 5.6.0

package/dist/MsaViewPanel/afterCreateAutoruns.d.ts

@@ -57,3 +57,4 @@ export declare function syncGenomeHoverToMsaColumn(self: JBrowsePluginMsaViewMod
  */
 export declare function observeProteinHighlights(self: JBrowsePluginMsaViewModel): () => void;
 export declare function runCleanup(): void;
+export declare function showDomainsOnGenomeIfAsked(self: JBrowsePluginMsaViewModel): void;

package/dist/MsaViewPanel/afterCreateAutoruns.js

@@ -390,3 +390,11 @@ export function runCleanup() {
         console.error('Failed to cleanup old MSA data:', e);
     });
 }
+export function showDomainsOnGenomeIfAsked(self) {
+    if (self.domainsOnGenome &&
+        self.connectedView &&
+        self.connectedDomains.features.length > 0) {
+        self.showDomainsOnGenome();
+        self.setDomainsOnGenome(false);
+    }
+}

package/dist/MsaViewPanel/connectedDomains.d.ts

@@ -0,0 +1,58 @@
+import type { GenomeRegion, SeqPosModel } from './msaCoordToGenomeCoord';
+import type { Annotation } from 'react-msaview';
+export type DomainKind = 'domain' | 'site';
+/** One accession the alignment draws on the query row. */
+export interface ConnectedDomain {
+    /** the label the alignment's legend shows for the accession */
+    name: string;
+    accession: string;
+    /**
+     * `site` for a set of functional residues (a CDD Site, a GFF `*_site`),
+     * `domain` for anything else
+     */
+    kind: DomainKind;
+    /**
+     * 0-based half-open, ascending, contiguous bases merged: one region per exon
+     * piece of a domain, or per run of a site's scattered residues, in the
+     * transcript's refName spelling
+     */
+    regions: GenomeRegion[];
+}
+/** A categorical color object, spelt as a JBrowse display's `color` config. */
+export interface DomainColor {
+    field: 'accession';
+    domain: string[];
+    range: string[];
+    labels: string[];
+}
+export interface ConnectedDomains {
+    /** largest first by residues covered */
+    features: ConnectedDomain[];
+    color: DomainColor;
+}
+/**
+ * `site` for CDD's GenPept `Site` key, a Sequence Ontology `*_site` type,
+ * InterPro's `Binding_site`, `Active_site` and `Conserved_site`, and UniProt's
+ * spelled-out `Binding site`
+ */
+export declare function annotationKind(featureType: string | undefined): DomainKind;
+export interface DomainSource extends SeqPosModel {
+    showDomains: boolean;
+    querySeqName: string;
+    annotationsByRow: Record<string, Annotation[]>;
+    annotationTypes: Map<string, Annotation>;
+    featureColors: Map<Annotation, {
+        fill: string;
+    }>;
+}
+/**
+ * The genome regions under the query row's residues `positions`, 0-based
+ * ungapped.
+ */
+export declare function residuesToGenomeRegions(model: SeqPosModel, positions: Iterable<number>): GenomeRegion[];
+/**
+ * The query row's domains as the alignment shows them, one per accession, so
+ * a CDD site's scattered residues are one feature. Empty while the domain
+ * overlay is off.
+ */
+export declare function connectedDomains(model: DomainSource): ConnectedDomains;

package/dist/MsaViewPanel/connectedDomains.js

@@ -0,0 +1,101 @@
+/**
+ * The query row's domains on the genome, as data plus one color object. A
+ * cross-plugin contract: jbrowse-plugin-protein3d reads it off the view.
+ *
+ * In grammar-of-graphics terms, `features` is the data and `kind` the field a
+ * consumer filters its layers on (protein3d draws `domain` as cartoon and
+ * `site` as side chains). `color` is the color channel: a categorical scale
+ * over `accession`, whose `domain` lists the accessions, `range` the fills
+ * the alignment draws them in, and `labels` what a guide (a legend) names
+ * them. Every surface reads that one object: the genome track's display, the
+ * structure's layers, its overview rows and each legend.
+ */
+import { seqPosToGenomeRegions } from './msaCoordToGenomeCoord';
+/**
+ * `site` for CDD's GenPept `Site` key, a Sequence Ontology `*_site` type,
+ * InterPro's `Binding_site`, `Active_site` and `Conserved_site`, and UniProt's
+ * spelled-out `Binding site`
+ */
+export function annotationKind(featureType) {
+    return featureType && /(^|[_ ])site$/i.test(featureType) ? 'site' : 'domain';
+}
+function mergeAdjacent(regions) {
+    const merged = [];
+    for (const region of regions.toSorted((a, b) => a.start - b.start)) {
+        const last = merged.at(-1);
+        if (last && last.refName === region.refName && region.start <= last.end) {
+            last.end = Math.max(last.end, region.end);
+        }
+        else {
+            merged.push({ ...region });
+        }
+    }
+    return merged;
+}
+/**
+ * The genome regions under the query row's residues `positions`, 0-based
+ * ungapped.
+ */
+export function residuesToGenomeRegions(model, positions) {
+    const pieces = [];
+    for (const pos of positions) {
+        pieces.push(...seqPosToGenomeRegions(model, pos));
+    }
+    return mergeAdjacent(pieces);
+}
+/**
+ * The query row's domains as the alignment shows them, one per accession, so
+ * a CDD site's scattered residues are one feature. Empty while the domain
+ * overlay is off.
+ */
+export function connectedDomains(model) {
+    const byAccession = new Map();
+    if (model.showDomains) {
+        for (const annotation of model.annotationsByRow[model.querySeqName] ?? []) {
+            const list = byAccession.get(annotation.accession);
+            if (list) {
+                list.push(annotation);
+            }
+            else {
+                byAccession.set(annotation.accession, [annotation]);
+            }
+        }
+    }
+    const placed = [...byAccession]
+        .flatMap(([accession, annotations]) => {
+        // annotations count residues 1-based inclusive
+        const positions = new Set();
+        for (const { start, end } of annotations) {
+            for (let pos = start - 1; pos < end; pos++) {
+                positions.add(pos);
+            }
+        }
+        const first = annotations[0];
+        const fill = model.featureColors.get(first)?.fill;
+        const regions = residuesToGenomeRegions(model, positions);
+        return fill && regions.length > 0
+            ? [
+                {
+                    feature: {
+                        name: model.annotationTypes.get(accession)?.name ?? first.name,
+                        accession,
+                        kind: annotationKind(first.featureType),
+                        regions,
+                    },
+                    fill,
+                    residues: positions.size,
+                },
+            ]
+            : [];
+    })
+        .toSorted((a, b) => b.residues - a.residues);
+    return {
+        features: placed.map(p => p.feature),
+        color: {
+            field: 'accession',
+            domain: placed.map(p => p.feature.accession),
+            range: placed.map(p => p.fill),
+            labels: placed.map(p => p.feature.name),
+        },
+    };
+}

package/dist/MsaViewPanel/connectedDomains.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/MsaViewPanel/connectedDomains.test.js

@@ -0,0 +1,147 @@
+import { genomeToTranscriptSeqMapping } from 'g2p_mapper';
+import { describe, expect, test } from 'vitest';
+import { annotationKind, connectedDomains } from './connectedDomains';
+// five codons read from 207 down: 207-205, 204-202, 201-200 then 106 across
+// the intron, 105-103, 102-100
+const reverseTranscript = genomeToTranscriptSeqMapping({
+    refName: 'chr1',
+    strand: -1,
+    start: 100,
+    end: 208,
+    subfeatures: [
+        { refName: 'chr1', type: 'CDS', start: 100, end: 107, phase: 0 },
+        { refName: 'chr1', type: 'CDS', start: 200, end: 208, phase: 0 },
+    ],
+});
+function annotation(accession, start, end, id = 'QUERY') {
+    return {
+        id,
+        accession,
+        name: `name ${accession}`,
+        description: '',
+        start,
+        end,
+    };
+}
+function source(annotations, overrides = {}) {
+    return {
+        showDomains: true,
+        querySeqName: 'QUERY',
+        transcriptToMsaMap: reverseTranscript,
+        annotationsByRow: Object.groupBy(annotations, a => a.id),
+        annotationTypes: new Map(annotations.map(a => [
+            a.accession,
+            { ...a, name: `legend ${a.accession}` },
+        ])),
+        featureColors: new Map(annotations.map(a => [a, { fill: `fill-${a.accession}` }])),
+        ...overrides,
+    };
+}
+describe('connectedDomains on a reverse-strand transcript', () => {
+    test('a domain crossing the exon boundary is one region per exon piece', () => {
+        expect(connectedDomains(source([annotation('site', 2, 4)]))).toEqual({
+            features: [
+                {
+                    name: 'legend site',
+                    accession: 'site',
+                    kind: 'domain',
+                    regions: [
+                        { refName: 'chr1', start: 103, end: 107 },
+                        { refName: 'chr1', start: 200, end: 205 },
+                    ],
+                },
+            ],
+            color: {
+                field: 'accession',
+                domain: ['site'],
+                range: ['fill-site'],
+                labels: ['legend site'],
+            },
+        });
+    });
+    test('the longest comes first, in the features and the color domain alike', () => {
+        const { features, color } = connectedDomains(source([annotation('site', 2, 4), annotation('domain', 1, 5)]));
+        expect(features.map(d => d.accession)).toEqual(['domain', 'site']);
+        expect(color.domain).toEqual(['domain', 'site']);
+        expect(color.range).toEqual(['fill-domain', 'fill-site']);
+        expect(features[0].regions).toEqual([
+            { refName: 'chr1', start: 100, end: 107 },
+            { refName: 'chr1', start: 200, end: 208 },
+        ]);
+    });
+    test('a scattered site is one entry, its residues merged where they touch', () => {
+        const { features } = connectedDomains(source([
+            annotation('small', 4, 5),
+            annotation('heme', 1, 1),
+            annotation('heme', 3, 3),
+            annotation('heme', 4, 4),
+        ]));
+        expect(features.map(d => d.accession)).toEqual(['heme', 'small']);
+        expect(features[0]).toEqual({
+            name: 'legend heme',
+            accession: 'heme',
+            kind: 'domain',
+            regions: [
+                { refName: 'chr1', start: 103, end: 107 },
+                { refName: 'chr1', start: 200, end: 202 },
+                { refName: 'chr1', start: 205, end: 208 },
+            ],
+        });
+    });
+    test('a trimmed query row shifts by querySeqOffset', () => {
+        const [domain] = connectedDomains(source([annotation('site', 1, 2)], { querySeqOffset: 1 })).features;
+        expect(domain.regions).toEqual([
+            { refName: 'chr1', start: 106, end: 107 },
+            { refName: 'chr1', start: 200, end: 205 },
+        ]);
+    });
+    test('residues past the transcript drop out, and a domain with none left', () => {
+        expect(connectedDomains(source([annotation('tail', 5, 9), annotation('off', 7, 9)])).features).toEqual([
+            expect.objectContaining({
+                accession: 'tail',
+                regions: [{ refName: 'chr1', start: 100, end: 103 }],
+            }),
+        ]);
+    });
+    test('only the query row, and nothing while the overlay is off', () => {
+        const annotations = [annotation('other', 1, 5, 'Mouse')];
+        expect(connectedDomains(source(annotations)).features).toEqual([]);
+        expect(connectedDomains(source([annotation('domain', 1, 5)], { showDomains: false }))).toEqual({
+            features: [],
+            color: { field: 'accession', domain: [], range: [], labels: [] },
+        });
+    });
+});
+test('a MAF row maps one base per residue', () => {
+    const [domain] = connectedDomains(source([annotation('d', 3, 6)], {
+        transcriptToMsaMap: undefined,
+        mafRegion: { refName: 'chr2', start: 50, end: 100, assemblyName: 'hg38' },
+    })).features;
+    expect(domain.regions).toEqual([{ refName: 'chr2', start: 52, end: 56 }]);
+});
+test('an entry is a site when its featureType names one', () => {
+    const { features } = connectedDomains(source([
+        { ...annotation('heme', 2, 2), featureType: 'Site' },
+        { ...annotation('globin', 1, 5), featureType: 'Region' },
+        annotation('gff', 1, 4),
+    ]));
+    expect(features.map(d => [d.accession, d.kind])).toEqual([
+        ['globin', 'domain'],
+        ['gff', 'domain'],
+        ['heme', 'site'],
+    ]);
+});
+test.each([
+    ['Site', 'site'],
+    ['binding_site', 'site'],
+    ['Active_site', 'site'],
+    ['Conserved_site', 'site'],
+    ['Binding site', 'site'],
+    ['Region', 'domain'],
+    ['protein_match', 'domain'],
+    ['Domain', 'domain'],
+    ['siteless', 'domain'],
+    [undefined, 'domain'],
+])('annotationKind(%s) is %s', (featureType, kind) => {
+    expect(annotationKind(featureType)).toBe(kind);
+});

package/dist/MsaViewPanel/domainTrack.d.ts

@@ -0,0 +1,84 @@
+import type { ConnectedDomains } from './connectedDomains';
+export declare function domainTrackId(viewId: string): string;
+/**
+ * A session FeatureTrack drawing `domains` on the genome: one feature per
+ * domain, one subfeature per region, so a domain spanning exons draws as boxes
+ * joined across the intron. The display's color is the domains' color object,
+ * a categorical scale over each feature's `accession`, so its key names each
+ * color with its domain.
+ */
+export declare function domainTrackConf({ viewId, assemblyName, name, strand, domains, }: {
+    viewId: string;
+    assemblyName: string;
+    name: string;
+    strand?: number;
+    domains: ConnectedDomains;
+}): {
+    type: string;
+    trackId: string;
+    name: string;
+    assemblyNames: string[];
+    adapter: {
+        type: string;
+        features: ({
+            type: string;
+            name: string;
+            accession: string;
+            subfeatures: ({
+                type: string;
+                strand?: undefined;
+                uniqueId: string;
+                refName: string;
+                start: number;
+                end: number;
+            } | {
+                type: string;
+                strand: number;
+                uniqueId: string;
+                refName: string;
+                start: number;
+                end: number;
+            })[];
+            strand?: undefined;
+            uniqueId: string;
+            refName: string;
+            start: number;
+            end: number;
+        } | {
+            type: string;
+            name: string;
+            accession: string;
+            subfeatures: ({
+                type: string;
+                strand?: undefined;
+                uniqueId: string;
+                refName: string;
+                start: number;
+                end: number;
+            } | {
+                type: string;
+                strand: number;
+                uniqueId: string;
+                refName: string;
+                start: number;
+                end: number;
+            })[];
+            strand: number;
+            uniqueId: string;
+            refName: string;
+            start: number;
+            end: number;
+        })[];
+    };
+    displays: {
+        type: string;
+        displayId: string;
+        color: {
+            title: string;
+            field: "accession";
+            domain: string[];
+            range: string[];
+            labels: string[];
+        };
+    }[];
+};

package/dist/MsaViewPanel/domainTrack.js

@@ -0,0 +1,51 @@
+export function domainTrackId(viewId) {
+    return `msaview-domains-${viewId}`;
+}
+/**
+ * A session FeatureTrack drawing `domains` on the genome: one feature per
+ * domain, one subfeature per region, so a domain spanning exons draws as boxes
+ * joined across the intron. The display's color is the domains' color object,
+ * a categorical scale over each feature's `accession`, so its key names each
+ * color with its domain.
+ */
+export function domainTrackConf({ viewId, assemblyName, name, strand, domains, }) {
+    const trackId = domainTrackId(viewId);
+    const stranded = strand === undefined ? {} : { strand };
+    return {
+        type: 'FeatureTrack',
+        trackId,
+        name,
+        assemblyNames: [assemblyName],
+        adapter: {
+            type: 'FromConfigAdapter',
+            features: domains.features.map(({ name, accession, regions }, i) => {
+                const uniqueId = `${trackId}-${i}`;
+                return {
+                    uniqueId,
+                    refName: regions[0].refName,
+                    start: Math.min(...regions.map(r => r.start)),
+                    end: Math.max(...regions.map(r => r.end)),
+                    ...stranded,
+                    type: 'protein_domain',
+                    name,
+                    accession,
+                    subfeatures: regions.map((r, j) => ({
+                        uniqueId: `${uniqueId}-${j}`,
+                        refName: r.refName,
+                        start: r.start,
+                        end: r.end,
+                        ...stranded,
+                        type: 'protein_domain_part',
+                    })),
+                };
+            }),
+        },
+        displays: [
+            {
+                type: 'LinearBasicDisplay',
+                displayId: `${trackId}-LinearBasicDisplay`,
+                color: { ...domains.color, title: 'Domains' },
+            },
+        ],
+    };
+}

package/dist/MsaViewPanel/domainTrack.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/MsaViewPanel/domainTrack.test.js

@@ -0,0 +1,69 @@
+import { expect, test } from 'vitest';
+import { domainTrackConf } from './domainTrack';
+const domains = {
+    features: [
+        {
+            name: 'Hb beta-like',
+            accession: 'cd1',
+            kind: 'domain',
+            regions: [
+                { refName: 'chr11', start: 100, end: 107 },
+                { refName: 'chr11', start: 200, end: 208 },
+            ],
+        },
+        {
+            name: 'heme binding site',
+            accession: 'cd2',
+            kind: 'site',
+            regions: [{ refName: 'chr11', start: 103, end: 107 }],
+        },
+    ],
+    color: {
+        field: 'accession',
+        domain: ['cd1', 'cd2'],
+        range: ['#1b9e77', '#d95f02'],
+        labels: ['Hb beta-like', 'heme binding site'],
+    },
+};
+const conf = domainTrackConf({
+    viewId: 'msa1',
+    assemblyName: 'hg38',
+    name: 'HBB domains (from the alignment)',
+    strand: -1,
+    domains,
+});
+test('one feature per domain, one subfeature per region, spanning them all', () => {
+    const [first] = conf.adapter.features;
+    expect(conf.trackId).toBe('msaview-domains-msa1');
+    expect(conf.adapter.features).toHaveLength(2);
+    expect(first).toMatchObject({
+        refName: 'chr11',
+        start: 100,
+        end: 208,
+        strand: -1,
+        name: 'Hb beta-like',
+        accession: 'cd1',
+    });
+    expect(first.subfeatures.map(s => [s.start, s.end])).toEqual([
+        [100, 107],
+        [200, 208],
+    ]);
+});
+test('the display paints through the domains color object and names each in the key', () => {
+    expect(conf.displays[0].color).toEqual({
+        field: 'accession',
+        domain: ['cd1', 'cd2'],
+        range: ['#1b9e77', '#d95f02'],
+        labels: ['Hb beta-like', 'heme binding site'],
+        title: 'Domains',
+    });
+});
+test('a MAF view knows no strand, and the features carry none', () => {
+    const unstranded = domainTrackConf({
+        viewId: 'msa1',
+        assemblyName: 'hg38',
+        name: 'x',
+        domains,
+    });
+    expect('strand' in unstranded.adapter.features[0]).toBe(false);
+});

package/dist/MsaViewPanel/loadProteinDomains.js

@@ -11,12 +11,13 @@ export async function loadProteinDomains(self, signal) {
         throw new Error('No NCBI accessions found in alignment rows');
     }
     const byAccession = await fetchProteinDomains(rowAccessions.map(r => r.accession), signal);
-    const annotations = rowAccessions.flatMap(({ rowName, accession }) => (byAccession.get(accession) ?? []).flatMap(({ signature, locations }) => signature.entry
+    const annotations = rowAccessions.flatMap(({ rowName, accession }) => (byAccession.get(accession) ?? []).flatMap(({ signature, locations, featureType }) => signature.entry
         ? locations.map(({ start, end }) => ({
             id: rowName,
             accession: signature.entry.accession,
             name: signature.entry.name,
             description: signature.entry.description,
+            featureType,
             start,
             end,
         }))

package/dist/MsaViewPanel/loadProteinDomains.test.js

@@ -7,6 +7,7 @@ const MATCH = {
         entry: { accession: 'cd00093', name: 'HTH_XRE', description: 'a domain' },
     },
     locations: [{ start: 5, end: 40 }],
+    featureType: 'Region',
 };
 function model(treeMetadata) {
     return {
@@ -27,6 +28,7 @@ test('an accession row becomes one annotation per location, keyed by row name',
             accession: 'cd00093',
             name: 'HTH_XRE',
             description: 'a domain',
+            featureType: 'Region',
             start: 5,
             end: 40,
         },

package/dist/MsaViewPanel/model.d.ts

@@ -1,6 +1,7 @@
 export type { MSAFormat } from 'msa-parsers';
 import type { BlastDatabase, MsaAlgorithm, PhmmerDatabase } from '../LaunchMsaView/components/BlastQuery/consts';
 import type { UnirefIdentity } from '../utils/unirefHomologs';
+import type { ConnectedDomains } from './connectedDomains';
 import type { MsaDataPayload } from './msaDataStore';
 import type { MafRegion, MsaViewInitState } from './types';
 import type { TranscriptRef } from './util';
@@ -497,7 +498,7 @@ export default function stateModelFactory(): import("@jbrowse/mobx-state-tree").
     clades: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").IArrayType<import("@jbrowse/mobx-state-tree").IType<import("react-msaview").Clade, import("react-msaview").Clade, import("react-msaview").Clade>>, [undefined]>;
     encodings: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").IArrayType<import("@jbrowse/mobx-state-tree").IType<import("react-msaview").Encoding, import("react-msaview").Encoding, import("react-msaview").Encoding>>, [undefined]>;
     rowPanels: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").IArrayType<import("@jbrowse/mobx-state-tree").IType<import("react-msaview").RowPanelSpec, import("react-msaview").RowPanelSpec, import("react-msaview").RowPanelSpec>>, [undefined]>;
-}, "init" | "querySeqName" | "launchCompleted" | "embeddedMode" | "connectedViewId" | "connectedFeature" | "connectedTranscript" | "blastParams" | "orthologParams" | "querySeqOffset" | "uniprotId" | "zoomToBaseLevel" | "dataStoreId" | "mafRegion"> & {
+}, "init" | "querySeqName" | "launchCompleted" | "embeddedMode" | "connectedViewId" | "connectedFeature" | "connectedTranscript" | "blastParams" | "orthologParams" | "querySeqOffset" | "uniprotId" | "zoomToBaseLevel" | "dataStoreId" | "mafRegion" | "domainsOnGenome"> & {
     connectedViewId: import("@jbrowse/mobx-state-tree").IMaybe<import("@jbrowse/mobx-state-tree").ISimpleType<string>>;
     connectedFeature: import("@jbrowse/mobx-state-tree").IType<any, any, any>;
     connectedTranscript: import("@jbrowse/mobx-state-tree").IMaybe<import("@jbrowse/mobx-state-tree").ISimpleType<string>>;
@@ -512,6 +513,7 @@ export default function stateModelFactory(): import("@jbrowse/mobx-state-tree").
     launchCompleted: import("@jbrowse/mobx-state-tree").IType<boolean | undefined, boolean, boolean>;
     mafRegion: import("@jbrowse/mobx-state-tree").IType<MafRegion | undefined, MafRegion | undefined, MafRegion | undefined>;
     embeddedMode: import("@jbrowse/mobx-state-tree").IType<boolean | undefined, boolean, boolean>;
+    domainsOnGenome: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").ISimpleType<boolean>, [undefined]>;
 }, {
     width: number;
     bodyMounted: boolean;
@@ -979,6 +981,13 @@ export default function stateModelFactory(): import("@jbrowse/mobx-state-tree").
      * to draw the same highlights in its own display
      */
     readonly connectedHighlights: IRegion[];
+    /**
+     * #getter
+     * cross-plugin contract: the query row's domains on the genome, with
+     * the color object every surface paints them through.
+     * jbrowse-plugin-protein3d reads it to draw them on the structure
+     */
+    readonly connectedDomains: ConnectedDomains;
 } & {
     /**
      * #getter
@@ -1089,6 +1098,16 @@ export default function stateModelFactory(): import("@jbrowse/mobx-state-tree").
      * #action
      */
     setDomainsRequested(arg: boolean): void;
+    /**
+     * #action
+     */
+    setDomainsOnGenome(arg: boolean): void;
+    /**
+     * #action
+     * Add the query row's domains to the connected genome view as a session
+     * track, replacing the one an earlier call added.
+     */
+    showDomainsOnGenome(): void;
     /**
      * #action
      */
@@ -1510,7 +1529,7 @@ export default function stateModelFactory(): import("@jbrowse/mobx-state-tree").
     clades: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").IArrayType<import("@jbrowse/mobx-state-tree").IType<import("react-msaview").Clade, import("react-msaview").Clade, import("react-msaview").Clade>>, [undefined]>;
     encodings: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").IArrayType<import("@jbrowse/mobx-state-tree").IType<import("react-msaview").Encoding, import("react-msaview").Encoding, import("react-msaview").Encoding>>, [undefined]>;
     rowPanels: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").IArrayType<import("@jbrowse/mobx-state-tree").IType<import("react-msaview").RowPanelSpec, import("react-msaview").RowPanelSpec, import("react-msaview").RowPanelSpec>>, [undefined]>;
-}, "init" | "querySeqName" | "launchCompleted" | "embeddedMode" | "connectedViewId" | "connectedFeature" | "connectedTranscript" | "blastParams" | "orthologParams" | "querySeqOffset" | "uniprotId" | "zoomToBaseLevel" | "dataStoreId" | "mafRegion"> & {
+}, "init" | "querySeqName" | "launchCompleted" | "embeddedMode" | "connectedViewId" | "connectedFeature" | "connectedTranscript" | "blastParams" | "orthologParams" | "querySeqOffset" | "uniprotId" | "zoomToBaseLevel" | "dataStoreId" | "mafRegion" | "domainsOnGenome"> & {
     connectedViewId: import("@jbrowse/mobx-state-tree").IMaybe<import("@jbrowse/mobx-state-tree").ISimpleType<string>>;
     connectedFeature: import("@jbrowse/mobx-state-tree").IType<any, any, any>;
     connectedTranscript: import("@jbrowse/mobx-state-tree").IMaybe<import("@jbrowse/mobx-state-tree").ISimpleType<string>>;
@@ -1525,6 +1544,7 @@ export default function stateModelFactory(): import("@jbrowse/mobx-state-tree").
     launchCompleted: import("@jbrowse/mobx-state-tree").IType<boolean | undefined, boolean, boolean>;
     mafRegion: import("@jbrowse/mobx-state-tree").IType<MafRegion | undefined, MafRegion | undefined, MafRegion | undefined>;
     embeddedMode: import("@jbrowse/mobx-state-tree").IType<boolean | undefined, boolean, boolean>;
+    domainsOnGenome: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").ISimpleType<boolean>, [undefined]>;
 }>, "id" | "type" | "drawLabels" | "drawNodeBubbles" | "drawNodeLabels" | "drawTree" | "labelsAlignRight" | "overviewHeight" | "showBranchLen" | "showTreeOverview" | "treeAreaWidth" | "treeOrder" | "treeWidth" | "bgColor" | "colorSchemeName" | "customColorScheme" | "msaFormat" | "showColumnStats" | "allowedGappyness" | "clades" | "colWidth" | "collapsed" | "columnTracks" | "currentAlignment" | "data" | "drawMsaLetters" | "encodings" | "features" | "gffFilehandle" | "height" | "hideGaps" | "highlightColumns" | "highlights" | "msaFilehandle" | "region" | "relativeTo" | "residueMappings" | "rotated" | "rowHeight" | "rowPanels" | "scrollX" | "scrollY" | "scrollZoom" | "scrollZoomAxis" | "selection" | "showDomainLegend" | "showDomains" | "showOnly" | "subFeatureRows" | "trackHeights" | "treeFilehandle" | "treeMetadataFilehandle" | "treeRoot" | "turnedOffFeatures" | "turnedOffTracks"> & ({
     bgColor: boolean;
     colorSchemeName: string;