jbrowse-plugin-protein3d 0.6.0 → 0.7.0

package/dist/AddHighlightModel/GenomeTo1DProteinHoverHighlight.js

@@ -20,11 +20,14 @@ const GenomeTo1DProteinHoverHighlight = observer(function GenomeTo1DProteinHover
     if (!checkHovered(hovered)) {
         return null;
     }
-    const { coord } = hovered.hoverPosition;
+    const { coord, refName } = hovered.hoverPosition;
     const feature = new SimpleFeature(protein1DInfo.feature);
     const mapping = genomeToTranscriptSeqMapping(feature);
     const { g2p } = mapping;
-    const proteinPos = g2p[coord - 1];
+    // g2p is keyed by genomic position on the transcript's own refName; without
+    // this gate the same numeric coord on an unrelated chromosome would match a
+    // key and light a protein residue for a different locus.
+    const proteinPos = refName === mapping.refName ? g2p[coord - 1] : undefined;
     if (proteinPos === undefined) {
         return null;
     }

package/dist/AddHighlightModel/ProteinToMsaHoverSync.js

@@ -43,6 +43,10 @@ const ProteinToMsaHoverSync = observer(function ProteinToMsaHoverSync({ model, }
                         : seqPos;
                     setMousePos(col);
                 }
+                else {
+                    // structure went away (e.g. removed); clear the stale MSA hover
+                    setMousePos(undefined);
+                }
             }));
         }
         disposers.push(autorun(() => {

package/dist/AlphaFoldConfidenceAdapter/AlphaFoldConfidenceAdapter.d.ts

@@ -1,18 +1,18 @@
-import { BaseFeatureDataAdapter } from '@jbrowse/core/data_adapters/BaseAdapter';
-import type { BaseOptions } from '@jbrowse/core/data_adapters/BaseAdapter';
-import type { Feature, Region } from '@jbrowse/core/util';
-import type { Observable } from 'rxjs';
-export default class AlphaFoldConfidenceAdapter extends BaseFeatureDataAdapter {
-    static capabilities: string[];
-    feats: Promise<{
-        uniqueId: string;
-        start: number;
-        end: number;
-        score: number;
-    }[]> | undefined;
-    private loadDataP;
-    private loadData;
-    getRefNames(_opts?: BaseOptions): Promise<never[]>;
-    getFeatures(query: Region, _opts?: BaseOptions): Observable<Feature>;
-    freeResources(): void;
+import { BaseProteinAnnotationAdapter, type ProteinAnnotationRow } from '../BaseProteinAnnotationAdapter';
+export interface AlphaFoldConfidenceRow extends ProteinAnnotationRow {
+    score: number;
 }
+interface AlphaFoldConfidenceJson {
+    residueNumber: number[];
+    confidenceScore: number[];
+}
+/**
+ * Converts AlphaFold confidence JSON to features. residueNumber is 1-based, so
+ * residue n becomes the 0-based half-open interval [n-1, n) to line up with the
+ * interbase protein reference sequence.
+ */
+export declare function parseAlphaFoldConfidence(json: AlphaFoldConfidenceJson): AlphaFoldConfidenceRow[];
+export default class AlphaFoldConfidenceAdapter extends BaseProteinAnnotationAdapter<AlphaFoldConfidenceRow> {
+    protected loadFeatures(): Promise<AlphaFoldConfidenceRow[]>;
+}
+export {};

package/dist/AlphaFoldConfidenceAdapter/AlphaFoldConfidenceAdapter.js

@@ -1,40 +1,21 @@
-import { BaseFeatureDataAdapter } from '@jbrowse/core/data_adapters/BaseAdapter';
-import { SimpleFeature, doesIntersect2 } from '@jbrowse/core/util';
 import { openLocation } from '@jbrowse/core/util/io';
-import { ObservableCreate } from '@jbrowse/core/util/rxjs';
-export default class AlphaFoldConfidenceAdapter extends BaseFeatureDataAdapter {
-    static capabilities = ['getFeatures', 'getRefNames'];
-    feats;
-    async loadDataP() {
-        const scores = JSON.parse(await openLocation(this.getConf('location')).readFile('utf8'));
-        return scores.residueNumber.map((value, idx) => ({
-            uniqueId: `feat-${idx}`,
-            start: value,
-            end: value + 1,
-            score: scores.confidenceScore[idx],
-        }));
-    }
-    async loadData(_opts = {}) {
-        this.feats ??= this.loadDataP().catch((e) => {
-            this.feats = undefined;
-            throw e;
-        });
-        return this.feats;
-    }
-    async getRefNames(_opts = {}) {
-        return [];
-    }
-    getFeatures(query, _opts = {}) {
-        return ObservableCreate(async (observer) => {
-            const { start, end, refName } = query;
-            const data = await this.loadData();
-            for (const f of data) {
-                if (doesIntersect2(f.start, f.end, start, end)) {
-                    observer.next(new SimpleFeature({ ...f, refName }));
-                }
-            }
-            observer.complete();
-        });
+import { BaseProteinAnnotationAdapter, } from '../BaseProteinAnnotationAdapter';
+/**
+ * Converts AlphaFold confidence JSON to features. residueNumber is 1-based, so
+ * residue n becomes the 0-based half-open interval [n-1, n) to line up with the
+ * interbase protein reference sequence.
+ */
+export function parseAlphaFoldConfidence(json) {
+    return json.residueNumber.map((residue, idx) => ({
+        uniqueId: `feat-${idx}`,
+        start: residue - 1,
+        end: residue,
+        score: json.confidenceScore[idx],
+    }));
+}
+export default class AlphaFoldConfidenceAdapter extends BaseProteinAnnotationAdapter {
+    async loadFeatures() {
+        const json = JSON.parse(await openLocation(this.getConf('location')).readFile('utf8'));
+        return parseAlphaFoldConfidence(json);
     }
-    freeResources() { }
 }

package/dist/AlphaMissensePathogenicityAdapter/AlphaMissensePathogenicityAdapter.d.ts

@@ -1,28 +1,26 @@
-import { BaseFeatureDataAdapter } from '@jbrowse/core/data_adapters/BaseAdapter';
+import { BaseProteinAnnotationAdapter, type ProteinAnnotationRow } from '../BaseProteinAnnotationAdapter';
 import type { BaseOptions } from '@jbrowse/core/data_adapters/BaseAdapter';
-import type { Feature, Region } from '@jbrowse/core/util';
-import type { Observable } from 'rxjs';
-export interface AlphaMissenseRow {
-    uniqueId: string;
-    start: number;
-    end: number;
+import type { Region } from '@jbrowse/core/util';
+export interface AlphaMissenseRow extends ProteinAnnotationRow {
     score: number;
     ref: string;
     variant: string;
     am_class: string;
 }
-/**
- * Parses AlphaMissense CSV text (protein_variant,score,am_class). The
- * protein_variant column looks like "V123L": a ref AA, a 1-based residue
- * coordinate, and a variant AA. Rows that don't parse to a numeric coordinate
- * are skipped rather than emitted as bogus position-0 features.
- */
 export declare function parseAlphaMissense(text: string): AlphaMissenseRow[];
-export default class AlphaMissensePathogenicityAdapter extends BaseFeatureDataAdapter {
-    static capabilities: string[];
-    feats: Promise<AlphaMissenseRow[]> | undefined;
-    private loadDataP;
-    private loadData;
+export default class AlphaMissensePathogenicityAdapter extends BaseProteinAnnotationAdapter<AlphaMissenseRow> {
+    protected loadFeatures(): Promise<AlphaMissenseRow[]>;
+    protected featureData(row: AlphaMissenseRow, refName: string): {
+        refName: string;
+        source: string;
+        score: number;
+        ref: string;
+        variant: string;
+        am_class: string;
+        uniqueId: string;
+        start: number;
+        end: number;
+    };
     getGlobalStats(_opts?: BaseOptions): Promise<{
         scoreMin: number;
         scoreMax: number;
@@ -30,11 +28,8 @@ export default class AlphaMissensePathogenicityAdapter extends BaseFeatureDataAd
     getMultiRegionFeatureDensityStats(_regions: Region[]): Promise<{
         featureDensity: number;
     }>;
-    getRefNames(_opts?: BaseOptions): Promise<never[]>;
-    getFeatures(query: Region, _opts?: BaseOptions): Observable<Feature>;
     getSources(): Promise<{
         name: string;
         __name: string;
     }[]>;
-    freeResources(): void;
 }

package/dist/AlphaMissensePathogenicityAdapter/AlphaMissensePathogenicityAdapter.js

@@ -1,13 +1,15 @@
-import { BaseFeatureDataAdapter } from '@jbrowse/core/data_adapters/BaseAdapter';
-import { SimpleFeature, doesIntersect2, max, min } from '@jbrowse/core/util';
+import { max, min } from '@jbrowse/core/util';
 import { openLocation } from '@jbrowse/core/util/io';
-import { ObservableCreate } from '@jbrowse/core/util/rxjs';
+import { BaseProteinAnnotationAdapter, } from '../BaseProteinAnnotationAdapter';
 /**
  * Parses AlphaMissense CSV text (protein_variant,score,am_class). The
  * protein_variant column looks like "V123L": a ref AA, a 1-based residue
- * coordinate, and a variant AA. Rows that don't parse to a numeric coordinate
- * are skipped rather than emitted as bogus position-0 features.
+ * coordinate, and a variant AA, converted here to a 0-based half-open interval
+ * to match the interbase protein reference sequence. Rows that don't match the
+ * ref/coord/variant shape are skipped rather than emitted as bogus features (a
+ * short string like "VL" would otherwise parse to a position-0 feature).
  */
+const VARIANT_RE = /^([A-Za-z])(\d+)([A-Za-z])$/;
 export function parseAlphaMissense(text) {
     return text
         .split('\n')
@@ -16,21 +18,15 @@ export function parseAlphaMissense(text) {
         .filter(f => !!f)
         .flatMap((row, idx) => {
         const [protein_variant = '', score, am_class] = row.split(',');
-        const ref = protein_variant[0];
-        const variant = protein_variant.at(-1);
-        const coord = +protein_variant.slice(1, -1);
-        return ref !== undefined &&
-            variant !== undefined &&
-            !Number.isNaN(coord) &&
-            score !== undefined &&
-            am_class !== undefined
+        const match = VARIANT_RE.exec(protein_variant);
+        return match && score !== undefined && am_class !== undefined
             ? [
                 {
                     uniqueId: `feat-${idx}`,
-                    ref,
-                    variant,
-                    start: coord,
-                    end: coord + 1,
+                    ref: match[1],
+                    variant: match[3],
+                    start: +match[2] - 1,
+                    end: +match[2],
                     score: +score,
                     am_class,
                 },
@@ -38,58 +34,23 @@ export function parseAlphaMissense(text) {
             : [];
     });
 }
-export default class AlphaMissensePathogenicityAdapter extends BaseFeatureDataAdapter {
-    static capabilities = ['getFeatures', 'getRefNames'];
-    feats;
-    async loadDataP() {
-        const scores = await openLocation(this.getConf('location')).readFile('utf8');
-        return parseAlphaMissense(scores);
+export default class AlphaMissensePathogenicityAdapter extends BaseProteinAnnotationAdapter {
+    async loadFeatures() {
+        return parseAlphaMissense(await openLocation(this.getConf('location')).readFile('utf8'));
     }
-    async loadData(_opts = {}) {
-        this.feats ??= this.loadDataP().catch((e) => {
-            this.feats = undefined;
-            throw e;
-        });
-        return this.feats;
+    featureData(row, refName) {
+        return { ...row, refName, source: row.variant };
     }
     async getGlobalStats(_opts) {
-        const data = await this.loadData();
-        const scores = data.map(s => s.score);
+        const scores = (await this.loadData()).map(s => s.score);
         return { scoreMin: min(scores), scoreMax: max(scores) };
     }
     // always render bigwig instead of calculating a feature density for it
     async getMultiRegionFeatureDensityStats(_regions) {
         return { featureDensity: 0 };
     }
-    async getRefNames(_opts = {}) {
-        return [];
-    }
-    getFeatures(query, _opts = {}) {
-        return ObservableCreate(async (observer) => {
-            const { start, end, refName } = query;
-            const data = await this.loadData();
-            for (const f of data) {
-                if (doesIntersect2(f.start, f.end, start, end)) {
-                    observer.next(new SimpleFeature({
-                        ...f,
-                        refName,
-                        source: f.variant,
-                    }));
-                }
-            }
-            observer.complete();
-        });
-    }
     async getSources() {
-        const sources = new Set();
-        const data = await this.loadData();
-        for (const f of data) {
-            sources.add(f.variant);
-        }
-        return [...sources].map(s => ({
-            name: s,
-            __name: s,
-        }));
+        const sources = new Set((await this.loadData()).map(f => f.variant));
+        return [...sources].map(s => ({ name: s, __name: s }));
     }
-    freeResources() { }
 }

package/dist/BaseProteinAnnotationAdapter.d.ts

@@ -0,0 +1,29 @@
+import { BaseFeatureDataAdapter } from '@jbrowse/core/data_adapters/BaseAdapter';
+import type { BaseOptions } from '@jbrowse/core/data_adapters/BaseAdapter';
+import type { Feature, Region, SimpleFeatureSerialized } from '@jbrowse/core/util';
+import type { Observable } from 'rxjs';
+export interface ProteinAnnotationRow {
+    [key: string]: unknown;
+    uniqueId: string;
+    start: number;
+    end: number;
+}
+/**
+ * Shared plumbing for the protein-annotation adapters (AlphaFold confidence,
+ * AlphaMissense, UniProt variation). Each lives on the temporary protein
+ * assembly, exposes no ref names, caches its parsed rows once, and emits the
+ * rows that intersect a query region. Subclasses supply the parsing
+ * (loadFeatures) and may decorate the emitted feature (featureData).
+ */
+export declare abstract class BaseProteinAnnotationAdapter<T extends ProteinAnnotationRow> extends BaseFeatureDataAdapter {
+    static capabilities: string[];
+    private feats;
+    /** Parse the configured source into rows. */
+    protected abstract loadFeatures(): Promise<T[]>;
+    /** Fields for the emitted feature; override to add extras (e.g. `source`). */
+    protected featureData(row: T, refName: string): SimpleFeatureSerialized;
+    protected loadData(): Promise<T[]>;
+    getRefNames(_opts?: BaseOptions): Promise<never[]>;
+    getFeatures(query: Region, _opts?: BaseOptions): Observable<Feature>;
+    freeResources(): void;
+}

package/dist/BaseProteinAnnotationAdapter.js

@@ -0,0 +1,41 @@
+import { BaseFeatureDataAdapter } from '@jbrowse/core/data_adapters/BaseAdapter';
+import { SimpleFeature, doesIntersect2 } from '@jbrowse/core/util';
+import { ObservableCreate } from '@jbrowse/core/util/rxjs';
+/**
+ * Shared plumbing for the protein-annotation adapters (AlphaFold confidence,
+ * AlphaMissense, UniProt variation). Each lives on the temporary protein
+ * assembly, exposes no ref names, caches its parsed rows once, and emits the
+ * rows that intersect a query region. Subclasses supply the parsing
+ * (loadFeatures) and may decorate the emitted feature (featureData).
+ */
+export class BaseProteinAnnotationAdapter extends BaseFeatureDataAdapter {
+    static capabilities = ['getFeatures', 'getRefNames'];
+    feats;
+    /** Fields for the emitted feature; override to add extras (e.g. `source`). */
+    featureData(row, refName) {
+        return { ...row, refName };
+    }
+    // Parse once and cache; a failed parse clears the cache so it can retry.
+    loadData() {
+        this.feats ??= this.loadFeatures().catch((e) => {
+            this.feats = undefined;
+            throw e;
+        });
+        return this.feats;
+    }
+    async getRefNames(_opts = {}) {
+        return [];
+    }
+    getFeatures(query, _opts = {}) {
+        return ObservableCreate(async (observer) => {
+            const { start, end, refName } = query;
+            for (const f of await this.loadData()) {
+                if (doesIntersect2(f.start, f.end, start, end)) {
+                    observer.next(new SimpleFeature(this.featureData(f, refName)));
+                }
+            }
+            observer.complete();
+        });
+    }
+    freeResources() { }
+}

package/dist/LaunchProteinView/components/FoldseekSearch.js

@@ -36,9 +36,19 @@ const FoldseekSearch = observer(function FoldseekSearch({ feature, session, view
         ? stripStopCodon(selectedIsoformData.seq)
         : '';
     const sequence = userEditedSequence ?? cleanedSequence;
+    // Any change to the input sequence makes an existing 3Di prediction (and any
+    // results derived from it) stale. Clearing it returns the UI to the Predict
+    // step so a search can't silently run against the previously-predicted
+    // sequence after the user switches transcript or edits the residues.
+    const invalidatePrediction = () => {
+        if (di3Sequence !== undefined || results !== undefined) {
+            reset();
+        }
+    };
     const setUserSelectionWithReset = (id) => {
         setUserSelection(id);
         setUserEditedSequence(undefined);
+        invalidatePrediction();
     };
     const canPredict = sequence.trim().length > 0 && !isPredicting && !isLoading;
     const canSearch = !!cleanedAaSequence &&
@@ -55,6 +65,7 @@ const FoldseekSearch = observer(function FoldseekSearch({ feature, session, view
                 React.createElement(TranscriptSelector, { val: effectiveSelectedTranscriptId, setVal: setUserSelectionWithReset, isoforms: transcripts, isoformSequences: isoformSequences, feature: feature, disabled: isBusy }),
                 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,
                     } }))) : null,

package/dist/LaunchProteinView/hooks/useUniProtSearch.js

@@ -24,6 +24,7 @@ export default function useUniProtSearch({ recognizedIds = [], geneId, geneName,
             selectedQueryId,
             idsToSearch.join(','),
             geneNameToSearch,
+            geneId,
         ]
         : null, async () => searchUniProtEntries({
         recognizedIds: idsToSearch,

package/dist/LaunchProteinView/services/lookupMethods.js

@@ -53,7 +53,7 @@ export async function searchUniProtEntries({ recognizedIds = [], geneId, geneNam
     let geneNameError;
     if (!entries.some(e => e.isReviewed) && geneName) {
         try {
-            const query = `gene:${geneName}+AND+organism_id:${organismId}+AND+reviewed:true`;
+            const query = `gene:${geneName} AND organism_id:${organismId} AND reviewed:true`;
             const geneNameResults = await searchUniProt(query, 5);
             entries = deduplicateEntries([...entries, ...geneNameResults]);
         }

package/dist/LaunchProteinView/utils/launchViewUtils.js

@@ -1,6 +1,7 @@
 import { isSessionWithAddTracks } from '@jbrowse/core/util';
 import { maybeLaunchSideBySide } from './sideBySide';
 import { getGeneDisplayName, getTranscriptDisplayName } from './util';
+import { proteinViewSnapshot } from '../../ProteinView/proteinViewSpec';
 import { launchProteinAnnotationView } from '../components/launchProteinAnnotationView';
 export const ALPHAFOLD_VERSION = 'v6';
 export function getAlphaFoldStructureUrl(uniprotId, version = ALPHAFOLD_VERSION) {
@@ -60,22 +61,21 @@ export function formatViewName(prefix, feature, selectedTranscript, uniprotId) {
         .join(' - ');
 }
 export function launch3DProteinView({ session, view, feature, selectedTranscript, uniprotId, url, data, userProvidedTranscriptSequence, alignmentAlgorithm, displayName, connectedMsaViewId, sideBySide, }) {
-    const snap = {
-        type: 'ProteinView',
+    const snap = proteinViewSnapshot({
         alignmentAlgorithm,
         connectedMsaViewId,
+        displayName: displayName ??
+            formatViewName('Protein view', feature, selectedTranscript, uniprotId),
         structures: [
             {
                 url,
                 data,
-                userProvidedTranscriptSequence: userProvidedTranscriptSequence ?? '',
+                userProvidedTranscriptSequence,
                 feature: selectedTranscript?.toJSON(),
                 connectedViewId: view.id,
             },
         ],
-        displayName: displayName ??
-            formatViewName('Protein view', feature, selectedTranscript, uniprotId),
-    };
+    });
     const proteinView = session.addView('ProteinView', snap);
     maybeLaunchSideBySide(session, proteinView.id, sideBySide);
     return proteinView;

package/dist/LaunchProteinViewExtensionPoint/index.js

@@ -1,5 +1,6 @@
 import { resolveShortLaunch } from './resolveShortLaunch';
 import { maybeLaunchSideBySide } from '../LaunchProteinView/utils/sideBySide';
+import { proteinViewSnapshot } from '../ProteinView/proteinViewSpec';
 export default function LaunchProteinViewExtensionPointF(pluginManager) {
     pluginManager.addToExtensionPoint('LaunchView-ProteinView', 
     // LaunchView extension points are typed as transformers `(extendee, props)
@@ -51,8 +52,7 @@ export default function LaunchProteinViewExtensionPointF(pluginManager) {
                     init: connectedView,
                 }).id
                 : undefined);
-        const proteinView = session.addView('ProteinView', {
-            type: 'ProteinView',
+        const proteinView = session.addView('ProteinView', proteinViewSnapshot({
             alignmentAlgorithm,
             displayName,
             height,
@@ -63,14 +63,13 @@ export default function LaunchProteinViewExtensionPointF(pluginManager) {
                 {
                     url: finalUrl,
                     userProvidedTranscriptSequence: resolved?.userProvidedTranscriptSequence ??
-                        userProvidedTranscriptSequence ??
-                        '',
+                        userProvidedTranscriptSequence,
                     feature: resolved?.feature ?? feature,
                     connectedViewId: resolvedConnectedViewId,
                     initialSelection,
                 },
             ],
-        });
+        }));
         if (ownsConnectedView) {
             maybeLaunchSideBySide(session, proteinView.id, sideBySide);
         }

package/dist/Protein1DViewRegistry/index.d.ts

@@ -15,8 +15,13 @@ declare class Protein1DViewRegistry {
     constructor();
     register(info: Protein1DViewInfo): void;
     unregister(viewId: string): void;
-    cleanupStaleViews(session: SessionWithViews): void;
     get(viewId: string): Protein1DViewInfo | undefined;
+    /**
+     * Pure lookup. When a session is supplied, entries whose view has since been
+     * closed are skipped rather than deleted, so this stays side-effect-free and
+     * safe to call from an observer's render (mutating the observable map there
+     * would be a MobX anti-pattern).
+     */
     getByUniprotId(uniprotId: string, session?: SessionWithViews): Protein1DViewInfo | undefined;
     get entries(): Protein1DViewInfo[];
     getGenomeHighlightForProteinPosition(uniprotId: string, proteinPos: number, session?: SessionWithViews): {

package/dist/Protein1DViewRegistry/index.js

@@ -7,7 +7,6 @@ class Protein1DViewRegistry {
         makeObservable(this, {
             register: action,
             unregister: action,
-            cleanupStaleViews: action,
             entries: computed,
         });
     }
@@ -17,23 +16,22 @@ class Protein1DViewRegistry {
     unregister(viewId) {
         this.views.delete(viewId);
     }
-    cleanupStaleViews(session) {
-        const activeViewIds = new Set(session.views.map(v => v.id));
-        for (const viewId of this.views.keys()) {
-            if (!activeViewIds.has(viewId)) {
-                this.views.delete(viewId);
-            }
-        }
-    }
     get(viewId) {
         return this.views.get(viewId);
     }
+    /**
+     * Pure lookup. When a session is supplied, entries whose view has since been
+     * closed are skipped rather than deleted, so this stays side-effect-free and
+     * safe to call from an observer's render (mutating the observable map there
+     * would be a MobX anti-pattern).
+     */
     getByUniprotId(uniprotId, session) {
-        if (session) {
-            this.cleanupStaleViews(session);
-        }
+        const liveViewIds = session
+            ? new Set(session.views.map(v => v.id))
+            : undefined;
         for (const info of this.views.values()) {
-            if (info.uniprotId === uniprotId) {
+            if (info.uniprotId === uniprotId &&
+                (!liveViewIds || liveViewIds.has(info.viewId))) {
                 return info;
             }
         }
@@ -44,17 +42,12 @@ class Protein1DViewRegistry {
     }
     getGenomeHighlightForProteinPosition(uniprotId, proteinPos, session) {
         const info = this.getByUniprotId(uniprotId, session);
-        if (!info) {
-            return undefined;
-        }
-        const feature = new SimpleFeature(info.feature);
-        const mapping = genomeToTranscriptSeqMapping(feature);
-        if (!mapping) {
-            return undefined;
+        if (info) {
+            const { p2gCodon, refName } = genomeToTranscriptSeqMapping(new SimpleFeature(info.feature));
+            const span = codonGenomeSpan(p2gCodon, proteinPos);
+            return span ? { refName, start: span[0], end: span[1] } : undefined;
         }
-        const { p2gCodon, refName } = mapping;
-        const span = codonGenomeSpan(p2gCodon, proteinPos);
-        return span ? { refName, start: span[0], end: span[1] } : undefined;
+        return undefined;
     }
 }
 export const protein1DViewRegistry = new Protein1DViewRegistry();

package/dist/ProteinView/components/AddStructureDialog.js

@@ -36,7 +36,7 @@ const AddStructureDialog = observer(function AddStructureDialog({ model, }) {
                 data = await file.text();
             }
             if (url !== undefined || data !== undefined) {
-                await model.addStructureAndSuperpose({ url, data });
+                model.addStructure({ url, data });
                 handleClose();
             }
         }

package/dist/ProteinView/components/FeatureBar.js

@@ -1,8 +1,8 @@
 import React, { useState } from 'react';
 import { Tooltip } from '@mui/material';
 import { observer } from 'mobx-react';
-import { setMolstarLoci } from '../applyLociInteractivity';
 import { HOVERED_BORDER, SELECTED_BORDER } from '../constants';
+import { oneBasedUniProtFeatureToStructureRange } from '../hooks/useProteinFeatureTrackData';
 import { getFeatureColor } from '../hooks/useUniProtFeatures';
 import { clickProteinToGenome } from '../proteinToGenomeMapping';
 function FeatureTooltipContent({ feature }) {
@@ -18,7 +18,7 @@ function FeatureTooltipContent({ feature }) {
 }
 const FeatureBar = observer(function FeatureBar({ layout, top, model, }) {
     const [isHovered, setIsHovered] = useState(false);
-    const { molstarPluginContext, selectedFeatureId } = model;
+    const { selectedFeatureId } = model;
     const { feature, left, width } = layout;
     const isSelected = selectedFeatureId === feature.uniqueId;
     const handleMouseEnter = () => {
@@ -32,38 +32,28 @@ const FeatureBar = observer(function FeatureBar({ layout, top, model, }) {
         setIsHovered(false);
         model.setAlignmentHoverRange(undefined);
     };
+    // The model's `select` autorun owns the magenta molstar selection, deriving
+    // it from clickedStructureRange. Setting/clearing that range here (rather than
+    // also driving molstar imperatively) keeps a single source of truth: on
+    // deselect the autorun correctly falls back to the whole-alignment highlight
+    // when showHighlight is on, instead of blanking the selection.
     const handleClick = () => {
-        const structure = model.molstarStructure;
-        const newSelected = !isSelected;
-        if (structure && molstarPluginContext) {
-            setMolstarLoci({
-                structure,
-                plugin: molstarPluginContext,
-                channel: 'select',
-                entityId: model.mappedEntityId,
-                spec: newSelected
-                    ? { kind: 'range', start: feature.start - 1, end: feature.end }
-                    : undefined,
-            }).catch((e) => {
-                console.error(e);
-                model.setError(e);
-            });
+        if (isSelected) {
+            model.setSelectedFeatureId(undefined);
+            model.setClickedStructureRange(undefined);
         }
-        if (newSelected) {
+        else {
+            const { start, end } = oneBasedUniProtFeatureToStructureRange(feature);
             model.setSelectedFeatureId(feature.uniqueId);
             clickProteinToGenome({
                 model,
-                structureSeqPos: feature.start - 1,
-                structureSeqEndPos: feature.end,
+                structureSeqPos: start,
+                structureSeqEndPos: end,
             }).catch((e) => {
                 console.error(e);
                 model.setError(e);
             });
         }
-        else {
-            model.setSelectedFeatureId(undefined);
-            model.setClickedStructureRange(undefined);
-        }
     };
     const color = getFeatureColor(feature.type);
     return (React.createElement(Tooltip, { title: React.createElement(FeatureTooltipContent, { feature: feature }), followCursor: true },