jbrowse-plugin-protein3d 1.0.0 → 1.0.1

package/dist/LaunchProteinView/components/PdbSearch.js

@@ -70,16 +70,30 @@ const PdbSearch = observer(function PdbSearch({ feature, preferredTranscriptId,
         preferredTranscriptId,
         resetKey: uniprotId,
     });
-    const loadingStatuses = [
-        isLookupLoading && 'Looking up UniProt ID',
+    const isoformStatuses = [
         isIsoformLoading && 'Loading protein sequences from transcript isoforms',
         isRanking && 'Aligning isoforms to the structure',
+    ];
+    const lookupStatuses = [
+        isLookupLoading && 'Looking up UniProt ID',
         isPdbLoading && 'Listing PDB entries from PDBe',
-    ].filter((s) => !!s);
+    ];
+    const loadingStatuses = [...lookupStatuses, ...isoformStatuses].filter((s) => !!s);
     const isLoading = loadingStatuses.length > 0;
     const error = isLoading
         ? undefined
         : (isoformError ?? lookup.lookupError ?? pdbError);
+    // A typed PDB ID exists to get around a lookup that is slow, failing or
+    // wrong, so only the isoforms it is ranked against hold its launch back
+    const typedIdOverrides = isPdbId(debouncedTypedPdbId);
+    const launchWaiting = typedIdOverrides
+        ? isoformStatuses.some(Boolean)
+        : isLoading;
+    const launchError = typedIdOverrides
+        ? launchWaiting
+            ? undefined
+            : isoformError
+        : error;
     return (React.createElement(React.Fragment, null,
         React.createElement(DialogContent, { className: classes.dialogContent },
             error ? React.createElement(ErrorMessage, { error: error }) : null,
@@ -113,6 +127,6 @@ const PdbSearch = observer(function PdbSearch({ feature, preferredTranscriptId,
                 ". The AlphaFoldDB tab has a predicted one."))) : null,
             ranking && selectedTranscript ? (React.createElement(TranscriptSelector, { val: selectedTranscriptId, setVal: setSelectedTranscriptId, structureSequence: structureSequence, feature: feature, isoforms: transcripts, ranking: ranking })) : null),
         React.createElement(DialogActions, null,
-            React.createElement(ProteinViewActions, { handleClose: handleClose, uniprotId: uniprotId, userSelectedProteinSequence: selectedIsoform, selectedTranscript: selectedTranscript, url: structureUrl, pdbId: selectedPdbId, feature: feature, view: view, session: session, sideBySide: sideBySide, onSideBySideChange: onSideBySideChange, isLoading: isLoading, error: error }))));
+            React.createElement(ProteinViewActions, { handleClose: handleClose, uniprotId: uniprotId, userSelectedProteinSequence: selectedIsoform, selectedTranscript: selectedTranscript, url: structureUrl, pdbId: selectedPdbId, feature: feature, view: view, session: session, sideBySide: sideBySide, onSideBySideChange: onSideBySideChange, isLoading: launchWaiting, error: launchError }))));
 });
 export default PdbSearch;

package/dist/LaunchProteinView/hooks/useAlphaFoldData.js

@@ -7,8 +7,11 @@ import useIsoformProteinSequences from './useIsoformProteinSequences';
 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]);
+    // keepPreviousData hands back the last accession's models after an error
+    // and after the accession is cleared, when the key is null
+    const model = useMemo(() => uniprotId && data && !error
+        ? pickAlphaFoldModel(data, isoformSequences)
+        : undefined, [uniprotId, data, error, isoformSequences]);
     return {
         isLoading,
         isValidating,

package/dist/LaunchProteinView/hooks/useUniProtIdLookup.js

@@ -17,10 +17,16 @@ export function describeOrganism(taxonId, source) {
  * to every tab, so all of them run one search and agree on what the gene is.
  */
 export default function useUniProtIdLookup({ feature, view, }) {
-    const [lookupMode, setLookupMode] = useState('auto');
+    const geneIds = extractFeatureIdentifiers(feature);
+    const featureUniprotId = geneIds.uniprotId;
+    const hasSearchableIdentifier = geneIds.recognizedIds.length > 0 || !!geneIds.geneName;
+    // Nothing to search and no accession on the feature: the auto mode has no
+    // query to run, so the dialog opens on the manual field instead of reporting
+    // an empty result for an empty query. Only the opening mode is chosen here;
+    // deciding it on every render snapped the user's pick back.
+    const [lookupMode, setLookupMode] = useState(() => featureUniprotId ? 'feature' : hasSearchableIdentifier ? 'auto' : 'manual');
     const [manualUniprotId, setManualUniprotId] = useState('');
     const [taxonIdInput, setTaxonIdInput] = useState('');
-    const geneIds = extractFeatureIdentifiers(feature);
     // The gene-name UniProt search is ambiguous across species, so scope it to
     // the assembly's organism where the assembly says what that is. jb2hubs
     // assemblies carry the NCBI taxon in the reference-sequence track metadata
@@ -46,17 +52,7 @@ export default function useUniProtIdLookup({ feature, view, }) {
     const taxonIdError = typedTaxon !== '' && !hasOverride;
     const [selectedQueryId, setSelectedQueryId] = useState('auto');
     const [selectedUniprotId, setSelectedUniprotId] = useState();
-    const featureUniprotId = geneIds.uniprotId;
-    const hasSearchableIdentifier = geneIds.recognizedIds.length > 0 || !!geneIds.geneName;
-    // Nothing to search and no accession on the feature: the auto mode has no
-    // query to run, so the dialog opens on the manual field instead of reporting
-    // an empty result for an empty query.
-    const effectiveLookupMode = lookupMode === 'auto' && featureUniprotId
-        ? 'feature'
-        : lookupMode === 'auto' && !hasSearchableIdentifier
-            ? 'manual'
-            : lookupMode;
-    const isAutoMode = effectiveLookupMode === 'auto';
+    const isAutoMode = lookupMode === 'auto';
     const { entries: uniprotEntries, isLoading: isLookupLoading, error: lookupError, partialFailure: lookupPartialFailure, } = useUniProtSearch({
         recognizedIds: geneIds.recognizedIds,
         geneId: geneIds.geneId,
@@ -74,13 +70,13 @@ export default function useUniProtIdLookup({ feature, view, }) {
         ? selectedUniprotId
         : undefined;
     const autoUniprotId = uniprotEntries[0]?.accession;
-    const uniprotId = effectiveLookupMode === 'feature'
+    const uniprotId = lookupMode === 'feature'
         ? featureUniprotId
         : isAutoMode
             ? (pickedUniprotId ?? autoUniprotId)
             : debouncedManualUniprotId;
     return {
-        lookupMode: effectiveLookupMode,
+        lookupMode,
         setLookupMode,
         manualUniprotId,
         setManualUniprotId,

package/dist/LaunchProteinView/services/foldseekApi.js

@@ -69,11 +69,35 @@ export async function submitFoldseekSearch({ aaSequence, di3Sequence, databases,
     if (!response.ok) {
         throw await httpError(response, url);
     }
-    // Read the body as text rather than response.json() so a non-JSON error page
-    // (a gateway 500's HTML) surfaces as itself instead of an opaque
-    // SyntaxError.
+    // The server answers a refusal (RATELIMIT, MAINTENANCE) with a 200 and no
+    // id, which used to be polled as ticket "undefined" for three minutes
     const text = await response.text();
-    return JSON.parse(text);
+    const ticket = parseTicket(text);
+    if (!ticket) {
+        throw new Error(`Foldseek did not accept the search: ${text.slice(0, 200)}`);
+    }
+    return ticket;
+}
+function parseTicket(text) {
+    let body;
+    try {
+        body = JSON.parse(text);
+    }
+    catch {
+        return undefined;
+    }
+    if (typeof body !== 'object' || body === null) {
+        return undefined;
+    }
+    const id = Reflect.get(body, 'id');
+    const status = Reflect.get(body, 'status');
+    return typeof id === 'string' &&
+        (status === 'PENDING' ||
+            status === 'RUNNING' ||
+            status === 'COMPLETE' ||
+            status === 'ERROR')
+        ? { id, status }
+        : undefined;
 }
 async function pollFoldseekStatus({ ticketId, signal, }) {
     // Use the /tickets endpoint (plural) with POST
@@ -114,10 +138,6 @@ export async function waitForFoldseekResults({ ticketId, onStatusChange, signal,
             throw abortError(signal);
         }
         const status = await pollFoldseekStatus({ ticketId, signal });
-        if (status.status === 'ERROR') {
-            console.error('[Foldseek] Search error:', status);
-            throw new Error(`Foldseek search failed: ${status.error ?? 'Unknown error'}`);
-        }
         if (status.status === 'COMPLETE') {
             onStatusChange?.('Fetching results...');
             const apiResponse = await getFoldseekResults({ ticketId, signal });
@@ -131,6 +151,11 @@ export async function waitForFoldseekResults({ ticketId, onStatusChange, signal,
             };
             return results;
         }
+        // the server also answers RATELIMIT, MAINTENANCE and UNKNOWN, none of
+        // which a wait resolves
+        if (status.status !== 'PENDING' && status.status !== 'RUNNING') {
+            throw new Error(`Foldseek search failed: ${status.error ?? status.status}`);
+        }
         onStatusChange?.(`Search ${status.status.toLowerCase()}... (${elapsedSeconds()}s)`);
         await timeout(1000, signal);
     }

package/dist/LaunchProteinView/utils/launchHelpers.js

@@ -22,9 +22,9 @@ export async function safeLaunch(fn, onSuccess, onError) {
  * A launch that names its own structure needs no accession. Bypassing a lookup
  * that failed or resolved the wrong gene is the whole point of typing a PDB id,
  * and the view resolves SIFTS from the entry itself; the accession only feeds
- * the feature tracks and the view's name, both of which do without it. The
- * AlphaFold tab keeps the requirement for free — its structure url is derived
- * from the accession, so no accession means no structure either.
+ * the feature tracks and the view's name, both of which do without it. On the
+ * AlphaFold tab the url is derived from the accession, so no accession means
+ * no url either; `useAlphaFoldData` makes sure of it.
  */
 export function getLaunchMissingReasons({ uniprotId, userSelectedProteinSequence, selectedTranscript, url, pdbId, }) {
     const namesOwnStructure = !!url || !!pdbId;

package/dist/ProteinView/components/ChainSelect.js

@@ -5,13 +5,16 @@ import { entityLabel } from 'p2s_mapper';
 // Which chain the transcript maps to. The structure picks the protein chain
 // the transcript explains most of, which cannot separate paralogs in a complex
 // or the halves of a chimeric construct, so the choice is exposed for the
-// cases it gets wrong.
+// cases it gets wrong. With no transcript it picks the chain hovers and the
+// ruler read.
 const ChainSelect = observer(function ChainSelect({ model, }) {
     const { entities, mappedEntity, userProvidedTranscriptSequence } = model;
-    if (!entities || entities.length < 2 || !userProvidedTranscriptSequence) {
+    if (!entities || entities.length < 2) {
         return null;
     }
-    return (React.createElement(Tooltip, { title: "Mapped chain: the one the transcript maps to", placement: "left" },
+    return (React.createElement(Tooltip, { title: userProvidedTranscriptSequence
+            ? 'Mapped chain: the one the transcript maps to'
+            : 'Chain: the one hovers read', placement: "left" },
         React.createElement(TextField, { select: true, size: "small", variant: "standard", "data-testid": "protein-mapped-chain", value: model.pendingEntityId ?? mappedEntity?.entityId ?? '', onChange: event => {
                 model.chooseEntity(event.target.value);
             }, slotProps: {

package/dist/ProteinView/components/FeatureBar.js

@@ -47,7 +47,7 @@ const FeatureBar = observer(function FeatureBar({ layout, top, selected, model,
                         structureSeqEndPos: layout.structureEnd,
                     }).catch((e) => {
                         console.error(e);
-                        model.setError(e);
+                        model.setViewError(e);
                     });
                 }
             }, onMouseEnter: () => {

package/dist/ProteinView/components/HeaderStructureRow.js

@@ -2,6 +2,8 @@ import React from 'react';
 import ChevronRightIcon from '@mui/icons-material/ChevronRight';
 import CloseIcon from '@mui/icons-material/Close';
 import ExpandMoreIcon from '@mui/icons-material/ExpandMore';
+import VisibilityIcon from '@mui/icons-material/Visibility';
+import VisibilityOffIcon from '@mui/icons-material/VisibilityOff';
 import Chip from '@mui/material/Chip';
 import IconButton from '@mui/material/IconButton';
 import Link from '@mui/material/Link';
@@ -23,11 +25,13 @@ const UniProtLink = observer(function UniProtLink({ structure, }) {
             uniprotId))) : null;
 });
 const StructureRow = observer(function StructureRow({ model, structure, readout, }) {
-    const { label, alignmentQuality: quality, statusMessage } = structure;
-    const switchable = model.showAlignment && model.structures.length > 1;
+    const { label, alignmentQuality: quality, statusMessage, hidden } = structure;
+    const several = model.structures.length > 1;
+    const switchable = model.showAlignment && several;
     const open = model.alignmentStructure === structure;
     const coveredRange = quality ? describeCoveredRange(quality) : undefined;
-    return (React.createElement("div", { "data-testid": "structure-row", "data-label": label, "data-open": switchable ? open : undefined, style: {
+    return (React.createElement("div", { "data-testid": "structure-row", "data-label": label, "data-open": switchable ? open : undefined, "data-hidden": hidden || undefined, style: {
+            opacity: hidden ? 0.6 : undefined,
             display: 'flex',
             alignItems: 'center',
             gap: 8,
@@ -47,9 +51,14 @@ const StructureRow = observer(function StructureRow({ model, structure, readout,
             React.createElement(Typography, { variant: "caption", color: "textSecondary", noWrap: true, "data-testid": "header-alignment-quality" }, describeCoverage(quality)))) : null,
         React.createElement(UniProtLink, { structure: structure }),
         React.createElement("div", { style: { flex: 1 } }),
-        open && model.showAlignment ? React.createElement(ChainSelect, { model: structure }) : null,
+        (open && model.showAlignment) ||
+            !structure.userProvidedTranscriptSequence ? (React.createElement(ChainSelect, { model: structure })) : null,
         quality && isLowSimilarity(quality) ? (React.createElement(Tooltip, { title: LOW_SIMILARITY_EXPLANATION },
             React.createElement(Chip, { size: "small", color: "warning", variant: "outlined", label: "low similarity", "data-testid": "header-low-similarity" }))) : null,
+        several || hidden ? (React.createElement(Tooltip, { title: hidden ? `Show ${label}` : `Hide ${label}` },
+            React.createElement(IconButton, { size: "small", "aria-label": hidden ? `Show ${label}` : `Hide ${label}`, "aria-pressed": hidden, onClick: () => {
+                    structure.setHidden(!hidden);
+                }, sx: { p: 0.25 } }, hidden ? (React.createElement(VisibilityOffIcon, { fontSize: "small" })) : (React.createElement(VisibilityIcon, { fontSize: "small" }))))) : null,
         React.createElement(Tooltip, { title: `Remove ${label}` },
             React.createElement(IconButton, { size: "small", "aria-label": `Remove ${label}`, onClick: () => {
                     model.removeStructure(structure);

package/dist/ProteinView/components/ManualAlignmentDialog.js

@@ -2,11 +2,11 @@ import React, { useState } from 'react';
 import { Button, Dialog, DialogActions, DialogContent, DialogTitle, TextField, Typography, } from '@mui/material';
 import { parsePairwise } from 'clustal-js';
 import { observer } from 'mobx-react';
-import { pairwiseAlignmentProblem, pairwiseAlignmentSequenceProblem, stripStopCodon, } from 'p2s_mapper';
+import { entityAlignedTo, withoutStopColumn } from '../entityAlignedTo';
 const ManualAlignmentDialog = observer(function ManualAlignmentDialog({ model, }) {
     const [alignment, setAlignment] = useState('');
     const [parseError, setParseError] = useState();
-    const { showManualAlignmentDialog, primaryStructure } = model;
+    const { showManualAlignmentDialog, alignmentStructure } = model;
     const handleClose = () => {
         setAlignment('');
         setParseError(undefined);
@@ -16,26 +16,22 @@ const ManualAlignmentDialog = observer(function ManualAlignmentDialog({ model, }
         if (alignment.trim()) {
             try {
                 const parsed = parsePairwise(alignment.trim());
-                // Rejected here rather than committed: every coordinate map is built
-                // from these two rows by the `coordinateMapper` getter, which throws on
-                // a bad pair during render — outside this catch, taking the whole view
-                // down instead of reporting a bad paste. Same predicate the map builder
-                // asserts on, so what the dialog accepts is exactly what it can use.
-                // The rows also have to spell the transcript and the mapped chain:
-                // the maps count residues along each row, so an alignment made
-                // against another isoform or chain is well-formed and wrong.
-                const problem = pairwiseAlignmentProblem(parsed) ??
-                    (primaryStructure
-                        ? pairwiseAlignmentSequenceProblem(parsed, stripStopCodon(primaryStructure.userProvidedTranscriptSequence), stripStopCodon(primaryStructure.mappedStructureSeq ?? ''))
-                        : undefined);
-                if (!primaryStructure) {
+                const entities = alignmentStructure?.entities;
+                // Rejected here rather than committed: the `coordinateMapper` getter
+                // throws on a bad pair during render, outside this catch. The check is
+                // the one the model applies to an imported alignment, so a paste whose
+                // second row spells another chain switches to that chain.
+                const fit = alignmentStructure && entities
+                    ? entityAlignedTo(parsed, alignmentStructure.userProvidedTranscriptSequence, entities, alignmentStructure.mappedEntityId)
+                    : undefined;
+                if (!alignmentStructure || !fit) {
                     setParseError('No structure loaded to apply alignment to');
                 }
-                else if (problem) {
-                    setParseError(problem);
+                else if ('problem' in fit) {
+                    setParseError(fit.problem);
                 }
                 else {
-                    primaryStructure.importAlignment(parsed);
+                    alignmentStructure.importAlignment(withoutStopColumn(parsed));
                     handleClose();
                 }
             }

package/dist/ProteinView/entityAlignedTo.js

@@ -1,5 +1,5 @@
 import { pairwiseAlignmentProblem, pairwiseAlignmentSequenceProblem, stripStopCodon, structureAlignedSeq, transcriptAlignedSeq, } from 'p2s_mapper';
-function withoutStopColumn(alignment) {
+export function withoutStopColumn(alignment) {
     const t = transcriptAlignedSeq(alignment);
     const s = structureAlignedSeq(alignment);
     const [a, b] = alignment.alns;

package/dist/ProteinView/frameSelection.js

@@ -1,14 +1,17 @@
 import { residueLoci } from './applyLociInteractivity';
 import loadMolstar from './loadMolstar';
 /**
- * Every structure loaded and aligned and, with several, superposed: the
- * reset that ends a superposition would undo any framing done before it.
+ * Every structure loaded and aligned or failed and, with several loaded,
+ * superposed: the reset that ends a superposition would undo any framing done
+ * before it. The superposer counts only what reached Mol*, so a failed
+ * structure is left out of the comparison.
  */
 export function structuresSettled(host) {
     const { structures, superposedCount } = host;
+    const loadedCount = structures.filter(s => s.loadedToMolstar).length;
     return (structures.length > 0 &&
         structures.every(s => !s.loading) &&
-        (structures.length < 2 || superposedCount === structures.length));
+        (loadedCount < 2 || superposedCount === loadedCount));
 }
 /**
  * Moves the camera to the residues. A single residue is also focused, which
@@ -45,7 +48,10 @@ export function makeSelectionFramer(host) {
         }
         // a seed resolved by the same change that settles the structure may land
         // after this run, so the plugin counts as framed only once it has targets
-        const targets = structures.flatMap(s => s.seedLit && s.molstarStructure && s.clickedLabelSeqIds.length
+        const targets = structures.flatMap(s => s.seedLit &&
+            !s.hidden &&
+            s.molstarStructure &&
+            s.clickedLabelSeqIds.length
             ? [
                 {
                     structure: s.molstarStructure,

package/dist/ProteinView/model.js

@@ -13,7 +13,7 @@ import { readStoredSettings, storeSetting, withStoredSettings, } from './storedS
 import { makeStructureLoader } from './structureLoader';
 import Structure from './structureModel';
 import { makeStructureSuperposer } from './structureSuperposer';
-import { superposeStructures } from './superposeStructures';
+import { setStructuresHidden } from './structureVisibility';
 import { attachViewInteractions } from './viewInteractions';
 // What a click and a highlight do, as opposed to what the panel shows. Named
 // here rather than in storedSettings because these are deliberately not
@@ -277,6 +277,18 @@ function stateModelFactory() {
                     });
                 }
             }));
+            addDisposer(self, autorun(() => {
+                const plugin = self.molstarPluginContext;
+                for (const s of self.structures) {
+                    const { hidden, molstarStructures: structures } = s;
+                    if (plugin && structures.length > 0) {
+                        setStructuresHidden({ plugin, structures, hidden }).catch((e) => {
+                            console.error(e);
+                            self.setError(e);
+                        });
+                    }
+                }
+            }));
             // Load structures into Molstar as they appear or whenever the plugin
             // context changes. See makeStructureLoader for why the autorun body is
             // synchronous and how it guards against duplicate/stale loads.
@@ -432,12 +444,7 @@ function stateModelFactory() {
                 {
                     label: 'Re-align structures (TM-align)',
                     onClick: () => {
-                        if (self.molstarPluginContext) {
-                            superposeStructures(self.molstarPluginContext, self.structures.map(s => s.molstarStructures)).catch((e) => {
-                                console.error(e);
-                                self.setError(e);
-                            });
-                        }
+                        self.setSuperposedCount(0);
                     },
                 },
                 {

package/dist/ProteinView/molstarExports.js

@@ -4,6 +4,7 @@ export { Mat4 } from 'molstar/lib/mol-math/linear-algebra';
 export { QueryContext, StructureElement, StructureProperties, StructureSelection, } from 'molstar/lib/mol-model/structure';
 export { tmAlign } from 'molstar/lib/mol-model/structure/structure/util/tm-align';
 export { MmcifFormat } from 'molstar/lib/mol-model-formats/structure/mmcif';
+export { setSubtreeVisibility } from 'molstar/lib/mol-plugin/behavior/static/state';
 export { PluginCommands } from 'molstar/lib/mol-plugin/commands';
 export { PluginConfig } from 'molstar/lib/mol-plugin/config';
 export { PluginContext } from 'molstar/lib/mol-plugin/context';

package/dist/ProteinView/storedSettings.js

@@ -34,8 +34,24 @@ export function withStoredSettings(snapshot, stored) {
     }
     return filled;
 }
+/**
+ * The stored settings that are booleans. Anything else in storage (an older
+ * format, a hand edit) is dropped: copied into the snapshot it fails MST's
+ * type check and the view never opens.
+ */
 export function readStoredSettings() {
-    return readStoredJson(SETTINGS_KEY);
+    const stored = readStoredJson(SETTINGS_KEY);
+    if (typeof stored !== 'object' || stored === null) {
+        return undefined;
+    }
+    const settings = {};
+    for (const key of PERSISTED_SETTINGS) {
+        const value = Reflect.get(stored, key);
+        if (typeof value === 'boolean') {
+            settings[key] = value;
+        }
+    }
+    return settings;
 }
 /** Remembers one choice, leaving the other stored settings as they were. */
 export function storeSetting(key, value) {

package/dist/ProteinView/structureLoader.js

@@ -23,6 +23,7 @@ import { removeMolstarStructure } from './removeStructure';
  */
 export function makeStructureLoader(host, fetchModels = fetchAlphaFoldModels) {
     const loadingStructures = new Set();
+    const failedIn = new WeakMap();
     /** The accession a structure still has to turn into a file, if any. */
     function unresolvedAccession(structure) {
         const { url, data, uniprotId } = structure;
@@ -70,9 +71,15 @@ export function makeStructureLoader(host, fetchModels = fetchAlphaFoldModels) {
         const accession = unresolvedAccession(structure);
         const loaded = accession === undefined
             ? loadStructureData({ structure, plugin })
-            : resolveAlphaFoldUrl(structure, accession).then(() => loadStructureData({ structure, plugin }));
+            : resolveAlphaFoldUrl(structure, accession).then(() => isAlive(structure)
+                ? loadStructureData({ structure, plugin })
+                : undefined);
         loaded
             .then(data => {
+            if (!data) {
+                loadingStructures.delete(structure);
+                return;
+            }
             if (!isAlive(structure)) {
                 // Removed while it was loading. The load still put a trajectory in
                 // Mol*, and no model owns it any more, so it would stay on the
@@ -111,6 +118,7 @@ export function makeStructureLoader(host, fetchModels = fetchAlphaFoldModels) {
             else {
                 // the structure carries its own failure: a view-wide "Failed to
                 // fetch" names neither which structure nor what it was fetching
+                failedIn.set(structure, plugin);
                 structure.setError(e);
                 console.error(e);
             }
@@ -120,7 +128,9 @@ export function makeStructureLoader(host, fetchModels = fetchAlphaFoldModels) {
         const { structures, molstarPluginContext } = host;
         if (molstarPluginContext) {
             for (const structure of structures) {
-                if (!structure.loadedToMolstar && !loadingStructures.has(structure)) {
+                if (!structure.loadedToMolstar &&
+                    !loadingStructures.has(structure) &&
+                    failedIn.get(structure) !== molstarPluginContext) {
                     loadInto(structure, molstarPluginContext);
                 }
             }