@jbrowse/core 5.0.0-beta.2 → 5.0.0-beta.4

package/README.md

@@ -149,12 +149,11 @@ default" action, which passes the slots it actually listed
 
 **`slots` is required, and an all-slots default is not the convenience it looks
 like.** It reaches further than any list a dialog can have shown: a promoted
-default the track _customized_ over, or one promoted to a value equal to
-`promotedBase`, is `inherited: false` and so appears in no row, yet still
-governs sibling tracks — so clearing it from a dialog that never showed it moves
-tracks other than the one whose badge was clicked. Clearing every promoted
-default at once is a preferences-scope action, and Preferences → "Reset to
-defaults" is where it lives (`clearPreferenceOverrides`).
+default the track _customized_ over is `inherited: false` and so appears in no
+row, yet still governs sibling tracks — so clearing it from a dialog that never
+showed it moves tracks other than the one whose badge was clicked. Clearing
+every promoted default at once is a preferences-scope action, and Preferences →
+"Reset to defaults" is where it lives (`clearPreferenceOverrides`).
 
 ```js
 // type signature
@@ -423,10 +422,10 @@ default" predicate for a promotable slot: comparing the resolved value to the
 base instead reads as at-default for a track merely _following_ a non-base
 promoted default, so the reset control lights up on a no-op.
 
-`SLOT` is constrained the way `getConf`'s is. A pin or a reset over a slot name
-the schema does not declare is inert and silent — `resolveSlot` answers about
-nothing, so the control draws outline forever — and a widened `self` switches
-the check off (`HostChecksSlotNames`).
+`SLOT` is constrained the way `getConf`'s is, and a widened `self` switches the
+check off (`HostChecksSlotNames`). A slot name the schema does not declare
+throws at the first read (`getSlotDefinition`), and a declared but
+non-promotable one throws in `resolveSlotIn`.
 
 ```js
 // type signature
@@ -449,20 +448,22 @@ synchronous `addOrReplaceView` requires it loaded already.
 
 ### makePin
 
-The pin for one promotable slot: "apply this value to every open track of this
+The pin on a radio or slider row: "apply this value to every open track of this
 display type", and — via the snackbar it raises — "keep it as the default for
 the ones opened later".
 
 `value` chooses between the subsystem's two meanings, which are otherwise
 identical:
 
-- **Give it** for a per-value pin — "make _arcs_ the default" — independent of
-  what the track currently shows. Use on an always-visible pin so it can never
-  promote a meaningless value, and so two rows sharing one slot (arcs `'arc'` vs
-  read cloud `'cloud'`; sashimi `'down'` vs `'auto'`) stay independent.
+- **Give it** for a per-value pin — "make _compact_ the default" — independent
+  of what the track currently shows. Use on an always-visible pin so it can
+  never promote a meaningless value, and so two rows sharing one slot (sashimi
+  `'down'` vs `'auto'`) stay independent.
 - **Omit it** for "whatever I'm showing", resolved through the cascade. Use for
-  a symmetric or continuous setting where no fixed on-value makes sense (wiggle
-  point size, arc line width, `mismatchAlpha`).
+  a continuous setting where no fixed on-value makes sense (wiggle point size,
+  arc line width).
+
+A checkbox row takes neither: makeTogglePin.
 
 One function with an optional argument, rather than the two exported builders it
 replaces — a per-value one and a `…CurrentValue…` one, the second of which was
@@ -472,7 +473,32 @@ argument now says what the longer name said.
 
 ```js
 // type signature
-<CONFMODEL extends AnyConfigurationModel, SLOT extends ConfigurationSlotName<…>>(self: ResolvableDisplay<CONFMODEL>, slot: SLOT, ...value: [] | [...]) => Pin
+<CONFMODEL extends AnyConfigurationModel, SLOT extends ConfigurationSlotName<…>>(self: ResolvableDisplay<CONFMODEL>, slot: SLOT, ...value: [] | [...]) => ValuePin
+```
+
+[Source code](https://github.com/GMOD/jbrowse-components/blob/main/packages/core/src/configuration/promotableDefaults.ts)
+
+### makeTogglePin
+
+The pin on a checkbox row: the row's own checkbox, acting on every open track of
+the display type. `active` mirrors the row, so the pin draws filled exactly when
+the box is ticked; a click flips the row's state on every open track and offers
+the new state as the display type's default. It never clears a default the way
+makePin's filled pin does — flipping back and taking the offer promotes the
+other value, and promoting the base value clears the default
+(`applyAndOfferDefault`).
+
+Replaces a symmetric `makePin(self, slot)` on these rows, which carried the
+row's current state: beside an unchecked box that applied _off_ everywhere and
+visibly did nothing. It also replaces the per-value `makePin` a checkbox row
+over a shared enum slot used to carry, which gave two checkbox rows in one
+submenu two different pins: one filled when its value was promoted and clearing
+on a second click, the other filled when the box was ticked and flipping. With
+`states`, a checkbox row is always the toggle kind.
+
+```js
+// type signature
+<…>(self: ResolvableDisplay<CONFMODEL>, slot: SLOT, ...states: ConfigurationSlotValueResolved<...> extends boolean ? [] | [...] : [...]) => TogglePin
 ```
 
 [Source code](https://github.com/GMOD/jbrowse-components/blob/main/packages/core/src/configuration/promotableDefaults.ts)
@@ -505,28 +531,12 @@ each display whether it has anything to promote.
 ### Pin
 
 The "apply this to every open track of this type" affordance on a menu row — the
-trailing `PushPin`, bundled so the row consumes it as one prop. Built by
-makePin.
-
-`active` = this value is currently the session default (a filled pin), which is
-the state, not the click. `toggle` **applies the value to every open track of
-the display type** and raises a snackbar whose one action promotes it to the
-display type's default; on an already-promoted value it clears that default
-instead, touching no track (see `applyPinClick`).
-
-**`toggle` rather than an `apply`/`clear` pair**, which was tried and dropped:
-the sole renderer is a MUI `ToggleButton` whose `onChange` means exactly "flip",
-so splitting it adds a member _and_ a branch at the one call site that never
-needed one. `active` is already public for a caller that wants to state a
-direction. (The house preference for explicit setters over toggles is about MST
-actions, where a toggle destroys the ability to set a known state; nothing here
-stores a value.)
-
-Lives here, alone and with no imports, rather than beside `makePin` in
-`promotableDefaults.ts`: the menu types describe a pin without building one, and
-`MenuTypes.ts` taking this one interface from that module gave a React-free type
-file a type closure of 374 files. See
-`agent-docs/ideas/barrels-block-extraction.md` and `scripts/moduleClosure.ts`.
+trailing `PushPin`, bundled so the row consumes it as one prop.
+
+`kind` is what the adornment words itself from and what the row builders check:
+a checkbox row takes a TogglePin, a radio or slider row a ValuePin. The two used
+to be told apart by `typeof onValue === 'boolean'`, which let a value pin over a
+boolean slot compile and read as a toggle while clearing on its second click.
 
 [Source code](https://github.com/GMOD/jbrowse-components/blob/main/packages/core/src/configuration/promotablePin.ts)
 
@@ -796,6 +806,16 @@ never baked into the color string.
 
 [Source code](https://github.com/GMOD/jbrowse-components/blob/main/packages/core/src/util/colorRamp.ts)
 
+### TogglePin
+
+The pin on a checkbox row, built by makeTogglePin: the row's own checkbox over
+every open track of the display type. `active` mirrors the row, `onValue` is the
+state a click applies (the row's opposite), and `toggle` applies it everywhere
+and offers it as the default. It never clears a default on its own — promoting
+the slot's base value is what clears one.
+
+[Source code](https://github.com/GMOD/jbrowse-components/blob/main/packages/core/src/configuration/promotablePin.ts)
+
 ### TrackConfigWithPromotables
 
 A track config snapshot with every display's `promotable` slots resolved, plus
@@ -827,6 +847,16 @@ reader has promoted in their own browser. Pinned by
 
 [Source code](https://github.com/GMOD/jbrowse-components/blob/main/packages/core/src/configuration/promotableDefaults.ts)
 
+### ValuePin
+
+The pin on a radio or slider row, built by makePin: `onValue` is the row's own
+value, `active` means that value is the display type's promoted default, and
+`toggle` on an outline pin applies the value to every open track and offers it
+as the default, while on a filled pin it clears that default and touches no
+track (`applyAndOfferDefault` / `clearDefault`).
+
+[Source code](https://github.com/GMOD/jbrowse-components/blob/main/packages/core/src/configuration/promotablePin.ts)
+
 ### VIRIDIS_STOPS
 
 The 256 viridis stops, fully opaque. Feed them to buildColorRampLut for the

package/esm/BaseFeatureWidget/BaseFeatureDetail/FeatureDetails.d.ts

@@ -1,8 +1,7 @@
 import type { SimpleFeatureSerialized } from '../../util/index.ts';
-import type { Descriptors, FeatureFormatter } from '../types.tsx';
-import type { IAnyStateTreeNode } from '@jbrowse/mobx-state-tree';
+import type { Descriptors, FeatureDetailsModel, FeatureFormatter } from '../types.tsx';
 interface FeatureDetailsProps {
-    model: IAnyStateTreeNode;
+    model: FeatureDetailsModel;
     feature: SimpleFeatureSerialized;
     depth?: number;
     omit?: string[];

package/esm/BaseFeatureWidget/BaseFeatureDetail/ParentFeatureLine.d.ts

@@ -0,0 +1,4 @@
+import type { ParentFeatureSummary } from '../../util/index.ts';
+export default function ParentFeatureLine({ parentFeature, }: {
+    parentFeature: ParentFeatureSummary;
+}): import("react").JSX.Element;

package/esm/BaseFeatureWidget/BaseFeatureDetail/ParentFeatureLine.js

@@ -0,0 +1,17 @@
+import { jsxs as _jsxs } from "react/jsx-runtime";
+import { Typography } from '@mui/material';
+import { makeStyles } from '../../util/tss-react/index.js';
+const useStyles = makeStyles()(theme => ({
+    line: {
+        padding: theme.spacing(0.5, 1, 0),
+    },
+}));
+// Which gene a transcript came out of, above the card naming the transcript.
+// The panel is opened on the exact isoform the click resolved to, and that
+// isoform's own record is regularly the only place its accession appears --
+// nothing in `NM_004006.2 - mRNA` says DMD.
+export default function ParentFeatureLine({ parentFeature, }) {
+    const { classes } = useStyles();
+    const { name, type } = parentFeature;
+    return (_jsxs(Typography, { variant: "body2", color: "textSecondary", className: classes.line, "data-testid": "parent-feature-line", children: ["in ", type ? `${type} ` : '', name] }));
+}

package/esm/BaseFeatureWidget/BaseFeatureDetail/index.js

@@ -1,11 +1,12 @@
-import { jsx as _jsx } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { observer } from 'mobx-react';
 import { ErrorBanner } from '../../ui/index.js';
 import FeatureDetails from './FeatureDetails.js';
 import FeatureWash from './FeatureWash.js';
+import ParentFeatureLine from './ParentFeatureLine.js';
 import { isEmpty } from './util.js';
 const BaseFeatureDetail = observer(function BaseFeatureDetail({ model, }) {
-    const { error, featureData } = model;
+    const { error, featureData, parentFeature } = model;
     // annotated to shed the MST node brand types.frozen() carries on the instance
     const descriptions = model.descriptions;
     // A field is hidden by a formatDetails callback returning undefined (jexl
@@ -19,7 +20,7 @@ const BaseFeatureDetail = observer(function BaseFeatureDetail({ model, }) {
         return null;
     }
     else {
-        return (_jsx(FeatureWash, { uniqueId: featureData.uniqueId, children: _jsx(FeatureDetails, { model: model, feature: featureData, descriptions: descriptions }) }));
+        return (_jsxs(FeatureWash, { uniqueId: featureData.uniqueId, children: [parentFeature ? (_jsx(ParentFeatureLine, { parentFeature: parentFeature })) : null, _jsx(FeatureDetails, { model: model, feature: featureData, descriptions: descriptions })] }));
     }
 });
 export default BaseFeatureDetail;

package/esm/BaseFeatureWidget/SequenceFeatureDetails/SequenceFeaturePanel.d.ts

@@ -1,7 +1,7 @@
 import type { SimpleFeatureSerialized } from '../../util/index.ts';
-import type { BaseFeatureWidgetModel } from '../stateModelFactory.ts';
+import type { FeatureDetailsModel } from '../types.tsx';
 declare const SequenceFeaturePanel: ({ model, feature, }: {
-    model: BaseFeatureWidgetModel;
+    model: FeatureDetailsModel;
     feature: SimpleFeatureSerialized;
 }) => import("react").JSX.Element;
 export default SequenceFeaturePanel;

package/esm/BaseFeatureWidget/index.d.ts

@@ -1,5 +1,5 @@
 export { configSchema } from './configSchema.ts';
-export type { Descriptors, MaybeSerializedFeat } from './types.tsx';
+export type { Descriptors, FeatureDetailsModel, MaybeSerializedFeat, } from './types.tsx';
 export type { SequenceHoverPosition, ShowCoordinatesMode, } from './SequenceFeatureDetails/model.ts';
 export { stateModelFactory } from './stateModelFactory.ts';
 export type { BaseFeatureWidgetModel, BaseFeatureWidgetStateModel, } from './stateModelFactory.ts';

package/esm/BaseFeatureWidget/stateModelFactory.d.ts

@@ -1,5 +1,5 @@
 import type PluginManager from '../PluginManager.ts';
-import type { SimpleFeatureSerialized } from '../util/index.ts';
+import type { ParentFeatureSummary, SimpleFeatureSerialized } from '../util/index.ts';
 import type { SequenceHoverPosition } from './SequenceFeatureDetails/model.ts';
 import type { Descriptors, MaybeSerializedFeat } from './types.tsx';
 import type { Instance } from '@jbrowse/mobx-state-tree';
@@ -69,6 +69,12 @@ export declare function stateModelFactory(pluginManager: PluginManager): import(
      * #property
      */
     descriptions: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").IType<Descriptors | undefined, Descriptors | undefined, Descriptors | undefined>, [undefined]>;
+    /**
+     * #property
+     * names the feature this one was reached through, when it was reached
+     * through one -- a transcript clicked inside its gene
+     */
+    parentFeature: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").IType<ParentFeatureSummary | undefined, ParentFeatureSummary | undefined, ParentFeatureSummary | undefined>, [undefined]>;
 }, {
     error: unknown;
     sequenceHoverPosition: SequenceHoverPosition | undefined;
@@ -113,6 +119,7 @@ export declare function stateModelFactory(pluginManager: PluginManager): import(
     maxDepth: number | undefined;
     sequenceFeatureDetails: import("@jbrowse/mobx-state-tree").ModelSnapshotType<{}>;
     descriptions: Descriptors | undefined;
+    parentFeature: ParentFeatureSummary | undefined;
     finalizedFeatureData: any;
 }>;
 export type BaseFeatureWidgetStateModel = ReturnType<typeof stateModelFactory>;

package/esm/BaseFeatureWidget/stateModelFactory.js

@@ -59,6 +59,12 @@ export function stateModelFactory(pluginManager) {
          * #property
          */
         descriptions: types.optional(types.frozen(), undefined),
+        /**
+         * #property
+         * names the feature this one was reached through, when it was reached
+         * through one -- a transcript clicked inside its gene
+         */
+        parentFeature: types.optional(types.frozen(), undefined),
     })
         .volatile(() => ({
         /**

package/esm/BaseFeatureWidget/types.d.ts

@@ -1,6 +1,14 @@
 import type { SimpleFeatureSerialized } from '../util/simpleFeature.ts';
-import type { BaseFeatureWidgetModel } from './stateModelFactory.ts';
+import type { SequenceFeatureDetailsModel, SequenceHoverTarget } from './SequenceFeatureDetails/model.ts';
+import type { IStateTreeNode } from '@jbrowse/mobx-state-tree';
 import type React from 'react';
+export interface FeatureDetailsModel extends IStateTreeNode, SequenceHoverTarget {
+    maxDepth: number | undefined;
+    sequenceFeatureDetails: SequenceFeatureDetailsModel;
+    view: {
+        assemblyNames: string[];
+    } | undefined;
+}
 export interface Descriptors {
     [key: string]: React.ReactNode | Descriptors;
 }
@@ -9,7 +17,7 @@ export interface BaseProps extends BaseCardProps {
     feature: SimpleFeatureSerialized;
     formatter?: FeatureFormatter;
     descriptions?: Descriptors;
-    model?: BaseFeatureWidgetModel;
+    model?: FeatureDetailsModel;
 }
 export interface BaseCardProps {
     title?: string;

package/esm/PluginManager.d.ts

@@ -1,6 +1,7 @@
 import PhasedScheduler from './PhasedScheduler.ts';
 import './util/tracks.ts';
 import type Plugin from './Plugin.ts';
+import type { PluginConstructor } from './Plugin.ts';
 import type AdapterType from './pluggableElementTypes/AdapterType.ts';
 import type AddTrackWorkflowType from './pluggableElementTypes/AddTrackWorkflowType.ts';
 import type ConnectionType from './pluggableElementTypes/ConnectionType.ts';
@@ -290,6 +291,15 @@ export interface PluginLoadRecord {
     metadata?: PluginMetadata;
     plugin: Plugin;
 }
+/**
+ * Instantiate an application's bundled plugin list as `isCore` load records —
+ * what tells the plugin store these came with the bundle rather than being
+ * installed by the user, so `InstalledPluginsList` filters them out and the
+ * About widget lists them. Every product and every test harness builds its
+ * manager from one of these lists, and a harness that passed bare instances
+ * silently disagreed with the app it was testing.
+ */
+export declare function corePluginRecords(plugins: PluginConstructor[]): PluginLoadRecord[];
 export interface RuntimePluginLoadRecord extends PluginLoadRecord {
     definition: PluginDefinition;
 }
@@ -367,6 +377,14 @@ export default class PluginManager {
     pluggableMstType(groupName: PluggableElementTypeGroup, fieldName: string, fallback?: IAnyType): IAnyType;
     /** get a MST type for the union of all specified pluggable config schemas */
     pluggableConfigSchemaType(typeGroup: PluggableElementTypeGroup, fieldName?: string): IAnyType;
+    /**
+     * An adapter union dispatches on `type`, so a config still spelling an
+     * adapter's old name has to be rewritten to the name it registers under
+     * before the union sees it. Here rather than in each schema holding an
+     * adapter slot, so a track, an assembly's sequence and a connection all take
+     * it.
+     */
+    private canonicalizeAdapterSnapshot;
     jbrequireCache: Map<any, any>;
     get lib(): Record<string, unknown>;
     load: <FTYPE extends AnyFunction>(lib: FTYPE) => ReturnType<FTYPE>;
@@ -380,6 +398,12 @@ export default class PluginManager {
         default: AnyFunction;
     }) => any;
     getAdapterType(typeName: string): AdapterType;
+    /**
+     * The name an adapter `type` registers under: itself, or the adapter that
+     * declares it in `aliases`. A name nothing answers to comes back as written,
+     * so the registered-names error still names what the config said.
+     */
+    canonicalAdapterTypeName(typeName: string): string;
     /**
      * Whether an adapter type is registered, for a caller walking a config where
      * `type` names a track, a display and an adapter alike — `getAdapterType`
@@ -394,7 +418,12 @@ export default class PluginManager {
         stateModel: ViewTypeRegistry[N];
     };
     getViewType(typeName: string): ViewType;
-    private sessionTypeNames;
+    /**
+     * The registered view and display types a snapshot names, from every `type`
+     * string anywhere in it — `heldForMissingPlugins` included. Over-collection
+     * is harmless: a name that resolves to neither is dropped here.
+     */
+    private sessionElementTypes;
     /**
      * Every async code path that hands a snapshot to a synchronous session
      * instantiation (`setSession`, `cast`) must await this first.

package/esm/PluginManager.js

@@ -3,6 +3,7 @@ import CorePlugin from './CorePlugin.js';
 import PhasedScheduler from './PhasedScheduler.js';
 import { getReExportRegistry } from './ReExports/registry.js';
 import { ConfigurationSchema, isBareConfigurationSchemaType, } from './configuration/index.js';
+import LazyStateModelElement from './pluggableElementTypes/LazyStateModelElement.js';
 import createJexlInstance from './util/jexl.js';
 import { expandLooseTrackConfig } from './util/tracks.js';
 /**
@@ -24,6 +25,9 @@ export const pluggableElementTypeGroups = [
     'internet account',
     'add track workflow',
 ];
+function isUnloadedLazyElement(element) {
+    return element instanceof LazyStateModelElement && !element.isStateModelLoaded;
+}
 /** internal class that holds the info for a certain element type */
 class TypeRecord {
     registeredTypes = {};
@@ -90,6 +94,17 @@ function nextAccumulator(name, accumulator, result) {
 function logCallbackError(name, error) {
     console.error(`error in a ${name} extension point callback`, error);
 }
+/**
+ * Instantiate an application's bundled plugin list as `isCore` load records —
+ * what tells the plugin store these came with the bundle rather than being
+ * installed by the user, so `InstalledPluginsList` filters them out and the
+ * About widget lists them. Every product and every test harness builds its
+ * manager from one of these lists, and a harness that passed bare instances
+ * silently disagreed with the app it was testing.
+ */
+export function corePluginRecords(plugins) {
+    return plugins.map(P => ({ plugin: new P(), metadata: { isCore: true } }));
+}
 export default class PluginManager {
     plugins = [];
     jexl = createJexlInstance();
@@ -307,9 +322,28 @@ export default class PluginManager {
                 console.warn(`${groupName} ${newElement.name} already registered, cannot register it again`);
             }
             else {
-                typeRecord.add(newElement.name, this.evaluateExtensionPoint(
+                const extend = () => this.evaluateExtensionPoint(
                 /** #extensionPoint Core-extendPluggableElement | sync | Mutate any pluggable element after it is created */
-                'Core-extendPluggableElement', newElement, { group: groupName }));
+                'Core-extendPluggableElement', newElement, { group: groupName });
+                // A lazily registered state model is not there for a callback to
+                // extend yet, so the point fires when the loader resolves instead.
+                // agent-docs/reference/EAGER_BUNDLE.md
+                if (isUnloadedLazyElement(newElement)) {
+                    newElement.onStateModelLoaded = () => {
+                        const extended = extend();
+                        if (extended !== newElement) {
+                            typeRecord.add(newElement.name, extended);
+                            if (extended instanceof LazyStateModelElement &&
+                                extended.isStateModelLoaded) {
+                                newElement.stateModel = extended.stateModel;
+                            }
+                        }
+                    };
+                    typeRecord.add(newElement.name, newElement);
+                }
+                else {
+                    typeRecord.add(newElement.name, extend());
+                }
             }
         });
         return this;
@@ -348,18 +382,20 @@ export default class PluginManager {
      */
     pluggableMstType(groupName, fieldName, fallback = types.maybe(types.null)) {
         const record = this.getElementTypeRecord(groupName);
+        const fieldOf = (t) => isUnloadedLazyElement(t)
+            ? undefined
+            : t[fieldName];
         const anyMember = record.all().some(t => {
-            const element = t;
-            const field = element[fieldName];
+            const field = fieldOf(t);
             return ((isType(field) && isModelType(field)) ||
-                typeof element[`${fieldName}Loader`] === 'function');
+                typeof t[`${fieldName}Loader`] === 'function');
         });
         if (!anyMember) {
             return fallback;
         }
         const modelsOf = () => record
             .all()
-            .map(t => t[fieldName])
+            .map(t => fieldOf(t))
             .filter(t => isType(t) && isModelType(t));
         let members = modelsOf();
         return types.union({
@@ -395,7 +431,28 @@ export default class PluginManager {
             ? types.snapshotProcessor(union, {
                 preProcessor: (snap) => expandLooseTrackConfig(snap, this),
             })
-            : union;
+            : typeGroup === 'adapter'
+                ? types.snapshotProcessor(union, {
+                    preProcessor: (snap) => this.canonicalizeAdapterSnapshot(snap),
+                })
+                : union;
+    }
+    /**
+     * An adapter union dispatches on `type`, so a config still spelling an
+     * adapter's old name has to be rewritten to the name it registers under
+     * before the union sees it. Here rather than in each schema holding an
+     * adapter slot, so a track, an assembly's sequence and a connection all take
+     * it.
+     */
+    canonicalizeAdapterSnapshot(snap) {
+        if (typeof snap === 'object' &&
+            snap !== null &&
+            'type' in snap &&
+            typeof snap.type === 'string') {
+            const canonical = this.canonicalAdapterTypeName(snap.type);
+            return canonical === snap.type ? snap : { ...snap, type: canonical };
+        }
+        return snap;
     }
     jbrequireCache = new Map();
     // populated by PluginLoader once a runtime plugin is actually being loaded,
@@ -434,7 +491,18 @@ export default class PluginManager {
         throw new TypeError('lib passed to jbrequire must be either a string or a function');
     };
     getAdapterType(typeName) {
-        return this.adapterTypes.get(typeName);
+        return this.adapterTypes.get(this.canonicalAdapterTypeName(typeName));
+    }
+    /**
+     * The name an adapter `type` registers under: itself, or the adapter that
+     * declares it in `aliases`. A name nothing answers to comes back as written,
+     * so the registered-names error still names what the config said.
+     */
+    canonicalAdapterTypeName(typeName) {
+        return this.adapterTypes.has(typeName)
+            ? typeName
+            : (this.adapterTypes.all().find(t => t.aliases?.includes(typeName))
+                ?.name ?? typeName);
     }
     /**
      * Whether an adapter type is registered, for a caller walking a config where
@@ -443,7 +511,7 @@ export default class PluginManager {
      * claims to be an adapter and wrong when you are asking whether it is one.
      */
     hasAdapterType(typeName) {
-        return this.adapterTypes.has(typeName);
+        return this.adapterTypes.has(this.canonicalAdapterTypeName(typeName));
     }
     getTextSearchAdapterType(typeName) {
         return this.textSearchAdapterTypes.get(typeName);
@@ -457,81 +525,50 @@ export default class PluginManager {
     getViewType(typeName) {
         return this.viewTypes.get(typeName);
     }
-    sessionTypeNames(sessionSnapshot) {
-        const viewNames = new Set();
-        const displayNames = new Set();
-        const collectTracks = (tracks) => {
-            if (Array.isArray(tracks)) {
-                for (const track of tracks) {
-                    const { displays } = track && typeof track === 'object'
-                        ? track
-                        : {};
-                    if (Array.isArray(displays)) {
-                        for (const display of displays) {
-                            const type = display && typeof display === 'object'
-                                ? display.type
-                                : undefined;
-                            if (typeof type === 'string') {
-                                displayNames.add(type);
-                            }
-                        }
-                    }
+    /**
+     * The registered view and display types a snapshot names, from every `type`
+     * string anywhere in it — `heldForMissingPlugins` included. Over-collection
+     * is harmless: a name that resolves to neither is dropped here.
+     */
+    sessionElementTypes(sessionSnapshot) {
+        const names = new Set();
+        const walk = (node) => {
+            if (Array.isArray(node)) {
+                for (const item of node) {
+                    walk(item);
                 }
             }
-        };
-        const collectViews = (views) => {
-            if (Array.isArray(views)) {
-                for (const view of views) {
-                    if (view && typeof view === 'object') {
-                        const { type, views: children, tracks, levels, } = view;
-                        if (typeof type === 'string') {
-                            viewNames.add(type);
-                        }
-                        collectViews(children);
-                        collectTracks(tracks);
-                        if (Array.isArray(levels)) {
-                            for (const level of levels) {
-                                collectTracks(level && typeof level === 'object'
-                                    ? level.tracks
-                                    : undefined);
-                            }
-                        }
+            else if (node && typeof node === 'object') {
+                for (const [key, value] of Object.entries(node)) {
+                    if (key === 'type' && typeof value === 'string') {
+                        names.add(value);
+                    }
+                    else {
+                        walk(value);
                     }
                 }
             }
         };
-        if (sessionSnapshot && typeof sessionSnapshot === 'object') {
-            const { view, views } = sessionSnapshot;
-            collectViews(views);
-            collectViews(view ? [view] : undefined);
-        }
-        return { viewNames, displayNames };
+        walk(sessionSnapshot);
+        return [...names].flatMap(name => {
+            const display = this.resolveDisplayTypeRecord(name);
+            return [
+                ...(this.viewTypes.has(name) ? [this.getViewType(name)] : []),
+                ...(display ? [display] : []),
+            ];
+        });
     }
     /**
      * Every async code path that hands a snapshot to a synchronous session
      * instantiation (`setSession`, `cast`) must await this first.
      */
     async preloadSessionTypes(sessionSnapshot) {
-        const { viewNames, displayNames } = this.sessionTypeNames(sessionSnapshot);
-        await Promise.all([
-            ...[...viewNames]
-                .filter(name => this.viewTypes.has(name))
-                .map(name => this.getViewType(name).loadStateModel()),
-            ...[...displayNames]
-                .map(name => this.resolveDisplayTypeRecord(name))
-                .flatMap(display => (display ? [display.loadStateModel()] : [])),
-        ]);
+        await Promise.all(this.sessionElementTypes(sessionSnapshot).map(t => t.loadStateModel()));
     }
     unloadedSessionTypes(sessionSnapshot) {
-        const { viewNames, displayNames } = this.sessionTypeNames(sessionSnapshot);
-        return [
-            ...[...viewNames].filter(name => this.viewTypes.has(name) &&
-                !this.getViewType(name).isStateModelLoaded),
-            ...[...displayNames].filter(name => {
-                const display = this.resolveDisplayTypeRecord(name);
-                return display !== undefined && !display.isStateModelLoaded;
-            }),
-        ];
+        return this.sessionElementTypes(sessionSnapshot)
+            .filter(t => !t.isStateModelLoaded)
+            .map(t => t.name);
     }
     /**
      * Without this, a snapshot naming an unloaded lazy type fails inside MST as

package/esm/ReExports/BaseFeatureDetails.js

@@ -7,4 +7,4 @@ export const BaseFeatureDetail = lazyMap({
     BaseCard: lazy(() => import('../BaseFeatureWidget/BaseFeatureDetail/BaseCard.js')),
     BaseAttributes: lazy(() => import('../BaseFeatureWidget/BaseFeatureDetail/BaseAttributes.js')),
     BaseCoreDetails: lazy(() => import('../BaseFeatureWidget/BaseFeatureDetail/BaseCoreDetails.js')),
-}, '@jbrowse/core/BaseFeatureWidget/BaseFeatureDetail/');
+});