@jbrowse/core 5.0.0-beta.1 → 5.0.0-beta.11

package/esm/pluggableElementTypes/models/BaseTrackModel.d.ts

@@ -1,6 +1,6 @@
 import type PluginManager from '../../PluginManager.ts';
 import type { RefNameMismatch } from '../../assemblyManager/refNameMismatch.ts';
-import type { AnyConfigurationSchemaType } from '../../configuration/index.ts';
+import type { AnyConfigurationModel, AnyConfigurationSchemaType } from '../../configuration/index.ts';
 import type { MenuItem } from '../../ui/index.ts';
 import type { DisplayModel } from './BaseDisplayModel.tsx';
 import type { FileTypeExporter } from './saveTrackFileTypes/types.ts';
@@ -97,8 +97,17 @@ export declare function createBaseTrackModel(pm: PluginManager, trackType: strin
     readonly activeDisplay: DisplayModel & import("@jbrowse/mobx-state-tree").IStateTreeNode<IType<unknown, unknown, DisplayModel>>;
     /**
      * #getter
+     * the configured displays the CONTAINING VIEW can draw and the track's
+     * adapter feeds, which is the set `replaceDisplay` will accept
+     *
+     * `configuration.displays` is not that set: baseTrackConfig injects one
+     * entry per display type registered for the track TYPE, across every
+     * view type, so a VariantTrack carries a ChordVariantDisplay a linear
+     * view cannot draw. The track menu's own "Display types" submenu has
+     * always filtered them; this exposes the same list to code, because the
+     * alternative is every caller re-deriving it from the plugin manager.
      */
-    readonly canConfigure: boolean;
+    readonly compatibleDisplays: AnyConfigurationModel[];
 } & {
     /**
      * #getter
@@ -130,8 +139,14 @@ export declare function createBaseTrackModel(pm: PluginManager, trackType: strin
     /**
      * #getter
      */
-    readonly adapterType: import("../AdapterType.ts").default;
+    readonly adapterType: import("../AdapterType.ts").default<any>;
 } & {
+    /**
+     * #action
+     * Write the config to the session now rather than after the 400 ms
+     * wait, for an edit that has to be undoable the moment it lands.
+     */
+    persistConfigurationNow(): void;
     /**
      * #action
      */
@@ -144,6 +159,27 @@ export declare function createBaseTrackModel(pm: PluginManager, trackType: strin
      * #action
      */
     setResizing(flag: boolean): void;
+    /**
+     * #action
+     * `applyDisplaySettings` on the display being drawn (`activeDisplay`,
+     * which a shown track always has — this is not meaningful on a bare
+     * config node) — the track-level entry for "restyle this track in
+     * place" (a session spec's inline keys, an agent's settings bag). Only
+     * that one display: settings vocabularies are per display type, so
+     * broadcasting one bag across a track's other displays would mis-route
+     * keys; address a non-active display directly if that is what you mean.
+     * See BaseDisplayModel for the routing and the `allowSetters` opt-in.
+     */
+    applyDisplaySettings(settings: Record<string, unknown>, options?: {
+        allowSetters?: boolean;
+    }): {
+        applied: string[];
+        unapplied: import("../../util/unknownSnapshotKeys.ts").UnappliedSetting[];
+        failed: {
+            key: string;
+            error: string;
+        }[];
+    };
     /**
      * #action
      */
@@ -165,15 +201,28 @@ export declare function createBaseTrackModel(pm: PluginManager, trackType: strin
      *
      * `equals: compareStructural` is load-bearing, not an optimization:
      * `self.configuration` is a re-resolving reference, and persisting a save
-     * swaps the resolved node identity (admin `updateTrackConf` replaces the
-     * frozen `jbrowse.tracks` entry, rehydrating a brand-new MST node; the
-     * non-admin path reconciles in place but still churns once). Referential
-     * comparison would treat every such swap as a fresh change and re-fire the
-     * save, which for the admin/desktop path (new node every write) is an
-     * unbounded debounced loop. Structural comparison settles once the content
-     * stops changing.
+     * can swap the resolved node identity (the delta path reconciles in place
+     * but still churns once, and a session without deltas replaces the frozen
+     * `jbrowse.tracks` entry, rehydrating a brand-new MST node every write).
+     * Referential comparison would treat every such swap as a fresh change
+     * and re-fire the save, an unbounded debounced loop. Structural
+     * comparison settles once the content stops changing.
      */
     afterAttach(): void;
+} & {
+    /**
+     * #action
+     * The awaitable sibling of `replaceDisplay`: loads the target display's
+     * state model, then swaps to it carrying whatever settings the outgoing
+     * display can hand over.
+     *
+     * `replaceDisplay` stays a plain sync action and ASSERTS the model is
+     * loaded, and every display state model in this tree is a dynamic import
+     * until something shows one — so a caller that has not already shown the
+     * target needs this. Named like `launchTrack`, which is the same problem
+     * one level up.
+     */
+    launchDisplay(displayId: string): Promise<void>;
 } & {
     /**
      * #getter
@@ -185,12 +234,12 @@ export declare function createBaseTrackModel(pm: PluginManager, trackType: strin
     readonly exportsDataViaAdapter: boolean;
     /**
      * #getter
-     * What "Save track data" may pull before it asks. The adapter's own
-     * `fetchSizeLimit` where it declares one, so a save does not quietly
-     * disagree with the size this track's display already refuses to render;
-     * otherwise a default. Deliberately generous — unlike the display's gate
-     * this is a confirmation rather than a refusal, and the user asked for
-     * these bytes by name.
+     * The size in bytes above which "Save track data" asks for confirmation
+     * before fetching. Uses the adapter's `fetchSizeLimit` where it declares
+     * one, so a save asks at the same size at which the track's display
+     * refuses to render; otherwise a default. The default is generous
+     * because exceeding it only prompts for confirmation, and the user
+     * explicitly requested the data.
      */
     readonly exportByteLimit: number;
     /**

package/esm/pluggableElementTypes/models/BaseTrackModel.js

@@ -1,5 +1,5 @@
 import { lazy } from 'react';
-import { addDisposer, getSnapshot, types } from '@jbrowse/mobx-state-tree';
+import { addDisposer, getSnapshot, isAlive, types, } from '@jbrowse/mobx-state-tree';
 import Save from '@mui/icons-material/Save';
 import { compareStructural, reaction } from 'mobx';
 import { ConfigurationReference, getConf } from '../../configuration/index.js';
@@ -10,6 +10,7 @@ import { getContainingView, getDialogHost, getEnv, getSession, } from '../../uti
 import { getConfAssemblyNamesOrNone, viewDisplayNames, } from '../../util/tracks.js';
 import { isSessionModelWithConfigEditing } from '../../util/types/index.js';
 import { ElementId } from '../../util/types/mst.js';
+import { displayTypesFedBy } from './baseTrackConfig.js';
 import { stringifyBED } from './saveTrackFileTypes/bed.js';
 import { stringifyGBK } from './saveTrackFileTypes/genbank.js';
 import { stringifyGFF3 } from './saveTrackFileTypes/gff3.js';
@@ -18,12 +19,11 @@ const DEFAULT_EXPORT_BYTE_LIMIT = 5_000_000;
 function getCompatibleDisplays(self) {
     const { pluginManager } = getEnv(self);
     const view = getContainingView(self);
-    // which of THIS track's configured displays the view draws — a different
-    // question from viewCanDisplayTrack's "can it open the track at all", over
-    // the same set of names
-    const compatTypes = viewDisplayNames(pluginManager, view.type);
-    const displays = self.configuration.displays;
-    return displays.filter(d => compatTypes.has(d.type));
+    const { configuration } = self;
+    const viewDisplays = viewDisplayNames(pluginManager, view.type);
+    const fed = new Set(displayTypesFedBy(pluginManager, configuration.type, configuration.adapter));
+    const displays = configuration.displays;
+    return displays.filter(d => viewDisplays.has(d.type) && fed.has(d.type));
 }
 function getDisplayConf(displays, displayId) {
     const displayConf = displays.find(d => d.displayId === displayId);
@@ -158,14 +158,18 @@ export function createBaseTrackModel(pm, trackType, baseTrackConfig) {
         },
         /**
          * #getter
+         * the configured displays the CONTAINING VIEW can draw and the track's
+         * adapter feeds, which is the set `replaceDisplay` will accept
+         *
+         * `configuration.displays` is not that set: baseTrackConfig injects one
+         * entry per display type registered for the track TYPE, across every
+         * view type, so a VariantTrack carries a ChordVariantDisplay a linear
+         * view cannot draw. The track menu's own "Display types" submenu has
+         * always filtered them; this exposes the same list to code, because the
+         * alternative is every caller re-deriving it from the plugin manager.
          */
-        get canConfigure() {
-            const session = getSession(self);
-            const { sessionTracks, trackConfigDeltas, adminMode } = session;
-            return (isSessionModelWithConfigEditing(session) &&
-                (adminMode ||
-                    !!sessionTracks?.find(t => t.trackId === this.trackId) ||
-                    this.trackId in (trackConfigDeltas ?? {})));
+        get compatibleDisplays() {
+            return getCompatibleDisplays(self);
         },
     }))
         .views(self => ({
@@ -232,106 +236,158 @@ export function createBaseTrackModel(pm, trackType, baseTrackConfig) {
             return pm.getAdapterType(type);
         },
     }))
-        .actions(self => ({
-        /**
-         * #action
-         */
-        setPinned(flag) {
-            self.pinned = flag;
-        },
-        /**
-         * #action
-         */
-        setMinimized(flag) {
-            self.minimized = flag;
-        },
-        /**
-         * #action
-         */
-        setResizing(flag) {
-            self.resizing = flag;
-        },
-        /**
-         * #action
-         */
-        replaceDisplay(oldDisplayId, newDisplayId, initialSnapshot = {}) {
-            const idx = self.displays.findIndex(d => d.configuration.displayId === oldDisplayId);
-            if (idx === -1) {
-                throw new Error(`could not find display id ${oldDisplayId} to replace`);
+        .actions(self => {
+        let persistTimeout;
+        // Reads the config when it fires rather than when it was scheduled, so
+        // what reaches the session is the config as it stands, whatever swapped
+        // the resolved node inside the wait.
+        function persistConfiguration() {
+            persistTimeout = undefined;
+            const session = getSession(self);
+            if (isSessionModelWithConfigEditing(session)) {
+                session.updateTrackConfiguration(getSnapshot(self.configuration));
             }
-            const displays = self.configuration.displays;
-            const displayConf = getDisplayConf(displays, newDisplayId);
-            self.displays[idx] = {
-                ...initialSnapshot,
-                type: displayConf.type,
-                configuration: newDisplayId,
-            };
-        },
+        }
+        return {
+            /**
+             * #action
+             * Write the config to the session now rather than after the 400 ms
+             * wait, for an edit that has to be undoable the moment it lands.
+             */
+            persistConfigurationNow() {
+                clearTimeout(persistTimeout);
+                persistConfiguration();
+            },
+            /**
+             * #action
+             */
+            setPinned(flag) {
+                self.pinned = flag;
+            },
+            /**
+             * #action
+             */
+            setMinimized(flag) {
+                self.minimized = flag;
+            },
+            /**
+             * #action
+             */
+            setResizing(flag) {
+                self.resizing = flag;
+            },
+            /**
+             * #action
+             * `applyDisplaySettings` on the display being drawn (`activeDisplay`,
+             * which a shown track always has — this is not meaningful on a bare
+             * config node) — the track-level entry for "restyle this track in
+             * place" (a session spec's inline keys, an agent's settings bag). Only
+             * that one display: settings vocabularies are per display type, so
+             * broadcasting one bag across a track's other displays would mis-route
+             * keys; address a non-active display directly if that is what you mean.
+             * See BaseDisplayModel for the routing and the `allowSetters` opt-in.
+             */
+            applyDisplaySettings(settings, options) {
+                return self.activeDisplay.applyDisplaySettings(settings, options);
+            },
+            /**
+             * #action
+             */
+            replaceDisplay(oldDisplayId, newDisplayId, initialSnapshot = {}) {
+                const idx = self.displays.findIndex(d => d.configuration.displayId === oldDisplayId);
+                if (idx === -1) {
+                    throw new Error(`could not find display id ${oldDisplayId} to replace`);
+                }
+                const displayConf = getDisplayConf(self.configuration.displays, newDisplayId);
+                // same interception showTrackGeneric makes: a registered-but-unloaded
+                // display would otherwise fail as an opaque union mismatch below
+                pm.resolveDisplayTypeRecord(displayConf.type)?.assertStateModelLoaded();
+                self.displays[idx] = {
+                    ...initialSnapshot,
+                    type: displayConf.type,
+                    configuration: newDisplayId,
+                };
+            },
+            /**
+             * #action
+             * Persist any config-schema mutation (quick track-menu edits calling
+             * `setSlot` directly, or the full Settings dialog) back to the session,
+             * debounced, mirroring ConfigurationEditorWidget's own save. Both savers
+             * intentionally coexist — this one covers direct setSlot edits on a shown
+             * track, the widget covers an unshown track edited from the selector (no
+             * BaseTrackModel). When both fire they compute an identical delta, deduped
+             * in updateTrackConfiguration; don't drop one to "simplify". `reaction`
+             * (not `autorun`) on purpose: `self.configuration` is defined
+             * immediately on attach, unlike ConfigurationEditorWidget's `target`
+             * (which starts undefined), so an autorun's guaranteed first run would
+             * otherwise schedule a spurious flush for every track ever shown, even
+             * completely untouched ones — `reaction` only fires on an actual change.
+             *
+             * `equals: compareStructural` is load-bearing, not an optimization:
+             * `self.configuration` is a re-resolving reference, and persisting a save
+             * can swap the resolved node identity (the delta path reconciles in place
+             * but still churns once, and a session without deltas replaces the frozen
+             * `jbrowse.tracks` entry, rehydrating a brand-new MST node every write).
+             * Referential comparison would treat every such swap as a fresh change
+             * and re-fire the save, an unbounded debounced loop. Structural
+             * comparison settles once the content stops changing.
+             */
+            afterAttach() {
+                addDisposer(self, reaction(() => getSnapshot(self.configuration), () => {
+                    clearTimeout(persistTimeout);
+                    persistTimeout = setTimeout(persistConfiguration, 400);
+                }, { equals: compareStructural }));
+                addDisposer(self, () => {
+                    clearTimeout(persistTimeout);
+                });
+                // Hold a claim on this track's rpcSessionId for as long as the track is
+                // open, so closing the last track using an adapter config evicts that
+                // adapter from the worker's dataAdapterCache. Without this nothing in
+                // the app ever reaches CoreFreeResources, and an adapter — with its
+                // parsed chunks, or in the unindexed case its whole parsed file — is
+                // reachable from module scope for as long as the worker lives, which no
+                // amount of garbage collection can help with.
+                //
+                // The id is tracked by reaction rather than captured once: rpcSessionId
+                // is derived from the adapter config, which a settings edit can change
+                // under a live track, and releasing an id we never retained would free
+                // an adapter another track is still using.
+                const { rpcManager } = getSession(self);
+                let retained = self.rpcSessionId;
+                retainAdapterSession(rpcManager, retained);
+                addDisposer(self, reaction(() => self.rpcSessionId, next => {
+                    if (next !== retained) {
+                        const previous = retained;
+                        retained = next;
+                        retainAdapterSession(rpcManager, next);
+                        void releaseAdapterSession(rpcManager, previous);
+                    }
+                }));
+                addDisposer(self, () => {
+                    void releaseAdapterSession(rpcManager, retained);
+                });
+            },
+        };
+    })
+        .actions(self => ({
         /**
          * #action
-         * Persist any config-schema mutation (quick track-menu edits calling
-         * `setSlot` directly, or the full Settings dialog) back to the session,
-         * debounced, mirroring ConfigurationEditorWidget's own save. Both savers
-         * intentionally coexist — this one covers direct setSlot edits on a shown
-         * track, the widget covers an unshown track edited from the selector (no
-         * BaseTrackModel). When both fire they compute an identical delta, deduped
-         * in updateTrackConfiguration; don't drop one to "simplify". `reaction`
-         * (not `autorun`) on purpose: `self.configuration` is defined
-         * immediately on attach, unlike ConfigurationEditorWidget's `target`
-         * (which starts undefined), so an autorun's guaranteed first run would
-         * otherwise schedule a spurious flush for every track ever shown, even
-         * completely untouched ones — `reaction` only fires on an actual change.
+         * The awaitable sibling of `replaceDisplay`: loads the target display's
+         * state model, then swaps to it carrying whatever settings the outgoing
+         * display can hand over.
          *
-         * `equals: compareStructural` is load-bearing, not an optimization:
-         * `self.configuration` is a re-resolving reference, and persisting a save
-         * swaps the resolved node identity (admin `updateTrackConf` replaces the
-         * frozen `jbrowse.tracks` entry, rehydrating a brand-new MST node; the
-         * non-admin path reconciles in place but still churns once). Referential
-         * comparison would treat every such swap as a fresh change and re-fire the
-         * save, which for the admin/desktop path (new node every write) is an
-         * unbounded debounced loop. Structural comparison settles once the content
-         * stops changing.
+         * `replaceDisplay` stays a plain sync action and ASSERTS the model is
+         * loaded, and every display state model in this tree is a dynamic import
+         * until something shows one — so a caller that has not already shown the
+         * target needs this. Named like `launchTrack`, which is the same problem
+         * one level up.
          */
-        afterAttach() {
-            let timeout;
-            addDisposer(self, reaction(() => getSnapshot(self.configuration), snapshot => {
-                clearTimeout(timeout);
-                timeout = setTimeout(() => {
-                    const session = getSession(self);
-                    if (isSessionModelWithConfigEditing(session)) {
-                        session.updateTrackConfiguration(snapshot);
-                    }
-                }, 400);
-            }, { equals: compareStructural }));
-            addDisposer(self, () => {
-                clearTimeout(timeout);
-            });
-            // Hold a claim on this track's rpcSessionId for as long as the track is
-            // open, so closing the last track using an adapter config evicts that
-            // adapter from the worker's dataAdapterCache. Without this nothing in
-            // the app ever reaches CoreFreeResources, and an adapter — with its
-            // parsed chunks, or in the unindexed case its whole parsed file — is
-            // reachable from module scope for as long as the worker lives, which no
-            // amount of garbage collection can help with.
-            //
-            // The id is tracked by reaction rather than captured once: rpcSessionId
-            // is derived from the adapter config, which a settings edit can change
-            // under a live track, and releasing an id we never retained would free
-            // an adapter another track is still using.
-            const { rpcManager } = getSession(self);
-            let retained = self.rpcSessionId;
-            retainAdapterSession(rpcManager, retained);
-            addDisposer(self, reaction(() => self.rpcSessionId, next => {
-                if (next !== retained) {
-                    const previous = retained;
-                    retained = next;
-                    retainAdapterSession(rpcManager, next);
-                    void releaseAdapterSession(rpcManager, previous);
-                }
-            }));
-            addDisposer(self, () => {
-                void releaseAdapterSession(rpcManager, retained);
-            });
+        async launchDisplay(displayId) {
+            const { type } = getDisplayConf(self.configuration.displays, displayId);
+            await pm.resolveDisplayTypeRecord(type)?.loadStateModel();
+            if (isAlive(self)) {
+                self.replaceDisplay(self.activeDisplay.configuration.displayId, displayId, self.activeDisplay.getPortableSettings?.(displayId) ?? {});
+            }
         },
     }))
         .views(self => ({
@@ -349,12 +405,12 @@ export function createBaseTrackModel(pm, trackType, baseTrackConfig) {
         },
         /**
          * #getter
-         * What "Save track data" may pull before it asks. The adapter's own
-         * `fetchSizeLimit` where it declares one, so a save does not quietly
-         * disagree with the size this track's display already refuses to render;
-         * otherwise a default. Deliberately generous — unlike the display's gate
-         * this is a confirmation rather than a refusal, and the user asked for
-         * these bytes by name.
+         * The size in bytes above which "Save track data" asks for confirmation
+         * before fetching. Uses the adapter's `fetchSizeLimit` where it declares
+         * one, so a save asks at the same size at which the track's display
+         * refuses to render; otherwise a default. The default is generous
+         * because exceeding it only prompts for confirmation, and the user
+         * explicitly requested the data.
          */
         get exportByteLimit() {
             return adapterByteLimit(getConf(self, ['adapter', 'fetchSizeLimit']), DEFAULT_EXPORT_BYTE_LIMIT);
@@ -413,7 +469,7 @@ export function createBaseTrackModel(pm, trackType, baseTrackConfig) {
         trackMenuItems() {
             const menuItems = self.displays.flatMap(d => d.trackMenuItems());
             const shownId = self.activeDisplay.configuration.displayId;
-            const compatDisp = getCompatibleDisplays(self);
+            const compatDisp = self.compatibleDisplays;
             return [
                 ...menuItems,
                 ...(compatDisp.length > 1 && shownId
@@ -434,9 +490,15 @@ export function createBaseTrackModel(pm, trackType, baseTrackConfig) {
                                     // being replaced, so leaving the menu up would keep a
                                     // list of items built against a destroyed MST node
                                     keepMenuOpen: false,
+                                    // launchDisplay, because the chosen display's state
+                                    // model may still be a dynamic import away
                                     onClick: () => {
                                         if (d.displayId !== shownId) {
-                                            self.replaceDisplay(shownId, d.displayId, self.activeDisplay.getPortableSettings?.(d.displayId) ?? {});
+                                            void self
+                                                .launchDisplay(d.displayId)
+                                                .catch((e) => {
+                                                getSession(self).notifyError(`${e}`, e);
+                                            });
                                         }
                                     },
                                 };

package/esm/pluggableElementTypes/models/BaseViewModel.d.ts

@@ -1,4 +1,5 @@
 import type { MenuItem } from '../../ui/index.ts';
+import type { AbstractTrackModel, AbstractViewModel } from '../../util/types/index.ts';
 import type { Instance } from '@jbrowse/mobx-state-tree';
 /**
  * #stateModel BaseViewModel
@@ -28,7 +29,7 @@ declare const BaseViewModel: import("@jbrowse/mobx-state-tree").IModelType<{
      *
      * `ViewContainer` mounts a view's body only while an IntersectionObserver
      * says it is on screen, to hold the app under the WebGL2 context ceiling
-     * (`reference/GPU_CONTEXT_BUDGET.md`). A view below the fold therefore has
+     * (`reference/GPU_PORTABILITY.md`). A view below the fold therefore has
      * no canvas, so nothing ever calls `markCanvasDrawn` and the pre-first-paint
      * term of `displayPhase` pins every display in it at `loading` with nothing
      * left to resolve it — which parks `[data-app-phase="ready"]` for the whole
@@ -46,15 +47,25 @@ declare const BaseViewModel: import("@jbrowse/mobx-state-tree").IModelType<{
 } & {
     /**
      * #getter
-     * Whether this view's body is in the DOM, counting the views it is nested
-     * inside — which is the question a display's phase actually asks.
+     * Overridable hook (default true): whether this view's mounted body
+     * renders its own displays. A linear genome view collapsed to its ruler
+     * mounts the scalebar and none of its tracks, so a display in it can no
+     * more paint than one in a view scrolled off screen. Views nested in this
+     * one are unaffected: they paint wherever their own body is.
+     */
+    readonly rendersDisplays: boolean;
+    /**
+     * #getter
+     * Whether this view's displays have a canvas to paint into: its body is in
+     * the DOM, counting the views it is nested inside, and the body renders
+     * them (`rendersDisplays`). This is the question a display's phase asks.
      *
-     * `bodyMounted` alone answers it only for a view a container renders
-     * directly. A view nested in another view (a synteny row, a breakpoint
-     * panel) has no container writing its flag, so it reads `true` forever
-     * while its whole subtree is out of the DOM, and every display in it waits
-     * for a first paint that nothing will make — the hang this flag exists to
-     * prevent, one level down.
+     * `bodyMounted` alone answers the DOM half only for a view a container
+     * renders directly. A view nested in another view (a synteny row, a
+     * breakpoint panel) has no container writing its flag, so it reads `true`
+     * forever while its whole subtree is out of the DOM, and every display in
+     * it waits for a first paint that nothing will make — the hang this flag
+     * exists to prevent, one level down.
      *
      * An ancestor that does not carry the flag at all leaves the answer alone
      * rather than excusing the paint: only an explicit `false` unmounts, so a
@@ -66,6 +77,30 @@ declare const BaseViewModel: import("@jbrowse/mobx-state-tree").IModelType<{
      * #method
      */
     menuItems(): MenuItem[];
+    /**
+     * #getter
+     * The tracks this view puts in the census — its own, not a nested view's.
+     *
+     * Empty here, and overridden by the views that have any: the base cannot
+     * read `self.tracks` for them, because what a view keeps under that name
+     * is the view's business. react-msaview's holds its MSA annotation rows —
+     * `{ReactComponent, model}` objects with no configuration and no displays
+     * — and a base that helped itself to them handed them to the readiness
+     * marker as tracks, which error-paged every session holding an MSA view.
+     */
+    readonly ownTracks: AbstractTrackModel[];
+    /**
+     * #getter
+     * The views nested directly inside this one, which the census counts as
+     * views in their own right — a synteny stack's genome rows, a breakpoint
+     * split view's panels.
+     *
+     * Empty here for the same reason, and the dotplot is why it has to be a
+     * declaration rather than a walk of `views`: that prop name holds its two
+     * 1D *axis* models, which are view-shaped and are not views the user
+     * opened. No structural test separates the two — only the view knows.
+     */
+    readonly ownViews: AbstractViewModel[];
 } & {
     /**
      * #action
@@ -134,7 +169,7 @@ export declare const BaseViewModelWithDisplayedRegions: import("@jbrowse/mobx-st
      *
      * `ViewContainer` mounts a view's body only while an IntersectionObserver
      * says it is on screen, to hold the app under the WebGL2 context ceiling
-     * (`reference/GPU_CONTEXT_BUDGET.md`). A view below the fold therefore has
+     * (`reference/GPU_PORTABILITY.md`). A view below the fold therefore has
      * no canvas, so nothing ever calls `markCanvasDrawn` and the pre-first-paint
      * term of `displayPhase` pins every display in it at `loading` with nothing
      * left to resolve it — which parks `[data-app-phase="ready"]` for the whole
@@ -152,15 +187,25 @@ export declare const BaseViewModelWithDisplayedRegions: import("@jbrowse/mobx-st
 } & {
     /**
      * #getter
-     * Whether this view's body is in the DOM, counting the views it is nested
-     * inside — which is the question a display's phase actually asks.
+     * Overridable hook (default true): whether this view's mounted body
+     * renders its own displays. A linear genome view collapsed to its ruler
+     * mounts the scalebar and none of its tracks, so a display in it can no
+     * more paint than one in a view scrolled off screen. Views nested in this
+     * one are unaffected: they paint wherever their own body is.
+     */
+    readonly rendersDisplays: boolean;
+    /**
+     * #getter
+     * Whether this view's displays have a canvas to paint into: its body is in
+     * the DOM, counting the views it is nested inside, and the body renders
+     * them (`rendersDisplays`). This is the question a display's phase asks.
      *
-     * `bodyMounted` alone answers it only for a view a container renders
-     * directly. A view nested in another view (a synteny row, a breakpoint
-     * panel) has no container writing its flag, so it reads `true` forever
-     * while its whole subtree is out of the DOM, and every display in it waits
-     * for a first paint that nothing will make — the hang this flag exists to
-     * prevent, one level down.
+     * `bodyMounted` alone answers the DOM half only for a view a container
+     * renders directly. A view nested in another view (a synteny row, a
+     * breakpoint panel) has no container writing its flag, so it reads `true`
+     * forever while its whole subtree is out of the DOM, and every display in
+     * it waits for a first paint that nothing will make — the hang this flag
+     * exists to prevent, one level down.
      *
      * An ancestor that does not carry the flag at all leaves the answer alone
      * rather than excusing the paint: only an explicit `false` unmounts, so a
@@ -172,6 +217,30 @@ export declare const BaseViewModelWithDisplayedRegions: import("@jbrowse/mobx-st
      * #method
      */
     menuItems(): MenuItem[];
+    /**
+     * #getter
+     * The tracks this view puts in the census — its own, not a nested view's.
+     *
+     * Empty here, and overridden by the views that have any: the base cannot
+     * read `self.tracks` for them, because what a view keeps under that name
+     * is the view's business. react-msaview's holds its MSA annotation rows —
+     * `{ReactComponent, model}` objects with no configuration and no displays
+     * — and a base that helped itself to them handed them to the readiness
+     * marker as tracks, which error-paged every session holding an MSA view.
+     */
+    readonly ownTracks: AbstractTrackModel[];
+    /**
+     * #getter
+     * The views nested directly inside this one, which the census counts as
+     * views in their own right — a synteny stack's genome rows, a breakpoint
+     * split view's panels.
+     *
+     * Empty here for the same reason, and the dotplot is why it has to be a
+     * declaration rather than a walk of `views`: that prop name holds its two
+     * 1D *axis* models, which are view-shaped and are not views the user
+     * opened. No structural test separates the two — only the view knows.
+     */
+    readonly ownViews: AbstractViewModel[];
 } & {
     /**
      * #action