jbrowse-plugin-protein3d 0.11.0 → 0.11.2

package/README.md

@@ -29,6 +29,13 @@ Source and details in [harness/](harness/).
 Example at
 https://jbrowse.org/code/jb2/latest/?config=%2Fucsc%2Fhg38%2Fconfig.json&session=share-aZOIjR_qs4&password=NT4sa
 
+## Demos
+
+[Structures that are easy to map wrong](docs/demos.md), each one link away: a
+peptide bound to a larger partner, a protein bound to DNA, a receptor with
+another protein fused into it, a phosphorylated residue, and a mitochondrial
+protein.
+
 ## Publication
 
 If you find this tool useful please cite our work
@@ -54,6 +61,10 @@ See [DEVELOPERS.md](DEVELOPERS.md)
 Notes on the parts that are easy to get subtly wrong, written for someone
 extending the plugin or checking what a number on screen means:
 
+- [Genome to structure alignment](docs/genome-to-structure-alignment.md): why
+  the plugin aligns the transcript's translation to the structure on the fly,
+  the precedent for that in SIFTS and G2S, how it picks the chain and isoform,
+  and what sequence alignment cannot decide.
 - [Residue numbering](docs/residue-numbering.md): how a paper's R248 becomes
   position 154 in the file, `label_seq_id` 155 for Mol\*, and the codon on
   chr17, and how a session spec names a residue the literature's way.

package/dist/AddHighlightModel/HighlightComponents.js

@@ -4,14 +4,12 @@ import GenomeMouseoverHighlight from './GenomeMouseoverHighlight';
 import GenomeTo1DProteinHoverHighlight from './GenomeTo1DProteinHoverHighlight';
 import Protein1DToGenomeHoverHighlight from './Protein1DToGenomeHoverHighlight';
 import { ProteinToGenomeClickHighlight, ProteinToGenomeHoverHighlight, } from './ProteinToGenomeHighlight';
-import ProteinToMsaHoverSync from './ProteinToMsaHoverSync';
 const HighlightComponents = observer(function Highlight({ model, }) {
     return (React.createElement(React.Fragment, null,
         React.createElement(ProteinToGenomeClickHighlight, { model: model }),
         React.createElement(ProteinToGenomeHoverHighlight, { model: model }),
         React.createElement(Protein1DToGenomeHoverHighlight, { model: model }),
         React.createElement(GenomeTo1DProteinHoverHighlight, { model: model }),
-        React.createElement(GenomeMouseoverHighlight, { model: model }),
-        React.createElement(ProteinToMsaHoverSync, { model: model })));
+        React.createElement(GenomeMouseoverHighlight, { model: model })));
 });
 export default HighlightComponents;

package/dist/AddHighlightModel/index.js

@@ -1,9 +1,9 @@
 import React from 'react';
 import HighlightComponents from './HighlightComponents';
 export default function AddHighlightModelF(pluginManager) {
-    pluginManager.addToExtensionPoint('LinearGenomeView-TracksContainerComponent', 
-    // @ts-expect-error
-    (rest, { model }) => {
+    pluginManager.addToExtensionPoint(
+    // @ts-expect-error v4 hosts have no contributeToExtensionPoint
+    'LinearGenomeView-TracksContainerComponent', (rest, { model }) => {
         return [
             ...rest,
             React.createElement(HighlightComponents, { key: "highlight_protein_viewer_protein3d", model: model }),

package/dist/AddHighlightModel/proteinViewLookup.js

@@ -1,16 +1,6 @@
 export function getProteinViews(session) {
     return session.views.filter(v => v.type === 'ProteinView');
 }
-/**
- * NOTE: assumes a single ProteinView. Unlike the genome-highlight bridge (which
- * pairs by the declared `connectedViewId`, see getStructuresConnectedTo), a
- * second ProteinView's MSA hover sync is skipped — pairing an MSA to one of
- * several protein views has no reliable rule when the protein view declares
- * neither a connectedMsaViewId nor a connectedViewId.
- */
-export function getProteinView(session) {
-    return getProteinViews(session)[0];
-}
 /**
  * Every structure across all ProteinViews that declares this genome view as its
  * connection. Structures are paired to a genome view explicitly, so a second

package/dist/LaunchProteinView/components/AlphaFoldDBSearch.js

@@ -6,7 +6,6 @@ import { makeStyles } from 'tss-react/mui';
 import AlphaFoldDBSearchStatus from './AlphaFoldDBSearchStatus';
 import IdentifierSelector from './IdentifierSelector';
 import ProteinViewActions from './ProteinViewActions';
-import SequenceSearchStatus from './SequenceSearchStatus';
 import TranscriptSelector from './TranscriptSelector';
 import UniProtIdInput from './UniProtIdInput';
 import UniProtResultsTable from './UniProtResultsTable';
@@ -41,7 +40,11 @@ const AlphaFoldDBSearch = observer(function AlphaFoldDBSearch({ feature, session
     return (React.createElement(React.Fragment, null,
         React.createElement(DialogContent, { className: classes.dialogContent },
             state.error ? React.createElement(ErrorMessage, { error: state.error }) : null,
-            React.createElement(UniProtIdInput, { lookupMode: state.lookupMode, onLookupModeChange: state.setLookupMode, manualUniprotId: state.manualUniprotId, onManualUniprotIdChange: state.setManualUniprotId, featureUniprotId: state.featureUniprotId, hasProteinSequence: !!state.userSelectedProteinSequence?.seq, sequenceSearchType: state.sequenceSearchType, onSequenceSearchTypeChange: state.setSequenceSearchType, endContent: state.showIdentifierSelector ? (React.createElement("div", { className: classes.endRow },
+            state.noModel ? (React.createElement(Typography, null,
+                "AlphaFold DB has no model for ",
+                state.uniprotId,
+                ". The PDB and Foldseek tabs may have a structure.")) : null,
+            React.createElement(UniProtIdInput, { lookupMode: state.lookupMode, onLookupModeChange: state.setLookupMode, manualUniprotId: state.manualUniprotId, onManualUniprotIdChange: state.setManualUniprotId, featureUniprotId: state.featureUniprotId, endContent: state.showIdentifierSelector ? (React.createElement("div", { className: classes.endRow },
                     React.createElement(IdentifierSelector, { recognizedIds: state.recognizedIds, geneName: state.geneName, selectedId: state.selectedQueryId, onSelectedIdChange: state.setSelectedQueryId }),
                     React.createElement(TextField, { size: "small", label: "Organism (NCBI taxon)", helperText: "Scopes the gene-name search", value: state.taxonId, onChange: event => {
                             state.setTaxonId(event.target.value);
@@ -65,13 +68,15 @@ const AlphaFoldDBSearch = observer(function AlphaFoldDBSearch({ feature, session
                 ' ',
                 React.createElement(ExternalLink, { href: "https://www.uniprot.org/" }, "UniProt"),
                 ' ',
-                "directly and use \"Enter manually\" above, or use \"Search sequence against AlphaFoldDB API\" if available.")),
-            state.showStructureSelectors && state.isoformSequences ? (React.createElement(React.Fragment, null,
+                "directly and use \"Enter manually\" above.")),
+            state.isoformSequences &&
+                state.selectedTranscript &&
+                state.structureSequence &&
+                state.uniprotId ? (React.createElement(React.Fragment, null,
                 React.createElement("div", { className: classes.selectorsRow },
                     React.createElement(TranscriptSelector, { val: state.userSelection, setVal: state.setUserSelection, structureSequence: state.structureSequence, feature: feature, isoforms: state.transcriptOptions, isoformSequences: state.isoformSequences })),
-                state.showSequenceSearchStatus && (React.createElement(SequenceSearchStatus, { isLoading: state.isSequenceSearchLoading, uniprotId: state.uniprotId, url: state.url, hasProteinSequence: !!state.userSelectedProteinSequence?.seq, sequenceSearchType: state.sequenceSearchType })),
-                state.showAlphaFoldDBSearchStatus && (React.createElement(AlphaFoldDBSearchStatus, { uniprotId: state.uniprotId, selectedTranscript: state.selectedTranscript, structureSequence: state.structureSequence, isoformSequences: state.isoformSequences, url: state.url })))) : null),
+                React.createElement(AlphaFoldDBSearchStatus, { uniprotId: state.modelAccession ?? state.uniprotId, structureSequence: state.structureSequence, isoformSequences: state.isoformSequences, url: state.url }))) : null),
         React.createElement(DialogActions, null,
-            React.createElement(ProteinViewActions, { handleClose: handleClose, uniprotId: state.uniprotId, userSelectedProteinSequence: state.userSelectedProteinSequence, selectedTranscript: state.selectedTranscript, url: state.url, confidenceUrl: state.confidenceUrl, feature: feature, view: view, session: session, alignmentAlgorithm: alignmentAlgorithm, onAlignmentAlgorithmChange: onAlignmentAlgorithmChange, sequencesMatch: state.sequencesMatch, isLoading: state.isLoading, error: state.error }))));
+            React.createElement(ProteinViewActions, { handleClose: handleClose, uniprotId: state.modelAccession ?? state.uniprotId, userSelectedProteinSequence: state.userSelectedProteinSequence, selectedTranscript: state.selectedTranscript, url: state.url, confidenceUrl: state.confidenceUrl, feature: feature, view: view, session: session, alignmentAlgorithm: alignmentAlgorithm, onAlignmentAlgorithmChange: onAlignmentAlgorithmChange, sequencesMatch: state.sequencesMatch, isLoading: state.isLoading, error: state.error }))));
 });
 export default AlphaFoldDBSearch;

package/dist/LaunchProteinView/components/AlphaFoldDBSearchStatus.js

@@ -3,15 +3,8 @@ import { Typography } from '@mui/material';
 import IsoformSequencesToggle from './IsoformSequencesToggle';
 import ExternalLink from '../../components/ExternalLink';
 import { uniprotEntryUrl } from '../utils/structureUrls';
-import { getTranscriptDisplayName } from '../utils/util';
-function NotFound({ uniprotId }) {
-    return (React.createElement(Typography, null,
-        "No structure found for this UniProtID in AlphaFoldDB",
-        ' ',
-        React.createElement(ExternalLink, { href: `https://alphafold.ebi.ac.uk/search/text/${uniprotId}` }, "(search for results)")));
-}
-export default function AlphaFoldDBSearchStatus({ uniprotId, selectedTranscript, structureSequence, isoformSequences, url, }) {
-    return uniprotId ? (React.createElement(React.Fragment, null,
+export default function AlphaFoldDBSearchStatus({ uniprotId, structureSequence, isoformSequences, url, }) {
+    return (React.createElement(React.Fragment, null,
         React.createElement("div", null,
             React.createElement(Typography, null,
                 "UniProt link:",
@@ -20,12 +13,5 @@ export default function AlphaFoldDBSearchStatus({ uniprotId, selectedTranscript,
             React.createElement(Typography, null,
                 "AlphaFoldDB link: ",
                 React.createElement(ExternalLink, { href: url }, url))),
-        structureSequence ? (React.createElement(IsoformSequencesToggle, { structureSequence: structureSequence, structureName: uniprotId, isoformSequences: isoformSequences })) : (React.createElement(NotFound, { uniprotId: uniprotId })))) : (React.createElement(Typography, null,
-        "Searching",
-        ' ',
-        selectedTranscript
-            ? getTranscriptDisplayName(selectedTranscript)
-            : 'transcript',
-        ' ',
-        "for UniProt ID"));
+        React.createElement(IsoformSequencesToggle, { structureSequence: structureSequence, structureName: uniprotId, isoformSequences: isoformSequences })));
 }

package/dist/LaunchProteinView/components/FoldseekSearch.js

@@ -66,18 +66,17 @@ const FoldseekSearch = observer(function FoldseekSearch({ feature, session, view
                 React.createElement(TextField, { label: "Protein sequence (amino acids)", multiline: true, rows: 4, value: sequence, onChange: e => {
                         setUserEditedSequence(e.target.value);
                         invalidatePrediction();
-                    }, placeholder: `MKTVRQERLKSIVRILERSKEPVSGAQLAEEL...`, disabled: isBusy, InputProps: {
-                        className: classes.sequenceInput,
+                    }, placeholder: `MKTVRQERLKSIVRILERSKEPVSGAQLAEEL...`, disabled: isBusy, slotProps: {
+                        input: { className: classes.sequenceInput },
                     } }))) : null,
             di3Sequence ? (React.createElement("div", { className: classes.di3Section },
                 React.createElement(Typography, { variant: "subtitle2" }, "3Di structural alphabet (used for searching):"),
-                React.createElement(TextField, { multiline: true, rows: 4, value: di3Sequence, InputProps: {
-                        className: classes.sequenceInput,
-                        readOnly: true,
+                React.createElement(TextField, { multiline: true, rows: 4, value: di3Sequence, slotProps: {
+                        input: { className: classes.sequenceInput, readOnly: true },
                     } }))) : null,
             React.createElement(FoldseekDatabaseSelector, { selected: selectedDatabases, onChange: setSelectedDatabases, disabled: isBusy }),
             statusMessage ? (React.createElement(LoadingEllipses, { variant: "subtitle2", message: statusMessage })) : null,
-            results ? (React.createElement(FoldseekResultsTable, { results: results, session: session, view: view, feature: feature, selectedTranscript: selectedTranscript, userProvidedTranscriptSequence: sequence, onClose: handleClose })) : null),
+            results ? (React.createElement(FoldseekResultsTable, { results: results, session: session, view: view, feature: feature, selectedTranscript: selectedTranscript, userProvidedTranscriptSequence: selectedIsoformData?.seq, onClose: handleClose })) : null),
         React.createElement(DialogActions, null,
             React.createElement(Button, { variant: "contained", color: "secondary", onClick: () => {
                     handleClose();

package/dist/LaunchProteinView/components/ProteinViewActions.js

@@ -18,9 +18,9 @@ export default function ProteinViewActions({ handleClose, uniprotId, userSelecte
         selectedTranscript,
         url,
     });
-    // Disable launch while loading — SWR's keepPreviousData would otherwise let
-    // a user click Launch on stale results (wrong UniProt ID) during a refetch.
-    const canLaunch = !isLoading && missingReasons.length === 0;
+    // Loading or errored, SWR's keepPreviousData can still hold the previous
+    // accession's structure, which Launch would open under the new name.
+    const canLaunch = !isLoading && !error && missingReasons.length === 0;
     // Suppress the derived reasons while loading or while a real upstream error
     // is displayed above via <ErrorMessage> — a duplicate hint would mislead.
     const showMissingReasons = !isLoading && !error && missingReasons.length > 0;

package/dist/LaunchProteinView/components/TranscriptSelector.js

@@ -1,6 +1,7 @@
 import React from 'react';
 import { MenuItem, TextField } from '@mui/material';
-import { classifyIsoforms, getGeneDisplayName, getTranscriptDisplayName, } from '../utils/util';
+import { classifyIsoforms } from '../utils/isoformRanking';
+import { getGeneDisplayName, getTranscriptDisplayName, stripStopCodon, } from '../utils/util';
 export default function TranscriptSelector({ val, setVal, isoforms, isoformSequences, structureSequence, feature, disabled, }) {
     const geneName = getGeneDisplayName(feature);
     const { matches, nonMatches, noData } = classifyIsoforms({
@@ -8,7 +9,12 @@ export default function TranscriptSelector({ val, setVal, isoforms, isoformSeque
         isoformSequences,
         structureSequence,
     });
-    const renderOption = ({ feature: f, length }, note = '') => (React.createElement(MenuItem, { value: f.id(), key: f.id() },
+    const structureLength = structureSequence
+        ? stripStopCodon(structureSequence).length
+        : undefined;
+    const renderOption = ({ feature: f, length, identical }, note = identical === undefined
+        ? ''
+        : ` (${identical}/${structureLength} structure residues identical)`) => (React.createElement(MenuItem, { value: f.id(), key: f.id() },
         geneName,
         " - ",
         getTranscriptDisplayName(f),

package/dist/LaunchProteinView/components/UniProtIdInput.js

@@ -1,32 +1,27 @@
 import React from 'react';
 import { FormControl, FormControlLabel, Radio, RadioGroup, TextField, Typography, } from '@mui/material';
 import ExternalLink from '../../components/ExternalLink';
-export default function UniProtIdInput({ lookupMode, onLookupModeChange, manualUniprotId, onManualUniprotIdChange, featureUniprotId, hasProteinSequence, sequenceSearchType, onSequenceSearchTypeChange, endContent, }) {
+const LOOKUP_MODES = ['auto', 'manual', 'feature'];
+function isLookupMode(value) {
+    return LOOKUP_MODES.some(mode => mode === value);
+}
+export default function UniProtIdInput({ lookupMode, onLookupModeChange, manualUniprotId, onManualUniprotIdChange, featureUniprotId, endContent, }) {
     return (React.createElement(React.Fragment, null,
         React.createElement("div", { style: { display: 'flex', alignItems: 'center', flexWrap: 'wrap' } },
             React.createElement(FormControl, { component: "fieldset" },
                 React.createElement(RadioGroup, { row: true, value: lookupMode, onChange: event => {
-                        onLookupModeChange(event.target.value);
+                        if (isLookupMode(event.target.value)) {
+                            onLookupModeChange(event.target.value);
+                        }
                     } },
                     featureUniprotId && (React.createElement(FormControlLabel, { value: "feature", control: React.createElement(Radio, null), label: `From feature (${featureUniprotId})` })),
                     React.createElement(FormControlLabel, { value: "auto", control: React.createElement(Radio, null), label: "Auto-detect using UniProt ID mapping API" }),
-                    React.createElement(FormControlLabel, { value: "manual", control: React.createElement(Radio, null), label: "Enter manually" }),
-                    hasProteinSequence && (React.createElement(FormControlLabel, { value: "sequence", control: React.createElement(Radio, null), label: "Search sequence against AlphaFoldDB API" })))),
+                    React.createElement(FormControlLabel, { value: "manual", control: React.createElement(Radio, null), label: "Enter manually" }))),
             endContent),
         lookupMode === 'manual' && (React.createElement("div", null,
             React.createElement(TextField, { label: "UniProt ID", variant: "outlined", placeholder: "e.g. P68871", size: "small", value: manualUniprotId, onChange: e => {
                     onManualUniprotIdChange(e.target.value);
                 } }))),
-        lookupMode === 'sequence' &&
-            sequenceSearchType &&
-            onSequenceSearchTypeChange && (React.createElement("div", null,
-            React.createElement(FormControl, { component: "fieldset" },
-                React.createElement(RadioGroup, { row: true, value: sequenceSearchType, onChange: event => {
-                        onSequenceSearchTypeChange(event.target.value);
-                    } },
-                    React.createElement(FormControlLabel, { value: "md5", control: React.createElement(Radio, null), label: "Exact match" }),
-                    React.createElement(FormControlLabel, { value: "sequence", control: React.createElement(Radio, null), label: "Fuzzy match" }))),
-            React.createElement(Typography, { variant: "body2", color: "text.secondary" }, "May not find the canonical UniProt entry."))),
         lookupMode === 'manual' && !manualUniprotId && (React.createElement(Typography, { variant: "body2", color: "text.secondary" },
             "Search",
             ' ',

package/dist/LaunchProteinView/components/launchProteinAnnotationView.js

@@ -13,10 +13,13 @@ export async function launchProteinAnnotationView({ session, feature, selectedTr
     const proteinLinkage = connectedViewId && selectedTranscript
         ? { connectedViewId, feature: selectedTranscript.toJSON(), uniprotId }
         : undefined;
-    const view = session.addView('LinearGenomeView', {
+    // a named object, because proteinLinkage comes from this plugin's own
+    // LinearGenomeView extension, which the launch snapshot type cannot see
+    const snapshot = {
         type: 'LinearGenomeView',
         displayName: formatViewName('Protein annotations', feature, selectedTranscript, uniprotId),
         proteinLinkage,
-    });
+    };
+    const view = session.addView('LinearGenomeView', snapshot);
     await view.navToLocString(uniprotId, uniprotId);
 }

package/dist/LaunchProteinView/components/proteinTrackSetup.js

@@ -92,6 +92,18 @@ function addAlphaFoldConfidenceTrack({ session, uniprotId, confidenceUrl, }) {
                 },
             },
             assemblyNames: [uniprotId],
+            displays: [
+                {
+                    type: 'LinearWiggleDisplay',
+                    displayId: `${uniprotId}-AlphaFold-confidence-LinearWiggleDisplay`,
+                    // pLDDT 50 is AlphaFold's own line between low and very low
+                    // confidence: residues above it in AlphaFold's blue, below in its
+                    // orange
+                    bicolorPivot: 50,
+                    posColor: '#0053d6',
+                    negColor: '#ff7d45',
+                },
+            ],
         });
     }
 }
@@ -115,14 +127,11 @@ function addAlphaMissenseTrack({ session, uniprotId, }) {
                 type: 'MultiLinearWiggleDisplay',
                 displayId: `${uniprotId}-AlphaMissense-scores-MultiLinearWiggleDisplay`,
                 defaultRendering: 'multirowdensity',
-                renderers: {
-                    MultiDensityRenderer: {
-                        type: 'MultiDensityRenderer',
-                        bicolorPivotValue: 0.5,
-                        posColor: 'red',
-                        negColor: 'blue',
-                    },
-                },
+                // AlphaMissense's own reading: likely pathogenic red, likely benign
+                // blue, fading to white at the midpoint of its 0-1 score
+                bicolorPivot: 0.5,
+                posColor: '#d7191c',
+                negColor: '#2c7bb6',
             },
         ],
     });
@@ -150,8 +159,11 @@ export async function addAllProteinTracks({ session, uniprotId, confidenceUrl, }
         uniprotId,
         confidenceUrl,
     });
-    addAlphaMissenseTrack({
-        session,
-        uniprotId,
-    });
+    // AlphaFold DB publishes substitution scores for canonical entries only
+    if (!uniprotId.includes('-')) {
+        addAlphaMissenseTrack({
+            session,
+            uniprotId,
+        });
+    }
 }

package/dist/LaunchProteinView/hooks/useAlphaFoldDBSearch.js

@@ -1,80 +1,51 @@
-import { useState } from 'react';
+import { useMemo } from 'react';
 import useAlphaFoldData from './useAlphaFoldData';
-import useAlphaFoldSequenceSearch from './useAlphaFoldSequenceSearch';
 import useTranscriptIsoformSelection from './useTranscriptIsoformSelection';
 import useUniProtIdLookup from './useUniProtIdLookup';
 import { stripStopCodon } from '../utils/util';
 export default function useAlphaFoldDBSearch({ feature, view, }) {
     const lookup = useUniProtIdLookup({ feature, view });
-    const { uniprotId, isSequenceMode, isAutoMode, isLookupLoading } = lookup;
-    const [sequenceSearchType, setSequenceSearchType] = useState('md5');
-    const { isLoading: isAlphaFoldLoading, isValidating: isAlphaFoldValidating, error: alphaFoldError, url: alphaFoldUrl, confidenceUrl: alphaFoldConfidenceUrl, structureSequences: alphaFoldStructureSequences, } = useAlphaFoldData({ uniprotId });
-    const { transcripts: transcriptOptions, isoformSequences, structureSequence: alphaFoldStructureSequence, isLoading: isIsoformLoading, error: isoformError, selectedTranscriptId: effectiveTranscriptId, setSelectedTranscriptId: setUserSelection, selectedTranscript, selectedIsoform: userSelectedProteinSequence, } = useTranscriptIsoformSelection({
+    const { uniprotId, isAutoMode, isLookupLoading } = lookup;
+    const { isLoading: isAlphaFoldLoading, isValidating: isAlphaFoldValidating, error: alphaFoldError, model, noModel, } = useAlphaFoldData({ uniprotId, feature, view });
+    // a stable array, or the isoform picker realigns on every render
+    const modelSequence = model?.sequence;
+    const structureSequences = useMemo(() => (modelSequence ? [modelSequence] : undefined), [modelSequence]);
+    const { transcripts: transcriptOptions, isoformSequences, structureSequence, isLoading: isIsoformLoading, error: isoformError, selectedTranscriptId: userSelection, setSelectedTranscriptId: setUserSelection, selectedTranscript, selectedIsoform: userSelectedProteinSequence, } = useTranscriptIsoformSelection({
         feature,
         view,
-        structureSequences: alphaFoldStructureSequences,
-        resetKey: uniprotId,
+        structureSequences,
+        resetKey: model?.url,
     });
-    const { uniprotId: seqSearchUniprotId, cifUrl: seqSearchUrl, plddtDocUrl: seqSearchConfidenceUrl, structureSequence: seqSearchStructureSequence, isLoading: isSequenceSearchLoading, isValidating: isSequenceSearchValidating, error: sequenceSearchError, } = useAlphaFoldSequenceSearch({
-        sequence: userSelectedProteinSequence?.seq,
-        searchType: sequenceSearchType,
-        enabled: isSequenceMode,
-    });
-    // Merge alphafold / sequence-search results
-    const finalUrl = isSequenceMode ? seqSearchUrl : alphaFoldUrl;
-    const finalConfidenceUrl = isSequenceMode
-        ? seqSearchConfidenceUrl
-        : alphaFoldConfidenceUrl;
-    const finalStructureSequence = isSequenceMode
-        ? seqSearchStructureSequence
-        : alphaFoldStructureSequence;
-    const finalUniprotId = isSequenceMode ? seqSearchUniprotId : uniprotId;
-    // While a structure fetch is in flight, finalStructureSequence may still be
-    // the previous selection's sequence (keepPreviousData). Comparing that stale
-    // sequence to the freshly-selected transcript would give a wrong match, so
-    // the match is treated as unknown until the fetch settles.
-    const isStructureValidating = isSequenceMode
-        ? isSequenceSearchValidating
-        : isAlphaFoldValidating;
     const loadingStatuses = [
         isLookupLoading && 'Looking up UniProt ID',
         isIsoformLoading && 'Loading protein sequences from transcript isoforms',
-        !isSequenceMode && isAlphaFoldLoading && 'Fetching AlphaFold structure URL',
-        isSequenceMode &&
-            isSequenceSearchLoading &&
-            'Searching AlphaFoldDB by sequence',
-    ].filter((s) => !!s);
+        isAlphaFoldLoading && 'Asking AlphaFold DB for models',
+    ].filter(s => typeof s === 'string');
     const isLoading = loadingStatuses.length > 0;
-    // Only show errors once all loading is done — the synchronous
-    // effectiveLookupMode and autoTranscriptId computations prevent the
-    // one-frame gaps that previously caused brief error flashes
-    const rawError = isoformError ?? lookup.lookupError ?? alphaFoldError ?? sequenceSearchError;
+    // errors wait for loading to finish, so a lookup in flight doesn't flash one
+    const rawError = isoformError ?? lookup.lookupError ?? alphaFoldError;
     const error = isLoading ? undefined : rawError;
     return {
         ...lookup,
-        sequenceSearchType,
-        setSequenceSearchType,
-        userSelection: effectiveTranscriptId,
+        userSelection,
         setUserSelection,
         transcriptOptions,
         selectedTranscript,
         isoformSequences,
         userSelectedProteinSequence,
-        uniprotId: finalUniprotId,
-        url: finalUrl,
-        confidenceUrl: finalConfidenceUrl,
-        structureSequence: finalStructureSequence,
+        url: model?.url,
+        confidenceUrl: model?.confidenceUrl,
+        modelAccession: model?.accession,
+        structureSequence,
+        noModel,
         error,
         loadingStatuses,
-        isSequenceSearchLoading,
-        showStructureSelectors: !!isoformSequences &&
-            !!selectedTranscript &&
-            (isSequenceMode || !!(finalStructureSequence && finalUniprotId)),
-        sequencesMatch: !isStructureValidating &&
+        // While the structure is refetched, structureSequence is still the previous
+        // selection's (keepPreviousData), so a match is unknown until it settles.
+        sequencesMatch: !isAlphaFoldValidating &&
             userSelectedProteinSequence?.seq &&
-            finalStructureSequence
-            ? stripStopCodon(userSelectedProteinSequence.seq) ===
-                finalStructureSequence
+            structureSequence
+            ? stripStopCodon(userSelectedProteinSequence.seq) === structureSequence
             : undefined,
         showUniprotResults: !!isoformSequences &&
             isAutoMode &&
@@ -83,8 +54,6 @@ export default function useAlphaFoldDBSearch({ feature, view, }) {
             isAutoMode &&
             !isLookupLoading &&
             lookup.uniprotEntries.length === 0,
-        showSequenceSearchStatus: isSequenceMode,
-        showAlphaFoldDBSearchStatus: !!finalStructureSequence && !!finalUniprotId && !isSequenceMode,
         isLoading,
     };
 }

package/dist/LaunchProteinView/hooks/useAlphaFoldData.js

@@ -1,17 +1,19 @@
-import useStructureFileSequence from './useStructureFileSequence';
-import { getAlphaFoldConfidenceUrl, getAlphaFoldStructureUrl, } from '../utils/structureUrls';
-export default function useAlphaFoldData({ uniprotId, }) {
-    const url = uniprotId ? getAlphaFoldStructureUrl(uniprotId) : undefined;
-    const confidenceUrl = uniprotId
-        ? getAlphaFoldConfidenceUrl(uniprotId)
-        : undefined;
-    const { sequences, isLoading, isValidating, error } = useStructureFileSequence({ url });
+import { useMemo } from 'react';
+import useSWR from 'swr';
+import { STATIC_SWR_OPTIONS } from './swrOptions';
+import useIsoformProteinSequences from './useIsoformProteinSequences';
+import { fetchAlphaFoldModels, pickAlphaFoldModel, } from '../services/alphaFoldModels';
+/** The AlphaFold DB model a launch opens for this gene's accession. */
+export default function useAlphaFoldData({ uniprotId, feature, view, }) {
+    const { data, isLoading, isValidating, error } = useSWR(uniprotId ? ['alphafold-models', uniprotId] : null, ([, id]) => fetchAlphaFoldModels(id), { ...STATIC_SWR_OPTIONS, keepPreviousData: true });
+    const { isoformSequences } = useIsoformProteinSequences({ feature, view });
+    // with an error, data is the previous accession's (keepPreviousData)
+    const model = useMemo(() => data && !error ? pickAlphaFoldModel(data, isoformSequences) : undefined, [data, error, isoformSequences]);
     return {
         isLoading,
         isValidating,
         error,
-        url,
-        confidenceUrl,
-        structureSequences: sequences,
+        model,
+        noModel: !!uniprotId && !isLoading && !error && data?.length === 0,
     };
 }

package/dist/LaunchProteinView/hooks/useFoldseekSearch.js

@@ -80,12 +80,15 @@ export default function useFoldseekSearch() {
             }
         }
     };
+    // the aborted operation's own finally skips these, so reset clears them
     const reset = () => {
         abortRef.current?.abort();
         setResults(undefined);
         setPredictData(undefined);
         setError(undefined);
         setStatusMessage('');
+        setIsLoading(false);
+        setIsPredicting(false);
     };
     return {
         results,

package/dist/LaunchProteinView/hooks/useTranscriptIsoformSelection.js

@@ -1,6 +1,8 @@
+import { useMemo } from 'react';
 import useIsoformProteinSequences from './useIsoformProteinSequences';
 import useTranscriptSelection from './useTranscriptSelection';
-import { getId, getTranscriptFeatures, pickStructureSequence, } from '../utils/util';
+import { pickStructureSequence } from '../utils/isoformRanking';
+import { getId, getTranscriptFeatures } from '../utils/util';
 // Bundles the transcript-isoform wiring shared by all three launch tabs:
 // list transcripts, fetch their protein sequences, pick which chain of the
 // structure to compare against, auto/manually select a transcript, and resolve
@@ -11,7 +13,8 @@ export default function useTranscriptIsoformSelection({ feature, view, structure
         feature,
         view,
     });
-    const structureSequence = pickStructureSequence(structureSequences, isoformSequences);
+    // one alignment per chain, so not once per render
+    const structureSequence = useMemo(() => pickStructureSequence(structureSequences, isoformSequences), [structureSequences, isoformSequences]);
     const { userSelection, setUserSelection } = useTranscriptSelection({
         options: transcripts,
         isoformSequences,

package/dist/LaunchProteinView/hooks/useTranscriptSelection.js

@@ -1,5 +1,5 @@
 import { useState } from 'react';
-import { selectBestTranscript } from '../utils/util';
+import { selectBestTranscript } from '../utils/isoformRanking';
 export default function useTranscriptSelection({ options, isoformSequences, structureSequence, resetKey, }) {
     const [userSelection, setUserSelection] = useState();
     const [prevResetKey, setPrevResetKey] = useState(resetKey);

package/dist/LaunchProteinView/hooks/useUniProtIdLookup.js

@@ -8,8 +8,7 @@ import { extractFeatureIdentifiers, extractTaxonId } from '../utils/util';
 /**
  * Which UniProt entry a feature is, by the dialog's lookup modes: the
  * feature's own attribute, the ID-mapping search over its recognised ids and
- * gene name, a typed accession, or none (sequence mode, where the structure
- * search itself names the entry). Shared by every tab that starts from an
+ * gene name, or a typed accession. Shared by every tab that starts from an
  * accession so they agree on what the gene is.
  */
 export default function useUniProtIdLookup({ feature, view, }) {
@@ -39,7 +38,6 @@ export default function useUniProtIdLookup({ feature, view, }) {
     const [selectedUniprotId, setSelectedUniprotId] = useState();
     const featureUniprotId = geneIds.uniprotId;
     const effectiveLookupMode = lookupMode === 'auto' && featureUniprotId ? 'feature' : lookupMode;
-    const isSequenceMode = effectiveLookupMode === 'sequence';
     const isAutoMode = effectiveLookupMode === 'auto';
     const { entries: uniprotEntries, isLoading: isLookupLoading, error: lookupError, } = useUniProtSearch({
         recognizedIds: geneIds.recognizedIds,
@@ -52,14 +50,17 @@ export default function useUniProtIdLookup({ feature, view, }) {
     // Debounce manual entry so fetches don't fire on every keystroke and
     // pollute the SWR cache with partial-ID 404s.
     const debouncedManualUniprotId = useDebouncedValue(manualUniprotId, 400);
+    // a row picked from an earlier search (another taxon, another identifier)
+    // stops counting once the table no longer lists it
+    const pickedUniprotId = uniprotEntries.some(e => e.accession === selectedUniprotId)
+        ? selectedUniprotId
+        : undefined;
     const autoUniprotId = uniprotEntries[0]?.accession;
     const uniprotId = effectiveLookupMode === 'feature'
         ? featureUniprotId
         : isAutoMode
-            ? (selectedUniprotId ?? autoUniprotId)
-            : effectiveLookupMode === 'manual'
-                ? debouncedManualUniprotId
-                : undefined;
+            ? (pickedUniprotId ?? autoUniprotId)
+            : debouncedManualUniprotId;
     return {
         lookupMode: effectiveLookupMode,
         setLookupMode,
@@ -71,9 +72,8 @@ export default function useUniProtIdLookup({ feature, view, }) {
         effectiveTaxonId: effectiveTaxonId ?? 9606,
         selectedQueryId,
         setSelectedQueryId,
-        selectedUniprotId,
         setSelectedUniprotId,
-        selectedTableAccession: selectedUniprotId ?? autoUniprotId,
+        selectedTableAccession: pickedUniprotId ?? autoUniprotId,
         uniprotEntries,
         isLookupLoading,
         lookupError,
@@ -82,7 +82,6 @@ export default function useUniProtIdLookup({ feature, view, }) {
         recognizedIds: geneIds.recognizedIds,
         geneName: geneIds.geneName,
         isAutoMode,
-        isSequenceMode,
         showIdentifierSelector: isAutoMode && (geneIds.recognizedIds.length > 0 || !!geneIds.geneName),
         searchDescription: getSearchDescription({
             selectedQueryId,