jbrowse-plugin-msaview 5.15.0 → 5.16.0

package/README.md

@@ -79,6 +79,8 @@ Linking and embedding:
 - [Launch parameters](docs/launch-parameters.md): every argument and field.
 - [Linked views](docs/linked-views.md): how a column reaches its codon and a
   protein3d structure.
+- [Reading the view](docs/reading-the-view.md): `view.report` and `notices`,
+  what a launch resolved to, as data a script or an agent reads.
 
 Working on the plugin:
 

package/dist/MsaViewPanel/afterCreateAutoruns.d.ts

@@ -8,6 +8,18 @@ export declare function loadStoredData(self: JBrowsePluginMsaViewModel): void;
  * refusing IndexedDB fails once rather than in a loop.
  */
 export declare function storeDataToIndexedDB(self: JBrowsePluginMsaViewModel): void;
+interface TranscriptWait {
+    connectedTranscript?: string;
+    connectedFeature?: unknown;
+    blastParams?: unknown;
+    orthologParams?: unknown;
+    launchCompleted: boolean;
+}
+/**
+ * A launch that has not run yet and is held back by the transcript lookup, so
+ * a lookup that fails is a launch that cannot proceed.
+ */
+export declare function launchAwaitsTranscript(self: TranscriptWait): boolean;
 export declare function launchOrthologsIfNeeded(self: JBrowsePluginMsaViewModel): void;
 export declare function launchBlastIfNeeded(self: JBrowsePluginMsaViewModel): void;
 /**
@@ -57,4 +69,10 @@ export declare function syncGenomeHoverToMsaColumn(self: JBrowsePluginMsaViewMod
  */
 export declare function observeProteinHighlights(self: JBrowsePluginMsaViewModel): () => void;
 export declare function runCleanup(): void;
+/**
+ * Waits for the genome view to show an assembly, since the track is added to
+ * that assembly: before navigation `showDomainsOnGenome` has none to name, and
+ * clearing the request then dropped it unfulfilled.
+ */
 export declare function showDomainsOnGenomeIfAsked(self: JBrowsePluginMsaViewModel): void;
+export {};

package/dist/MsaViewPanel/afterCreateAutoruns.js

@@ -11,7 +11,7 @@ import { cleanupOldData, generateDataStoreId, retrieveMsaData, storeMsaData, } f
 import { runLaunch } from './runLaunch';
 import { getProteinViews } from './structureConnection';
 import { proteinPositionsInRange } from './transcriptMap';
-import { getUniprotIdFromAlphaFoldUrl, hasQueryRow, transcriptPosToVisibleCol, } from './util';
+import { errorMessage, getUniprotIdFromAlphaFoldUrl, hasQueryRow, transcriptPosToVisibleCol, } from './util';
 const EXPIRED_MESSAGE = "This view's alignment is no longer in browser storage. Stored alignments are kept for 7 days after they were last used, and are lost when site data is cleared.";
 const RELAUNCHABLE = ' Retry runs the original search again and rebuilds it.';
 const START_OVER = ' Relaunch it from the gene to rebuild it.';
@@ -140,6 +140,15 @@ export function storeDataToIndexedDB(self) {
 function awaitingTranscript(self) {
     return !!self.connectedTranscript && !self.connectedFeature;
 }
+/**
+ * A launch that has not run yet and is held back by the transcript lookup, so
+ * a lookup that fails is a launch that cannot proceed.
+ */
+export function launchAwaitsTranscript(self) {
+    return (!!(self.blastParams ?? self.orthologParams) &&
+        !self.launchCompleted &&
+        awaitingTranscript(self));
+}
 /**
  * The params are the request and `launchCompleted` marks it done. They stay in
  * place on failure, so the error is attributable, and on success, because a
@@ -180,22 +189,30 @@ export function autoLoadProteinDomains(self) {
         };
         addDisposer(self, abort);
         self.setDomainsRequested(true);
+        self.setLoadingDomains(true);
         self.setStatus({
             msg: 'Fetching protein domains from NCBI',
             onCancel: abort,
         });
         void (async () => {
             try {
-                await loadProteinDomains(self, controller.signal);
+                const notice = await loadProteinDomains(self, controller.signal);
+                if (notice && isAlive(self)) {
+                    self.addWarning(notice);
+                }
             }
             catch (e) {
                 if (!isAbortError(e)) {
                     console.error('[msaview-domains] auto-load failed:', e);
+                    if (isAlive(self)) {
+                        self.addWarning(`Protein domains did not load from NCBI: ${errorMessage(e)}`);
+                    }
                 }
             }
             finally {
                 if (isAlive(self)) {
                     self.setStatus(undefined);
+                    self.setLoadingDomains(false);
                 }
             }
         })();
@@ -390,9 +407,14 @@ export function runCleanup() {
         console.error('Failed to cleanup old MSA data:', e);
     });
 }
+/**
+ * Waits for the genome view to show an assembly, since the track is added to
+ * that assembly: before navigation `showDomainsOnGenome` has none to name, and
+ * clearing the request then dropped it unfulfilled.
+ */
 export function showDomainsOnGenomeIfAsked(self) {
     if (self.domainsOnGenome &&
-        self.connectedView &&
+        self.connectedView?.assemblyNames[0] &&
         self.connectedDomains.features.length > 0) {
         self.showDomainsOnGenome();
         self.setDomainsOnGenome(false);

package/dist/MsaViewPanel/loadProteinDomains.d.ts

@@ -8,6 +8,10 @@ interface DomainModel {
  * annotations. Each launch stores a row's accession in its row data, so those
  * are looked up via efetch and keyed by MSA row name, which is what
  * react-msaview matches annotations against.
+ *
+ * Throws when NCBI answered for none of the rows. When it answered for some,
+ * their domains are drawn and the returned notice names what is missing. A
+ * set of proteins with no CDD annotation leaves the overlay as it was.
  */
-export declare function loadProteinDomains(self: DomainModel, signal?: AbortSignal): Promise<void>;
+export declare function loadProteinDomains(self: DomainModel, signal?: AbortSignal): Promise<string | undefined>;
 export {};

package/dist/MsaViewPanel/loadProteinDomains.js

@@ -1,16 +1,26 @@
 import { fetchProteinDomains } from '../utils/ncbiDomains';
+import { errorMessage } from './util';
 /**
  * Overlay protein domains on the alignment using NCBI's pre-computed CDD
  * annotations. Each launch stores a row's accession in its row data, so those
  * are looked up via efetch and keyed by MSA row name, which is what
  * react-msaview matches annotations against.
+ *
+ * Throws when NCBI answered for none of the rows. When it answered for some,
+ * their domains are drawn and the returned notice names what is missing. A
+ * set of proteins with no CDD annotation leaves the overlay as it was.
  */
 export async function loadProteinDomains(self, signal) {
     const rowAccessions = Object.entries(self.rowData).flatMap(([rowName, row]) => row?.Accession ? [{ rowName, accession: row.Accession }] : []);
     if (rowAccessions.length === 0) {
         throw new Error('No NCBI accessions found in alignment rows');
     }
-    const byAccession = await fetchProteinDomains(rowAccessions.map(r => r.accession), signal);
+    const asked = new Set(rowAccessions.map(r => r.accession));
+    const { byAccession, failure } = await fetchProteinDomains([...asked], signal);
+    const answered = [...asked].filter(a => byAccession.has(a)).length;
+    if (failure !== undefined && answered === 0) {
+        throw new Error(errorMessage(failure), { cause: failure });
+    }
     const annotations = rowAccessions.flatMap(({ rowName, accession }) => (byAccession.get(accession) ?? []).flatMap(({ signature, locations, featureType }) => signature.entry
         ? locations.map(({ start, end }) => ({
             id: rowName,
@@ -22,8 +32,10 @@ export async function loadProteinDomains(self, signal) {
             end,
         }))
         : []));
-    if (annotations.length === 0) {
-        throw new Error('No CDD domain annotations found for these proteins');
+    if (annotations.length > 0) {
+        self.setAnnotations(annotations);
     }
-    self.setAnnotations(annotations);
+    return failure === undefined
+        ? undefined
+        : `Protein domains loaded for ${answered} of ${asked.size} proteins; NCBI failed on the rest: ${errorMessage(failure)}`;
 }

package/dist/MsaViewPanel/loadProteinDomains.test.js

@@ -16,12 +16,15 @@ function model(treeMetadata) {
     };
 }
 test('an accession row becomes one annotation per location, keyed by row name', async () => {
-    vi.mocked(fetchProteinDomains).mockResolvedValue(new Map([['NP_1', [MATCH]]]));
+    vi.mocked(fetchProteinDomains).mockResolvedValue({
+        byAccession: new Map([['NP_1', [MATCH]]]),
+        failure: undefined,
+    });
     const self = model({
         QUERY: { Accession: 'NP_1' },
         other: { 'Scientific name': 'Mus musculus' },
     });
-    await loadProteinDomains(self);
+    expect(await loadProteinDomains(self)).toBeUndefined();
     expect(self.setAnnotations).toHaveBeenCalledWith([
         {
             id: 'QUERY',
@@ -34,9 +37,37 @@ test('an accession row becomes one annotation per location, keyed by row name',
         },
     ]);
 });
-test('says so rather than clearing the overlay when NCBI has nothing', async () => {
-    vi.mocked(fetchProteinDomains).mockResolvedValue(new Map());
+test('proteins with no CDD annotation leave the overlay alone', async () => {
+    vi.mocked(fetchProteinDomains).mockResolvedValue({
+        byAccession: new Map([['NP_1', []]]),
+        failure: undefined,
+    });
+    const self = model({ QUERY: { Accession: 'NP_1' } });
+    expect(await loadProteinDomains(self)).toBeUndefined();
+    expect(self.setAnnotations).not.toHaveBeenCalled();
+});
+test('a fetch that failed outright throws its failure', async () => {
+    const failure = new Error('HTTP 429 fetching efetch');
+    vi.mocked(fetchProteinDomains).mockResolvedValue({
+        byAccession: new Map(),
+        failure,
+    });
     const self = model({ QUERY: { Accession: 'NP_1' } });
-    await expect(loadProteinDomains(self)).rejects.toThrow('No CDD domain annotations found');
+    await expect(loadProteinDomains(self)).rejects.toMatchObject({
+        message: 'HTTP 429 fetching efetch',
+        cause: failure,
+    });
     expect(self.setAnnotations).not.toHaveBeenCalled();
 });
+test('a fetch that half failed draws what loaded and names what did not', async () => {
+    vi.mocked(fetchProteinDomains).mockResolvedValue({
+        byAccession: new Map([['NP_1', [MATCH]]]),
+        failure: new Error('HTTP 429 fetching efetch'),
+    });
+    const self = model({
+        QUERY: { Accession: 'NP_1' },
+        mouse: { Accession: 'NP_2' },
+    });
+    expect(await loadProteinDomains(self)).toBe('Protein domains loaded for 1 of 2 proteins; NCBI failed on the rest: HTTP 429 fetching efetch');
+    expect(self.setAnnotations).toHaveBeenCalledTimes(1);
+});

package/dist/MsaViewPanel/model.d.ts

@@ -6,10 +6,10 @@ import type { MsaDataPayload } from './msaDataStore';
 import type { MafRegion, MsaViewInitState } from './types';
 import type { TranscriptRef } from './util';
 import type { MenuItem } from '@jbrowse/core/ui';
+import type { AbstractViewModel } from '@jbrowse/core/util';
 import type { Instance } from '@jbrowse/mobx-state-tree';
 import type { LinearGenomeViewModel } from '@jbrowse/plugin-linear-genome-view';
 type LGV = LinearGenomeViewModel;
-type MaybeLGV = LGV | undefined;
 export interface IRegion {
     refName: string;
     start: number;
@@ -524,7 +524,7 @@ export default function stateModelFactory(): import("@jbrowse/mobx-state-tree").
     readonly effectiveBodyMounted: boolean;
     menuItems(): MenuItem[];
     readonly ownTracks: import("@jbrowse/core/util").AbstractTrackModel[];
-    readonly ownViews: import("@jbrowse/core/util").AbstractViewModel[];
+    readonly ownViews: AbstractViewModel[];
 } & {
     setDisplayName(name: string): void;
     setWidth(newWidth: number): void;
@@ -977,15 +977,48 @@ export default function stateModelFactory(): import("@jbrowse/mobx-state-tree").
     ownsDataStoreRow: boolean;
     launchController: AbortController | undefined;
     domainsRequested: boolean;
+    loadingDomains: boolean;
+    connectionError: unknown;
 } & {
     /**
      * #getter
+     * the linked transcript's genome mapping, or why it has none
      */
-    readonly transcriptToMsaMap: import("./transcriptMap").TranscriptMap | undefined;
+    readonly transcriptMapping: {
+        reason: string;
+    } | {
+        map: {
+            codingPositions: number[];
+            g2p: Record<number, number>;
+            p2g: Record<number, number>;
+            p2gCodon: Record<number, number[]>;
+            refName: string;
+            strand: number;
+        };
+    } | undefined;
+    /**
+     * #getter
+     * whatever view `connectedViewId` names, genome view or not
+     */
+    readonly viewNamedByConnectedViewId: AbstractViewModel | undefined;
+} & {
     /**
      * #getter
+     * the view `connectedViewId` names, when it is a genome view
      */
-    readonly connectedView: MaybeLGV;
+    readonly connectedView: LGV | undefined;
+} & {
+    /**
+     * #getter
+     */
+    readonly transcriptToMsaMap: {
+        codingPositions: number[];
+        g2p: Record<number, number>;
+        p2g: Record<number, number>;
+        p2gCodon: Record<number, number[]>;
+        refName: string;
+        strand: number;
+    } | undefined;
 } & {
     /**
      * #getter
@@ -1035,11 +1068,108 @@ export default function stateModelFactory(): import("@jbrowse/mobx-state-tree").
     readonly unsavedDocuments: MsaDataPayload;
     /**
      * #getter
-     * true while a launch, stored data or a file is still loading and no
-     * error has ended it. jb.waitReady, the app's ready marker and
+     * what is wrong with the link to the genome, derived from the view's
+     * state so each clears when its cause does. A connection failure that
+     * is already the view's `error` is not repeated here.
+     */
+    readonly linkNotices: string[];
+    /**
+     * #getter
+     * true while a launch, stored data, a file, the transcript lookup or the
+     * protein domains are still loading and no error has ended it. Every
+     * term settles on failure. jb.waitReady, the app's ready marker and
      * screenshot tools read it for a view.
      */
     readonly showLoading: boolean;
+} & {
+    /**
+     * #getter
+     * overrides base
+     *
+     * react-msaview's load and data warnings, plus the plugin's link
+     * notices, which the header's warning chip lists and dismisses alike
+     */
+    readonly warnings: string[];
+} & {
+    /**
+     * #getter
+     * what failed and left the view working: the messages the header's
+     * warning chip lists. A notice does not end `showLoading`.
+     */
+    readonly notices: string[];
+} & {
+    /**
+     * #getter
+     * what the view resolved to, as plain JSON. See docs/reading-the-view.md
+     */
+    readonly report: {
+        loading: boolean;
+        error: string | undefined;
+        notices: string[];
+        source: {
+            kind: string;
+            database: "uniprotkb_swissprot" | "uniprotkb" | "pan_proteomes" | "uniprotkb_trembl" | "swissprot" | "uniprotrefprot" | "rp75" | "rp55" | "rp35" | "rp15";
+            msaAlgorithm: "clustalo" | "muscle" | "kalign" | "mafft" | "browser" | undefined;
+            maxHits: number | undefined;
+            accession: string | undefined;
+            queryLength: number | undefined;
+            jobId: string | undefined;
+            completed: boolean;
+        } | {
+            kind: string;
+            orthologSource: "ncbi" | "panther" | "uniref";
+            taxId: number;
+            identity: UnirefIdentity | undefined;
+            maxSpecies: number | undefined;
+            taxa: number[] | undefined;
+            geneCandidates: string[];
+            msaAlgorithm: "clustalo" | "muscle" | "kalign" | "mafft" | "browser";
+            queryLength: number | undefined;
+            jobId: string | undefined;
+            completed: boolean;
+        } | {
+            kind: string;
+            url: string;
+            uri?: undefined;
+            name?: undefined;
+            location?: undefined;
+        } | {
+            kind: string;
+            uri: string;
+            name: string | undefined;
+            url?: undefined;
+            location?: undefined;
+        } | {
+            kind: string;
+            location: string | undefined;
+            url?: undefined;
+            uri?: undefined;
+            name?: undefined;
+        } | {
+            kind: string;
+            url?: undefined;
+            uri?: undefined;
+            name?: undefined;
+            location?: undefined;
+        };
+        rows: number;
+        columns: number;
+        domainAnnotations: number;
+        uniprotId: string | undefined;
+        queryRow: {
+            name: string;
+            found: boolean;
+            offset: number;
+        };
+        connection: {
+            viewId: string | undefined;
+            viewOpen: boolean;
+            transcript: string | undefined;
+            refName: string | undefined;
+            mapped: boolean;
+            unmappedBecause: string | undefined;
+        } | undefined;
+    };
 } & {
     /**
      * #action
@@ -1130,6 +1260,21 @@ export default function stateModelFactory(): import("@jbrowse/mobx-state-tree").
      * #action
      */
     setDomainsRequested(arg: boolean): void;
+    /**
+     * #action
+     */
+    setLoadingDomains(arg: boolean): void;
+    /**
+     * #action
+     * `connectedTranscript` could not be resolved. A launch waiting on it
+     * cannot run, so for one that is the view's error; an alignment from
+     * anywhere else is still worth showing, so then it is a notice.
+     */
+    failConnection(e: unknown): void;
+    /**
+     * #action
+     */
+    clearConnectionFailure(): void;
     /**
      * #action
      */
@@ -1163,6 +1308,13 @@ export default function stateModelFactory(): import("@jbrowse/mobx-state-tree").
      * once per view, never fired again.
      */
     reset(): void;
+} & {
+    /**
+     * #action
+     * overrides base, so dismissing the warning chip hides the link
+     * notices too until their cause changes
+     */
+    clearWarnings(): void;
 } & {
     /**
      * #method

package/dist/MsaViewPanel/model.js

@@ -3,14 +3,19 @@ import { getSession, isSessionWithAddSessionTrack, isSessionWithDeleteTrackConf,
 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, showDomainsOnGenomeIfAsked, syncGenomeHoverToMsaColumn, } from './afterCreateAutoruns';
+import { autoLoadProteinDomains, launchAwaitsTranscript, launchBlastIfNeeded, launchOrthologsIfNeeded, loadStoredData, observeProteinHighlights, processInit, runCleanup, storeDataToIndexedDB, showDomainsOnGenomeIfAsked, syncGenomeHoverToMsaColumn, } from './afterCreateAutoruns';
 import { connectedDomains } from './connectedDomains';
 import { domainTrackConf } from './domainTrack';
 import { isLaunching } from './isLaunching';
 import { msaCoordToGenomeCoord, msaCoordToGenomeRegions, } from './msaCoordToGenomeCoord';
 import { resolveConnectedTranscriptIfNeeded } from './resolveConnectedTranscript';
 import { syncSessionHighlights } from './sessionHighlights';
-import { transcriptMap } from './transcriptMap';
+import { transcriptMapping } from './transcriptMap';
+import { errorMessage, hasQueryRow } from './util';
+import { viewReport } from './viewReport';
+function isLinearGenomeView(view) {
+    return view.type === 'LinearGenomeView';
+}
 /**
  * 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
@@ -163,23 +168,57 @@ export default function stateModelFactory() {
          * when NCBI returns no domains (leaving the annotation list empty)
          */
         domainsRequested: false,
+        /**
+         * #volatile
+         * the protein domain auto-load is in flight
+         */
+        loadingDomains: false,
+        /**
+         * #volatile
+         * why `connectedTranscript` could not be resolved: the lookup missed,
+         * or the genome view it needs is absent or has no feature tracks. It
+         * is also the view's `error` when a launch was waiting on the
+         * transcript, and a notice otherwise
+         */
+        connectionError: undefined,
     }))
         .views(self => ({
         /**
          * #getter
+         * the linked transcript's genome mapping, or why it has none
          */
-        get transcriptToMsaMap() {
+        get transcriptMapping() {
             return self.connectedFeature
-                ? transcriptMap(self.connectedFeature)
+                ? transcriptMapping(self.connectedFeature)
                 : undefined;
         },
         /**
          * #getter
+         * whatever view `connectedViewId` names, genome view or not
          */
-        get connectedView() {
+        get viewNamedByConnectedViewId() {
             const { views } = getSession(self);
             return views.find(f => f.id === self.connectedViewId);
         },
+    }))
+        .views(self => ({
+        /**
+         * #getter
+         * the view `connectedViewId` names, when it is a genome view
+         */
+        get connectedView() {
+            const view = self.viewNamedByConnectedViewId;
+            return view && isLinearGenomeView(view) ? view : undefined;
+        },
+    }))
+        .views(self => ({
+        /**
+         * #getter
+         */
+        get transcriptToMsaMap() {
+            const mapping = self.transcriptMapping;
+            return mapping && 'map' in mapping ? mapping.map : undefined;
+        },
     }))
         .views(self => ({
         /**
@@ -267,15 +306,84 @@ export default function stateModelFactory() {
         },
         /**
          * #getter
-         * true while a launch, stored data or a file is still loading and no
-         * error has ended it. jb.waitReady, the app's ready marker and
+         * what is wrong with the link to the genome, derived from the view's
+         * state so each clears when its cause does. A connection failure that
+         * is already the view's `error` is not repeated here.
+         */
+        get linkNotices() {
+            const { connectionError, error, transcriptMapping, connectedFeature, mafRegion, querySeqName, dataInitialized, } = self;
+            return [
+                ...(connectionError !== undefined && connectionError !== error
+                    ? [errorMessage(connectionError)]
+                    : []),
+                ...(transcriptMapping && 'reason' in transcriptMapping
+                    ? [
+                        `The linked transcript is not mapped to the genome: ${transcriptMapping.reason}`,
+                    ]
+                    : []),
+                ...((connectedFeature || mafRegion) &&
+                    dataInitialized &&
+                    !hasQueryRow(self)
+                    ? [
+                        `No row is named "${querySeqName}", the query row, so the alignment is not linked to the genome`,
+                    ]
+                    : []),
+            ];
+        },
+        /**
+         * #getter
+         * true while a launch, stored data, a file, the transcript lookup or the
+         * protein domains are still loading and no error has ended it. Every
+         * term settles on failure. jb.waitReady, the app's ready marker and
          * screenshot tools read it for a view.
          */
         get showLoading() {
+            const { connectedView, connectedTranscript, connectedFeature, connectionError, } = self;
             return (!self.error &&
                 (isLaunching(self) ||
                     (self.loadingStoredData && !self.dataInitialized) ||
-                    self.isLoading));
+                    self.isLoading ||
+                    self.loadingDomains ||
+                    (!!connectedTranscript &&
+                        !connectedFeature &&
+                        connectionError === undefined) ||
+                    (self.domainsOnGenome &&
+                        self.connectedDomains.features.length > 0 &&
+                        !!connectedView?.showLoading)));
+        },
+    }))
+        .views(self => ({
+        /**
+         * #getter
+         * overrides base
+         *
+         * react-msaview's load and data warnings, plus the plugin's link
+         * notices, which the header's warning chip lists and dismisses alike
+         */
+        get warnings() {
+            return [
+                ...self.loadWarnings,
+                ...[...self.dataWarnings, ...self.linkNotices].filter(w => !self.dismissedWarnings.includes(w)),
+            ];
+        },
+    }))
+        .views(self => ({
+        /**
+         * #getter
+         * what failed and left the view working: the messages the header's
+         * warning chip lists. A notice does not end `showLoading`.
+         */
+        get notices() {
+            return self.warnings;
+        },
+    }))
+        .views(self => ({
+        /**
+         * #getter
+         * what the view resolved to, as plain JSON. See docs/reading-the-view.md
+         */
+        get report() {
+            return viewReport(self);
         },
     }))
         .actions(self => ({
@@ -428,6 +536,34 @@ export default function stateModelFactory() {
         setDomainsRequested(arg) {
             self.domainsRequested = arg;
         },
+        /**
+         * #action
+         */
+        setLoadingDomains(arg) {
+            self.loadingDomains = arg;
+        },
+        /**
+         * #action
+         * `connectedTranscript` could not be resolved. A launch waiting on it
+         * cannot run, so for one that is the view's error; an alignment from
+         * anywhere else is still worth showing, so then it is a notice.
+         */
+        failConnection(e) {
+            self.connectionError = e;
+            if (launchAwaitsTranscript(self)) {
+                self.setError(e);
+            }
+        },
+        /**
+         * #action
+         */
+        clearConnectionFailure() {
+            if (self.connectionError !== undefined &&
+                self.error === self.connectionError) {
+                self.setError(undefined);
+            }
+            self.connectionError = undefined;
+        },
         /**
          * #action
          */
@@ -528,6 +664,24 @@ export default function stateModelFactory() {
                 self.setDomainsRequested(false);
                 self.setLastStoredData(undefined);
                 self.setOwnsDataStoreRow(false);
+                self.clearConnectionFailure();
+            },
+        };
+    })
+        .actions(self => {
+        const superClearWarnings = self.clearWarnings.bind(self);
+        return {
+            /**
+             * #action
+             * overrides base, so dismissing the warning chip hides the link
+             * notices too until their cause changes
+             */
+            clearWarnings() {
+                superClearWarnings();
+                self.dismissedWarnings = [
+                    ...self.dismissedWarnings,
+                    ...self.linkNotices,
+                ];
             },
         };
     })