jbrowse-plugin-msaview 3.3.0 → 3.4.0

package/dist/utils/blastCache.d.ts

@@ -1,15 +1,18 @@
-import type { BlastDatabase, MsaAlgorithm } from '../LaunchMsaView/components/BlastQuery/consts';
+import type { BlastDatabase, MsaAlgorithm, PhmmerDatabase, SearchProgram } from '../LaunchMsaView/components/BlastQuery/consts';
 export interface CachedBlastResult {
     id: string;
     proteinSequence: string;
-    blastDatabase: BlastDatabase;
+    blastDatabase: BlastDatabase | PhmmerDatabase;
     /**
      * Only ever set on rows cached by a version that still queried NCBI, where
      * the choice between blastp and quick-blastp was real. Kept so those rows
      * still display; never written now.
      */
     blastProgram?: string;
-    msaAlgorithm: MsaAlgorithm;
+    /** absent on rows cached before phmmer existed, which were all blastp */
+    searchProgram?: SearchProgram;
+    /** absent on phmmer rows, which are aligned by the search itself */
+    msaAlgorithm?: MsaAlgorithm;
     msa: string;
     tree: string;
     treeMetadata: string;
@@ -20,10 +23,11 @@ export interface CachedBlastResult {
     transcriptName?: string;
     geneName?: string;
 }
-export declare function saveBlastResult({ proteinSequence, blastDatabase, msaAlgorithm, msa, tree, treeMetadata, rid, geneId, transcriptId, transcriptName, geneName, }: {
+export declare function saveBlastResult({ proteinSequence, blastDatabase, msaAlgorithm, searchProgram, msa, tree, treeMetadata, rid, geneId, transcriptId, transcriptName, geneName, }: {
     proteinSequence: string;
-    blastDatabase: BlastDatabase;
-    msaAlgorithm: MsaAlgorithm;
+    blastDatabase: BlastDatabase | PhmmerDatabase;
+    msaAlgorithm?: MsaAlgorithm;
+    searchProgram?: SearchProgram;
     msa: string;
     tree: string;
     treeMetadata: string;

package/dist/utils/blastCache.js

@@ -10,21 +10,33 @@ const getDB = createDbOpener(DB_NAME, DB_VERSION, (db, oldVersion) => {
         db.createObjectStore(STORE_NAME, { keyPath: 'id' });
     }
 });
-function createCacheKey(proteinSequence, blastDatabase, msaAlgorithm, transcriptId) {
+function createCacheKey({ proteinSequence, blastDatabase, msaAlgorithm, searchProgram, transcriptId, }) {
     const idPart = transcriptId ? `:${transcriptId}` : '';
+    // phmmer keys are prefixed and blastp keys are left exactly as they were, so
+    // results cached before phmmer existed still resolve
+    if (searchProgram === 'phmmer') {
+        return `phmmer:${blastDatabase}${idPart}:${proteinSequence}`;
+    }
     // msaAlgorithm is part of the key because the stored msa/tree are produced by
     // it — without it, re-running the same query under a different algorithm
     // overwrites the earlier result and drops it from the history list
     return `${blastDatabase}:${msaAlgorithm}${idPart}:${proteinSequence}`;
 }
-export async function saveBlastResult({ proteinSequence, blastDatabase, msaAlgorithm, msa, tree, treeMetadata, rid, geneId, transcriptId, transcriptName, geneName, }) {
+export async function saveBlastResult({ proteinSequence, blastDatabase, msaAlgorithm, searchProgram, msa, tree, treeMetadata, rid, geneId, transcriptId, transcriptName, geneName, }) {
     const db = await getDB();
-    const id = createCacheKey(proteinSequence, blastDatabase, msaAlgorithm, transcriptId);
+    const id = createCacheKey({
+        proteinSequence,
+        blastDatabase,
+        msaAlgorithm,
+        searchProgram,
+        transcriptId,
+    });
     const entry = {
         id,
         proteinSequence,
         blastDatabase,
         msaAlgorithm,
+        searchProgram,
         msa,
         tree,
         treeMetadata,

package/dist/utils/ebiBlast.d.ts

@@ -1,5 +1,5 @@
-import type { BlastHit } from './types';
 import type { BlastDatabase } from '../LaunchMsaView/components/BlastQuery/consts';
+import type { BlastHit } from './types';
 /**
  * The subset of EBI's ncbiblast JSON result this plugin reads. The service
  * returns a great deal more per hit (urls, bit scores, e-values, the match

package/dist/utils/msa.d.ts

@@ -1,4 +1,16 @@
 import type { MsaAlgorithm } from '../LaunchMsaView/components/BlastQuery/consts';
+/**
+ * Build a tree from an alignment that already exists, which is what the phmmer
+ * path needs: phmmer produces the alignment itself, so there is no aligner run
+ * to take a guide tree from — and a guide tree is a byproduct of deciding
+ * progressive alignment order, not a phylogeny, so it is not what we would want
+ * even if there were one. simple_phylogeny is clustalw2's neighbour-joining on
+ * a real distance matrix, Kimura-corrected for protein distances.
+ */
+export declare function launchTree({ alignment, onProgress, }: {
+    alignment: string;
+    onProgress: (arg: string) => void;
+}): Promise<string>;
 export declare function launchMSA({ algorithm, sequence, onProgress, }: {
     algorithm: MsaAlgorithm;
     sequence: string;

package/dist/utils/msa.js

@@ -21,6 +21,35 @@ const algorithms = {
         treeResult: 'phylotree',
     },
 };
+/**
+ * Build a tree from an alignment that already exists, which is what the phmmer
+ * path needs: phmmer produces the alignment itself, so there is no aligner run
+ * to take a guide tree from — and a guide tree is a byproduct of deciding
+ * progressive alignment order, not a phylogeny, so it is not what we would want
+ * even if there were one. simple_phylogeny is clustalw2's neighbour-joining on
+ * a real distance matrix, Kimura-corrected for protein distances.
+ */
+export async function launchTree({ alignment, onProgress, }) {
+    const tool = 'simple_phylogeny';
+    onProgress('Building tree...');
+    const jobId = await submitEbiJob({
+        tool,
+        params: {
+            sequence: alignment,
+            tree: 'phylip',
+            clustering: 'Neighbour-joining',
+            kimura: 'true',
+        },
+    });
+    await waitForEbiJob({
+        tool,
+        jobId,
+        onCountdown: s => {
+            onProgress(`Re-checking tree status in... ${s}`);
+        },
+    });
+    return fetchEbiResult({ tool, jobId, type: 'tree' });
+}
 export async function launchMSA({ algorithm, sequence, onProgress, }) {
     const config = algorithms[algorithm];
     onProgress(`Launching ${algorithm} MSA...`);
@@ -35,16 +64,10 @@ export async function launchMSA({ algorithm, sequence, onProgress, }) {
             onProgress(`Re-checking MSA status in... ${s}`);
         },
     });
-    return {
-        msa: await fetchEbiResult({
-            tool: algorithm,
-            jobId,
-            type: config.msaResult,
-        }),
-        tree: await fetchEbiResult({
-            tool: algorithm,
-            jobId,
-            type: config.treeResult,
-        }),
-    };
+    // one finished job, two result files, neither derived from the other
+    const [msa, tree] = await Promise.all([
+        fetchEbiResult({ tool: algorithm, jobId, type: config.msaResult }),
+        fetchEbiResult({ tool: algorithm, jobId, type: config.treeResult }),
+    ]);
+    return { msa, tree };
 }

package/dist/utils/msaRows.d.ts

@@ -0,0 +1,31 @@
+import type { PhmmerRow } from './phmmer';
+import type { TaxonomyInfo } from './taxonomyNames';
+import type { BlastHitDescription } from './types';
+/**
+ * Turning search results into the rows the view is given, kept free of any
+ * jbrowse or network import so the whole assembly can be run and checked
+ * outside a browser — see test/phmmerLive.test.ts.
+ */
+export declare function buildRowMetadata(desc: BlastHitDescription, taxonomyInfo: Map<number, TaxonomyInfo>): Record<string, string>;
+/**
+ * One target can match the query in several places and phmmer emits a row per
+ * matched envelope — four for lamprey albumin against human albumin, which has
+ * three domains. Those rows share an accession and so would share a name, and
+ * duplicate names silently collapse rows in both the MSA and the tree, so the
+ * envelope disambiguates them.
+ */
+export declare function makeRowNames(rows: PhmmerRow[], taxonomyInfo: Map<number, TaxonomyInfo>): string[];
+/**
+ * The phmmer alignment as the view receives it: aligned FASTA whose first row
+ * is the query, plus the per-row metadata keyed by the same names, which are
+ * also what the tree's leaves are labelled with.
+ */
+export declare function buildPhmmerMsa({ rows, queryRow, taxonomyInfo, querySeqName, }: {
+    rows: PhmmerRow[];
+    queryRow: string;
+    taxonomyInfo: Map<number, TaxonomyInfo>;
+    querySeqName?: string;
+}): {
+    msa: string;
+    treeMetadata: Record<string, Record<string, string>>;
+};

package/dist/utils/msaRows.js

@@ -0,0 +1,67 @@
+import { makeId } from '../LaunchMsaView/components/util';
+/**
+ * Turning search results into the rows the view is given, kept free of any
+ * jbrowse or network import so the whole assembly can be run and checked
+ * outside a browser — see test/phmmerLive.test.ts.
+ */
+export 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;
+}
+/**
+ * One target can match the query in several places and phmmer emits a row per
+ * matched envelope — four for lamprey albumin against human albumin, which has
+ * three domains. Those rows share an accession and so would share a name, and
+ * duplicate names silently collapse rows in both the MSA and the tree, so the
+ * envelope disambiguates them.
+ */
+export function makeRowNames(rows, taxonomyInfo) {
+    const baseNames = rows.map(row => makeId(row, taxonomyInfo));
+    const counts = new Map();
+    for (const name of baseNames) {
+        counts.set(name, (counts.get(name) ?? 0) + 1);
+    }
+    const used = new Set();
+    return baseNames.map((base, i) => {
+        let name = counts.get(base) > 1 ? `${base}_${rows[i].range ?? i + 1}` : base;
+        while (used.has(name)) {
+            name = `${name}_${i + 1}`;
+        }
+        used.add(name);
+        return name;
+    });
+}
+/**
+ * The phmmer alignment as the view receives it: aligned FASTA whose first row
+ * is the query, plus the per-row metadata keyed by the same names, which are
+ * also what the tree's leaves are labelled with.
+ */
+export function buildPhmmerMsa({ rows, queryRow, taxonomyInfo, querySeqName = 'QUERY', }) {
+    const treeMetadata = {};
+    const rowNames = makeRowNames(rows, taxonomyInfo);
+    const sequences = rows.map((row, i) => {
+        const rowName = rowNames[i];
+        treeMetadata[rowName] = buildRowMetadata(row, taxonomyInfo);
+        return `>${rowName}\n${row.aligned}`;
+    });
+    return {
+        msa: [`>${querySeqName}\n${queryRow}`, ...sequences].join('\n'),
+        treeMetadata,
+    };
+}

package/dist/utils/phmmer.d.ts

@@ -0,0 +1,53 @@
+import type { PhmmerDatabase } from '../LaunchMsaView/components/BlastQuery/consts';
+export interface PhmmerRow {
+    accession: string;
+    id: string;
+    sciname: string;
+    taxid?: number;
+    title?: string;
+    /** the matched envelope on the target, e.g. '503-912', absent if unparseable */
+    range?: string;
+    /** the row as phmmer aligned it, uppercased with '.' inserts turned into '-' */
+    aligned: string;
+}
+export interface PhmmerAlignment {
+    rows: PhmmerRow[];
+    /**
+     * the query, placed into the same columns. phmmer does not put the query in
+     * its own output, so this is derived — see buildQueryRow.
+     */
+    queryRow: string;
+}
+/**
+ * Human-facing link to a job, shown while it runs and on error.
+ *
+ * The category has to be sss: jdispatcher serves its shell with a 200 for any
+ * category, so /pfa/ and /psa/ look fine to a fetch and render "Page Not Found"
+ * in a browser.
+ */
+export declare function phmmerResultUrl(jobId: string): string;
+/** EBI job ids are prefixed with the tool that made them */
+export declare function isPhmmerJobId(jobId: string): boolean;
+/**
+ * Exported for testing against a captured .sto — the annotation names (RF, the
+ * DE line's OS=/OX=) are the whole risk in this mapping, and nothing else in CI
+ * would notice if HMMER or EBI changed one.
+ */
+export declare function parsePhmmerAlignment({ stockholm, query, }: {
+    stockholm: string;
+    query: string;
+}): PhmmerAlignment;
+export declare function queryPhmmer({ query, database, onProgress, onRid, }: {
+    query: string;
+    database: PhmmerDatabase;
+    onProgress: (arg: string) => void;
+    onRid: (arg: string) => void;
+}): Promise<{
+    rows: PhmmerRow[];
+    /**
+     * the query, placed into the same columns. phmmer does not put the query in
+     * its own output, so this is derived — see buildQueryRow.
+     */
+    queryRow: string;
+    rid: string;
+}>;

package/dist/utils/phmmer.js

@@ -0,0 +1,118 @@
+import { StockholmMSA } from 'msa-parsers';
+import { fetchEbiResult, submitEbiJob, waitForEbiJob } from './ebiJobDispatcher';
+const TOOL = 'hmmer3_phmmer';
+/**
+ * Human-facing link to a job, shown while it runs and on error.
+ *
+ * The category has to be sss: jdispatcher serves its shell with a 200 for any
+ * category, so /pfa/ and /psa/ look fine to a fetch and render "Page Not Found"
+ * in a browser.
+ */
+export function phmmerResultUrl(jobId) {
+    return `https://www.ebi.ac.uk/jdispatcher/sss/${TOOL}/summary?jobId=${jobId}`;
+}
+/** EBI job ids are prefixed with the tool that made them */
+export function isPhmmerJobId(jobId) {
+    return jobId.startsWith(`${TOOL}-`);
+}
+/**
+ * phmmer aligns every hit to a profile built from the query, one match state
+ * per query residue, and marks those columns 'x' in #=GC RF. So the query's own
+ * row is exactly recoverable: walk RF, consume a query residue at each match
+ * column, gap everywhere else.
+ *
+ * This is the one piece of real logic here rather than a library call, and it
+ * is checked hard: if the match columns do not account for the query exactly,
+ * the columns and the query have drifted apart, and a query row that is off by
+ * even one residue would silently mis-map every column to the genome. Throwing
+ * is much better than drawing that.
+ */
+function buildQueryRow({ rf, query }) {
+    let consumed = 0;
+    const row = Array.from(rf, c => c === 'x' ? (query[consumed++] ?? '-') : '-').join('');
+    if (consumed !== query.length) {
+        throw new Error(`phmmer alignment has ${consumed} match columns for a query of ${query.length} residues, so the query row cannot be placed`);
+    }
+    return row;
+}
+/**
+ * '[subseq from] Albumin OS=Homo sapiens OX=9606 GN=ALB PE=1 SV=2' is what a
+ * UniProt target's #=GS DE looks like. Hits from the non-UniProt databases
+ * phmmer also offers (PDB, AlphaFold, MEROPS...) carry no OS=/OX= at all, so
+ * every field here is optional.
+ */
+function parseDescription(de) {
+    const text = (de ?? '').replace('[subseq from] ', '');
+    const sciname = /OS=(.*?)\s+(?:OX|GN|PE|SV)=/.exec(text)?.[1];
+    const ox = /OX=(\d+)/.exec(text)?.[1];
+    return {
+        sciname: sciname ?? 'unknown',
+        taxid: ox ? Number.parseInt(ox, 10) : undefined,
+        title: text.split(' OS=')[0] || undefined,
+    };
+}
+/**
+ * Target names look like 'sp|P02768|ALBU_HUMAN/1-609' for UniProt databases and
+ * like anything at all for the others, so an unrecognized name becomes its own
+ * accession rather than being dropped.
+ */
+function parseName(name) {
+    const slash = name.lastIndexOf('/');
+    const range = slash === -1 ? undefined : /^\d+-\d+$/.exec(name.slice(slash + 1))?.[0];
+    const bare = range === undefined ? name : name.slice(0, slash);
+    const parts = bare.split('|');
+    return parts.length === 3
+        ? { accession: parts[1], id: parts[2], range }
+        : { accession: bare, id: bare, range };
+}
+/**
+ * Exported for testing against a captured .sto — the annotation names (RF, the
+ * DE line's OS=/OX=) are the whole risk in this mapping, and nothing else in CI
+ * would notice if HMMER or EBI changed one.
+ */
+export function parsePhmmerAlignment({ stockholm, query, }) {
+    const { gc, gs, seqdata, seqname } = new StockholmMSA(stockholm, 0).getMSA();
+    const rf = gc.RF;
+    if (!rf) {
+        throw new Error('phmmer alignment has no #=GC RF line');
+    }
+    return {
+        queryRow: buildQueryRow({ rf, query }),
+        rows: seqname.map(name => ({
+            ...parseName(name),
+            ...parseDescription(gs.DE?.[name]?.[0]),
+            // insert columns come back lowercase with '.' for gaps; the MSA renderer
+            // looks colors up by the literal letter, so lowercase would draw
+            // uncolored. The insert columns stay visible as gaps in the query row.
+            aligned: (seqdata[name] ?? '').replaceAll('.', '-').toUpperCase(),
+        })),
+    };
+}
+export async function queryPhmmer({ query, database, onProgress, onRid, }) {
+    onProgress('Submitting to EBI phmmer...');
+    const jobId = await submitEbiJob({
+        tool: TOOL,
+        params: {
+            database,
+            sequence: query,
+            // the alignment is the whole point of using phmmer here
+            alignView: 'true',
+        },
+    });
+    onRid(jobId);
+    await waitForEbiJob({
+        tool: TOOL,
+        jobId,
+        onCountdown: s => {
+            onProgress(`Re-checking phmmer status in... ${s}`);
+        },
+    });
+    const alignment = parsePhmmerAlignment({
+        stockholm: await fetchEbiResult({ tool: TOOL, jobId, type: 'sto' }),
+        query,
+    });
+    if (alignment.rows.length === 0) {
+        throw new Error('No hits found');
+    }
+    return { rid: jobId, ...alignment };
+}

package/dist/utils/taxonomyNames.d.ts

@@ -2,4 +2,4 @@ export interface TaxonomyInfo {
     sciname: string;
     commonName?: string;
 }
-export declare function fetchTaxonomyInfo(taxids: number[]): Promise<Map<number, TaxonomyInfo>>;
+export declare function fetchTaxonomyInfo(taxidsWithRepeats: number[]): Promise<Map<number, TaxonomyInfo>>;

package/dist/utils/taxonomyNames.js

@@ -25,7 +25,12 @@ async function saveTaxonomyCache(entries) {
     }
     await tx.done;
 }
-export async function fetchTaxonomyInfo(taxids) {
+export async function fetchTaxonomyInfo(taxidsWithRepeats) {
+    // callers pass one taxid per alignment row, and a BLAST hit list is several
+    // rows per species: 100 albumin hits are maybe 50 taxa, and asking as they
+    // came did 100 IndexedDB reads and sent eutils 100 ids for 50 answers. The
+    // result is keyed by taxid, so no caller can tell the difference
+    const taxids = [...new Set(taxidsWithRepeats)];
     const result = new Map();
     const uncachedTaxids = [];
     const cachedResults = await getCachedTaxonomies(taxids);

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "3.3.0";
+export declare const version = "3.4.0";

package/dist/version.js

@@ -1 +1 @@
-export const version = '3.3.0';
+export const version = '3.4.0';

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "3.3.0",
+  "version": "3.4.0",
   "license": "MIT",
   "name": "jbrowse-plugin-msaview",
   "repository": {
@@ -17,8 +17,8 @@
   ],
   "dependencies": {
     "@emotion/styled": "^11.14.1",
-    "@gmod/bgzf-filehandle": "^6.2.0",
-    "g2p_mapper": "^2.1.5",
+    "@gmod/bgzf-filehandle": "^6.6.0",
+    "g2p_mapper": "^2.1.7",
     "idb": "^8.0.3"
   },
   "devDependencies": {
@@ -28,51 +28,57 @@
     "@jbrowse/core": "^4.3.0",
     "@jbrowse/mobx-state-tree": "^5.13.0",
     "@jbrowse/plugin-linear-genome-view": "^4.3.0",
-    "@mui/icons-material": "^9.2.0",
-    "@mui/material": "^9.2.0",
-    "@mui/system": "^9.2.0",
-    "@mui/x-data-grid": "^9.10.0",
+    "@mui/icons-material": "^9.3.1",
+    "@mui/material": "^9.3.1",
+    "@mui/system": "^9.3.0",
+    "@mui/x-data-grid": "^9.12.0",
     "@testing-library/dom": "^10.4.1",
     "@testing-library/react": "^16.3.2",
-    "@types/node": "^26.1.1",
-    "@types/react": "^19.2.17",
-    "esbuild": "^0.28.1",
-    "eslint": "^10.7.0",
+    "@types/node": "^26.3.0",
+    "@types/react": "^19.2.18",
+    "esbuild": "^0.28.2",
+    "eslint": "^10.9.1",
     "eslint-plugin-import-x": "^4.17.1",
     "eslint-plugin-react": "^7.37.5",
     "eslint-plugin-react-hooks": "^7.1.1",
-    "eslint-plugin-unicorn": "^72.0.0",
+    "eslint-plugin-unicorn": "^73.0.0",
     "git-cliff": "^2.13.1",
     "jsdom": "^30.0.1",
     "mobx": "^6.16.1",
     "mobx-react": "^9.2.2",
-    "msa-parsers": "^6.0.0",
+    "msa-parsers": "^6.1.0",
+    "oxfmt": "^0.65.0",
+    "oxlint": "^1.80.0",
+    "oxlint-tsgolint": "^7.0.2001",
     "pixelmatch": "^7.2.0",
     "pngjs": "^7.0.0",
-    "prettier": "^3.9.6",
     "pretty-bytes": "^7.1.1",
-    "puppeteer": "^25.3.0",
+    "puppeteer": "^25.8.0",
     "react": "^19.2.8",
     "react-dom": "^19.2.8",
-    "react-msaview": "^6.0.0",
+    "react-msaview": "^6.1.0",
     "rimraf": "^6.1.3",
     "rxjs": "^7.8.2",
     "serve": "^14.2.6",
     "tss-react": "^4.9.21",
     "typescript": "^6.0.2",
-    "typescript-eslint": "^8.65.0",
-    "vitest": "^4.1.10"
+    "typescript-eslint": "^8.68.0",
+    "vitest": "^4.1.11"
   },
   "scripts": {
     "clean": "rimraf dist",
     "start": "node esbuild.mjs --watch",
-    "format": "pnpm prettier --write .",
+    "format": "oxfmt",
+    "check-format": "oxfmt --check",
     "build": "tsc && NODE_ENV=production node esbuild.mjs && cp distconfig.json dist/config.json",
     "prebuild": "pnpm clean",
-    "lint": "eslint src --report-unused-disable-directives --max-warnings 0",
+    "lint": "oxlint --type-aware --deny-warnings",
+    "lint:fast": "oxlint --deny-warnings",
+    "lint:eslint": "eslint src --report-unused-disable-directives --max-warnings 0",
     "check-text-source": "node scripts/check-text-source.mjs",
     "check-ebi-params": "node scripts/check-ebi-params.mjs",
     "check-mui-imports": "node scripts/check-mui-imports.mjs",
+    "check-host-dep-pins": "node scripts/check-host-dep-pins.mjs",
     "pretest": "rm -rf .test-jbrowse && npx @jbrowse/cli create .test-jbrowse --nightly",
     "test": "vitest run",
     "test:watch": "vitest",
@@ -82,7 +88,7 @@
     "test:version": "node scripts/test-versions.mjs run",
     "host-compat": "node scripts/host-compat-probe.mjs --bundle dist/jbrowse-plugin-msaview.umd.production.min.js",
     "check-ci": "node scripts/require-green-ci.mjs",
-    "preversion": "pnpm check-ci && pnpm lint && pnpm build && pnpm host-compat",
+    "preversion": "pnpm check-ci && pnpm check-host-dep-pins && pnpm lint && pnpm build && pnpm host-compat",
     "version": "node -e \"console.log('export const version = \\'' + require('./package.json').version + '\\'')\" > src/version.ts && git-cliff --tag v$npm_package_version --unreleased --prepend CHANGELOG.md && git add src/version.ts CHANGELOG.md",
     "postversion": "git push --follow-tags"
   }

package/src/AddHighlightModel/GenomeMouseoverHighlight.tsx

@@ -3,8 +3,8 @@ import React from 'react'
 import { getSession } from '@jbrowse/core/util'
 import { observer } from 'mobx-react'
 
-import { hasHoverPosition, useStyles } from './util'
 import { isMsaView } from '../MsaViewPanel/model'
+import { hasHoverPosition, useStyles } from './util'
 
 import type { LinearGenomeViewModel } from '@jbrowse/plugin-linear-genome-view'
 

package/src/AddHighlightModel/MsaToGenomeHighlight.tsx

@@ -3,8 +3,8 @@ import React from 'react'
 import { getSession } from '@jbrowse/core/util'
 import { observer } from 'mobx-react'
 
-import { hasHoverPosition, useStyles } from './util'
 import { isMsaView } from '../MsaViewPanel/model'
+import { hasHoverPosition, useStyles } from './util'
 
 import type { LinearGenomeViewModel } from '@jbrowse/plugin-linear-genome-view'
 

package/src/AddHighlightModel/index.tsx

@@ -2,8 +2,8 @@ import React from 'react'
 
 import { getSession } from '@jbrowse/core/util'
 
-import HighlightComponents from './HighlightComponents'
 import { isMsaView } from '../MsaViewPanel/model'
+import HighlightComponents from './HighlightComponents'
 
 import type PluginManager from '@jbrowse/core/PluginManager'
 import type { LinearGenomeViewModel } from '@jbrowse/plugin-linear-genome-view'