jbrowse-plugin-protein3d 0.11.0 → 0.11.1

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/proteinViewLookup.d.ts

@@ -8,19 +8,9 @@ import type { AbstractSessionModel } from '@jbrowse/core/util';
  */
 export interface HighlightSourceProteinView {
     id: string;
-    connectedMsaViewId?: string;
     structures: JBrowsePluginProteinStructureModel[];
-    primaryStructure?: JBrowsePluginProteinStructureModel;
 }
 export declare function getProteinViews(session: AbstractSessionModel): HighlightSourceProteinView[];
-/**
- * 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 declare function getProteinView(session: AbstractSessionModel): HighlightSourceProteinView | undefined;
 interface ConnectableStructure {
     connectedViewId?: string;
 }

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.d.ts

@@ -1,10 +1,8 @@
 import React from 'react';
 import type { IsoformSequences } from '../utils/util';
-import type { Feature } from '@jbrowse/core/util';
-export default function AlphaFoldDBSearchStatus({ uniprotId, selectedTranscript, structureSequence, isoformSequences, url, }: {
-    uniprotId?: string;
-    selectedTranscript?: Feature;
-    structureSequence?: string;
+export default function AlphaFoldDBSearchStatus({ uniprotId, structureSequence, isoformSequences, url, }: {
+    uniprotId: string;
+    structureSequence: string;
     isoformSequences: IsoformSequences;
     url?: string;
 }): React.JSX.Element;

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

@@ -77,7 +77,7 @@ const FoldseekSearch = observer(function FoldseekSearch({ feature, session, view
                     } }))) : 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.d.ts

@@ -1,16 +1,12 @@
 import React from 'react';
-import type { SequenceSearchType } from '../hooks/useAlphaFoldSequenceSearch';
-export type LookupMode = 'auto' | 'manual' | 'feature' | 'sequence';
+export type LookupMode = 'auto' | 'manual' | 'feature';
 interface UniProtIdInputProps {
     lookupMode: LookupMode;
     onLookupModeChange: (mode: LookupMode) => void;
     manualUniprotId: string;
     onManualUniprotIdChange: (id: string) => void;
     featureUniprotId?: string;
-    hasProteinSequence?: boolean;
-    sequenceSearchType?: SequenceSearchType;
-    onSequenceSearchTypeChange?: (type: SequenceSearchType) => void;
     endContent?: React.ReactNode;
 }
-export default function UniProtIdInput({ lookupMode, onLookupModeChange, manualUniprotId, onManualUniprotIdChange, featureUniprotId, hasProteinSequence, sequenceSearchType, onSequenceSearchTypeChange, endContent, }: UniProtIdInputProps): React.JSX.Element;
+export default function UniProtIdInput({ lookupMode, onLookupModeChange, manualUniprotId, onManualUniprotIdChange, featureUniprotId, endContent, }: UniProtIdInputProps): React.JSX.Element;
 export {};

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/proteinTrackSetup.js

@@ -150,8 +150,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.d.ts

@@ -1,31 +1,25 @@
-import type { SequenceSearchType } from './useAlphaFoldSequenceSearch';
 import type { Feature } from '@jbrowse/core/util';
 import type { LinearGenomeViewModel } from '@jbrowse/plugin-linear-genome-view';
 export default function useAlphaFoldDBSearch({ feature, view, }: {
     feature: Feature;
     view: LinearGenomeViewModel;
 }): {
-    sequenceSearchType: SequenceSearchType;
-    setSequenceSearchType: import("react").Dispatch<import("react").SetStateAction<SequenceSearchType>>;
     userSelection: string | undefined;
     setUserSelection: import("react").Dispatch<import("react").SetStateAction<string | undefined>>;
     transcriptOptions: Feature[];
     selectedTranscript: Feature | undefined;
     isoformSequences: import("../utils/util").IsoformSequences | undefined;
     userSelectedProteinSequence: import("../utils/util").IsoformSequence | undefined;
-    uniprotId: string | undefined;
     url: string | undefined;
     confidenceUrl: string | undefined;
+    modelAccession: string | undefined;
     structureSequence: string | undefined;
+    noModel: boolean;
     error: any;
     loadingStatuses: string[];
-    isSequenceSearchLoading: boolean;
-    showStructureSelectors: boolean;
     sequencesMatch: boolean | undefined;
     showUniprotResults: boolean;
     showNoResults: boolean;
-    showSequenceSearchStatus: boolean;
-    showAlphaFoldDBSearchStatus: boolean;
     isLoading: boolean;
     lookupMode: import("../components/UniProtIdInput").LookupMode;
     setLookupMode: import("react").Dispatch<import("react").SetStateAction<import("../components/UniProtIdInput").LookupMode>>;
@@ -36,17 +30,16 @@ export default function useAlphaFoldDBSearch({ feature, view, }: {
     effectiveTaxonId: number;
     selectedQueryId: string;
     setSelectedQueryId: import("react").Dispatch<import("react").SetStateAction<string>>;
-    selectedUniprotId: string | undefined;
     setSelectedUniprotId: import("react").Dispatch<import("react").SetStateAction<string | undefined>>;
     selectedTableAccession: string | undefined;
     uniprotEntries: import("../services/lookupMethods").UniProtEntry[];
     isLookupLoading: boolean;
     lookupError: any;
+    uniprotId: string | undefined;
     featureUniprotId: string | undefined;
     recognizedIds: string[];
     geneName: string | undefined;
     isAutoMode: boolean;
-    isSequenceMode: boolean;
     showIdentifierSelector: boolean;
     searchDescription: string;
     searchDescriptionOr: string;

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.d.ts

@@ -1,10 +1,15 @@
-export default function useAlphaFoldData({ uniprotId, }: {
+import type { Feature } from '@jbrowse/core/util';
+/** The AlphaFold DB model a launch opens for this gene's accession. */
+export default function useAlphaFoldData({ uniprotId, feature, view, }: {
     uniprotId?: string;
+    feature: Feature;
+    view?: {
+        assemblyNames?: string[];
+    };
 }): {
     isLoading: boolean;
     isValidating: boolean;
     error: any;
-    url: string | undefined;
-    confidenceUrl: string | undefined;
-    structureSequences: string[] | undefined;
+    model: import("../services/alphaFoldModels").AlphaFoldModel | undefined;
+    noModel: boolean;
 };

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.d.ts

@@ -4,8 +4,7 @@ import type { LinearGenomeViewModel } from '@jbrowse/plugin-linear-genome-view';
 /**
  * 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, }: {
@@ -21,7 +20,6 @@ export default function useUniProtIdLookup({ feature, view, }: {
     effectiveTaxonId: number;
     selectedQueryId: string;
     setSelectedQueryId: import("react").Dispatch<import("react").SetStateAction<string>>;
-    selectedUniprotId: string | undefined;
     setSelectedUniprotId: import("react").Dispatch<import("react").SetStateAction<string | undefined>>;
     selectedTableAccession: string | undefined;
     uniprotEntries: import("../services/lookupMethods").UniProtEntry[];
@@ -32,7 +30,6 @@ export default function useUniProtIdLookup({ feature, view, }: {
     recognizedIds: string[];
     geneName: string | undefined;
     isAutoMode: boolean;
-    isSequenceMode: boolean;
     showIdentifierSelector: boolean;
     searchDescription: string;
     searchDescriptionOr: string;