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

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';
@@ -20,7 +21,7 @@ import './ui/buildExtraTrackMenuItems.ts';
 import './ui/multiTrackMenuItems.ts';
 import './util/addTrackComponent.ts';
 import type { AbstractRootModel, AbstractSessionModel, SimpleFeatureSerialized } from './util/index.ts';
-import type { IAnyModelType, IStateTreeNode, IAnyType } from '@jbrowse/mobx-state-tree';
+import type { IAnyModelType, IStateTreeNode, IAnyType, SnapshotIn } from '@jbrowse/mobx-state-tree';
 import type { ComponentType, ReactNode } from 'react';
 /**
  * Every pluggable element group, in the order `elementCreationSchedule` builds
@@ -137,7 +138,18 @@ export interface ReplaceWidgetProps {
  *
  * That is what makes `extendViewType(pm, 'LinearGenomeView', …)` hand back a
  * typed state model, and a misspelled or renamed name a compile error rather
- * than an extension that quietly never applies. Declaring them here rather than
+ * than an extension that quietly never applies. `getViewType` reads it too, so
+ * a caller composing another view's model into its own gets the real type
+ * instead of `IAnyModelType`.
+ *
+ * AN AUGMENTATION IS HAND-WRITTEN, so each registration annotates the model it
+ * passes to `ViewType` against its own entry here (`const stateModel:
+ * ViewTypeRegistry['CircularView'] = …`). That one line is what makes the
+ * registry earn what `getViewType` promises: without it a drifted entry is
+ * worse than the `IAnyModelType` it replaced, since a caller would get a
+ * confidently wrong type rather than an unchecked one. It cannot live on
+ * `ViewType`'s constructor — TypeScript forbids type parameters there, and a
+ * class parameter widens `name` to `string`, so the conditional never fires. Declaring them here rather than
  * beside the helpers is load-bearing: an interface can only be augmented
  * through the module that declares it, and a barrel re-exporting the type would
  * give every augmentation its own unrelated copy.
@@ -148,6 +160,21 @@ export interface DisplayTypeRegistry {
 }
 export type ViewTypeName = keyof ViewTypeRegistry;
 export type DisplayTypeName = keyof DisplayTypeRegistry;
+/**
+ * What `addView(name, snapshot)` takes for a view type name. A registered name
+ * gets the view's authored shape — the snapshot type `withLaunchInput` widened
+ * to accept the launch keys beside the declared properties — so a misspelled
+ * key is a compile error at the literal site. `type` is optional because
+ * `addView` writes it. An unregistered name stays `Record<string, unknown>`,
+ * which is what an out-of-tree view's `addView` has always been.
+ *
+ * Read off `ViewTypeRegistry` rather than registered a second time, so the
+ * snapshot type cannot drift from the model: a view that augments the registry
+ * has typed `addView`, `replaceView` and `addOrReplaceView` for free.
+ */
+export type ViewSnapshotInput<N extends string> = N extends ViewTypeName ? Omit<SnapshotIn<ViewTypeRegistry[N]>, 'type'> & {
+    type?: N;
+} : Record<string, unknown>;
 export interface ExtensionPointRegistry {
     'Core-extendSession': {
         args: IAnyModelType;
@@ -264,10 +291,20 @@ 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;
 }
 export default class PluginManager {
+    #private;
     plugins: Plugin[];
     jexl: import("@jbrowse/jexl").Jexl;
     pluginMetadata: Record<string, PluginMetadata>;
@@ -289,25 +326,27 @@ export default class PluginManager {
     extensionPoints: Map<string, ExtensionPointCallback[]>;
     warnedClobber: Set<string>;
     /**
-     * Lazy-hydration cache for `TrackConfigurationReference`/
-     * `DisplayConfigurationReference` (configuration/configurationSchema.ts).
+     * The lazily-hydrated MST config node for one frozen track config, built by
+     * `build` on first ask and returned by identity after that.
+     * `configuration/configurationSchema.ts` is the only caller.
+     *
      * `jbrowse.tracks` is `types.frozen` for large-tracklist performance, so a
-     * track config is a plain JS object until first referenced; hydrating it
-     * into an MST node is deferred to that read. MST's custom-reference
-     * `getValue` has no memoization of its own — it reruns on every property
-     * access — so without this cache, every read of `track.configuration` would
-     * fabricate a fresh, non-identical MST node. Keyed by schemaType (each track
-     * type's config schema is rebuilt fresh per PluginManager instance, see
-     * addTrackType) then by the frozen object itself, so a cache hit can only
-     * ever come from this same PluginManager instance and this same track type.
-     * See ADR-031.
+     * track config is a plain JS object until first referenced; hydrating it into
+     * an MST node is deferred to that read. MST's custom-reference `getValue` has
+     * no memoization of its own — it reruns on every property access — so without
+     * this, every read of `track.configuration` would fabricate a fresh,
+     * non-identical node. Keyed by schemaType (each track type's config schema is
+     * rebuilt fresh per PluginManager instance, see addTrackType) then by the
+     * frozen object, so a hit can only ever come from this same instance and this
+     * same track type. See ADR-031.
      *
-     * This node is never mutated: admin edits replace the frozen entry (new
+     * The node is never mutated: admin edits replace the frozen entry (new
      * identity drops the WeakMap entry), and a non-admin's edits go to a private
      * session working copy, not here (ADR-032). Both levels are `WeakMap`s so
-     * entries collect normally — no manual invalidation needed.
+     * entries collect normally — no manual invalidation needed, which is why this
+     * is a memo and not a cache with a lifecycle to expose.
      */
-    trackConfigHydrationCache: WeakMap<object, WeakMap<object, unknown>>;
+    hydratedTrackConfig(schemaType: IAnyType, frozen: object, build: () => unknown): unknown;
     constructor(initialPlugins?: (Plugin | PluginLoadRecord | RuntimePluginLoadRecord)[]);
     pluginConfigurationNamespacedSchemas(): Record<string, unknown>;
     pluginConfigurationUnnamespacedSchemas(): Record<string, unknown>;
@@ -330,10 +369,22 @@ export default class PluginManager {
     getRpcElements(): RpcMethodType[];
     getDisplayElements(): DisplayType[];
     getAdapterElements(): AdapterType[];
-    /** get a MST type for the union of all specified pluggable MST types */
+    /**
+     * get a MST type for the union of all specified pluggable MST types.
+     * Membership is late-bound, so a lazily registered state model joins when
+     * its loader resolves; a snapshot naming one cannot be cast until then.
+     */
     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>;
@@ -347,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`
@@ -357,7 +414,32 @@ export default class PluginManager {
     getTextSearchAdapterType(typeName: string): TextSearchAdapterType;
     getTrackType(typeName: string): TrackType;
     getDisplayType(typeName: string): DisplayType;
+    getViewType<N extends ViewTypeName>(typeName: N): Omit<ViewType, 'stateModel'> & {
+        stateModel: ViewTypeRegistry[N];
+    };
     getViewType(typeName: string): ViewType;
+    /**
+     * 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.
+     */
+    preloadSessionTypes(sessionSnapshot: unknown): Promise<void>;
+    unloadedSessionTypes(sessionSnapshot: unknown): string[];
+    /**
+     * Without this, a snapshot naming an unloaded lazy type fails inside MST as
+     * a union mismatch that reads like a corrupt snapshot.
+     */
+    assertSessionTypesLoaded(sessionSnapshot: unknown): void;
+    /**
+     * Aliases resolve here because a legacy session names the alias, and the
+     * model that remaps it cannot be consulted before it is loaded.
+     */
+    resolveDisplayTypeRecord(name: string): DisplayType | undefined;
     getAddTrackWorkflow(typeName: string): AddTrackWorkflowType;
     getWidgetType(typeName: string): WidgetType;
     getConnectionType(typeName: string): ConnectionType;

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();
@@ -113,26 +128,41 @@ export default class PluginManager {
     // singular component points are re-evaluated on every render, so the
     // clobber warning is emitted once per point per app
     warnedClobber = new Set();
+    #trackConfigHydrationCache = new WeakMap();
     /**
-     * Lazy-hydration cache for `TrackConfigurationReference`/
-     * `DisplayConfigurationReference` (configuration/configurationSchema.ts).
+     * The lazily-hydrated MST config node for one frozen track config, built by
+     * `build` on first ask and returned by identity after that.
+     * `configuration/configurationSchema.ts` is the only caller.
+     *
      * `jbrowse.tracks` is `types.frozen` for large-tracklist performance, so a
-     * track config is a plain JS object until first referenced; hydrating it
-     * into an MST node is deferred to that read. MST's custom-reference
-     * `getValue` has no memoization of its own — it reruns on every property
-     * access — so without this cache, every read of `track.configuration` would
-     * fabricate a fresh, non-identical MST node. Keyed by schemaType (each track
-     * type's config schema is rebuilt fresh per PluginManager instance, see
-     * addTrackType) then by the frozen object itself, so a cache hit can only
-     * ever come from this same PluginManager instance and this same track type.
-     * See ADR-031.
+     * track config is a plain JS object until first referenced; hydrating it into
+     * an MST node is deferred to that read. MST's custom-reference `getValue` has
+     * no memoization of its own — it reruns on every property access — so without
+     * this, every read of `track.configuration` would fabricate a fresh,
+     * non-identical node. Keyed by schemaType (each track type's config schema is
+     * rebuilt fresh per PluginManager instance, see addTrackType) then by the
+     * frozen object, so a hit can only ever come from this same instance and this
+     * same track type. See ADR-031.
      *
-     * This node is never mutated: admin edits replace the frozen entry (new
+     * The node is never mutated: admin edits replace the frozen entry (new
      * identity drops the WeakMap entry), and a non-admin's edits go to a private
      * session working copy, not here (ADR-032). Both levels are `WeakMap`s so
-     * entries collect normally — no manual invalidation needed.
+     * entries collect normally — no manual invalidation needed, which is why this
+     * is a memo and not a cache with a lifecycle to expose.
      */
-    trackConfigHydrationCache = new WeakMap();
+    hydratedTrackConfig(schemaType, frozen, build) {
+        let byFrozen = this.#trackConfigHydrationCache.get(schemaType);
+        if (!byFrozen) {
+            byFrozen = new WeakMap();
+            this.#trackConfigHydrationCache.set(schemaType, byFrozen);
+        }
+        let node = byFrozen.get(frozen);
+        if (!node) {
+            node = build();
+            byFrozen.set(frozen, node);
+        }
+        return node;
+    }
     constructor(initialPlugins = []) {
         // add the core plugin
         this.addPlugin({
@@ -292,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;
@@ -326,16 +375,38 @@ export default class PluginManager {
     getAdapterElements() {
         return this.getElementTypesInGroup('adapter');
     }
-    /** get a MST type for the union of all specified pluggable MST types */
+    /**
+     * get a MST type for the union of all specified pluggable MST types.
+     * Membership is late-bound, so a lazily registered state model joins when
+     * its loader resolves; a snapshot naming one cannot be cast until then.
+     */
     pluggableMstType(groupName, fieldName, fallback = types.maybe(types.null)) {
-        const pluggableTypes = this.getElementTypeRecord(groupName)
-            .all()
-            .map(t => t[fieldName])
-            .filter(t => isType(t) && isModelType(t));
-        if (pluggableTypes.length === 0) {
+        const record = this.getElementTypeRecord(groupName);
+        const fieldOf = (t) => isUnloadedLazyElement(t)
+            ? undefined
+            : t[fieldName];
+        const anyMember = record.all().some(t => {
+            const field = fieldOf(t);
+            return ((isType(field) && isModelType(field)) ||
+                typeof t[`${fieldName}Loader`] === 'function');
+        });
+        if (!anyMember) {
             return fallback;
         }
-        return types.union(...pluggableTypes);
+        const modelsOf = () => record
+            .all()
+            .map(t => fieldOf(t))
+            .filter(t => isType(t) && isModelType(t));
+        let members = modelsOf();
+        return types.union({
+            name: `pluggable(${groupName} ${fieldName})`,
+            members: () => {
+                if (members.length !== modelsOf().length) {
+                    members = modelsOf();
+                }
+                return members;
+            },
+        });
     }
     /** get a MST type for the union of all specified pluggable config schemas */
     pluggableConfigSchemaType(typeGroup, fieldName = 'configSchema') {
@@ -360,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,
@@ -399,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
@@ -408,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);
@@ -422,6 +525,71 @@ export default class PluginManager {
     getViewType(typeName) {
         return this.viewTypes.get(typeName);
     }
+    /**
+     * 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);
+                }
+            }
+            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);
+                    }
+                }
+            }
+        };
+        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) {
+        await Promise.all(this.sessionElementTypes(sessionSnapshot).map(t => t.loadStateModel()));
+    }
+    unloadedSessionTypes(sessionSnapshot) {
+        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
+     * a union mismatch that reads like a corrupt snapshot.
+     */
+    assertSessionTypesLoaded(sessionSnapshot) {
+        const unloaded = this.unloadedSessionTypes(sessionSnapshot);
+        if (unloaded.length > 0) {
+            throw new Error(`session names lazily loaded types that are not loaded yet: ${unloaded.join(', ')}. Await pluginManager.preloadSessionTypes(snapshot) before setting the session`);
+        }
+    }
+    /**
+     * Aliases resolve here because a legacy session names the alias, and the
+     * model that remaps it cannot be consulted before it is loaded.
+     */
+    resolveDisplayTypeRecord(name) {
+        if (this.displayTypes.has(name)) {
+            return this.getDisplayType(name);
+        }
+        return this.getDisplayElements().find(d => d.aliases?.includes(name));
+    }
     getAddTrackWorkflow(typeName) {
         return this.addTrackWidgets.get(typeName);
     }

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/');
+});

package/esm/ReExports/MuiDataGridReExports.d.ts

@@ -1,2 +1,3 @@
 import type { ComponentType } from 'react';
+export declare const DATA_GRID_NAMES: string[];
 export declare const DataGridEntries: Record<string, ComponentType<any>>;

package/esm/ReExports/MuiDataGridReExports.js

@@ -3,7 +3,7 @@ import { lazy } from 'react';
 // export off it, so they're generated from a name list rather than written out
 // 45 times. The static import specifier means webpack still emits a single
 // x-data-grid chunk shared by all entries.
-const names = [
+export const DATA_GRID_NAMES = [
     'DataGrid',
     'GridActionsCellItem',
     'GridAddIcon',
@@ -51,7 +51,7 @@ const names = [
     'GridViewHeadlineIcon',
     'GridViewStreamIcon',
 ];
-export const DataGridEntries = Object.fromEntries(names.map(name => [
+export const DataGridEntries = Object.fromEntries(DATA_GRID_NAMES.map(name => [
     name,
     lazy(() => import('@mui/x-data-grid').then(m => ({
         default: m[name],

package/esm/ReExports/barrelOnlyNames.d.ts

@@ -0,0 +1,5 @@
+export declare const BARREL_ONLY_NAMES: {
+    '@jbrowse/core/ui': never[];
+    '@jbrowse/core/util/tracks': never[];
+    '@jbrowse/core/util': string[];
+};

package/esm/ReExports/barrelOnlyNames.js

@@ -0,0 +1,63 @@
+// Names a source barrel exports that its ABI file deliberately does not serve.
+//
+// The public*.ts split stopped a barrel removal from silently narrowing the ABI
+// -- take a name out of ui/index.ts and publicUi.tsx no longer compiles. This
+// closes the other direction, which the split opened: a name *added* to a barrel
+// is not served until someone adds it here too, and an external plugin cannot
+// see that. Its `import { X } from '@jbrowse/core/ui'` type-checks, because
+// package.json's `./ui` resolves to the barrel, and reads undefined off
+// JBrowseExports at runtime -- the same shape of failure a removal used to
+// cause, just for new code instead of old.
+//
+// So publicSurface.test.ts requires barrel-minus-ABI to be exactly this list.
+// Adding an export to a barrel then fails until the ABI question is answered,
+// and either answer is one line: serve it from the public*.ts file, or name it
+// here. Nothing about being on this list is wrong -- most of these are helpers
+// for app code, session plumbing and in-tree hooks that a plugin has no use for.
+export const BARREL_ONLY_NAMES = {
+    '@jbrowse/core/ui': [],
+    '@jbrowse/core/util/tracks': [],
+    '@jbrowse/core/util': [
+        'MAX_GLOB_REGIONS',
+        'adapterNeedsAddTrackComponent',
+        'assembleLocStrings',
+        'canonicalizeViewRefName',
+        'clampToContig',
+        'clampToListedContig',
+        'containerDisplaysAssembly',
+        'downloadPhase',
+        'finishAddTrack',
+        'formatBytes',
+        'getDisplayStr',
+        'getLocationUri',
+        'handleFetchError',
+        'indexedDBAvailable',
+        'installablePlugins',
+        'isSessionWithMultipleViews',
+        'isSessionWithPermanentPlugins',
+        'isWebWorker',
+        'localStorageAvailable',
+        'localStorageGetStringArray',
+        'matchRefNames',
+        'measuredFont',
+        'namesTemporaryAssembly',
+        'notifyFeatureDetailsMiss',
+        'notifyLocalStorageKey',
+        'parseBpString',
+        'parseRegionNames',
+        'resolveNamedRegions',
+        'resolveStorePluginRefs',
+        'resolveStoreRefs',
+        'resolveUri',
+        'sessionStorageAvailable',
+        'sessionStorageGetItem',
+        'sessionStorageRemoveItem',
+        'sessionStorageSetItem',
+        'statusSource',
+        'subscribeToLocalStorageKey',
+        'throttleStatusEmits',
+        'useCreateOnce',
+        'useFinalUnmount',
+        'withFeatureDetails',
+    ],
+};