jbrowse-plugin-msaview 3.5.0 → 3.7.0

package/dist/LaunchMsaView/components/PreLoadedMSA/PreLoadedMSADataPanel.js

@@ -1,31 +1,34 @@
-import React, { useState } from 'react';
+import React, { useMemo, useState } from 'react';
 import { LoadingEllipses, SanitizedHTML } from '@jbrowse/core/ui';
 import { getEnv, getSession } from '@jbrowse/core/util';
-import { MenuItem } from '@mui/material';
+import { MenuItem, Typography } from '@mui/material';
 import { observer } from 'mobx-react';
 import { makeStyles } from 'tss-react/mui';
 import TextField2 from '../../../components/TextField2';
 import { useFetch } from '../../../utils/useFetch';
-import { getGeneDisplayName, getLinearGenomeView } from '../../util';
+import { resolveQueryRowName, useQueryRowName } from '../../useQueryRowName';
+import { getGeneDisplayName, getLinearGenomeView, getTranscriptDisplayName, } from '../../util';
 import LaunchPanelContent from '../LaunchPanelContent';
+import QueryRowSelector from '../QueryRowSelector';
+import SequenceStatusMessage from '../SequenceStatus';
 import SubmitCancelActions from '../SubmitCancelActions';
 import TranscriptSelector from '../TranscriptSelector';
+import { launchConnectedView, useLaunchSubmit } from '../launchConnectedView';
 import { useTranscriptSelection } from '../useTranscriptSelection';
 import { fetchMSA, fetchMSAList } from './fetchMSAData';
-import { preCalculatedLaunchView } from './preCalculatedLaunchView';
 import { readMsaDatasets } from './types';
 const useStyles = makeStyles()({
     selectedContainer: {
         marginTop: 50,
     },
 });
-const PreLoadedMSA = observer(function ({ model, feature, handleClose, }) {
+const PreLoadedMSA = observer(function ({ model, feature, handleClose, preferredTranscriptId, }) {
     const session = getSession(model);
     const view = getLinearGenomeView(model);
     const { classes } = useStyles();
     const { pluginManager } = getEnv(model);
     const { assemblyNames } = view;
-    const [viewError, setViewError] = useState();
+    const { launchError, submit } = useLaunchSubmit(handleClose);
     const datasets = readMsaDatasets(session.jbrowse);
     const [selectedDatasetId, setSelectedDatasetId] = useState(datasets?.[0]?.datasetId);
     const selectedDataset = datasets?.find(d => d.datasetId === selectedDatasetId);
@@ -34,8 +37,9 @@ const PreLoadedMSA = observer(function ({ model, feature, handleClose, }) {
         feature,
         view,
         validIds: msaList,
+        preferredTranscriptId,
     });
-    const { selectedId, selectedTranscript } = transcriptSelection;
+    const { selectedId, selectedTranscript, proteinSequence, sequenceStatus } = transcriptSelection;
     const { data: msaData, isLoading: msaDataLoading, error: msaDataFetchError, } = useFetch(selectedId && selectedDataset && msaList
         ? `${selectedDataset.datasetId}-${selectedId}-msa`
         : null, () => fetchMSA({
@@ -43,41 +47,60 @@ const PreLoadedMSA = observer(function ({ model, feature, handleClose, }) {
         config: selectedDataset.adapter,
         pluginManager,
     }));
+    const msaText = useMemo(() => msaData?.map(r => `>${r.get('refName')}\n${r.get('seq')}`).join('\n') ??
+        '', [msaData]);
+    // The dataset's row for this transcript used to be assumed -- the launch
+    // named `<transcriptId>_<assembly>` and hoped the file agreed. Nothing
+    // checked, and a name the alignment does not carry fails silently: the view
+    // opens, renders, and never navigates. The row is found by sequence instead,
+    // the same way the Manual tab finds it.
+    const queryRow = useQueryRowName(msaText, proteinSequence);
+    // The name this panel used to launch with unconditionally. A dataset built to
+    // that convention does carry the row, so it is worth falling back to when the
+    // residues do not match closely enough to find it -- but only when the
+    // alignment really has it, which is the check the old code never made.
+    const querySeqName = resolveQueryRowName(queryRow, `${selectedId}_${assemblyNames[0] ?? ''}`);
     const e = msaListFetchError ??
         msaDataFetchError ??
         transcriptSelection.error ??
-        viewError;
+        launchError;
     return (React.createElement(React.Fragment, null,
         React.createElement(LaunchPanelContent, { error: e },
             React.createElement(TextField2, { select: true, label: "Select MSA dataset", value: selectedDatasetId, onChange: event => {
                     setSelectedDatasetId(event.target.value);
                 } }, datasets?.map(d => (React.createElement(MenuItem, { key: d.datasetId, value: d.datasetId }, d.name)))),
             selectedDataset ? (React.createElement("div", { className: classes.selectedContainer },
-                !msaListLoading && msaDataLoading ? (React.createElement(LoadingEllipses, { variant: "h6", message: `Loading MSA for (${selectedId})` })) : null,
+                !msaListLoading && msaDataLoading ? (React.createElement(LoadingEllipses, { variant: "h6", message: `Loading MSA for ${getTranscriptDisplayName(selectedTranscript) || selectedId}` })) : null,
                 msaListLoading ? (React.createElement(LoadingEllipses, { variant: "h6", message: `Loading available MSAs for (${selectedDataset.name})` })) : null,
                 msaList ? (React.createElement("div", null,
                     React.createElement(SanitizedHTML, { html: selectedDataset.description }),
-                    React.createElement(TranscriptSelector, { feature: feature, ...transcriptSelection }))) : null)) : null),
-        React.createElement(SubmitCancelActions, { model: model, submitDisabled: !selectedTranscript || !msaData?.length, onSubmit: () => {
-                try {
-                    if (selectedTranscript && msaData) {
-                        const querySeqName = `${selectedId}_${assemblyNames[0]}`;
-                        preCalculatedLaunchView({
-                            newViewTitle: getGeneDisplayName(selectedTranscript),
+                    React.createElement(TranscriptSelector, { feature: feature, ...transcriptSelection }),
+                    msaText ? (React.createElement(QueryRowSelector, { ...queryRow, querySeqName: querySeqName })) : null)) : null)) : null),
+        React.createElement(SubmitCancelActions, { model: model, hint: msaDataLoading ? (React.createElement(LoadingEllipses, { message: "Loading alignment" })) : !!msaData?.length && !querySeqName ? (React.createElement(Typography, { color: "textSecondary", variant: "body2" }, "no row matches this transcript")) : (React.createElement(SequenceStatusMessage, { status: sequenceStatus })), 
+            // launching without a query row opens a view that renders and then
+            // never navigates, which reads as a broken feature rather than a
+            // dataset that does not cover this gene
+            submitDisabled: !selectedTranscript || !msaData?.length || !querySeqName, onSubmit: placement => {
+                if (selectedTranscript && msaText) {
+                    submit(() => {
+                        launchConnectedView({
                             view,
-                            querySeqName,
                             feature: selectedTranscript,
-                            data: {
-                                msa: msaData
-                                    .map(r => `>${r.get('refName')}\n${r.get('seq')}`)
-                                    .join('\n'),
-                            },
+                            placement,
+                            displayName: getGeneDisplayName(selectedTranscript),
+                            treeAreaWidth: 200,
+                            treeWidth: 100,
+                            drawNodeBubbles: false,
+                            labelsAlignRight: true,
+                            showBranchLen: false,
+                            colWidth: 10,
+                            rowHeight: 12,
+                            colorSchemeName: 'percent_identity_dynamic',
+                            querySeqName,
+                            querySeqOffset: queryRow.querySeqOffset,
+                            data: { msa: msaText },
                         });
-                        handleClose();
-                    }
-                }
-                catch (e) {
-                    setViewError(e);
+                    });
                 }
             }, onCancel: handleClose })));
 });

package/dist/LaunchMsaView/components/SequenceStatus.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+export type SequenceStatus = 'loading' | 'ready' | 'missing' | 'error';
+/**
+ * Why Submit is grey. The query row is the selected transcript's translation,
+ * and fetching and translating it takes a round trip to the sequence adapter,
+ * so the button starts disabled on every panel — with nothing to distinguish
+ * "wait a moment" from "this gene has no protein and never will".
+ *
+ * An error says so through the panel's own ErrorMessage, so this stays quiet
+ * for that one rather than saying it twice.
+ */
+export default function SequenceStatusMessage({ status, }: {
+    status: SequenceStatus;
+}): React.JSX.Element | null;

package/dist/LaunchMsaView/components/SequenceStatus.js

@@ -0,0 +1,15 @@
+import React from 'react';
+import { LoadingEllipses } from '@jbrowse/core/ui';
+import { Typography } from '@mui/material';
+/**
+ * Why Submit is grey. The query row is the selected transcript's translation,
+ * and fetching and translating it takes a round trip to the sequence adapter,
+ * so the button starts disabled on every panel — with nothing to distinguish
+ * "wait a moment" from "this gene has no protein and never will".
+ *
+ * An error says so through the panel's own ErrorMessage, so this stays quiet
+ * for that one rather than saying it twice.
+ */
+export default function SequenceStatusMessage({ status, }) {
+    return status === 'loading' ? (React.createElement(LoadingEllipses, { message: "Translating transcript" })) : status === 'missing' ? (React.createElement(Typography, { color: "textSecondary", variant: "body2" }, "no coding sequence to align")) : null;
+}

package/dist/LaunchMsaView/components/SubmitCancelActions.d.ts

@@ -1,9 +1,13 @@
 import React from 'react';
+import type { MsaViewPlacement } from '../../utils/workspaces';
 import type { AbstractTrackModel } from '@jbrowse/core/util';
-export default function SubmitCancelActions({ onSubmit, onCancel, submitDisabled, submitLabel, cancelLabel, model, }: {
-    onSubmit: () => void;
+export default function SubmitCancelActions({ onSubmit, onCancel, submitDisabled, hint, submitLabel, cancelLabel, model, }: {
+    /** handed the placement the box states, so no launch re-reads storage */
+    onSubmit: (placement: MsaViewPlacement) => void;
     onCancel: () => void;
     submitDisabled?: boolean;
+    /** why Submit is grey, shown beside it */
+    hint?: React.ReactNode;
     submitLabel?: string;
     cancelLabel?: string;
     /** omitted by a panel that submits something other than a view launch */

package/dist/LaunchMsaView/components/SubmitCancelActions.js

@@ -1,7 +1,8 @@
-import React, { useState } from 'react';
+import React from 'react';
 import { getSession } from '@jbrowse/core/util';
 import { Button, Checkbox, DialogActions, FormControlLabel, } from '@mui/material';
 import { readLaunchPlacement, sessionSupportsPlacement, writeLaunchPlacement, } from '../../utils/workspaces';
+import { useLaunchPlacement } from './launchPlacement';
 /**
  * Where the launch puts the view, offered wherever a launch is submitted.
  *
@@ -13,21 +14,35 @@ import { readLaunchPlacement, sessionSupportsPlacement, writeLaunchPlacement, }
  * release that places views its own way — because the box would do nothing
  * there and every launch would quietly ignore it.
  */
-function PlacementToggle({ model }) {
-    const session = getSession(model);
-    const [sideBySide, setSideBySide] = useState(() => readLaunchPlacement() === 'splitRight');
-    return sessionSupportsPlacement(session) ? (React.createElement(FormControlLabel, { label: "Open beside the genome view", control: React.createElement(Checkbox, { checked: sideBySide, onChange: event => {
-                const { checked } = event.target;
-                setSideBySide(checked);
-                writeLaunchPlacement(checked ? 'splitRight' : 'stack');
-            } }) })) : null;
+function PlacementToggle({ checked, onChange, }) {
+    return (React.createElement(FormControlLabel, { label: "Open beside the genome view", control: React.createElement(Checkbox, { checked: checked, onChange: event => {
+                onChange(event.target.checked);
+            } }) }));
 }
-export default function SubmitCancelActions({ onSubmit, onCancel, submitDisabled, submitLabel = 'Submit', cancelLabel = 'Cancel', model, }) {
+export default function SubmitCancelActions({ onSubmit, onCancel, submitDisabled, hint, submitLabel = 'Submit', cancelLabel = 'Cancel', model, }) {
+    const [sideBySide, setSideBySide] = useLaunchPlacement();
+    // The stored value is what the next dialog opens on, so it is written on
+    // submit rather than on the click: a dialog the user backed out of must not
+    // move where every future launch lands.
+    const offerPlacement = !!model && sessionSupportsPlacement(getSession(model));
     return (React.createElement(DialogActions, { sx: { flexWrap: 'wrap', rowGap: 1 } },
-        model ? React.createElement(PlacementToggle, { model: model }) : null,
-        React.createElement("div", { style: { display: 'flex', gap: 8, marginLeft: 'auto' } },
+        offerPlacement ? (React.createElement(PlacementToggle, { checked: sideBySide, onChange: setSideBySide })) : null,
+        React.createElement("div", { style: {
+                display: 'flex',
+                alignItems: 'center',
+                gap: 8,
+                marginLeft: 'auto',
+            } },
+            hint,
             React.createElement(Button, { sx: { flexShrink: 0 }, color: "primary", variant: "contained", disabled: submitDisabled, onClick: () => {
-                    onSubmit();
+                    if (offerPlacement) {
+                        const placement = sideBySide ? 'splitRight' : 'stack';
+                        writeLaunchPlacement(placement);
+                        onSubmit(placement);
+                    }
+                    else {
+                        onSubmit(readLaunchPlacement());
+                    }
                 } }, submitLabel),
             React.createElement(Button, { sx: { flexShrink: 0 }, color: "secondary", variant: "contained", onClick: () => {
                     onCancel();

package/dist/LaunchMsaView/components/SubmitCancelActions.test.js

@@ -4,6 +4,7 @@ import { cleanup, render, screen } from '@testing-library/react';
 import { afterEach, beforeEach, expect, test, vi } from 'vitest';
 import { LAUNCH_PLACEMENT_KEY } from '../../utils/workspaces';
 import SubmitCancelActions from './SubmitCancelActions';
+import { LaunchPlacementProvider } from './launchPlacement';
 // getSession walks the MST tree, and this component only wants the two actions
 // off the far end of that walk
 vi.mock('@jbrowse/core/util', () => ({
@@ -39,14 +40,61 @@ test('a panel that launches nothing passes no model, and gets no box', () => {
     render(React.createElement(SubmitCancelActions, { onSubmit: () => { }, onCancel: () => { } }));
     expect(toggle()).toBeNull();
 });
-test('clicking it writes the placement the next launch will read', () => {
-    render(React.createElement(SubmitCancelActions, { model: trackModel(tiling), onSubmit: () => { }, onCancel: () => { } }));
+test('submitting hands the launch the placement and remembers it', () => {
+    const onSubmit = vi.fn();
+    render(React.createElement(SubmitCancelActions, { model: trackModel(tiling), onSubmit: onSubmit, onCancel: () => { } }));
     toggle().click();
-    expect(localStorage.getItem(LAUNCH_PLACEMENT_KEY)).toBe('stack');
     expect(toggle().checked).toBe(false);
+    screen.getByText('Submit').click();
+    expect(onSubmit).toHaveBeenCalledWith('stack');
+    expect(localStorage.getItem(LAUNCH_PLACEMENT_KEY)).toBe('stack');
+});
+// an unticked box used to reach the launch only through storage, so a browser
+// refusing localStorage launched side by side anyway
+test('the box decides the launch even where storage throws', () => {
+    const onSubmit = vi.fn();
+    const setItem = vi
+        .spyOn(Storage.prototype, 'setItem')
+        .mockImplementation(() => {
+        throw new Error('SecurityError');
+    });
+    vi.spyOn(console, 'error').mockImplementation(() => { });
+    render(React.createElement(SubmitCancelActions, { model: trackModel(tiling), onSubmit: onSubmit, onCancel: () => { } }));
+    toggle().click();
+    screen.getByText('Submit').click();
+    expect(onSubmit).toHaveBeenCalledWith('stack');
+    setItem.mockRestore();
+});
+// the box is a property of this launch until it is launched; a dialog the user
+// backed out of should not have moved where every future one lands
+test('cancelling leaves the stored placement alone', () => {
+    render(React.createElement(SubmitCancelActions, { model: trackModel(tiling), onSubmit: () => { }, onCancel: () => { } }));
     toggle().click();
+    screen.getByText('Cancel').click();
+    expect(localStorage.getItem(LAUNCH_PLACEMENT_KEY)).toBeNull();
+});
+// a host with no tiling never shows the box, so submitting there must not
+// overwrite the choice the user made on a host that does
+test('a host that cannot tile writes nothing on submit', () => {
+    localStorage.setItem(LAUNCH_PLACEMENT_KEY, 'splitRight');
+    render(React.createElement(SubmitCancelActions, { model: trackModel({}), onSubmit: () => { }, onCancel: () => { } }));
+    screen.getByText('Submit').click();
     expect(localStorage.getItem(LAUNCH_PLACEMENT_KEY)).toBe('splitRight');
-    expect(toggle().checked).toBe(true);
+});
+// every visited tab stays mounted, so each has an actions row of its own; with
+// the answer held per row, ticking the box on one tab and submitting from
+// another wrote the other tab's stale one
+test('every tab in one dialog shares the answer', () => {
+    render(React.createElement(LaunchPlacementProvider, null,
+        React.createElement("div", { "data-testid": "tab-a" },
+            React.createElement(SubmitCancelActions, { model: trackModel(tiling), onSubmit: () => { }, onCancel: () => { } })),
+        React.createElement("div", { "data-testid": "tab-b" },
+            React.createElement(SubmitCancelActions, { model: trackModel(tiling), onSubmit: () => { }, onCancel: () => { }, submitLabel: "Launch" }))));
+    const boxes = screen.getAllByRole('checkbox');
+    boxes[0].click();
+    expect(boxes[1].checked).toBe(false);
+    screen.getByText('Launch').click();
+    expect(localStorage.getItem(LAUNCH_PLACEMENT_KEY)).toBe('stack');
 });
 test('a stored choice is what the box opens on', () => {
     localStorage.setItem(LAUNCH_PLACEMENT_KEY, 'stack');

package/dist/LaunchMsaView/components/TabPanel.js

@@ -1,5 +1,17 @@
-import React from 'react';
-// this is from MUI example
+import React, { useState } from 'react';
+// Once visited, a panel stays mounted and is hidden with the `hidden` attribute.
+// Unmounting it discarded whatever the user had typed and re-ran every fetch the
+// panel makes on the way back, so switching tabs to compare two of them cost an
+// EBI round trip and the pasted alignment.
+//
+// Lazy on first visit rather than mounted up front, because a panel mounts
+// fetches of its own: rendering all four on open would query the MSA dataset
+// adapter and the BLAST cache for tabs nobody looked at.
 export default function TabPanel({ children, value, index, ...other }) {
-    return (React.createElement("div", { role: "tabpanel", hidden: value !== index, ...other }, value === index ? children : null));
+    const active = value === index;
+    const [visited, setVisited] = useState(active);
+    if (active && !visited) {
+        setVisited(true);
+    }
+    return (React.createElement("div", { role: "tabpanel", hidden: !active, ...other }, visited || active ? children : null));
 }

package/dist/LaunchMsaView/components/TabPanel.test.d.ts

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

package/dist/LaunchMsaView/components/TabPanel.test.js

@@ -0,0 +1,36 @@
+// @vitest-environment jsdom
+import React from 'react';
+import { cleanup, render, screen } from '@testing-library/react';
+import { afterEach, expect, test, vi } from 'vitest';
+import TabPanel from './TabPanel';
+afterEach(() => {
+    cleanup();
+});
+function Panels({ value }) {
+    return (React.createElement(React.Fragment, null,
+        React.createElement(TabPanel, { value: value, index: "a" },
+            React.createElement(Probe, { name: "a" })),
+        React.createElement(TabPanel, { value: value, index: "b" },
+            React.createElement(Probe, { name: "b" }))));
+}
+const mounted = vi.fn();
+function Probe({ name }) {
+    React.useEffect(() => {
+        mounted(name);
+    }, [name]);
+    return React.createElement("input", { defaultValue: name });
+}
+test('a visited panel keeps its state while another tab is shown', () => {
+    const { rerender } = render(React.createElement(Panels, { value: "a" }));
+    const typed = screen.getByDisplayValue('a');
+    typed.value = 'edited';
+    rerender(React.createElement(Panels, { value: "b" }));
+    rerender(React.createElement(Panels, { value: "a" }));
+    expect(screen.getByDisplayValue('edited')).toBeTruthy();
+    expect(mounted.mock.calls.filter(([n]) => n === 'a')).toHaveLength(1);
+});
+test('an unvisited panel does not mount, so it fetches nothing', () => {
+    mounted.mockClear();
+    render(React.createElement(Panels, { value: "a" }));
+    expect(mounted.mock.calls.map(([n]) => n)).toEqual(['a']);
+});

package/dist/LaunchMsaView/components/TranscriptSelector.d.ts

@@ -1,11 +1,13 @@
 import React from 'react';
+import type { SequenceStatus } from './SequenceStatus';
 import type { Feature } from '@jbrowse/core/util';
-export default function TranscriptSelector({ feature, options, selectedId, selectedTranscript, setSelectedId, proteinSequence, validIds, }: {
+export default function TranscriptSelector({ feature, options, selectedId, selectedTranscript, setSelectedId, proteinSequence, sequenceStatus, validIds, }: {
     feature: Feature;
     options: Feature[];
     selectedId: string;
     selectedTranscript: Feature | undefined;
     setSelectedId: (transcriptId: string) => void;
     proteinSequence: string | undefined;
+    sequenceStatus?: SequenceStatus;
     validIds?: string[];
 }): React.JSX.Element;

package/dist/LaunchMsaView/components/TranscriptSelector.js

@@ -15,7 +15,7 @@ const useStyles = makeStyles()({
         marginLeft: 20,
     },
 });
-export default function TranscriptSelector({ feature, options, selectedId, selectedTranscript, setSelectedId, proteinSequence, validIds, }) {
+export default function TranscriptSelector({ feature, options, selectedId, selectedTranscript, setSelectedId, proteinSequence, sequenceStatus = 'ready', validIds, }) {
     const { classes } = useStyles();
     const [showSequence, setShowSequence] = useState(false);
     return (React.createElement(React.Fragment, null,
@@ -48,5 +48,7 @@ export default function TranscriptSelector({ feature, options, selectedId, selec
                     } }, showSequence ? 'Hide sequence' : 'Show sequence'))),
         showSequence ? (React.createElement(ReadOnlyTextField2, { value: proteinSequence
                 ? `>${getTranscriptDisplayName(selectedTranscript)}\n${proteinSequence}`
-                : 'Loading...' })) : null));
+                : sequenceStatus === 'missing'
+                    ? 'This transcript has no coding sequence, so there is nothing to translate.'
+                    : 'Loading...' })) : null));
 }

package/dist/LaunchMsaView/components/calculateProteinSequence.d.ts

@@ -1,9 +1,11 @@
 import type { Feat } from './types';
 import type { Feature } from '@jbrowse/core/util';
-export declare function calculateProteinSequence({ cds, sequence, geneticCodeId, }: {
+import type { TranslExcept } from '@jbrowse/core/util/geneticCodes';
+export declare function calculateProteinSequence({ cds, sequence, geneticCodeId, translExcept, }: {
     cds: Feat[];
     sequence: string;
     geneticCodeId?: number;
+    translExcept?: TranslExcept[];
 }): string;
 export declare function revlist(list: Feat[], seqlen: number): {
     start: number;
@@ -11,7 +13,15 @@ export declare function revlist(list: Feat[], seqlen: number): {
     type?: string;
     phase?: number;
 }[];
-export declare function getProteinSequenceFromFeature({ feature, seq, }: {
+/**
+ * The translation core's own feature panel shows: the contig's or the
+ * feature's genetic code, its alternative initiators, and any `transl_except`
+ * (RefSeq's selenocysteines), read off the transcript or its CDS as core does.
+ */
+export declare function getProteinSequenceFromFeature({ feature, seq, assemblyGeneticCodeId, }: {
     seq: string;
     feature: Feature;
+    /** the assembly's code for the feature's contig, `{ chrM: 2 }` in hub
+     * configs; a transl_table on the feature wins */
+    assemblyGeneticCodeId?: number;
 }): string;

package/dist/LaunchMsaView/components/calculateProteinSequence.js

@@ -1,26 +1,29 @@
-import { dedupe, revcom } from '@jbrowse/core/util';
+import { revcom } from '@jbrowse/core/util';
 import { convertCodingSequenceToPeptides } from '@jbrowse/core/util/convertCodingSequenceToPeptides';
-import { getGeneticCode, parseTranslTable } from './geneticCodes';
-// `@jbrowse/core/util/convertCodingSequenceToPeptides` is a deep path, so unlike
-// the `@jbrowse/core/util` barrel it is absent from ReExports and gets bundled
-// rather than resolved out of the host's JBrowseExports. That is what makes
-// reusing core's translation safe across every host a config names: this module
-// previously built its codon table at module scope from the barrel's
-// `defaultCodonTable`, and a core build that dropped that export turned it into
-// `Object.keys(undefined)` while the UMD was still evaluating -- the plugin
-// global was never assigned and PluginLoader error-paged the whole app.
-export function calculateProteinSequence({ cds, sequence, geneticCodeId, }) {
-    // `starts` is deliberately not passed: @jbrowse/core 4.3.0's signature has no
-    // such parameter, so alternative initiators (GTG under table 11, ATA under
-    // table 2) render as their internal residue rather than M. Core main added it;
-    // pass it here when msaview's @jbrowse/core floor reaches that release.
-    const { codonTable } = getGeneticCode(geneticCodeId);
+import { getGeneticCode, parseTranslTable, relativizeTranslExcept, } from '@jbrowse/core/util/geneticCodes';
+// `@jbrowse/core/util/convertCodingSequenceToPeptides` and
+// `@jbrowse/core/util/geneticCodes` are deep paths absent from ReExports, so
+// they are bundled rather than resolved out of the host's JBrowseExports: every
+// host runs the version this build installs. Importing translation from the
+// `@jbrowse/core/util` barrel instead is what error-paged the whole app when a
+// core build dropped `defaultCodonTable`.
+export function calculateProteinSequence({ cds, sequence, geneticCodeId, translExcept, }) {
+    const { codonTable, starts } = getGeneticCode(geneticCodeId);
     return convertCodingSequenceToPeptides({
         cds,
         sequence,
         codonTable,
+        starts,
+        translExcept,
     });
 }
+// The CDS list is sorted by start, so adjacent comparison is the whole job.
+function cdsId(feat) {
+    return `${feat.start}-${feat.end}`;
+}
+function dedupe(list) {
+    return list.filter((item, pos, ary) => !pos || cdsId(item) !== cdsId(ary[pos - 1]));
+}
 export function revlist(list, seqlen) {
     return list
         .map(sub => ({
@@ -30,8 +33,13 @@ export function revlist(list, seqlen) {
     }))
         .toSorted((a, b) => a.start - b.start);
 }
-export function getProteinSequenceFromFeature({ feature, seq, }) {
-    const { subfeatures, start, strand } = feature.toJSON();
+/**
+ * The translation core's own feature panel shows: the contig's or the
+ * feature's genetic code, its alternative initiators, and any `transl_except`
+ * (RefSeq's selenocysteines), read off the transcript or its CDS as core does.
+ */
+export function getProteinSequenceFromFeature({ feature, seq, assemblyGeneticCodeId, }) {
+    const { subfeatures, start, end, strand } = feature.toJSON();
     const cds = dedupe(subfeatures
         ?.toSorted((a, b) => a.start - b.start)
         .map(sub => ({
@@ -39,18 +47,25 @@ export function getProteinSequenceFromFeature({ feature, seq, }) {
         start: sub.start - start,
         end: sub.end - start,
     }))
-        .filter(subfeature => subfeature.type === 'CDS') ?? [], feat => `${feat.start}-${feat.end}`);
-    // a mitochondrial gene declares e.g. transl_table=2, so it translates with
-    // NCBI table 2 rather than the standard code. GFF3 usually carries the
-    // attribute on the CDS rather than the transcript, so check both.
+        .filter(subfeature => subfeature.type === 'CDS') ?? []);
     const cdsSubfeature = feature
         .get('subfeatures')
         ?.find((f) => f.get('type')?.toLowerCase() === 'cds');
     const geneticCodeId = parseTranslTable(feature.get('transl_table')) ??
-        parseTranslTable(cdsSubfeature?.get('transl_table'));
+        parseTranslTable(cdsSubfeature?.get('transl_table')) ??
+        assemblyGeneticCodeId;
+    const rawTranslExcept = feature.get('transl_except') ?? cdsSubfeature?.get('transl_except');
     return calculateProteinSequence({
         cds: strand === -1 ? revlist(cds, seq.length) : cds,
         sequence: strand === -1 ? revcom(seq) : seq,
         geneticCodeId,
+        translExcept: rawTranslExcept
+            ? relativizeTranslExcept({
+                raw: rawTranslExcept,
+                featureStart: start,
+                featureLength: end - start,
+                strand,
+            })
+            : undefined,
     });
 }

package/dist/LaunchMsaView/components/fetchSeq.d.ts

@@ -5,4 +5,7 @@ export declare function fetchSeq({ start, end, refName, session, assemblyName, }
     refName: string;
     assemblyName: string;
     session: AbstractSessionModel;
-}): Promise<string>;
+}): Promise<{
+    seq: string;
+    assemblyGeneticCodeId: number | undefined;
+}>;

package/dist/LaunchMsaView/components/fetchSeq.js

@@ -6,17 +6,27 @@ export async function fetchSeq({ start, end, refName, session, assemblyName, })
         throw new Error('assembly not found');
     }
     const sessionId = 'getSequence';
-    const feats = (await rpcManager.call(sessionId, 'CoreGetFeatures', {
+    // a named object keeps sessionId, which v4 hosts read from the args
+    const args = {
         adapterConfig: getConf(assembly, ['sequence', 'adapter']),
         sessionId,
         regions: [
             {
                 start,
                 end,
-                refName: assembly.getCanonicalRefName(refName),
+                refName: assembly.getCanonicalRefName(refName) ?? refName,
                 assemblyName,
             },
         ],
-    }));
-    return feats[0]?.get('seq') ?? '';
+    };
+    const feats = await rpcManager.call(sessionId, 'CoreGetFeatures', args);
+    return {
+        seq: feats[0]?.get('seq') ?? '',
+        // travels with the sequence because the caller needs both to translate, and
+        // resolving the assembly twice to get them is the shape that lost it
+        assemblyGeneticCodeId: geneticCodeId(assembly, refName),
+    };
+}
+function geneticCodeId(assembly, refName) {
+    return assembly.getGeneticCodeId?.(refName);
 }

package/dist/LaunchMsaView/components/launchConnectedView.d.ts

@@ -0,0 +1,23 @@
+import type { MsaViewPlacement } from '../../utils/workspaces';
+import type { Feature } from '@jbrowse/core/util';
+import type { LinearGenomeViewModel } from '@jbrowse/plugin-linear-genome-view';
+/** how a view whose alignment the plugin builds opens */
+export declare const builtAlignmentLook: {
+    drawNodeBubbles: boolean;
+    colWidth: number;
+    rowHeight: number;
+};
+/**
+ * Every dialog launch: an MSA view tied to the genome view it came from, and
+ * through `feature` to the transcript whose codons its query row is read by.
+ */
+export declare function launchConnectedView({ view, feature, placement, ...snapshot }: {
+    view: LinearGenomeViewModel;
+    feature?: Feature;
+    placement: MsaViewPlacement;
+} & Record<string, unknown>): void;
+/** runs a panel's launch, closing the dialog on success and keeping the error */
+export declare function useLaunchSubmit(handleClose: () => void): {
+    launchError: unknown;
+    submit: (launch: () => void) => void;
+};