@jbrowse/core 5.0.0-beta.8 → 5.0.0-beta.9

package/esm/BaseFeatureWidget/formatDetails.js

@@ -1,61 +1,27 @@
-/**
- * @module
- * Resolving the `formatDetails` config hook across its two tiers, on behalf of
- * the feature-details widget's autorun. Plain functions rather than model
- * members: an MST action runs untracked, so folding these into one would leave
- * the autorun with no observable reads and fire it exactly once.
- */
-import { DEFAULT_FORMAT_DETAILS_DEPTH, getConf, mergeFormatCallbacks, } from '../configuration/index.js';
-import { isObject } from '../util/index.js';
-import { isEmpty } from './BaseFeatureDetail/util.js';
-import { formatSubfeatures } from './util.js';
-/** Both tiers of one slot, session first, so a spread puts the track on top. */
+import { DEFAULT_FORMAT_DETAILS_DEPTH, mergeFormatCallbacks, readConfObject, } from '../configuration/index.js';
+import { isPlainObject } from '../util/objectUtils.js';
 function readTiers({ session, track }, slot, args) {
     return [
-        getConf(session, ['formatDetails', slot], args),
-        track ? getConf(track, ['formatDetails', slot], args) : undefined,
+        readConfObject(session, ['formatDetails', slot], args),
+        track ? readConfObject(track, ['formatDetails', slot], args) : undefined,
     ];
 }
 /**
- * Whether either tier **declares** a callback for `slot`, read RAW off the
- * config node.
- *
- * Deliberately not `readTiers`: "is anything configured here" and "what does
- * this produce for this feature" are different questions, and an arg-less read
- * of a `jexl:` slot answers the second one badly — it evaluates the user's
- * expression against a context where `feature` is undefined (see
- * `configuration/CLAUDE.md`), which is a throw or a junk value, per tier, just
- * to find out the slot exists.
- *
- * Both callback slots default to `{}`, so a config that never mentions
- * `formatDetails` answers false for both and `applyFormatDetails` can hand the
- * feature straight back. That is the whole point of asking: the walk it skips
- * is proportional to the subfeature tree, and the tree can be very large (a
- * RefSeq BRCA1 is 368 transcripts, ~16k nodes) while the config that formats
- * none of it is the overwhelmingly common one.
+ * Whether either tier sets `slot`, read raw off the node: an arg-less read of
+ * a `jexl:` slot evaluates it against an empty context just to find out it
+ * exists. Both callback slots default to `{}`, so a config that never mentions
+ * `formatDetails` answers false and the walk below is skipped entirely, which
+ * matters on a RefSeq gene with 16k nested nodes.
  */
 function declaresCallback({ session, track }, slot) {
-    return [session, track].some(holder => {
-        // raw property access, not a reader: see above
-        const sub = holder?.configuration.formatDetails;
-        const value = sub?.[slot];
-        // a `jexl:` slot is a string; a plain-object slot counts only when it has
-        // keys, since `{}` is the schema default and merges to nothing
+    return [session, track].some(conf => {
+        const value = conf?.formatDetails?.[slot];
         return typeof value === 'string'
             ? value !== ''
-            : isObject(value) && !isEmpty(value);
+            : isPlainObject(value) && Object.keys(value).length > 0;
     });
 }
-/**
- * `depth` or `maxDepth`: the track's value when the track sets one, else the
- * session's, else unset.
- *
- * These override rather than merge, unlike the callback objects. That is only
- * expressible because both are `maybeNumber` slots with no `defaultValue` --
- * given a schema default the track reported a value whether or not anyone set
- * one, so the session-wide tier could never apply to a track, and every real
- * config has a track.
- */
+/** `depth` or `maxDepth`: the track's value when set, else the session's. */
 export function formatDetailsNumber(tiers, slot) {
     const [fromSession, fromTrack] = readTiers(tiers, slot);
     return typeof fromTrack === 'number'
@@ -65,39 +31,40 @@ export function formatDetailsNumber(tiers, slot) {
             : undefined;
 }
 /**
- * A copy of the feature with each tier's callback output merged onto it (and
- * onto its subfeatures, down to `depth`) as `__jbrowsefmt`, which the detail
- * components spread over the raw fields at render.
- *
- * `__jbrowsefmt` is attached only where a callback produced something, so a
- * config with no `formatDetails` at all leaves the feature exactly as it came
- * in rather than stamping empty objects through the persisted snapshot.
+ * The feature as the details panel shows it: each tier's `feature` callback
+ * output spread over the clicked feature, and `subfeatures` output over each
+ * subfeature down to `depth`. A key set to null or undefined hides that row,
+ * since every detail component filters with `!= null`. A config declaring no
+ * callback gets the input back untouched.
  */
-export function applyFormatDetails(tiers, featureData) {
-    const hasFeature = declaresCallback(tiers, 'feature');
-    const hasSubfeatures = declaresCallback(tiers, 'subfeatures');
-    // Nothing declared by either tier: the result is the input, so return the
-    // input. The clone and the per-node walk below are both proportional to the
-    // subfeature tree and both produce nothing here, and this is the default
-    // config -- most tracks never set `formatDetails` at all.
-    if (!hasFeature && !hasSubfeatures) {
-        return featureData;
-    }
-    const feature = structuredClone(featureData);
-    if (hasFeature) {
-        const fmt = mergeFormatCallbacks(...readTiers(tiers, 'feature', { feature }));
-        if (!isEmpty(fmt)) {
-            feature.__jbrowsefmt = fmt;
-        }
+export function applyFormatDetails(tiers, feature) {
+    const formatsFeature = declaresCallback(tiers, 'feature');
+    const formatsSubfeatures = declaresCallback(tiers, 'subfeatures');
+    if (!formatsFeature && !formatsSubfeatures) {
+        return feature;
     }
-    if (hasSubfeatures) {
-        const depth = formatDetailsNumber(tiers, 'depth') ?? DEFAULT_FORMAT_DETAILS_DEPTH;
-        formatSubfeatures(feature, depth, sub => {
-            const subFmt = mergeFormatCallbacks(...readTiers(tiers, 'subfeatures', { feature: sub }));
-            if (!isEmpty(subFmt)) {
-                sub.__jbrowsefmt = subFmt;
-            }
-        });
+    const depth = formatsSubfeatures
+        ? (formatDetailsNumber(tiers, 'depth') ?? DEFAULT_FORMAT_DETAILS_DEPTH)
+        : 0;
+    const track = tiers.track ? readConfObject(tiers.track) : undefined;
+    function format(node, level, fmt) {
+        const { subfeatures } = node;
+        return {
+            ...node,
+            ...(subfeatures && level < depth
+                ? {
+                    subfeatures: subfeatures.map(sub => format(sub, level + 1, mergeFormatCallbacks(...readTiers(tiers, 'subfeatures', {
+                        feature: sub,
+                        parent: node,
+                        depth: level + 1,
+                        track,
+                    })))),
+                }
+                : {}),
+            ...fmt,
+        };
     }
-    return feature;
+    return format(feature, 0, formatsFeature
+        ? mergeFormatCallbacks(...readTiers(tiers, 'feature', { feature, track }))
+        : {});
 }

package/esm/BaseFeatureWidget/index.d.ts

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

package/esm/BaseFeatureWidget/stateModelFactory.d.ts

@@ -1,14 +1,16 @@
 import type PluginManager from '../PluginManager.ts';
+import type { AnyConfigurationModel } from '../configuration/index.ts';
 import type { ParentFeatureSummary, SimpleFeatureSerialized } from '../util/index.ts';
 import type { SequenceHoverPosition } from './SequenceFeatureDetails/model.ts';
+import type { FormatDetailsTiers } from './formatDetails.ts';
 import type { Descriptors, MaybeSerializedFeat } from './types.tsx';
 import type { Instance } from '@jbrowse/mobx-state-tree';
 /**
  * #stateModel BaseFeatureWidget
- * displays data about features, allowing configuration callbacks to modify the
- * contents of what is displayed
- *
- * see: formatDetails-\>feature,formatDetails-\>subfeatures
+ * The feature-details panel. `featureData` is the clicked feature with the
+ * track's and the session's `formatDetails` callbacks applied, derived on read
+ * from the raw feature the widget was opened with, so the same widget follows a
+ * config edit and survives its track being closed.
  */
 export declare function stateModelFactory(pluginManager: PluginManager): import("@jbrowse/mobx-state-tree").IModelType<{
     /**
@@ -21,10 +23,8 @@ export declare function stateModelFactory(pluginManager: PluginManager): import(
     type: import("@jbrowse/mobx-state-tree").ILiteralType<"BaseFeatureWidget">;
     /**
      * #property
-     */
-    featureData: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").IType<MaybeSerializedFeat, MaybeSerializedFeat, MaybeSerializedFeat>, [undefined]>;
-    /**
-     * #property
+     * the feature as the click handed it over, before any callback ran.
+     * Persisted as `featureData`
      */
     unformattedFeatureData: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").IType<MaybeSerializedFeat, MaybeSerializedFeat, MaybeSerializedFeat>, [undefined]>;
     /**
@@ -43,10 +43,6 @@ export declare function stateModelFactory(pluginManager: PluginManager): import(
      * #property
      */
     trackType: import("@jbrowse/mobx-state-tree").IMaybe<import("@jbrowse/mobx-state-tree").ISimpleType<string>>;
-    /**
-     * #property
-     */
-    maxDepth: import("@jbrowse/mobx-state-tree").IMaybe<import("@jbrowse/mobx-state-tree").ISimpleType<number>>;
     /**
      * #property
      */
@@ -76,39 +72,51 @@ export declare function stateModelFactory(pluginManager: PluginManager): import(
      */
     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;
 } & {
     /**
-     * #action
+     * #getter
+     * the config the track tier of `formatDetails` reads. The open track's
+     * own while it is open; after it is closed, the session's copy of the
+     * same config, which is why the widget records `trackId`
      */
-    setSequenceHoverPosition(pos: SequenceHoverPosition | undefined): void;
+    readonly trackConfiguration: AnyConfigurationModel | undefined;
+} & {
+    readonly formatDetailsTiers: FormatDetailsTiers;
+} & {
+    readonly formatted: {
+        feature?: SimpleFeatureSerialized;
+        error?: Error;
+    };
     /**
-     * #action
+     * #getter
+     * levels of subfeature card the panel renders; unset means no limit
      */
-    setFeatureData(featureData: SimpleFeatureSerialized): void;
+    readonly maxDepth: number | undefined;
+} & {
     /**
-     * #action
+     * #getter
+     * the feature with every `formatDetails` callback applied
      */
-    clearFeatureData(): void;
+    readonly featureData: SimpleFeatureSerialized | undefined;
     /**
-     * #action
+     * #getter
      */
-    setFormattedData(feat: SimpleFeatureSerialized): void;
+    readonly error: Error | undefined;
+} & {
+    afterAttach(): void;
     /**
      * #action
      */
-    setTrackInfo(type?: string, trackId?: string): void;
+    setSequenceHoverPosition(pos: SequenceHoverPosition | undefined): void;
     /**
      * #action
      */
-    setMaxDepth(maxDepth?: number): void;
+    setFeatureData(featureData: SimpleFeatureSerialized): void;
     /**
      * #action
      */
-    setError(e: unknown): void;
-} & {
-    afterCreate(): void;
+    clearFeatureData(): void;
 }, import("@jbrowse/mobx-state-tree")._NotCustomized, {
     id: string;
     type: "BaseFeatureWidget";
@@ -116,11 +124,10 @@ export declare function stateModelFactory(pluginManager: PluginManager): import(
     track: import("@jbrowse/mobx-state-tree").ReferenceIdentifier | undefined;
     trackId: string | undefined;
     trackType: string | undefined;
-    maxDepth: number | undefined;
     sequenceFeatureDetails: import("@jbrowse/mobx-state-tree").ModelSnapshotType<{}>;
     descriptions: Descriptors | undefined;
     parentFeature: ParentFeatureSummary | undefined;
-    finalizedFeatureData: any;
+    featureData: MaybeSerializedFeat;
 }>;
 export type BaseFeatureWidgetStateModel = ReturnType<typeof stateModelFactory>;
 export type BaseFeatureWidgetModel = Instance<BaseFeatureWidgetStateModel>;

package/esm/BaseFeatureWidget/stateModelFactory.js

@@ -1,16 +1,15 @@
-import { addDisposer, types } from '@jbrowse/mobx-state-tree';
-import { autorun } from 'mobx';
+import { getEnv, isStateTreeNode, types } from '@jbrowse/mobx-state-tree';
+import { hydrateTrackConfig } from '../configuration/index.js';
 import { getSession } from '../util/index.js';
 import { ElementId } from '../util/types/mst.js';
 import { SequenceFeatureDetailsF } from './SequenceFeatureDetails/model.js';
 import { applyFormatDetails, formatDetailsNumber } from './formatDetails.js';
-import { nullReplacer } from './util.js';
 /**
  * #stateModel BaseFeatureWidget
- * displays data about features, allowing configuration callbacks to modify the
- * contents of what is displayed
- *
- * see: formatDetails-\>feature,formatDetails-\>subfeatures
+ * The feature-details panel. `featureData` is the clicked feature with the
+ * track's and the session's `formatDetails` callbacks applied, derived on read
+ * from the raw feature the widget was opened with, so the same widget follows a
+ * config edit and survives its track being closed.
  */
 export function stateModelFactory(pluginManager) {
     return types
@@ -25,10 +24,8 @@ export function stateModelFactory(pluginManager) {
         type: types.literal('BaseFeatureWidget'),
         /**
          * #property
-         */
-        featureData: types.optional(types.frozen(), undefined),
-        /**
-         * #property
+         * the feature as the click handed it over, before any callback ran.
+         * Persisted as `featureData`
          */
         unformattedFeatureData: types.optional(types.frozen(), undefined),
         /**
@@ -47,10 +44,6 @@ export function stateModelFactory(pluginManager) {
          * #property
          */
         trackType: types.maybe(types.string),
-        /**
-         * #property
-         */
-        maxDepth: types.maybe(types.number),
         /**
          * #property
          */
@@ -67,18 +60,93 @@ export function stateModelFactory(pluginManager) {
         parentFeature: types.optional(types.frozen(), undefined),
     })
         .volatile(() => ({
-        /**
-         * #volatile
-         */
-        error: undefined,
         /**
          * #volatile
          * genomic base currently hovered in this widget's sequence panel, read by
          * the LGV crosshair overlay
          */
         sequenceHoverPosition: undefined,
+    }))
+        .views(self => ({
+        /**
+         * #getter
+         * the config the track tier of `formatDetails` reads. The open track's
+         * own while it is open; after it is closed, the session's copy of the
+         * same config, which is why the widget records `trackId`
+         */
+        get trackConfiguration() {
+            const { track, trackId } = self;
+            if (track) {
+                return track.configuration;
+            }
+            if (!trackId) {
+                return undefined;
+            }
+            const conf = getSession(self).getTrackById(trackId);
+            return conf === undefined || isStateTreeNode(conf)
+                ? conf
+                : hydrateTrackConfig(getEnv(self).pluginManager, conf);
+        },
+    }))
+        .views(self => ({
+        get formatDetailsTiers() {
+            return {
+                session: getSession(self).configuration,
+                track: self.trackConfiguration,
+            };
+        },
+    }))
+        .views(self => ({
+        get formatted() {
+            const { unformattedFeatureData } = self;
+            if (!unformattedFeatureData) {
+                return {};
+            }
+            try {
+                return {
+                    feature: applyFormatDetails(self.formatDetailsTiers, unformattedFeatureData),
+                };
+            }
+            catch (e) {
+                const where = self.trackId
+                    ? `track "${self.trackId}"`
+                    : 'the session configuration';
+                const error = new Error(`Error running the formatDetails callbacks for ${where}: ${e}`, { cause: e });
+                console.error(error);
+                return { error };
+            }
+        },
+        /**
+         * #getter
+         * levels of subfeature card the panel renders; unset means no limit
+         */
+        get maxDepth() {
+            return formatDetailsNumber(self.formatDetailsTiers, 'maxDepth');
+        },
+    }))
+        .views(self => ({
+        /**
+         * #getter
+         * the feature with every `formatDetails` callback applied
+         */
+        get featureData() {
+            return self.formatted.feature;
+        },
+        /**
+         * #getter
+         */
+        get error() {
+            return self.formatted.error;
+        },
     }))
         .actions(self => ({
+        afterAttach() {
+            const { track } = self;
+            if (track) {
+                self.trackId = track.configuration.trackId;
+                self.trackType = track.type;
+            }
+        },
         /**
          * #action
          */
@@ -105,96 +173,20 @@ export function stateModelFactory(pluginManager) {
          * #action
          */
         clearFeatureData() {
-            self.featureData = undefined;
-        },
-        /**
-         * #action
-         */
-        setFormattedData(feat) {
-            self.featureData = feat;
-        },
-        /**
-         * #action
-         */
-        setTrackInfo(type, trackId) {
-            self.trackId = trackId;
-            self.trackType = type;
-        },
-        /**
-         * #action
-         */
-        setMaxDepth(maxDepth) {
-            self.maxDepth = maxDepth;
-        },
-        /**
-         * #action
-         */
-        setError(e) {
-            self.error = e;
-        },
-    }))
-        .actions(self => ({
-        afterCreate() {
-            addDisposer(self, autorun(function featureWidgetAutorun() {
-                const { track } = self;
-                // read before any config read so the catch below can attribute
-                // the failure without repeating one that may be what threw
-                let trackId;
-                try {
-                    const { unformattedFeatureData } = self;
-                    const session = getSession(self);
-                    if (track) {
-                        trackId = track.configuration.trackId;
-                        self.setTrackInfo(track.type, trackId);
-                    }
-                    // both tiers apply: a widget can outlive its track
-                    // (safeReference) or never have had one, and the session-wide
-                    // `configuration.formatDetails` still means something. The
-                    // reads stay here in the autorun body rather than moving into
-                    // an action, which would run untracked
-                    const tiers = { session, track };
-                    // an unset maxDepth is the meaningful value, not a missing one:
-                    // the panel reads it as no nesting limit
-                    self.setMaxDepth(formatDetailsNumber(tiers, 'maxDepth'));
-                    if (unformattedFeatureData) {
-                        self.setFormattedData(applyFormatDetails(tiers, unformattedFeatureData));
-                    }
-                }
-                catch (e) {
-                    // jexl throws a bare parse/eval message with nothing naming the
-                    // slot or the config it came from, and this banner replaces the
-                    // whole panel -- say where to look
-                    const where = trackId
-                        ? `track "${trackId}"`
-                        : 'the session configuration';
-                    const err = new Error(`Error running the formatDetails callbacks for ${where}: ${e}`, { cause: e });
-                    console.error(err);
-                    self.setError(err);
-                }
-            }, { name: 'FeatureWidget' }));
+            self.unformattedFeatureData = undefined;
         },
     }))
         .preProcessSnapshot((snap) => {
-        // old snapshots used `featureData`, new ones use `finalizedFeatureData`;
-        // accept both for backwards compat
-        const { featureData, finalizedFeatureData, ...rest } = (snap ?? {});
-        return {
-            unformattedFeatureData: featureData,
-            featureData: finalizedFeatureData,
-            ...rest,
-        };
+        const { featureData, ...rest } = snap ?? {};
+        return { unformattedFeatureData: featureData, ...rest };
     })
         .postProcessSnapshot(snap => {
-        const { unformattedFeatureData, featureData, ...rest } = snap;
+        const { unformattedFeatureData, ...rest } = snap;
         // JSON.stringify can return empty if too large
-        const s2 = JSON.stringify(featureData, nullReplacer);
-        const featureTooLargeToBeSerialized = !s2 || s2.length > 2_000_000;
-        // `finalizedFeatureData` is persisted (rather than `featureData`) so
-        // loading from snapshot doesn't re-run the formatter callbacks
+        const json = JSON.stringify(unformattedFeatureData);
+        const tooLargeToPersist = !json || json.length > 2_000_000;
         return {
-            finalizedFeatureData: featureTooLargeToBeSerialized
-                ? undefined
-                : JSON.parse(s2),
+            featureData: tooLargeToPersist ? undefined : unformattedFeatureData,
             ...rest,
         };
     });

package/esm/BaseFeatureWidget/types.d.ts

@@ -1,3 +1,4 @@
+import type { MenuItem } from '../ui/MenuTypes.ts';
 import type { SimpleFeatureSerialized } from '../util/simpleFeature.ts';
 import type { SequenceFeatureDetailsModel, SequenceHoverTarget } from './SequenceFeatureDetails/model.ts';
 import type { IStateTreeNode } from '@jbrowse/mobx-state-tree';
@@ -13,6 +14,8 @@ export interface Descriptors {
     [key: string]: React.ReactNode | Descriptors;
 }
 export type FeatureFormatter = (value: unknown, key: string, index?: number) => React.ReactNode;
+/** Menu items for one attribute's value, offered from a button on its row. */
+export type FieldActions = (path: string[], value: unknown) => MenuItem[];
 export interface BaseProps extends BaseCardProps {
     feature: SimpleFeatureSerialized;
     formatter?: FeatureFormatter;

package/esm/BaseFeatureWidget/util.d.ts

@@ -1,4 +1,3 @@
-import type { SerializedFeat } from './types.tsx';
 export interface Feat {
     start: number;
     end: number;
@@ -25,5 +24,3 @@ export interface ErrorState {
 export declare function filterSuccessiveElementsWithSameStartAndEndCoord(list: Feat[]): Feat[];
 export declare function ellipses(slug: string): string;
 export declare function getStrandStr(strand: number | undefined): "" | "(+)" | "(-)";
-export declare const nullReplacer: (_: string, v: unknown) => {} | null;
-export declare function formatSubfeatures(obj: SerializedFeat, depth: number, parse: (obj: Record<string, unknown>) => void, currentDepth?: number): void;

package/esm/BaseFeatureWidget/util.js

@@ -12,20 +12,3 @@ export function ellipses(slug) {
 export function getStrandStr(strand) {
     return strand === -1 ? '(-)' : strand === 1 ? '(+)' : '';
 }
-// JSON only serializes null, not undefined; feature fields are hidden by a
-// formatDetails callback returning undefined (jexl can't produce null), so when
-// persisting we round-trip undefined to null to keep the field hidden after
-// reload (detail components filter with `!= null`). see config guide.
-export const nullReplacer = (_, v) => v === undefined ? null : v;
-// `depth` is how many levels of subfeature the `formatDetails.subfeatures`
-// callback runs on, counted from the clicked feature. The caller resolves it
-// across the session and track tiers and passes 0 when neither declares one, so
-// a config with no formatDetails schema formats nothing rather than every level
-export function formatSubfeatures(obj, depth, parse, currentDepth = 0) {
-    if (currentDepth < depth) {
-        for (const sub of obj.subfeatures ?? []) {
-            formatSubfeatures(sub, depth, parse, currentDepth + 1);
-            parse(sub);
-        }
-    }
-}

package/esm/PluginLoader.d.ts

@@ -4,6 +4,9 @@ export interface PluginRecord {
     plugin: PluginConstructor;
     definition: PluginDefinition;
 }
+export type ReExportRegistryLoader = () => Promise<{
+    default: Record<string, unknown>;
+}>;
 export interface LoadedPlugin {
     default: PluginConstructor;
 }
@@ -27,19 +30,21 @@ export default class PluginLoader {
         default: PluginConstructor;
     }>;
     loadPlugin(def: PluginDefinition, baseUri?: string): Promise<PluginConstructor>;
-    private reExportTarget;
+    private reExports;
     /**
      * Ask for the runtime ABI (`JBrowseExports`) to be published on `target`
-     * before any plugin bundle is evaluated. Records the target; the registry
-     * itself is fetched in `loadSettled` below.
+     * before any plugin bundle is evaluated. Records the target and the loader;
+     * `loadSettled` fetches the registry, a ~126 KB gzipped module only a runtime
+     * plugin can use (see `ReExports/registry.ts` for why it cannot shrink).
      *
-     * The split is the point. Every product calls this at startup, synchronously,
-     * whether or not the config names a plugin — so importing the registry here
-     * put it in every host's first paint. It is a ~126 KB gzipped module (see
-     * `ReExports/registry.ts` for why it cannot shrink) that only a runtime plugin
-     * can use, and loading one is async anyway.
+     * `registry` is the product's generated map — `reExports.generated.ts` on
+     * the main thread, `workerReExports.generated.ts` in its worker — which
+     * serves every `@jbrowse` package the product bundles. The caller names it
+     * because the registry serves this module: an `import()` of it from here is
+     * a cycle rolldown keeps in any host bundling this file, whether or not
+     * anything loads a plugin (EAGER_BUNDLE.md §3).
      */
-    installGlobalReExports(target: WindowOrWorkerGlobalScope): this;
+    installGlobalReExports(target: WindowOrWorkerGlobalScope, registry: ReExportRegistryLoader): this;
     private publishReExports;
     /**
      * Loads every definition and separates the ones that worked from the ones