jbrowse-plugin-msaview 3.8.0 → 3.9.0

package/dist/MsaViewPanel/doLaunchBlast.js

@@ -1,8 +1,10 @@
 import { cleanProteinSequence } from '../LaunchMsaView/util';
 import { saveBlastResult } from '../utils/blastCache';
+import { checkPairSize } from '../utils/browserAlign';
 import { searchBackends } from '../utils/homologSearch';
 import { launchMSA } from '../utils/msa';
 import { buildSearchMsa } from '../utils/msaRows';
+import { getCachedSearch, saveSearch, searchKey } from '../utils/searchCache';
 import { fetchTaxonomyInfo } from '../utils/taxonomyNames';
 import { resolveUniProtEntry } from '../utils/unirefHomologs';
 import { transcriptFields, transcriptName } from './util';
@@ -38,23 +40,13 @@ async function resolveQuery(self, scope) {
     }
     throw new Error('No query: a search needs a proteinSequence, a UniProt accession, or a connectedTranscript to translate');
 }
-/**
- * A similarity search, then an alignment of what it found. The program is a
- * backend behind one interface (utils/homologSearch.ts); what differs between
- * them is settled by whether the result came back aligned. A program that
- * aligns as it searches (phmmer) hands over the alignment and the tree is
- * built from it in the browser; one that does not (blastp) hands over bare
- * hits and the chosen aligner runs on them.
- */
-export async function doLaunchBlast({ self, scope, }) {
+async function search({ self, scope, query, querySeqName, key, }) {
     const params = self.blastParams;
-    const { selectedTranscript, maxHits, searchProgram = 'blastp' } = params;
-    const { sequence: query, name: querySeqName } = await resolveQuery(self, scope);
     const { onProgress, onRid, signal } = scope;
-    const { hits, queryRow, rid } = await searchBackends[searchProgram]({
+    const { hits, queryRow, rid } = await searchBackends[params.searchProgram ?? 'blastp']({
         query,
         database: params.blastDatabase,
-        maxHits,
+        maxHits: params.maxHits,
         onProgress,
         onRid,
         signal,
@@ -63,7 +55,7 @@ export async function doLaunchBlast({ self, scope, }) {
         throw new Error('No hits found');
     }
     onProgress('Fetching species taxonomy info...');
-    const taxonomyInfo = await fetchTaxonomyInfo(hits.map(h => h.taxid).filter((t) => t !== undefined));
+    const taxonomyInfo = await fetchTaxonomyInfo(hits.map(h => h.taxid).filter((t) => t !== undefined), signal);
     const { msa: fasta, treeMetadata } = buildSearchMsa({
         hits,
         query,
@@ -71,10 +63,44 @@ export async function doLaunchBlast({ self, scope, }) {
         taxonomyInfo,
         querySeqName,
     });
+    if (!queryRow) {
+        await saveSearch({ id: key, fasta, treeMetadata, rid });
+    }
+    return { fasta, treeMetadata, rid, queryRow };
+}
+/**
+ * A similarity search, then an alignment of what it found. The program is a
+ * backend behind one interface (utils/homologSearch.ts); what differs between
+ * them is settled by whether the result came back aligned. A program that
+ * aligns as it searches (phmmer) hands over the alignment and the tree is
+ * built from it in the browser; one that does not (blastp) hands over bare
+ * hits and the chosen aligner runs on them.
+ */
+export async function doLaunchBlast({ self, scope, }) {
+    const params = self.blastParams;
+    const { selectedTranscript, maxHits, searchProgram = 'blastp' } = params;
+    const msaAlgorithm = params.msaAlgorithm ?? 'browser';
+    const { sequence: query, name: querySeqName } = await resolveQuery(self, scope);
+    if (searchProgram === 'blastp' && msaAlgorithm === 'browser') {
+        checkPairSize(querySeqName, query.length, query.length);
+    }
+    const { onProgress, signal } = scope;
+    const key = searchKey({
+        searchProgram,
+        database: params.blastDatabase,
+        maxHits,
+        querySeqName,
+        query,
+    });
+    const found = await getCachedSearch(key);
+    if (found) {
+        onProgress(`Reusing the ${searchProgram} search from ${new Date(found.timestamp).toLocaleString()}...`);
+    }
+    const { fasta, treeMetadata, rid, queryRow } = found ?? (await search({ self, scope, query, querySeqName, key }));
     const { msa, tree } = queryRow
         ? { msa: fasta, tree: '' }
         : await launchMSA({
-            algorithm: params.msaAlgorithm ?? 'browser',
+            algorithm: msaAlgorithm,
             sequence: fasta,
             onProgress,
             signal,
@@ -84,7 +110,7 @@ export async function doLaunchBlast({ self, scope, }) {
     await saveBlastResult({
         proteinSequence: query,
         blastDatabase: params.blastDatabase,
-        msaAlgorithm: queryRow ? undefined : (params.msaAlgorithm ?? 'browser'),
+        msaAlgorithm: queryRow ? undefined : msaAlgorithm,
         searchProgram: params.searchProgram,
         maxHits,
         msa,

package/dist/MsaViewPanel/doLaunchBlast.test.js

@@ -1,7 +1,9 @@
 import { beforeEach, expect, test, vi } from 'vitest';
 import { saveBlastResult } from '../utils/blastCache';
+import { MAX_PAIR_CELLS } from '../utils/browserAlign';
 import { searchBackends } from '../utils/homologSearch';
 import { launchMSA } from '../utils/msa';
+import { getCachedSearch, saveSearch } from '../utils/searchCache';
 import { fetchTaxonomyInfo } from '../utils/taxonomyNames';
 import { resolveUniProtEntry } from '../utils/unirefHomologs';
 import { doLaunchBlast } from './doLaunchBlast';
@@ -15,6 +17,11 @@ vi.mock('../utils/msa', () => ({ launchMSA: vi.fn() }));
 vi.mock('../utils/taxonomyNames', () => ({ fetchTaxonomyInfo: vi.fn() }));
 vi.mock('../utils/blastCache', () => ({ saveBlastResult: vi.fn() }));
 vi.mock('../utils/unirefHomologs', () => ({ resolveUniProtEntry: vi.fn() }));
+vi.mock('../utils/searchCache', async (importOriginal) => ({
+    ...(await importOriginal()),
+    getCachedSearch: vi.fn(),
+    saveSearch: vi.fn(),
+}));
 const blastp = vi.mocked(searchBackends.blastp);
 const phmmer = vi.mocked(searchBackends.phmmer);
 const mockLaunchMSA = vi.mocked(launchMSA);
@@ -44,6 +51,8 @@ beforeEach(() => {
     vi.clearAllMocks();
     vi.mocked(fetchTaxonomyInfo).mockResolvedValue(new Map());
     vi.mocked(saveBlastResult).mockResolvedValue(undefined);
+    vi.mocked(getCachedSearch).mockResolvedValue(undefined);
+    vi.mocked(saveSearch).mockResolvedValue(undefined);
 });
 test('bare hits go to the chosen aligner, with the query first', async () => {
     blastp.mockResolvedValue({ rid: 'job', hits: [{ ...HIT, sequence: 'MKWV' }] });
@@ -168,3 +177,48 @@ test('a live Feature handed over in the same session labels it the same way', as
         geneName: 'TP53',
     }));
 });
+const BLASTP_BROWSER = {
+    searchProgram: 'blastp',
+    blastDatabase: 'uniprotkb_swissprot',
+    msaAlgorithm: 'browser',
+    proteinSequence: 'MKWVTF',
+};
+test('the hits are saved before the aligner runs, so a failed alignment keeps them', async () => {
+    blastp.mockResolvedValue({ rid: 'job', hits: [{ ...HIT, sequence: 'MKWV' }] });
+    mockLaunchMSA.mockRejectedValue(new Error('aligner fell over'));
+    await expect(launch(makeModel(BLASTP_BROWSER))).rejects.toThrow('aligner fell over');
+    expect(saveSearch).toHaveBeenCalledWith(expect.objectContaining({
+        fasta: '>QUERY\nMKWVTF\n>P1-Mus_musculus\nMKWV',
+        rid: 'job',
+    }));
+});
+test('a relaunch with saved hits aligns them without searching again', async () => {
+    vi.mocked(getCachedSearch).mockResolvedValue({
+        id: 'k',
+        fasta: '>QUERY\nMKWVTF\n>P1\nMKWV',
+        treeMetadata: {},
+        rid: 'job',
+        timestamp: 0,
+    });
+    mockLaunchMSA.mockResolvedValue({ msa: 'aligned', tree: '' });
+    const result = await launch(makeModel(BLASTP_BROWSER));
+    expect(blastp).not.toHaveBeenCalled();
+    expect(mockLaunchMSA).toHaveBeenCalledWith(expect.objectContaining({ sequence: '>QUERY\nMKWVTF\n>P1\nMKWV' }));
+    expect(result.msa).toBe('aligned');
+});
+test('a query too long for the in-browser aligner is refused before the search', async () => {
+    const side = Math.ceil(Math.sqrt(MAX_PAIR_CELLS)) + 1;
+    await expect(launch(makeModel({ ...BLASTP_BROWSER, proteinSequence: 'M'.repeat(side) }))).rejects.toThrow(/too large to align in the browser/);
+    expect(blastp).not.toHaveBeenCalled();
+});
+test('the same long query goes to an EBI aligner without complaint', async () => {
+    const side = Math.ceil(Math.sqrt(MAX_PAIR_CELLS)) + 1;
+    blastp.mockResolvedValue({ rid: 'job', hits: [{ ...HIT, sequence: 'MKWV' }] });
+    mockLaunchMSA.mockResolvedValue({ msa: 'aligned', tree: 'tree' });
+    await launch(makeModel({
+        ...BLASTP_BROWSER,
+        msaAlgorithm: 'clustalo',
+        proteinSequence: 'M'.repeat(side),
+    }));
+    expect(blastp).toHaveBeenCalled();
+});

package/dist/MsaViewPanel/doLaunchOrthologs.js

@@ -1,4 +1,5 @@
 import { cleanProteinSequence } from '../LaunchMsaView/util';
+import { isAbortError } from '../utils/fetch';
 import { launchMSA } from '../utils/msa';
 import { dedupeLabels, fetchOrthologRows, fetchProteinForGene, resolveGeneId, } from '../utils/ncbiOrthologs';
 import { fetchPantherOrthologs } from '../utils/pantherOrthologs';
@@ -33,6 +34,7 @@ export async function doLaunchOrthologs({ self, scope, }) {
         exclude: taxId,
         limit: maxSpecies,
         onProgress,
+        signal,
     };
     const { geneId, representative, rows } = source === 'panther'
         ? await findPantherOrthologs(request)
@@ -41,7 +43,6 @@ export async function doLaunchOrthologs({ self, scope, }) {
                 ...request,
                 identity,
                 referenceProteomesOnly,
-                signal,
             })
             : await findNcbiOrthologs(request);
     // The query row. The dialog always supplies it — it is the user's OWN
@@ -68,7 +69,7 @@ export async function doLaunchOrthologs({ self, scope, }) {
     // taxon is excluded from that set, but a subspecies can sanitize to the same
     // token, and a collision would silently point the coordinate mapping at
     // another animal's row.
-    const queryLabel = await queryRowLabel(taxId, rows);
+    const queryLabel = await queryRowLabel(taxId, rows, signal);
     act(() => {
         self.setQuerySeqName(queryLabel);
     });
@@ -98,16 +99,17 @@ export async function doLaunchOrthologs({ self, scope, }) {
  * wants "this gene across species" gets NCBI's own order, which leads with the
  * reference organisms.
  */
-async function findNcbiOrthologs({ taxId, geneCandidates, onProgress, ...rest }) {
+async function findNcbiOrthologs({ taxId, geneCandidates, onProgress, signal, ...rest }) {
     onProgress('Resolving gene at NCBI...');
-    const resolved = await resolveGeneId(geneCandidates, taxId);
+    const resolved = await resolveGeneId(geneCandidates, taxId, signal);
     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 representative = await fetchRepresentativeQueryProtein(resolved.geneId, signal);
     const rows = await fetchOrthologRows({
         geneId: resolved.geneId,
         onProgress,
+        signal,
         ...rest,
     });
     return { geneId: resolved.geneId, representative, rows };
@@ -122,12 +124,11 @@ const sourceNames = {
  * entry the cluster was looked up from, whose sequence a spec-launched row
  * takes and whose accession earns the CDD overlay when the two match.
  */
-async function findUnirefHomologs({ geneCandidates, identity, referenceProteomesOnly, signal, ...rest }) {
+async function findUnirefHomologs({ geneCandidates, identity, referenceProteomesOnly, ...rest }) {
     const found = await fetchUnirefHomologs({
         candidates: geneCandidates,
         identity,
         referenceProteomesOnly,
-        signal,
         ...rest,
     });
     return {
@@ -160,13 +161,16 @@ async function findPantherOrthologs({ geneCandidates, ...rest }) {
  * marker when NCBI cannot name the taxon, which is a naming failure and must not
  * take down the launch.
  */
-async function queryRowLabel(taxId, rows) {
+async function queryRowLabel(taxId, rows, signal) {
     let name;
     try {
-        const info = (await fetchTaxonomyInfo([taxId])).get(taxId);
+        const info = (await fetchTaxonomyInfo([taxId], signal)).get(taxId);
         name = info?.commonName ?? info?.sciname;
     }
     catch (e) {
+        if (isAbortError(e)) {
+            throw e;
+        }
         console.warn('[msaview-orthologs] taxonomy name lookup failed:', e);
     }
     return dedupeLabels([
@@ -179,11 +183,14 @@ async function queryRowLabel(taxId, rows) {
  * that supplied no sequence of its own, the alignment — so it is reported by
  * returning nothing rather than by throwing here.
  */
-async function fetchRepresentativeQueryProtein(geneId) {
+async function fetchRepresentativeQueryProtein(geneId, signal) {
     try {
-        return await fetchProteinForGene(geneId);
+        return await fetchProteinForGene(geneId, signal);
     }
     catch (e) {
+        if (isAbortError(e)) {
+            throw e;
+        }
         console.warn('[msaview-orthologs] query protein lookup failed:', e);
         return undefined;
     }

package/dist/MsaViewPanel/launchAutoruns.test.js

@@ -8,7 +8,6 @@ vi.mock('@jbrowse/core/util', async (importOriginal) => ({
 vi.mock('./doLaunchBlast', () => ({ doLaunchBlast: vi.fn() }));
 vi.mock('./msaDataStore', () => ({
     cleanupOldData: vi.fn(async () => { }),
-    deleteMsaData: vi.fn(async () => { }),
     generateDataStoreId: vi.fn(),
     retrieveMsaData: vi.fn(),
     storeMsaData: vi.fn(),

package/dist/MsaViewPanel/model.d.ts

@@ -933,19 +933,14 @@ export default function stateModelFactory(): import("@jbrowse/mobx-state-tree").
     loadingStoredData: boolean;
     isStoringData: boolean;
     lastStoredData: MsaDataPayload | undefined;
+    ownsDataStoreRow: boolean;
     launchController: AbortController | undefined;
     domainsRequested: boolean;
 } & {
     /**
      * #getter
      */
-    readonly transcriptToMsaMap: {
-        g2p: Record<number, number>;
-        p2g: Record<number, number>;
-        p2gCodon: Record<number, number[]>;
-        refName: string;
-        strand: number;
-    } | undefined;
+    readonly transcriptToMsaMap: import("./transcriptMap").TranscriptMap | undefined;
     /**
      * #getter
      */
@@ -983,6 +978,13 @@ export default function stateModelFactory(): import("@jbrowse/mobx-state-tree").
      * alignment the link does carry.
      */
     readonly hostRestoresData: boolean;
+    /**
+     * #getter
+     * the documents a reload would lose: too big for react-msaview to keep
+     * in the snapshot, and with no filehandle or kept init to refetch them
+     * from. IndexedDB holds exactly these.
+     */
+    readonly unsavedDocuments: MsaDataPayload;
 } & {
     /**
      * #action
@@ -1040,6 +1042,10 @@ export default function stateModelFactory(): import("@jbrowse/mobx-state-tree").
      * #action
      */
     setLastStoredData(arg?: MsaDataPayload): void;
+    /**
+     * #action
+     */
+    setOwnsDataStoreRow(arg: boolean): void;
     /**
      * #action
      */

package/dist/MsaViewPanel/model.js

@@ -1,13 +1,12 @@
 import { BaseViewModel } from '@jbrowse/core/pluggableElementTypes';
 import { getSession } from '@jbrowse/core/util';
-import { addDisposer, types } from '@jbrowse/mobx-state-tree';
-import { genomeToTranscriptSeqMapping } from 'g2p_mapper';
+import { addDisposer, getSnapshot, types } from '@jbrowse/mobx-state-tree';
 import { autorun } from 'mobx';
 import { MSAModelF } from 'react-msaview';
 import { autoLoadProteinDomains, launchBlastIfNeeded, launchOrthologsIfNeeded, loadStoredData, observeProteinHighlights, processInit, runCleanup, storeDataToIndexedDB, syncGenomeHoverToMsaColumn, } from './afterCreateAutoruns';
 import { msaCoordToGenomeCoord, msaCoordToGenomeRegions, } from './msaCoordToGenomeCoord';
-import { deleteMsaData } from './msaDataStore';
 import { resolveConnectedTranscriptIfNeeded } from './resolveConnectedTranscript';
+import { transcriptMap } from './transcriptMap';
 /**
  * Where the homolog set comes from. NCBI's ortholog sets cover vertebrates and
  * insects; PANTHER's span its 144 reference proteomes, human to yeast to
@@ -132,6 +131,13 @@ export default function stateModelFactory() {
          * neighbor-joining tree, say) is recognized as needing a new one
          */
         lastStoredData: undefined,
+        /**
+         * #volatile
+         * whether this view wrote the row `dataStoreId` names, this session;
+         * a restored row may be shared with a copied view or a duplicated
+         * session, so a write to one the view did not create takes a fresh id
+         */
+        ownsDataStoreRow: false,
         /**
          * #volatile
          * aborts the launch currently in flight -- from the Cancel button, and
@@ -153,7 +159,7 @@ export default function stateModelFactory() {
          */
         get transcriptToMsaMap() {
             return self.connectedFeature
-                ? genomeToTranscriptSeqMapping(self.connectedFeature)
+                ? transcriptMap(self.connectedFeature)
                 : undefined;
         },
         /**
@@ -219,6 +225,26 @@ export default function stateModelFactory() {
             // away for every view this one does not speak for
             return self.hostCarriesData || !!(msaIndexedLocation && msaName);
         },
+        /**
+         * #getter
+         * the documents a reload would lose: too big for react-msaview to keep
+         * in the snapshot, and with no filehandle or kept init to refetch them
+         * from. IndexedDB holds exactly these.
+         */
+        get unsavedDocuments() {
+            const { data, init } = self;
+            const inSnapshot = getSnapshot(data);
+            const unsaved = (key, source) => {
+                const text = data[key];
+                return text && !source && !inSnapshot[key] ? text : undefined;
+            };
+            return {
+                msa: unsaved('msa', self.msaFilehandle ?? init?.msaIndexedLocation),
+                tree: unsaved('tree', self.treeFilehandle),
+                treeMetadata: unsaved('treeMetadata', self.treeMetadataFilehandle),
+                gff: unsaved('gff', self.gffFilehandle),
+            };
+        },
     }))
         .actions(self => ({
         /**
@@ -305,6 +331,12 @@ export default function stateModelFactory() {
         setLastStoredData(arg) {
             self.lastStoredData = arg;
         },
+        /**
+         * #action
+         */
+        setOwnsDataStoreRow(arg) {
+            self.ownsDataStoreRow = arg;
+        },
         /**
          * #action
          */
@@ -414,7 +446,7 @@ export default function stateModelFactory() {
              * once per view, never fired again.
              */
             reset() {
-                const { displayName, minimized, zoomToBaseLevel, dataStoreId } = self;
+                const { displayName, minimized, zoomToBaseLevel } = self;
                 superReset();
                 if (displayName !== undefined) {
                     self.setDisplayName(displayName);
@@ -423,10 +455,7 @@ export default function stateModelFactory() {
                 self.setZoomToBaseLevel(zoomToBaseLevel);
                 self.setDomainsRequested(false);
                 self.setLastStoredData(undefined);
-                if (dataStoreId) {
-                    // nothing points at that row now
-                    void deleteMsaData(dataStoreId);
-                }
+                self.setOwnsDataStoreRow(false);
             },
         };
     })
@@ -464,8 +493,8 @@ export default function stateModelFactory() {
             addDisposer(self, () => {
                 self.launchController?.abort();
             });
+            loadStoredData(self);
             for (const fn of [
-                loadStoredData,
                 storeDataToIndexedDB,
                 resolveConnectedTranscriptIfNeeded,
                 launchBlastIfNeeded,

package/dist/MsaViewPanel/model.test.js

@@ -1,7 +1,6 @@
 import { beforeEach, describe, expect, test, vi } from 'vitest';
 import { doLaunchBlast } from './doLaunchBlast';
 import stateModelFactory from './model';
-import { deleteMsaData } from './msaDataStore';
 // the launch autoruns are live on a real model, and a blastParams write is what
 // wakes them -- so the search is mocked rather than sent to EBI. The session is
 // mocked for the same reason: the hover and highlight autoruns reach for one on
@@ -13,7 +12,6 @@ vi.mock('@jbrowse/core/util', async (importOriginal) => ({
 vi.mock('./doLaunchBlast', () => ({ doLaunchBlast: vi.fn() }));
 vi.mock('./msaDataStore', () => ({
     cleanupOldData: vi.fn(async () => { }),
-    deleteMsaData: vi.fn(async () => { }),
     generateDataStoreId: vi.fn(),
     retrieveMsaData: vi.fn(),
     storeMsaData: vi.fn(),
@@ -152,15 +150,16 @@ describe('returning to the import form', () => {
         expect(model.zoomToBaseLevel).toBe(true);
         expect(model.dataInitialized).toBe(false);
     });
-    test('clears the volatiles applySnapshot cannot reach, and the stored row', () => {
+    test('clears the volatiles applySnapshot cannot reach, and the stored id', () => {
         const model = view();
         model.setDomainsRequested(true);
         model.setLastStoredData({ msa: '>a\nMK' });
         model.setDataStoreId('msa-1');
+        model.setOwnsDataStoreRow(true);
         model.reset();
         expect(model.domainsRequested).toBe(false);
         expect(model.lastStoredData).toBeUndefined();
+        expect(model.ownsDataStoreRow).toBe(false);
         expect(model.dataStoreId).toBeUndefined();
-        expect(deleteMsaData).toHaveBeenCalledWith('msa-1');
     });
 });

package/dist/MsaViewPanel/msaDataStore.d.ts

@@ -7,12 +7,11 @@ export interface MsaDataPayload {
 }
 export declare function generateDataStoreId(): string;
 export declare function storeMsaData(id: string, data: MsaDataPayload): Promise<boolean>;
+/** undefined only when no row has the id; a failed read throws */
 export declare function retrieveMsaData(id: string): Promise<{
     msa?: string;
     tree?: string;
     treeMetadata?: string;
     gff?: string;
 } | undefined>;
-/** drop one view's row, for a reset that just orphaned it */
-export declare function deleteMsaData(id: string): Promise<void>;
 export declare function cleanupOldData(maxAgeMs?: number): Promise<number>;

package/dist/MsaViewPanel/msaDataStore.js

@@ -23,39 +23,24 @@ export async function storeMsaData(id, data) {
         return false;
     }
 }
+/** undefined only when no row has the id; a failed read throws */
 export async function retrieveMsaData(id) {
-    try {
-        const db = await getDB();
-        const result = await db.get(STORE_NAME, id);
-        if (!result) {
-            return undefined;
-        }
-        // reading counts as use, which is what makes cleanupOldData's policy
-        // "unused for 7 days" rather than "written 7 days ago" -- a session opened
-        // every day used to lose its alignment on the eighth
-        try {
-            await db.put(STORE_NAME, { ...result, timestamp: Date.now() });
-        }
-        catch (e) {
-            console.warn('Failed to refresh MSA data timestamp:', e);
-        }
-        const { id: _id, timestamp: _timestamp, ...payload } = result;
-        return payload;
-    }
-    catch (e) {
-        console.warn('Failed to retrieve MSA data:', e);
+    const db = await getDB();
+    const result = await db.get(STORE_NAME, id);
+    if (!result) {
         return undefined;
     }
-}
-/** drop one view's row, for a reset that just orphaned it */
-export async function deleteMsaData(id) {
+    // reading counts as use, which is what makes cleanupOldData's policy
+    // "unused for 7 days" rather than "written 7 days ago" -- a session opened
+    // every day used to lose its alignment on the eighth
     try {
-        const db = await getDB();
-        await db.delete(STORE_NAME, id);
+        await db.put(STORE_NAME, { ...result, timestamp: Date.now() });
     }
     catch (e) {
-        console.warn('Failed to delete MSA data:', e);
+        console.warn('Failed to refresh MSA data timestamp:', e);
     }
+    const { id: _id, timestamp: _timestamp, ...payload } = result;
+    return payload;
 }
 export async function cleanupOldData(maxAgeMs = 7 * 24 * 60 * 60 * 1000) {
     try {

package/dist/MsaViewPanel/msaDataStore.test.js

@@ -4,11 +4,13 @@ import { retrieveMsaData, storeMsaData } from './msaDataStore';
 // switch for the write half so a browser that refuses writes can be played back.
 const { rows, state } = vi.hoisted(() => ({
     rows: new Map(),
-    state: { putFails: false },
+    state: { putFails: false, getFails: false },
 }));
 vi.mock('../utils/idb', () => ({
     createDbOpener: () => () => Promise.resolve({
-        get: (_store, id) => Promise.resolve(rows.get(id)),
+        get: (_store, id) => state.getFails
+            ? Promise.reject(new Error('InvalidStateError'))
+            : Promise.resolve(rows.get(id)),
         put: (_store, value) => {
             if (state.putFails) {
                 return Promise.reject(new Error('QuotaExceededError'));
@@ -21,6 +23,7 @@ vi.mock('../utils/idb', () => ({
 beforeEach(() => {
     rows.clear();
     state.putFails = false;
+    state.getFails = false;
 });
 // cleanupOldData deletes by timestamp, so without this a session opened every
 // single day still lost its alignment on the eighth
@@ -34,6 +37,11 @@ test('a row that is no longer there reads as undefined and writes nothing', asyn
     expect(await retrieveMsaData('msa-gone')).toBeUndefined();
     expect(rows.size).toBe(0);
 });
+test('a read that fails throws rather than reading as a missing row', async () => {
+    rows.set('msa-1', { id: 'msa-1', msa: '>a\nMK', timestamp: 1000 });
+    state.getFails = true;
+    await expect(retrieveMsaData('msa-1')).rejects.toThrow('InvalidStateError');
+});
 // the refresh is housekeeping; failing it must not turn a readable alignment
 // into a missing one, which is what the caller reports as expired
 test('a refresh that fails still hands back the data it read', async () => {

package/dist/MsaViewPanel/observeProteinHighlights.test.js

@@ -24,6 +24,7 @@ function makeModel({ highlightColumns, querySeqOffset = 0, } = {}) {
         // g2p is indexed by genome coord; identity keeps the arithmetic out of the way
         transcriptToMsaMap: {
             g2p: Object.fromEntries([...Array(200).keys()].map(i => [i, i])),
+            codingPositions: [...Array(200).keys()],
         },
         highlightColumns,
         highlightedColumns: undefined,

package/dist/MsaViewPanel/processInit.test.js

@@ -1,5 +1,5 @@
 import { beforeEach, expect, test, vi } from 'vitest';
-import { processInit, storeDataToIndexedDB } from './afterCreateAutoruns';
+import { processInit } from './afterCreateAutoruns';
 import { fetchIndexedMsa } from './fetchIndexedMsa';
 vi.mock('./fetchIndexedMsa', () => ({ fetchIndexedMsa: vi.fn() }));
 vi.mock('./msaDataStore', () => ({
@@ -64,9 +64,3 @@ test('a url init is still resolved once and cleared', async () => {
     expect(model.setMSAFilehandle).toHaveBeenCalled();
     expect(model.setInit).toHaveBeenCalledWith(undefined);
 });
-test('an indexed view writes no IndexedDB row', async () => {
-    const model = makeModel({ rows: [['a', 'MK']], data: { msa: '>a\nMK' } });
-    storeDataToIndexedDB(model);
-    await settle();
-    expect(model.setDataStoreId).not.toHaveBeenCalled();
-});

package/dist/MsaViewPanel/regionSnapshot.test.js

@@ -6,7 +6,6 @@ vi.mock('@jbrowse/core/util', async (importOriginal) => ({
 }));
 vi.mock('./msaDataStore', () => ({
     cleanupOldData: vi.fn(async () => { }),
-    deleteMsaData: vi.fn(async () => { }),
     generateDataStoreId: vi.fn(),
     retrieveMsaData: vi.fn(),
     storeMsaData: vi.fn(async () => true),

package/dist/MsaViewPanel/resolveConnectedTranscript.test.js

@@ -36,7 +36,6 @@ vi.mock('./doLaunchBlast', () => ({
 }));
 vi.mock('./msaDataStore', () => ({
     cleanupOldData: vi.fn(async () => { }),
-    deleteMsaData: vi.fn(async () => { }),
     generateDataStoreId: vi.fn(),
     retrieveMsaData: vi.fn(),
     storeMsaData: vi.fn(),