jbrowse-plugin-msaview 3.2.0 → 3.4.0

package/dist/LaunchMsaView/useQueryRowName.js

@@ -1,5 +1,5 @@
 import { useMemo, useState } from 'react';
-import { detectQueryRow, getMsaRowNames } from './detectQueryRow';
+import { findQueryRow } from './detectQueryRow';
 /**
  * The MSA row name to launch with, found by sequence rather than typed.
  *
@@ -12,15 +12,12 @@ export function useQueryRowName(msaText, proteinSequence) {
     const [override, setOverride] = useState();
     // parsing runs on every keystroke in the paste box otherwise, and an
     // alignment of a few hundred rows is not free
-    const { detected, names } = useMemo(() => ({
-        detected: detectQueryRow(msaText, proteinSequence),
-        names: getMsaRowNames(msaText),
-    }), [msaText, proteinSequence]);
+    const { names, match } = useMemo(() => findQueryRow(msaText, proteinSequence), [msaText, proteinSequence]);
     return {
-        detected,
+        detected: match,
         names,
-        querySeqName: override ?? detected?.name ?? '',
+        querySeqName: override ?? match?.name ?? '',
         setQuerySeqName: setOverride,
-        isAutoDetected: override === undefined && !!detected,
+        isAutoDetected: override === undefined && !!match,
     };
 }

package/dist/MsaViewPanel/afterCreateAutoruns.js

@@ -6,7 +6,7 @@ import { genomeToMSA } from './genomeToMSA';
 import { loadProteinDomains } from './loadProteinDomains';
 import { cleanupOldData, generateDataStoreId, retrieveMsaData, storeMsaData, } from './msaDataStore';
 import { getProteinViews } from './structureConnection';
-import { getUniprotIdFromAlphaFoldUrl } from './util';
+import { getUniprotIdFromAlphaFoldUrl, hasQueryRow } from './util';
 export function loadStoredData(self) {
     const { dataStoreId, rows } = self;
     if (dataStoreId && rows.length === 0) {
@@ -219,7 +219,7 @@ export function syncGenomeHoverToMsaColumn(self) {
  */
 function genomeHighlightsToVisibleColumns(self, field) {
     const { connectedViewId, transcriptToMsaMap, querySeqName } = self;
-    if (!transcriptToMsaMap) {
+    if (!transcriptToMsaMap || !hasQueryRow(self)) {
         return [];
     }
     const { g2p } = transcriptToMsaMap;

package/dist/MsaViewPanel/components/ErrorBoundary.d.ts

@@ -1,5 +1,5 @@
-import type { ReactNode } from 'react';
 import React, { Component } from 'react';
+import type { ReactNode } from 'react';
 interface Props {
     children: ReactNode;
 }
@@ -14,6 +14,6 @@ export declare class ErrorBoundary extends Component<Props, State> {
         error: unknown;
     };
     componentDidCatch(error: unknown, info: React.ErrorInfo): void;
-    render(): string | number | bigint | boolean | Iterable<ReactNode> | Promise<string | number | bigint | boolean | React.ReactPortal | React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | React.JSX.Element | null | undefined;
+    render(): string | number | bigint | boolean | Iterable<React.ReactNode> | Promise<string | number | bigint | boolean | React.ReactPortal | React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | Iterable<React.ReactNode> | null | undefined> | React.JSX.Element | null | undefined;
 }
 export {};

package/dist/MsaViewPanel/components/JobLink.js

@@ -2,12 +2,18 @@ import React from 'react';
 import { Typography } from '@mui/material';
 import ExternalLink from '../../components/ExternalLink';
 import { ebiBlastResultUrl } from '../../utils/ebiBlast';
+import { isPhmmerJobId, phmmerResultUrl } from '../../utils/phmmer';
 function JobLink({ jobId }) {
+    // read off the job id rather than the launch params, so a link rebuilt for an
+    // old cached job still points at the tool that actually ran it
+    const url = isPhmmerJobId(jobId)
+        ? phmmerResultUrl(jobId)
+        : ebiBlastResultUrl(jobId);
     return (React.createElement(Typography, null,
         "Job ",
         jobId,
         " (",
-        React.createElement(ExternalLink, { href: ebiBlastResultUrl(jobId) }, "see status"),
+        React.createElement(ExternalLink, { href: url }, "see status"),
         ")"));
 }
 export default JobLink;

package/dist/MsaViewPanel/components/LaunchProgress.d.ts

@@ -0,0 +1,17 @@
+import React from 'react';
+import type { JBrowsePluginMsaViewModel } from '../model';
+/**
+ * What a view shows while it is still building its alignment, and what it shows
+ * when that fails.
+ *
+ * Every launch that resolves something leaves its request on the model until it
+ * succeeds -- `blastParams`, `orthologParams`, `init` -- so one still being
+ * there IS "no alignment yet", and the error a failed launch records is only
+ * readable here. This used to key on `blastParams` alone, which left an ortholog
+ * launch rendering an empty MSAView for the minutes its alignment takes and, on
+ * failure, forever: the error was set and nothing drew it.
+ */
+declare const LaunchProgress: ({ model, }: {
+    model: JBrowsePluginMsaViewModel;
+}) => React.JSX.Element;
+export default LaunchProgress;

package/dist/MsaViewPanel/components/LaunchProgress.js

@@ -0,0 +1,41 @@
+import React from 'react';
+import { ErrorMessage, LoadingEllipses } from '@jbrowse/core/ui';
+import { Typography } from '@mui/material';
+import { observer } from 'mobx-react';
+import { makeStyles } from 'tss-react/mui';
+import JobLink from './JobLink';
+const useStyles = makeStyles()({
+    margin: {
+        padding: 20,
+    },
+});
+/**
+ * What a view shows while it is still building its alignment, and what it shows
+ * when that fails.
+ *
+ * Every launch that resolves something leaves its request on the model until it
+ * succeeds -- `blastParams`, `orthologParams`, `init` -- so one still being
+ * there IS "no alignment yet", and the error a failed launch records is only
+ * readable here. This used to key on `blastParams` alone, which left an ortholog
+ * launch rendering an empty MSAView for the minutes its alignment takes and, on
+ * failure, forever: the error was set and nothing drew it.
+ */
+const LaunchProgress = observer(function LaunchProgress2({ model, }) {
+    const { blastParams, orthologParams, progress, rid, error } = model;
+    const { classes } = useStyles();
+    const message = blastParams
+        ? 'Running EBI BLAST'
+        : orthologParams
+            ? 'Building ortholog alignment'
+            : 'Loading alignment';
+    return (React.createElement("div", { className: classes.margin }, error ? (React.createElement(React.Fragment, null,
+        React.createElement(Typography, { variant: "h5" },
+            message,
+            " failed"),
+        rid ? React.createElement(JobLink, { jobId: rid }) : null,
+        React.createElement(ErrorMessage, { error: error }))) : (React.createElement(React.Fragment, null,
+        React.createElement(LoadingEllipses, { message: message, variant: "h5" }),
+        rid ? React.createElement(JobLink, { jobId: rid }) : null,
+        React.createElement(Typography, null, progress || 'Initializing')))));
+});
+export default LaunchProgress;

package/dist/MsaViewPanel/components/MsaViewPanel.js

@@ -4,7 +4,7 @@ import { observer } from 'mobx-react';
 import { MSAView } from 'react-msaview';
 import { makeStyles } from 'tss-react/mui';
 import { ErrorBoundary } from './ErrorBoundary';
-import LoadingBLAST from './LoadingBLAST';
+import LaunchProgress from './LaunchProgress';
 const useStyles = makeStyles()({
     loadingContainer: {
         padding: 20,
@@ -12,9 +12,12 @@ const useStyles = makeStyles()({
 });
 const MsaViewPanel = observer(function MsaViewPanel2({ model, }) {
     const { classes } = useStyles();
-    const { blastParams, loadingStoredData } = model;
+    const { blastParams, orthologParams, init, loadingStoredData } = model;
+    // an unresolved launch request means there is no alignment to draw yet, so all
+    // three gate the same panel -- see LaunchProgress
+    const launching = !!(blastParams ?? orthologParams ?? init);
     return (React.createElement(ErrorBoundary, null,
-        React.createElement("div", null, blastParams ? (React.createElement(LoadingBLAST, { model: model })) : loadingStoredData ? (React.createElement("div", { className: classes.loadingContainer },
+        React.createElement("div", null, launching ? (React.createElement(LaunchProgress, { model: model })) : loadingStoredData ? (React.createElement("div", { className: classes.loadingContainer },
             React.createElement(LoadingEllipses, { message: "Loading MSA data", variant: "h6" }))) : (React.createElement(MSAView, { model: model })))));
 });
 export default MsaViewPanel;

package/dist/MsaViewPanel/components/MsaViewPanel.test.d.ts

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

package/dist/MsaViewPanel/components/MsaViewPanel.test.js

@@ -0,0 +1,68 @@
+// @vitest-environment jsdom
+import React from 'react';
+import { cleanup, render, screen } from '@testing-library/react';
+import { afterEach, expect, test, vi } from 'vitest';
+import MsaViewPanel from './MsaViewPanel';
+// react-msaview's MSAView is the "nothing is launching" branch and wants a real
+// MST model; a marker is enough to say the panel reached it
+vi.mock('react-msaview', () => ({
+    MSAView: () => React.createElement("div", null, "the alignment"),
+}));
+function panel(model) {
+    return render(React.createElement(MsaViewPanel, { model: model }));
+}
+afterEach(() => {
+    cleanup();
+});
+test('an alignment with no pending launch draws itself', () => {
+    panel({ progress: '' });
+    expect(screen.getByText('the alignment')).toBeTruthy();
+});
+test('a running BLAST shows its progress, not an empty alignment', () => {
+    panel({
+        blastParams: { proteinSequence: 'MKV' },
+        progress: 'Submitting query',
+    });
+    expect(screen.queryByText('the alignment')).toBeNull();
+    expect(screen.getByText(/Running EBI BLAST/)).toBeTruthy();
+    expect(screen.getByText('Submitting query')).toBeTruthy();
+});
+// the bug this file was written for: an ortholog launch sets orthologParams
+// rather than blastParams, and the panel keyed on blastParams alone -- so it
+// rendered an empty MSAView for the minutes the alignment takes, and drew
+// nothing at all when the launch failed
+test('a running ortholog launch shows its progress', () => {
+    panel({
+        orthologParams: { taxId: 9606 },
+        progress: 'Resolving orthologs',
+    });
+    expect(screen.queryByText('the alignment')).toBeNull();
+    expect(screen.getByText(/Building ortholog alignment/)).toBeTruthy();
+    expect(screen.getByText('Resolving orthologs')).toBeTruthy();
+});
+test('a failed ortholog launch shows why', () => {
+    panel({
+        orthologParams: { taxId: 9606 },
+        progress: '',
+        error: new Error('Only 1 ortholog(s) found for this gene'),
+    });
+    expect(screen.getByText(/Only 1 ortholog\(s\) found/)).toBeTruthy();
+});
+test('a failed init shows why', () => {
+    panel({
+        init: { msaName: 'ENST00000288602' },
+        progress: '',
+        error: new Error('No alignment named ENST00000288602 in msa.fa.gz'),
+    });
+    expect(screen.queryByText('the alignment')).toBeNull();
+    expect(screen.getByText(/No alignment named ENST00000288602/)).toBeTruthy();
+});
+test('a running job links out to it', () => {
+    panel({
+        blastParams: { proteinSequence: 'MKV' },
+        progress: 'Re-checking BLAST status in... 7',
+        rid: 'ncbiblast-R20260826-123456-0001-abc',
+    });
+    const link = screen.getByRole('link');
+    expect(link.getAttribute('href')).toContain('jobId=ncbiblast-R20260826-123456-0001-abc');
+});

package/dist/MsaViewPanel/doLaunchBlast.d.ts

@@ -2,7 +2,7 @@ import type { JBrowsePluginMsaViewModel } from './model';
 export declare function doLaunchBlast({ self, }: {
     self: JBrowsePluginMsaViewModel;
 }): Promise<{
-    treeMetadata: string;
     msa: string;
     tree: string;
+    treeMetadata: string;
 }>;

package/dist/MsaViewPanel/doLaunchBlast.js

@@ -2,29 +2,72 @@ import { makeId, strip } from '../LaunchMsaView/components/util';
 import { cleanProteinSequence } from '../LaunchMsaView/util';
 import { saveBlastResult } from '../utils/blastCache';
 import { queryEbiBlast } from '../utils/ebiBlast';
-import { launchMSA } from '../utils/msa';
+import { launchMSA, launchTree } from '../utils/msa';
+import { buildPhmmerMsa, buildRowMetadata } from '../utils/msaRows';
+import { queryPhmmer } from '../utils/phmmer';
 import { fetchTaxonomyInfo } from '../utils/taxonomyNames';
 export async function doLaunchBlast({ self, }) {
-    const { blastDatabase, msaAlgorithm, proteinSequence, selectedTranscript } = self.blastParams;
-    const cleanedSeq = cleanProteinSequence(proteinSequence);
+    // kept whole rather than destructured: the database's type depends on
+    // searchProgram, and pulling the two apart loses the link between them
+    const params = self.blastParams;
+    const { selectedTranscript } = params;
+    const cleanedSeq = cleanProteinSequence(params.proteinSequence);
     const onProgress = (arg) => {
         self.setProgress(arg);
     };
+    // publish the job id before the first poll so the view can link out while the
+    // job is still running
+    const onRid = (r) => {
+        self.setRid(r);
+    };
+    const { msa, tree, treeMetadata, rid } = params.searchProgram === 'phmmer'
+        ? await runPhmmer({
+            query: cleanedSeq,
+            database: params.blastDatabase,
+            onProgress,
+            onRid,
+        })
+        : await runBlast({
+            query: cleanedSeq,
+            blastDatabase: params.blastDatabase,
+            msaAlgorithm: params.msaAlgorithm,
+            onProgress,
+            onRid,
+        });
+    const treeMetadataJson = JSON.stringify(treeMetadata);
+    await saveBlastResult({
+        proteinSequence: cleanedSeq,
+        blastDatabase: params.blastDatabase,
+        msaAlgorithm: params.msaAlgorithm,
+        searchProgram: params.searchProgram,
+        msa,
+        tree,
+        treeMetadata: treeMetadataJson,
+        rid,
+        geneId: selectedTranscript?.get('parentId'),
+        transcriptId: selectedTranscript?.id(),
+        transcriptName: selectedTranscript?.get('name') ?? selectedTranscript?.get('id'),
+        geneName: selectedTranscript?.get('gene_name') ??
+            selectedTranscript?.get('parentId'),
+    });
+    return { msa, tree, treeMetadata: treeMetadataJson };
+}
+/**
+ * BLAST returns each hit already aligned to the query, but pairwise and one hit
+ * at a time, so the alignments are stripped back off and every hit is realigned
+ * together by a dedicated aligner.
+ */
+async function runBlast({ query, blastDatabase, msaAlgorithm, onProgress, onRid, }) {
     const { hits, rid } = await queryEbiBlast({
-        query: cleanedSeq,
+        query,
         blastDatabase,
         onProgress,
-        // publish the job id before the first poll so the view can link out while
-        // the job is still running
-        onRid: r => {
-            self.setRid(r);
-        },
+        onRid,
     });
-    self.setProgress('Fetching species taxonomy info...');
-    const taxids = hits
+    onProgress('Fetching species taxonomy info...');
+    const taxonomyInfo = await fetchTaxonomyInfo(hits
         .map(h => h.description[0]?.taxid)
-        .filter((t) => t !== undefined);
-    const taxonomyInfo = await fetchTaxonomyInfo(taxids);
+        .filter((t) => t !== undefined));
     const treeMetadata = {};
     const sequences = hits.map(h => {
         const desc = h.description[0] ?? {
@@ -33,52 +76,41 @@ export async function doLaunchBlast({ self, }) {
             sciname: 'unknown',
         };
         const rowName = makeId(desc, taxonomyInfo);
-        const seq = strip(h.hsps[0]?.hseq ?? '');
         treeMetadata[rowName] = buildRowMetadata(desc, taxonomyInfo);
-        return `>${rowName}\n${seq}`;
+        return `>${rowName}\n${strip(h.hsps[0]?.hseq ?? '')}`;
     });
     const result = await launchMSA({
         algorithm: msaAlgorithm,
-        sequence: [`>QUERY\n${cleanedSeq}`, ...sequences].join('\n'),
+        sequence: [`>QUERY\n${query}`, ...sequences].join('\n'),
         onProgress,
     });
-    const treeMetadataJson = JSON.stringify(treeMetadata);
-    await saveBlastResult({
-        proteinSequence: cleanedSeq,
-        blastDatabase,
-        msaAlgorithm,
-        msa: result.msa,
-        tree: result.tree,
-        treeMetadata: treeMetadataJson,
-        rid,
-        geneId: selectedTranscript?.get('parentId'),
-        transcriptId: selectedTranscript?.id(),
-        transcriptName: selectedTranscript?.get('name') ?? selectedTranscript?.get('id'),
-        geneName: selectedTranscript?.get('gene_name') ??
-            selectedTranscript?.get('parentId'),
+    return { ...result, treeMetadata, rid };
+}
+/**
+ * phmmer aligns every hit to a profile of the query as it searches, so its own
+ * output is the MSA and there is no realignment step — the hits keep the
+ * placement HMMER gave them, and the query row is derived from the alignment's
+ * match columns rather than being aligned back in afterwards. That leaves no
+ * aligner run to take a tree from, so the tree is built from this alignment.
+ */
+async function runPhmmer({ query, database, onProgress, onRid, }) {
+    const { rows, queryRow, rid } = await queryPhmmer({
+        query,
+        database,
+        onProgress,
+        onRid,
+    });
+    onProgress('Fetching species taxonomy info...');
+    const taxonomyInfo = await fetchTaxonomyInfo(rows.map(r => r.taxid).filter((t) => t !== undefined));
+    const { msa, treeMetadata } = buildPhmmerMsa({
+        rows,
+        queryRow,
+        taxonomyInfo,
     });
     return {
-        ...result,
-        treeMetadata: treeMetadataJson,
+        msa,
+        tree: await launchTree({ alignment: msa, onProgress }),
+        treeMetadata,
+        rid,
     };
 }
-function buildRowMetadata(desc, taxonomyInfo) {
-    const metadata = {};
-    const taxInfo = desc.taxid ? taxonomyInfo.get(desc.taxid) : undefined;
-    if (taxInfo?.sciname) {
-        metadata['Scientific name'] = taxInfo.sciname;
-    }
-    if (taxInfo?.commonName) {
-        metadata['Common name'] = taxInfo.commonName;
-    }
-    if (desc.accession) {
-        metadata.Accession = desc.accession;
-    }
-    if (desc.id) {
-        metadata.ID = desc.id;
-    }
-    if (desc.title) {
-        metadata.Description = desc.title;
-    }
-    return metadata;
-}

package/dist/MsaViewPanel/doLaunchOrthologs.d.ts

@@ -3,12 +3,14 @@ import type { JBrowsePluginMsaViewModel } from './model';
  * The no-search-job alternative to doLaunchBlast.
  *
  * BLAST spends 10+ minutes answering "what looks like this sequence" and
- * returns a redundant, accession-labelled hit list. This asks NCBI the question
- * the alignment actually wants — "what is this gene's ortholog in each species"
- * — which NCBI has already computed, so the whole NCBI half returns in about a
- * second and only the EBI alignment (~10s) costs real time.
+ * returns a redundant, accession-labelled hit list. This asks the question the
+ * alignment actually wants — "what is this gene's ortholog in each species" —
+ * which NCBI and PANTHER have already computed, so the lookup returns in
+ * seconds and only the EBI alignment (~10s) costs real time. `source` picks
+ * which of the two answers: NCBI for vertebrates and insects, PANTHER for
+ * everything else (yeast, worm, plants, and a fly gene's vertebrate relatives).
  *
- * The query row is the user's OWN selected transcript, not NCBI's
+ * The query row is the user's OWN selected transcript, not the source's
  * representative protein for the query species, because `connectedFeature`
  * maps genome coordinates through that row — swapping in a different isoform
  * would silently break the genome<->MSA linkage. The query species is therefore

package/dist/MsaViewPanel/doLaunchOrthologs.js

@@ -1,57 +1,55 @@
 import { cleanProteinSequence } from '../LaunchMsaView/util';
 import { launchMSA } from '../utils/msa';
 import { dedupeLabels, fetchOrthologRows, fetchProteinForGene, resolveGeneId, } from '../utils/ncbiOrthologs';
+import { fetchPantherOrthologs } from '../utils/pantherOrthologs';
 import { fetchTaxonomyInfo } from '../utils/taxonomyNames';
 /**
  * The no-search-job alternative to doLaunchBlast.
  *
  * BLAST spends 10+ minutes answering "what looks like this sequence" and
- * returns a redundant, accession-labelled hit list. This asks NCBI the question
- * the alignment actually wants — "what is this gene's ortholog in each species"
- * — which NCBI has already computed, so the whole NCBI half returns in about a
- * second and only the EBI alignment (~10s) costs real time.
+ * returns a redundant, accession-labelled hit list. This asks the question the
+ * alignment actually wants — "what is this gene's ortholog in each species" —
+ * which NCBI and PANTHER have already computed, so the lookup returns in
+ * seconds and only the EBI alignment (~10s) costs real time. `source` picks
+ * which of the two answers: NCBI for vertebrates and insects, PANTHER for
+ * everything else (yeast, worm, plants, and a fly gene's vertebrate relatives).
  *
- * The query row is the user's OWN selected transcript, not NCBI's
+ * The query row is the user's OWN selected transcript, not the source's
  * representative protein for the query species, because `connectedFeature`
  * maps genome coordinates through that row — swapping in a different isoform
  * would silently break the genome<->MSA linkage. The query species is therefore
  * excluded from the ortholog set rather than appearing twice.
  */
 export async function doLaunchOrthologs({ self, }) {
-    const { taxId, taxa, maxSpecies, geneCandidates, msaAlgorithm, proteinSequence, } = self.orthologParams;
+    const { taxId, taxa, maxSpecies, geneCandidates, msaAlgorithm, proteinSequence, source = 'ncbi', } = self.orthologParams;
     const onProgress = (arg) => {
         self.setProgress(arg);
     };
-    onProgress('Resolving gene at NCBI...');
-    const resolved = await resolveGeneId(geneCandidates, taxId);
-    if (!resolved) {
-        throw new Error(`Could not resolve any of ${geneCandidates.join(', ')} to an NCBI gene in taxon ${taxId}. Try the NCBI BLAST tab, which needs no gene identifier.`);
-    }
+    const request = {
+        taxId,
+        geneCandidates,
+        taxa: taxa ? new Set(taxa) : undefined,
+        // the query species is represented by the query row below
+        exclude: taxId,
+        limit: maxSpecies,
+        onProgress,
+    };
+    const { geneId, representative, rows } = source === 'panther'
+        ? await findPantherOrthologs(request)
+        : await findNcbiOrthologs(request);
     // The query row. The dialog always supplies it — it is the user's OWN
     // selected transcript, which is what makes `connectedFeature` map genome
     // coordinates through this row. A launch that has no transcript to translate
-    // (a session spec naming only a gene) falls back to NCBI's representative
-    // protein for the resolved gene, which is the same choice made for every
-    // other row, so the alignment is the one NCBI would build for that gene.
-    const representative = await fetchRepresentativeQueryProtein(resolved.geneId);
+    // (a session spec naming only a gene) falls back to the source's
+    // representative protein for the resolved gene, which is the same choice
+    // made for every other row, so the alignment is the one the source would
+    // build for that gene.
     const cleanedSeq = proteinSequence
         ? cleanProteinSequence(proteinSequence)
         : representative?.sequence;
     if (!cleanedSeq) {
-        throw new Error(`No query protein: none was supplied and NCBI returned no representative protein for gene ${resolved.geneId}.`);
+        throw new Error(`No query protein: none was supplied and ${source === 'panther' ? 'PANTHER' : 'NCBI'} returned no representative protein for gene ${geneId}.`);
     }
-    // Every species NCBI has an ortholog for, when a launch names none, capped at
-    // maxSpecies. A launch that wants specific species lists them; one that just
-    // wants "this gene across species" gets NCBI's own order, which leads with the
-    // reference organisms.
-    const rows = await fetchOrthologRows({
-        geneId: resolved.geneId,
-        taxa: taxa ? new Set(taxa) : undefined,
-        // the query species is represented by the query row above
-        exclude: taxId,
-        limit: maxSpecies,
-        onProgress,
-    });
     // The query row is named for its species like every other row, with a suffix
     // marking it as the one the genome view is linked to. A bare `QUERY` among
     // ninety-nine named species reads as a row whose species failed to resolve,
@@ -66,7 +64,7 @@ export async function doLaunchOrthologs({ self, }) {
     const queryLabel = await queryRowLabel(taxId, rows);
     self.setQuerySeqName(queryLabel);
     const treeMetadata = {
-        [queryLabel]: buildQueryMetadata(self, resolved.geneId, cleanedSeq, representative),
+        [queryLabel]: buildQueryMetadata(self, geneId, cleanedSeq, representative),
     };
     for (const row of rows) {
         treeMetadata[row.label] = buildRowMetadata(row);
@@ -84,6 +82,42 @@ export async function doLaunchOrthologs({ self, }) {
         treeMetadata: JSON.stringify(treeMetadata),
     };
 }
+/**
+ * Every species NCBI has an ortholog for, when a launch names none, capped at
+ * `limit`. A launch that wants specific species lists them; one that just
+ * wants "this gene across species" gets NCBI's own order, which leads with the
+ * reference organisms.
+ */
+async function findNcbiOrthologs({ taxId, geneCandidates, onProgress, ...rest }) {
+    onProgress('Resolving gene at NCBI...');
+    const resolved = await resolveGeneId(geneCandidates, taxId);
+    if (!resolved) {
+        throw new Error(`Could not resolve any of ${geneCandidates.join(', ')} to an NCBI gene in taxon ${taxId}. Try the NCBI BLAST tab, which needs no gene identifier.`);
+    }
+    const representative = await fetchRepresentativeQueryProtein(resolved.geneId);
+    const rows = await fetchOrthologRows({
+        geneId: resolved.geneId,
+        onProgress,
+        ...rest,
+    });
+    return { geneId: resolved.geneId, representative, rows };
+}
+/**
+ * One `matchortho` call resolves the gene, names its own UniProt entry and
+ * lists an ortholog per genome, so the representative protein needs no second
+ * lookup here.
+ */
+async function findPantherOrthologs({ geneCandidates, ...rest }) {
+    const found = await fetchPantherOrthologs({
+        candidates: geneCandidates,
+        ...rest,
+    });
+    return {
+        geneId: found.query?.geneRef ?? found.matched,
+        representative: found.query,
+        rows: found.rows,
+    };
+}
 /**
  * `<species>_query`, unique against the ortholog labels. Falls back to the bare
  * marker when NCBI cannot name the taxon, which is a naming failure and must not
@@ -120,7 +154,7 @@ async function fetchRepresentativeQueryProtein(geneId) {
 /**
  * The query row carries an Accession — which is what drives the automatic CDD
  * overlay (afterCreateAutoruns.autoLoadProteinDomains -> loadProteinDomains) —
- * ONLY when its sequence is byte-identical to the RefSeq protein that accession
+ * ONLY when its sequence is byte-identical to the protein that accession
  * names. Attaching it unconditionally would put every domain box at an offset
  * whenever the user picked a non-representative isoform, which is a silently
  * wrong figure rather than a missing one. A launch that took the representative