jbrowse-plugin-msaview 3.0.0 → 3.2.0

package/dist/LaunchMsaView/components/BlastQuery/BlastAutomaticPanel.js

@@ -50,7 +50,7 @@ const BlastAutomaticPanel = observer(function ({ handleClose, feature, model, ch
                     React.createElement(Typography, null, "Previous BLAST Results")),
                 React.createElement(AccordionDetails, null,
                     React.createElement(CachedBlastResults, { model: model, handleClose: handleClose, feature: feature })))) : null),
-        React.createElement(SubmitCancelActions, { submitDisabled: !proteinSequence, onSubmit: () => {
+        React.createElement(SubmitCancelActions, { model: model, submitDisabled: !proteinSequence, onSubmit: () => {
                 try {
                     if (selectedTranscript) {
                         setLaunchViewError(undefined);

package/dist/LaunchMsaView/components/BlastQuery/BlastManualPanel.d.ts

@@ -1,5 +1,16 @@
 import React from 'react';
 import type { AbstractTrackModel, Feature } from '@jbrowse/core/util';
+/**
+ * The route to NCBI's `nr`, which no plugin version can query directly: NCBI
+ * stopped sending Access-Control-Allow-Origin to third-party origins, so the
+ * browser cannot read Blast.cgi at all (see docs/blast.md).
+ *
+ * That makes the round trip through NCBI's own site the whole feature rather
+ * than a fallback, so the panel walks it end to end. It used to hand the user a
+ * link, tell them to "paste the results into JBrowse", and offer only a Close
+ * button -- leaving them to find the Manual upload tab, re-pick the transcript
+ * they had already chosen here, and hand-type the row name.
+ */
 declare const BlastManualPanel: ({ handleClose, feature, model, children, }: {
     children: React.ReactNode;
     model: AbstractTrackModel;

package/dist/LaunchMsaView/components/BlastQuery/BlastManualPanel.js

@@ -1,45 +1,102 @@
-import React from 'react';
+import React, { useState } from 'react';
 import { shorten2 } from '@jbrowse/core/util';
-import { Button, DialogActions, Typography } from '@mui/material';
+import { Alert, Typography } from '@mui/material';
 import { observer } from 'mobx-react';
 import { makeStyles } from 'tss-react/mui';
 import { BASE_BLAST_URL } from './consts';
 import ExternalLink from '../../../components/ExternalLink';
-import { cleanProteinSequence, getLinearGenomeView } from '../../util';
+import TextField2 from '../../../components/TextField2';
+import { useQueryRowName } from '../../useQueryRowName';
+import { cleanProteinSequence, getGeneDisplayName, getLinearGenomeView, } from '../../util';
 import LaunchPanelContent from '../LaunchPanelContent';
+import { launchView } from '../ManualMSALoader/launchView';
+import QueryRowSelector from '../QueryRowSelector';
+import SubmitCancelActions from '../SubmitCancelActions';
 import TranscriptSelector from '../TranscriptSelector';
 import { useTranscriptSelection } from '../useTranscriptSelection';
 const useStyles = makeStyles()({
     ncbiLink: {
         wordBreak: 'break-all',
-        margin: 30,
-        maxWidth: 600,
     },
-    infoText: {
+    textAreaFont: {
+        fontFamily: 'Courier New',
+    },
+    msaInput: {
+        marginBottom: 20,
+    },
+    step: {
         marginTop: 20,
     },
+    stepBody: {
+        marginLeft: 20,
+        marginTop: 8,
+    },
 });
+/**
+ * The route to NCBI's `nr`, which no plugin version can query directly: NCBI
+ * stopped sending Access-Control-Allow-Origin to third-party origins, so the
+ * browser cannot read Blast.cgi at all (see docs/blast.md).
+ *
+ * That makes the round trip through NCBI's own site the whole feature rather
+ * than a fallback, so the panel walks it end to end. It used to hand the user a
+ * link, tell them to "paste the results into JBrowse", and offer only a Close
+ * button -- leaving them to find the Manual upload tab, re-pick the transcript
+ * they had already chosen here, and hand-type the row name.
+ */
 const BlastManualPanel = observer(function ({ handleClose, feature, model, children, }) {
     const { classes } = useStyles();
     const view = getLinearGenomeView(model);
+    const [launchViewError, setLaunchViewError] = useState();
+    const [msaText, setMsaText] = useState('');
+    const [treeText, setTreeText] = useState('');
     const transcriptSelection = useTranscriptSelection({ feature, view });
-    const { proteinSequence, error } = transcriptSelection;
+    const { proteinSequence, selectedTranscript, error } = transcriptSelection;
+    const queryRow = useQueryRowName(msaText, proteinSequence);
     const s2 = cleanProteinSequence(proteinSequence);
     // a link the user follows to NCBI's own site, not something we fetch — which
     // is exactly why this route still works when the automatic one cannot
     const link = `${BASE_BLAST_URL}?PAGE_TYPE=BlastSearch&PAGE=Proteins&PROGRAM=blastp&QUERY=${s2}`;
     const link2 = `${BASE_BLAST_URL}?PAGE_TYPE=BlastSearch&PAGE=Proteins&PROGRAM=blastp&QUERY=${shorten2(s2, 10)}`;
     return (React.createElement(React.Fragment, null,
-        React.createElement(LaunchPanelContent, { error: error },
+        React.createElement(LaunchPanelContent, { error: launchViewError ?? error },
             children,
             React.createElement(TranscriptSelector, { feature: feature, ...transcriptSelection }),
-            proteinSequence ? (React.createElement("div", { className: classes.ncbiLink },
-                "Link to NCBI BLAST: ",
-                React.createElement(ExternalLink, { href: link }, link2))) : null,
-            React.createElement(Typography, { className: classes.infoText }, "Click the link above and run your BLAST query, and once you have results, click \"Multiple Alignment\" at the top of the results page to be redirected to COBALT, NCBI's multiple sequence aligner. Once COBALT completes, you can download an MSA (.aln file) and optionally a Newick tree (.nh) and paste the results into JBrowse")),
-        React.createElement(DialogActions, null,
-            React.createElement(Button, { color: "primary", variant: "contained", onClick: () => {
-                    handleClose();
-                } }, "Close"))));
+            React.createElement("div", { className: classes.step },
+                React.createElement(Typography, { variant: "subtitle2" }, "1. Run the search at NCBI"),
+                React.createElement("div", { className: classes.stepBody }, proteinSequence ? (React.createElement("div", { className: classes.ncbiLink },
+                    React.createElement(ExternalLink, { href: link }, link2))) : (React.createElement(Alert, { severity: "info" }, "Pick a transcript above to get a link carrying its protein sequence.")))),
+            React.createElement("div", { className: classes.step },
+                React.createElement(Typography, { variant: "subtitle2" }, "2. Align the hits"),
+                React.createElement("div", { className: classes.stepBody },
+                    React.createElement(Typography, null, "On the results page click \"Multiple Alignment\" to run COBALT, NCBI's aligner. Download the alignment (.aln) and, if you want the tree drawn, the Newick tree (.nh)."))),
+            React.createElement("div", { className: classes.step },
+                React.createElement(Typography, { variant: "subtitle2" }, "3. Paste the results back here"),
+                React.createElement("div", { className: classes.stepBody },
+                    React.createElement(TextField2, { variant: "outlined", label: "Alignment", multiline: true, minRows: 5, maxRows: 10, fullWidth: true, className: classes.msaInput, slotProps: { input: { className: classes.textAreaFont } }, placeholder: "Paste the .aln contents here", value: msaText, onChange: event => {
+                            setMsaText(event.target.value);
+                        } }),
+                    React.createElement(TextField2, { variant: "outlined", label: "Tree (optional)", multiline: true, minRows: 3, maxRows: 10, fullWidth: true, slotProps: { input: { className: classes.textAreaFont } }, placeholder: "Paste the .nh Newick tree here", value: treeText, onChange: event => {
+                            setTreeText(event.target.value);
+                        } }),
+                    React.createElement(QueryRowSelector, { ...queryRow })))),
+        React.createElement(SubmitCancelActions, { model: model, submitDisabled: !selectedTranscript || !msaText.trim(), onSubmit: () => {
+                try {
+                    if (selectedTranscript) {
+                        setLaunchViewError(undefined);
+                        launchView({
+                            newViewTitle: getGeneDisplayName(selectedTranscript),
+                            view,
+                            feature: selectedTranscript,
+                            querySeqName: queryRow.querySeqName,
+                            data: { msa: msaText, tree: treeText },
+                        });
+                        handleClose();
+                    }
+                }
+                catch (e) {
+                    console.error(e);
+                    setLaunchViewError(e);
+                }
+            }, onCancel: handleClose })));
 });
 export default BlastManualPanel;

package/dist/LaunchMsaView/components/BlastQuery/blastLaunchView.js

@@ -1,7 +1,9 @@
 import { getSession } from '@jbrowse/core/util';
+import { launchMsaView } from '../../../utils/launchMsaView';
+import { readLaunchPlacement } from '../../../utils/workspaces';
 export function blastLaunchView({ newViewTitle, view, feature, blastParams, }) {
-    getSession(view).addView('MsaView', {
-        type: 'MsaView',
+    launchMsaView(getSession(view), {
+        placement: readLaunchPlacement(),
         displayName: newViewTitle,
         connectedViewId: view.id,
         connectedFeature: feature.toJSON(),
@@ -12,8 +14,8 @@ export function blastLaunchView({ newViewTitle, view, feature, blastParams, }) {
     });
 }
 export function blastLaunchViewFromCache({ newViewTitle, view, cached, connectedFeature, }) {
-    getSession(view).addView('MsaView', {
-        type: 'MsaView',
+    launchMsaView(getSession(view), {
+        placement: readLaunchPlacement(),
         displayName: newViewTitle,
         connectedViewId: view.id,
         connectedFeature,

package/dist/LaunchMsaView/components/BlastQuery/consts.d.ts

@@ -7,6 +7,13 @@
 export declare const BASE_BLAST_URL = "https://blast.ncbi.nlm.nih.gov/Blast.cgi";
 export declare const msaAlgorithms: readonly ["clustalo", "muscle", "kalign", "mafft"];
 export type MsaAlgorithm = (typeof msaAlgorithms)[number];
-export declare const blastDatabaseOptions: readonly ["uniprotkb_swissprot", "uniprotkb", "uniprotkb_reference_proteomes", "uniprotkb_trembl"];
+/**
+ * EBI rejects a submission naming a database outside its own list with a 400,
+ * so every value here has to appear in
+ * https://www.ebi.ac.uk/Tools/services/rest/ncbiblast/parameterdetails/database
+ * -- `uniprotkb_reference_proteomes` did not, and 3.0.0 shipped it as a dead
+ * menu entry.
+ */
+export declare const blastDatabaseOptions: readonly ["uniprotkb_swissprot", "uniprotkb", "pan_proteomes", "uniprotkb_trembl"];
 export type BlastDatabase = (typeof blastDatabaseOptions)[number];
 export declare const defaultBlastDatabase: BlastDatabase;

package/dist/LaunchMsaView/components/BlastQuery/consts.js

@@ -6,10 +6,17 @@
  */
 export const BASE_BLAST_URL = 'https://blast.ncbi.nlm.nih.gov/Blast.cgi';
 export const msaAlgorithms = ['clustalo', 'muscle', 'kalign', 'mafft'];
+/**
+ * EBI rejects a submission naming a database outside its own list with a 400,
+ * so every value here has to appear in
+ * https://www.ebi.ac.uk/Tools/services/rest/ncbiblast/parameterdetails/database
+ * -- `uniprotkb_reference_proteomes` did not, and 3.0.0 shipped it as a dead
+ * menu entry.
+ */
 export const blastDatabaseOptions = [
     'uniprotkb_swissprot',
     'uniprotkb',
-    'uniprotkb_reference_proteomes',
+    'pan_proteomes',
     'uniprotkb_trembl',
 ];
 // curated, so it returns roughly one good sequence per species rather than the

package/dist/LaunchMsaView/components/ManualMSALoader/ManualMSALoader.js

@@ -1,12 +1,14 @@
 import React, { useState } from 'react';
 import { FileSelector } from '@jbrowse/core/ui';
-import { Alert, FormControl, FormControlLabel, Radio, RadioGroup, } from '@mui/material';
+import { FormControl, FormControlLabel, Radio, RadioGroup } from '@mui/material';
 import { observer } from 'mobx-react';
 import { makeStyles } from 'tss-react/mui';
 import { launchView } from './launchView';
 import TextField2 from '../../../components/TextField2';
+import { useQueryRowName } from '../../useQueryRowName';
 import { getGeneDisplayName, getLinearGenomeView } from '../../util';
 import LaunchPanelContent from '../LaunchPanelContent';
+import QueryRowSelector from '../QueryRowSelector';
 import SubmitCancelActions from '../SubmitCancelActions';
 import TranscriptSelector from '../TranscriptSelector';
 import { useTranscriptSelection } from '../useTranscriptSelection';
@@ -23,12 +25,6 @@ const useStyles = makeStyles()({
     msaInput: {
         marginBottom: 20,
     },
-    queryNameInput: {
-        marginTop: 20,
-    },
-    warningAlert: {
-        marginTop: 10,
-    },
 });
 const ManualMSALoader = observer(function PreLoadedMSA2({ model, feature, handleClose, }) {
     const view = getLinearGenomeView(model);
@@ -39,9 +35,9 @@ const ManualMSALoader = observer(function PreLoadedMSA2({ model, feature, handle
     const [treeText, setTreeText] = useState('');
     const [msaFileLocation, setMsaFileLocation] = useState();
     const [treeFileLocation, setTreeFileLocation] = useState();
-    const [querySeqName, setQuerySeqName] = useState('');
     const transcriptSelection = useTranscriptSelection({ feature, view });
-    const { selectedTranscript, error } = transcriptSelection;
+    const { selectedTranscript, proteinSequence, error } = transcriptSelection;
+    const queryRow = useQueryRowName(msaText, proteinSequence);
     const e = launchViewError ?? error;
     return (React.createElement(React.Fragment, null,
         React.createElement(LaunchPanelContent, { error: e },
@@ -61,11 +57,8 @@ const ManualMSALoader = observer(function PreLoadedMSA2({ model, feature, handle
                         setTreeText(event.target.value);
                     } })))),
             React.createElement(TranscriptSelector, { feature: feature, ...transcriptSelection }),
-            React.createElement(TextField2, { variant: "outlined", name: "MSA row name", fullWidth: true, required: true, className: classes.queryNameInput, placeholder: "Row name in MSA that corresponds to the selected transcript", helperText: "Required: Specify the name of the row in your MSA that should be aligned with the selected transcript", value: querySeqName, onChange: event => {
-                    setQuerySeqName(event.target.value);
-                } }),
-            !querySeqName.trim() ? (React.createElement(Alert, { severity: "warning", className: classes.warningAlert }, "Without specifying the MSA row name, clicking on the MSA will not navigate to the corresponding genome position, and hovering highlights will not work.")) : null),
-        React.createElement(SubmitCancelActions, { submitDisabled: !selectedTranscript ||
+            React.createElement(QueryRowSelector, { ...queryRow })),
+        React.createElement(SubmitCancelActions, { model: model, submitDisabled: !selectedTranscript ||
                 (inputMethod === 'file' && !msaFileLocation) ||
                 (inputMethod === 'text' && !msaText.trim()), onSubmit: () => {
                 try {
@@ -75,7 +68,7 @@ const ManualMSALoader = observer(function PreLoadedMSA2({ model, feature, handle
                             newViewTitle: getGeneDisplayName(selectedTranscript),
                             view,
                             feature: selectedTranscript,
-                            querySeqName: querySeqName.trim(),
+                            querySeqName: queryRow.querySeqName,
                             ...(inputMethod === 'file'
                                 ? {
                                     msaFilehandle: msaFileLocation,

package/dist/LaunchMsaView/components/ManualMSALoader/launchView.js

@@ -1,7 +1,9 @@
 import { getSession } from '@jbrowse/core/util';
+import { launchMsaView } from '../../../utils/launchMsaView';
+import { readLaunchPlacement } from '../../../utils/workspaces';
 export function launchView({ newViewTitle, view, feature, msaFilehandle, treeFilehandle, querySeqName, data, }) {
-    getSession(view).addView('MsaView', {
-        type: 'MsaView',
+    launchMsaView(getSession(view), {
+        placement: readLaunchPlacement(),
         displayName: newViewTitle,
         connectedViewId: view.id,
         connectedFeature: feature.toJSON(),

package/dist/LaunchMsaView/components/OrthologQuery/OrthologPanel.js

@@ -40,7 +40,7 @@ const OrthologPanel = observer(function ({ handleClose, feature, model, }) {
                         setMaxSpecies(event.target.value);
                     }, error: !rowCountValid, helperText: "the closest N species NCBI has" })),
             React.createElement(TranscriptSelector, { feature: feature, ...transcriptSelection })),
-        React.createElement(SubmitCancelActions, { submitDisabled: !proteinSequence || !rowCountValid, onSubmit: () => {
+        React.createElement(SubmitCancelActions, { model: model, submitDisabled: !proteinSequence || !rowCountValid, onSubmit: () => {
                 try {
                     if (selectedTranscript) {
                         setLaunchViewError(undefined);

package/dist/LaunchMsaView/components/OrthologQuery/orthologLaunchView.js

@@ -1,7 +1,9 @@
 import { getSession } from '@jbrowse/core/util';
+import { launchMsaView } from '../../../utils/launchMsaView';
+import { readLaunchPlacement } from '../../../utils/workspaces';
 export function orthologLaunchView({ newViewTitle, view, feature, orthologParams, }) {
-    getSession(view).addView('MsaView', {
-        type: 'MsaView',
+    launchMsaView(getSession(view), {
+        placement: readLaunchPlacement(),
         displayName: newViewTitle,
         connectedViewId: view.id,
         connectedFeature: feature.toJSON(),

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

@@ -58,7 +58,7 @@ const PreLoadedMSA = observer(function ({ model, feature, handleClose, }) {
                 msaList ? (React.createElement("div", null,
                     React.createElement(SanitizedHTML, { html: selectedDataset.description }),
                     React.createElement(TranscriptSelector, { feature: feature, ...transcriptSelection }))) : null)) : null),
-        React.createElement(SubmitCancelActions, { submitDisabled: !selectedTranscript || !msaData?.length, onSubmit: () => {
+        React.createElement(SubmitCancelActions, { model: model, submitDisabled: !selectedTranscript || !msaData?.length, onSubmit: () => {
                 try {
                     if (selectedTranscript && msaData) {
                         const querySeqName = `${selectedId}_${assemblyNames[0]}`;

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

@@ -1,7 +1,9 @@
 import { getSession } from '@jbrowse/core/util';
+import { launchMsaView } from '../../../utils/launchMsaView';
+import { readLaunchPlacement } from '../../../utils/workspaces';
 export function preCalculatedLaunchView({ newViewTitle, view, feature, data, querySeqName, }) {
-    getSession(view).addView('MsaView', {
-        type: 'MsaView',
+    launchMsaView(getSession(view), {
+        placement: readLaunchPlacement(),
         displayName: newViewTitle,
         treeAreaWidth: 200,
         querySeqName,

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

@@ -0,0 +1,16 @@
+import React from 'react';
+import type { QueryRowMatch } from '../detectQueryRow';
+/**
+ * Which MSA row corresponds to the selected transcript. Clicking and hovering in
+ * the alignment reach the genome only through this name, and a wrong one fails
+ * silently -- the view opens, renders, and never navigates -- so the field fills
+ * itself in from the pasted alignment and offers that alignment's own row names
+ * rather than a free text box the user can typo.
+ */
+export default function QueryRowSelector({ names, detected, querySeqName, setQuerySeqName, isAutoDetected, }: {
+    names: string[];
+    detected?: QueryRowMatch;
+    querySeqName: string;
+    setQuerySeqName: (arg: string) => void;
+    isAutoDetected: boolean;
+}): React.JSX.Element;

package/dist/LaunchMsaView/components/QueryRowSelector.js

@@ -0,0 +1,38 @@
+import React from 'react';
+import { Alert, MenuItem } from '@mui/material';
+import { makeStyles } from 'tss-react/mui';
+import TextField2 from '../../components/TextField2';
+const useStyles = makeStyles()({
+    field: {
+        marginTop: 20,
+    },
+    alert: {
+        marginTop: 10,
+    },
+});
+/**
+ * Which MSA row corresponds to the selected transcript. Clicking and hovering in
+ * the alignment reach the genome only through this name, and a wrong one fails
+ * silently -- the view opens, renders, and never navigates -- so the field fills
+ * itself in from the pasted alignment and offers that alignment's own row names
+ * rather than a free text box the user can typo.
+ */
+export default function QueryRowSelector({ names, detected, querySeqName, setQuerySeqName, isAutoDetected, }) {
+    const { classes } = useStyles();
+    return (React.createElement(React.Fragment, null,
+        names.length > 0 ? (React.createElement(TextField2, { variant: "outlined", label: "MSA row matching the selected transcript", select: true, fullWidth: true, className: classes.field, value: names.includes(querySeqName) ? querySeqName : '', onChange: event => {
+                setQuerySeqName(event.target.value);
+            } }, names.map(name => (React.createElement(MenuItem, { value: name, key: name },
+            name,
+            detected?.name === name ? ' — matches your protein' : ''))))) : (React.createElement(TextField2, { variant: "outlined", label: "MSA row matching the selected transcript", fullWidth: true, className: classes.field, helperText: "Paste an alignment above and this fills in on its own", value: querySeqName, onChange: event => {
+                setQuerySeqName(event.target.value);
+            } })),
+        isAutoDetected && detected ? (React.createElement(Alert, { severity: "success", className: classes.alert },
+            "Matched ",
+            React.createElement("strong", null, detected.name),
+            " to your protein sequence",
+            detected.quality === 'exact'
+                ? ''
+                : `, covering ${Math.round(detected.identity * 100)}% of it`,
+            ". Clicking the alignment will navigate the genome view.")) : names.length > 0 && !querySeqName ? (React.createElement(Alert, { severity: "warning", className: classes.alert }, "No row matched your protein sequence \u2014 pick the one for your gene above. Without it the alignment still renders, but clicking it will not navigate the genome view.")) : null));
+}

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

@@ -1,8 +1,11 @@
 import React from 'react';
-export default function SubmitCancelActions({ onSubmit, onCancel, submitDisabled, submitLabel, cancelLabel, }: {
+import type { AbstractTrackModel } from '@jbrowse/core/util';
+export default function SubmitCancelActions({ onSubmit, onCancel, submitDisabled, submitLabel, cancelLabel, model, }: {
     onSubmit: () => void;
     onCancel: () => void;
     submitDisabled?: boolean;
     submitLabel?: string;
     cancelLabel?: string;
+    /** omitted by a panel that submits something other than a view launch */
+    model?: AbstractTrackModel;
 }): React.JSX.Element;

package/dist/LaunchMsaView/components/SubmitCancelActions.js

@@ -1,11 +1,35 @@
-import React from 'react';
-import { Button, DialogActions } from '@mui/material';
-export default function SubmitCancelActions({ onSubmit, onCancel, submitDisabled, submitLabel = 'Submit', cancelLabel = 'Cancel', }) {
-    return (React.createElement(DialogActions, null,
-        React.createElement(Button, { color: "primary", variant: "contained", disabled: submitDisabled, onClick: () => {
-                onSubmit();
-            } }, submitLabel),
-        React.createElement(Button, { color: "secondary", variant: "contained", onClick: () => {
-                onCancel();
-            } }, cancelLabel)));
+import React, { useState } from 'react';
+import { getSession } from '@jbrowse/core/util';
+import { Button, Checkbox, DialogActions, FormControlLabel, } from '@mui/material';
+import { readLaunchPlacement, sessionSupportsPlacement, writeLaunchPlacement, } from '../../utils/workspaces';
+/**
+ * Where the launch puts the view, offered wherever a launch is submitted.
+ *
+ * A checkbox rather than a menu of the three placements: the choice a reader
+ * has at this point is "beside the genome view or under it", and `newTab` is a
+ * spec's to state, not a thing to pick before you have seen the alignment.
+ *
+ * Absent entirely on a host that cannot tile — an embedded session, or a
+ * 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;
+}
+export default function SubmitCancelActions({ onSubmit, onCancel, submitDisabled, submitLabel = 'Submit', cancelLabel = 'Cancel', 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' } },
+            React.createElement(Button, { sx: { flexShrink: 0 }, color: "primary", variant: "contained", disabled: submitDisabled, onClick: () => {
+                    onSubmit();
+                } }, submitLabel),
+            React.createElement(Button, { sx: { flexShrink: 0 }, color: "secondary", variant: "contained", onClick: () => {
+                    onCancel();
+                } }, cancelLabel))));
 }

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

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

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

@@ -0,0 +1,55 @@
+// @vitest-environment jsdom
+import React from 'react';
+import { cleanup, render, screen } from '@testing-library/react';
+import { afterEach, beforeEach, expect, test, vi } from 'vitest';
+import SubmitCancelActions from './SubmitCancelActions';
+import { LAUNCH_PLACEMENT_KEY } from '../../utils/workspaces';
+// 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', () => ({
+    getSession: (model) => model.session,
+}));
+function trackModel(session) {
+    return { session };
+}
+const tiling = { setUseWorkspaces() { }, setPendingMove() { } };
+beforeEach(() => {
+    localStorage.clear();
+});
+afterEach(() => {
+    cleanup();
+});
+function toggle() {
+    return screen.queryByRole('checkbox');
+}
+test('a host that can tile offers the choice, checked by default', () => {
+    render(React.createElement(SubmitCancelActions, { model: trackModel(tiling), onSubmit: () => { }, onCancel: () => { } }));
+    expect(toggle()).toBeTruthy();
+    expect(toggle().checked).toBe(true);
+    expect(localStorage.getItem(LAUNCH_PLACEMENT_KEY)).toBeNull();
+});
+// the box would do nothing on an embedded session, and a control that silently
+// does nothing is worse than one that is not there
+test('a host that cannot tile does not offer it', () => {
+    render(React.createElement(SubmitCancelActions, { model: trackModel({}), onSubmit: () => { }, onCancel: () => { } }));
+    expect(toggle()).toBeNull();
+    expect(screen.getByText('Submit')).toBeTruthy();
+});
+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: () => { } }));
+    toggle().click();
+    expect(localStorage.getItem(LAUNCH_PLACEMENT_KEY)).toBe('stack');
+    expect(toggle().checked).toBe(false);
+    toggle().click();
+    expect(localStorage.getItem(LAUNCH_PLACEMENT_KEY)).toBe('splitRight');
+    expect(toggle().checked).toBe(true);
+});
+test('a stored choice is what the box opens on', () => {
+    localStorage.setItem(LAUNCH_PLACEMENT_KEY, 'stack');
+    render(React.createElement(SubmitCancelActions, { model: trackModel(tiling), onSubmit: () => { }, onCancel: () => { } }));
+    expect(toggle().checked).toBe(false);
+});

package/dist/LaunchMsaView/detectQueryRow.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Which row of a pasted alignment is the gene the user launched from.
+ *
+ * The MsaView needs that row name to tie alignment columns back to genome
+ * coordinates, and until now the user typed it. Nothing validates a typo: the
+ * view opens, renders, and simply never navigates or highlights, which reads as
+ * a broken feature rather than a wrong field. Meanwhile the plugin already
+ * knows the protein sequence it sent to BLAST, so it can find the row by
+ * sequence instead of asking.
+ *
+ * NCBI and EBI both rename the query on the way through -- COBALT emits
+ * `Query_1`, EBI's aligners carry the accession -- so the name is no help. The
+ * residues are, and they survive every rename.
+ */
+export type MatchQuality = 'exact' | 'partial' | 'similar';
+export interface QueryRowMatch {
+    name: string;
+    quality: MatchQuality;
+    /** identity over the compared region, 0-1 */
+    identity: number;
+}
+export declare function detectQueryRow(msaText: string, proteinSequence: string): QueryRowMatch | undefined;
+export declare function getMsaRowNames(msaText: string): string[];

package/dist/LaunchMsaView/detectQueryRow.js

@@ -0,0 +1,94 @@
+import { getUngappedSequence, parseMSA } from 'msa-parsers';
+/**
+ * A stop codon is present in the transcript's translation and absent from
+ * anything an aligner returns, and case is not meaningful in either.
+ */
+function normalize(seq) {
+    return seq
+        .replaceAll('*', '')
+        .replaceAll('-', '')
+        .replaceAll('.', '')
+        .toUpperCase();
+}
+function identityOverOverlap(a, b) {
+    const len = Math.min(a.length, b.length);
+    if (len === 0) {
+        return 0;
+    }
+    let same = 0;
+    for (let i = 0; i < len; i++) {
+        if (a[i] === b[i]) {
+            same++;
+        }
+    }
+    return same / len;
+}
+/**
+ * Below this, a "best" row is not a match at all -- an alignment of homologs is
+ * full of rows in the 40-70% range, and picking the top one would silently wire
+ * the view to a paralog from another species.
+ */
+const SIMILARITY_FLOOR = 0.9;
+/**
+ * How much of the query a contained row has to cover. A short fragment is a
+ * substring of almost any protein, so without a floor the first few residues of
+ * a half-pasted alignment match the query and the field fills in with a row the
+ * user is still typing.
+ */
+const PARTIAL_COVERAGE_FLOOR = 0.5;
+export function detectQueryRow(msaText, proteinSequence) {
+    const query = normalize(proteinSequence);
+    if (!query || !msaText.trim()) {
+        return undefined;
+    }
+    let names;
+    let parsed;
+    try {
+        const msa = parseMSA(msaText);
+        names = msa.getNames();
+        parsed = msa;
+    }
+    catch {
+        // a half-pasted alignment throws here on every keystroke; the caller shows
+        // the field rather than an error
+        return undefined;
+    }
+    const candidates = [];
+    for (const name of names) {
+        const row = normalize(getUngappedSequence(parsed.getRow(name)));
+        if (!row) {
+            continue;
+        }
+        if (row === query) {
+            // nothing beats an exact match, and a second one would be a duplicate row
+            return { name, quality: 'exact', identity: 1 };
+        }
+        // BLAST reports the aligned region, so the row is often the query trimmed
+        // at one or both ends rather than the whole protein
+        if (query.includes(row) || row.includes(query)) {
+            const coverage = Math.min(row.length, query.length) / Math.max(row.length, query.length);
+            if (coverage >= PARTIAL_COVERAGE_FLOOR) {
+                candidates.push({ name, quality: 'partial', identity: coverage });
+            }
+            continue;
+        }
+        const identity = identityOverOverlap(row, query);
+        if (identity >= SIMILARITY_FLOOR) {
+            candidates.push({ name, quality: 'similar', identity });
+        }
+    }
+    const order = ['exact', 'partial', 'similar'];
+    return candidates.sort((a, b) => order.indexOf(a.quality) - order.indexOf(b.quality) ||
+        b.identity - a.identity)[0];
+}
+export function getMsaRowNames(msaText) {
+    if (!msaText.trim()) {
+        return [];
+    }
+    try {
+        return parseMSA(msaText).getNames();
+    }
+    catch {
+        return [];
+    }
+}

package/dist/LaunchMsaView/detectQueryRow.test.d.ts

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