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

package/esm/ReExports/modules.js

@@ -1,90 +1,13 @@
-import { alpha, createTheme, useTheme } from '@mui/material';
-import SvgIcon, { createSvgIcon } from '@mui/material/SvgIcon';
-import * as MUIUtils from '@mui/material/utils';
-import * as mxreact from 'mobx-react';
-import * as ReactDom from 'react-dom';
-import * as ReactDomClient from 'react-dom/client';
-import { cx, keyframes, makeStyles } from '../util/tss-react/index.js';
-import { BaseFeatureDetail } from './BaseFeatureDetails.js';
-import { DataGridEntries } from './MuiDataGridReExports.js';
-import { Entries } from './MuiReExports.js';
-import { MUIStyles } from './MuiStylesReExports.js';
-import { lazyMap } from './lazify.js';
-import * as coreUi from './publicUi.js';
-import { sharedModules } from './sharedModules.js';
-function makeLegacyMakeStyles() {
-    return (args) => {
-        const useStyles = makeStyles()(args);
-        return () => useStyles().classes;
-    };
-}
-const tssReact = { cx, keyframes, makeStyles };
-const legacyMakeStyles = makeLegacyMakeStyles();
-const materialUiCoreLib = {
-    ...lazyMap(Entries),
-    useTheme,
-    alpha,
-    makeStyles: legacyMakeStyles,
-};
-const muiMaterialLib = {
-    ...lazyMap(Entries),
-    alpha,
-    useTheme,
-    createTheme,
-};
-const materialUiLabLib = {
-    Alert: Entries.Alert,
-    Autocomplete: Entries.Autocomplete,
-    ToggleButton: Entries.ToggleButton,
-    ToggleButtonGroup: Entries.ToggleButtonGroup,
-};
-const muiStylesLib = { ...MUIStyles, makeStyles: legacyMakeStyles };
+// The runtime plugin ABI @jbrowse/core alone can serve, on the main thread: the
+// framework singletons and Material UI from frameworkModules.ts, and every
+// subpath core's exports map publishes from the generated half. A product
+// spreads this under the packages it bundles beyond core — see each
+// product's reExports.generated.ts, and scripts/generateReExports.ts for how
+// both halves and list.ts are derived.
+import coreModules from './coreModules.generated.js';
+import frameworkModules from './frameworkModules.js';
 const libs = {
-    ...sharedModules,
-    'mobx-react': mxreact,
-    'react-dom': ReactDom,
-    'react-dom/client': ReactDomClient,
-    // Only lazy component entries are re-exported. The grid *hooks*
-    // (useGridApiContext/useGridApiRef/useGridRootProps) are intentionally left
-    // out: statically importing them here pulled the entire ~1.2 MB
-    // @mui/x-data-grid package into the eager first-paint graph, defeating the
-    // lazy import('@mui/x-data-grid') in MuiDataGridReExports. First-party code
-    // that needs the hooks imports them directly from '@mui/x-data-grid'.
-    '@mui/x-data-grid': {
-        ...lazyMap(DataGridEntries),
-    },
-    '@mui/material/utils': MUIUtils,
-    '@material-ui/core/utils': MUIUtils,
-    'tss-react': tssReact,
-    'tss-react/mui': tssReact,
-    '@material-ui/core': materialUiCoreLib,
-    '@mui/material': muiMaterialLib,
-    ...lazyMap(Entries, '@mui/material/'),
-    ...lazyMap(Entries, '@material-ui/core/'),
-    // @mui/icons-material — bundled into external plugins — reads the
-    // `createSvgIcon` *named* export from @mui/material/SvgIcon, but lazyMap
-    // exposes only the component (its default). SvgIcon is a primitive that's
-    // eagerly loaded in practice, so expose it directly with createSvgIcon
-    // attached: a default import still lands on a usable component (rollup-plugin-
-    // external-globals substitutes the value itself, esbuild's globalExternals
-    // reads `.default`), while the named import and icons-material's CJS
-    // `require(...).createSvgIcon` both find the util. A shallow copy carries the
-    // forwardRef's $$typeof/render so the shared SvgIcon export isn't mutated.
-    // Overrides the lazy entry above; verified against both bundlers.
-    // GMOD/jbrowse-components#5606.
-    '@mui/material/SvgIcon': Object.assign({}, SvgIcon, { createSvgIcon }),
-    '@mui/material/styles': muiStylesLib,
-    '@material-ui/core/styles': muiStylesLib,
-    // these are core in @mui/material, but used to be in @material-ui/lab
-    '@material-ui/lab/ToggleButton': Entries.ToggleButton,
-    '@material-ui/lab/ToggleButtonGroup': Entries.ToggleButtonGroup,
-    '@material-ui/lab/Autocomplete': Entries.Autocomplete,
-    '@material-ui/lab/Alert': Entries.Alert,
-    '@material-ui/lab': materialUiLabLib,
-    '@jbrowse/core/ui': coreUi,
-    // the same lazy component publicUi.tsx puts on the namespace; published
-    // react-msaview deep-imports this path, apollo reads the namespace
-    '@jbrowse/core/ui/BaseTooltip': coreUi.BaseTooltip,
-    '@jbrowse/core/BaseFeatureWidget/BaseFeatureDetail': BaseFeatureDetail,
+    ...frameworkModules,
+    ...coreModules,
 };
 export default libs;

package/esm/ReExports/registry.d.ts

@@ -1,2 +1,3 @@
 export declare function setReExportRegistry(libs: Record<string, unknown>): void;
 export declare function getReExportRegistry(): Record<string, unknown>;
+export declare function loudOnMissingModule(libs: Record<string, unknown>): Record<string, unknown>;

package/esm/ReExports/registry.js

@@ -3,11 +3,11 @@
  * a runtime plugin.
  *
  * `ReExports/modules.ts` is the ABI external plugins link against, and it
- * reaches it by spreading `import * as` namespaces of `@jbrowse/core/ui`,
- * `configuration`, `util` and a dozen more into one object. A namespace spread
- * *names every export*, so nothing downstream of those barrels can be
- * tree-shaken — and the module also throws at top level if `libs` and `list.ts`
- * disagree, so it cannot be dropped either. `PluginManager` used to import it
+ * reaches it by spreading `import * as` namespaces of every subpath core
+ * publishes into one object, as each product's `reExports.generated.ts` does
+ * for every package it bundles. A namespace spread *names every export*, so
+ * nothing downstream of those modules can be tree-shaken. `PluginManager` used
+ * to import it
  * statically for `jbrequire`, which put the whole surface — most of
  * `@jbrowse/core/ui` and, behind it, ~400 KB of Material UI — into the eager
  * first-paint graph of **every** host, including embedded ones that load no
@@ -26,3 +26,21 @@ export function setReExportRegistry(libs) {
 export function getReExportRegistry() {
     return registry;
 }
+// A bundle built against another @jbrowse/core, or against a package this host
+// does not bundle, reads a key the map lacks — at module scope, so what it then
+// throws is `Cannot read properties of undefined` with no module named. A
+// plugin's own build tool only ever externalizes a key `ReExports/list.ts`
+// names, so every scoped-or-slashed read that misses is that case, and this
+// names it. Anything else missing reads `undefined` as it always did.
+export function loudOnMissingModule(libs) {
+    return new Proxy(libs, {
+        get(target, key, receiver) {
+            if (typeof key === 'string' &&
+                !(key in target) &&
+                (key.startsWith('@') || key.includes('/'))) {
+                throw new Error(`This JBrowse does not serve '${key}' to plugins: the plugin was built against an older or newer @jbrowse/core, or against a package this host does not bundle`);
+            }
+            return Reflect.get(target, key, receiver);
+        },
+    });
+}

package/esm/ReExports/uiStub.d.ts

@@ -1,2 +1,3 @@
 export declare const uiStub: unknown;
-export declare function uiNamespace(names: readonly string[]): Record<string, unknown>;
+export declare function uiNamespace(names: readonly string[], esModule?: boolean): Record<string, unknown>;
+export declare const REACT_INTERNAL_KEYS: Set<string>;

package/esm/ReExports/uiStub.js

@@ -6,6 +6,28 @@ export const uiStub = new Proxy(function stubTarget() { }, {
     apply: () => uiStub,
     construct: () => uiStub,
 });
-export function uiNamespace(names) {
-    return Object.fromEntries(names.map(name => [name, uiStub]));
+// `esModule` mirrors the `__esModule` the main thread sets on a namespace that
+// carries a default export beside named ones, so a bundler's interop reads the
+// stub's `default` the same way in both realms.
+export function uiNamespace(names, esModule = false) {
+    return {
+        ...(esModule ? { __esModule: true } : {}),
+        ...Object.fromEntries(names.map(name => [name, uiStub])),
+    };
 }
+// Own keys React puts on a component object, which are not export names and
+// so do not survive into a stub or the manifest.
+export const REACT_INTERNAL_KEYS = new Set([
+    '$$typeof',
+    '_debugInfo',
+    '_init',
+    '_payload',
+    'compare',
+    'contextTypes',
+    'defaultProps',
+    'displayName',
+    'muiName',
+    'propTypes',
+    'render',
+    'type',
+]);

package/esm/ReExports/workerModules.js

@@ -1,15 +1,11 @@
-import reExportsList from './list.js';
-import { sharedModules } from './sharedModules.js';
-import { uiNamespace, uiStub } from './uiStub.js';
-import { WORKER_NAMESPACE_NAMES } from './workerNamespaceNames.js';
-// Same keys as modules.ts; UI entries stubbed. agent-docs/reference/EAGER_BUNDLE.md
+// Same keys as modules.ts, as the RPC worker serves them: a module a plugin
+// reads only to render is a stub carrying the main thread's export names, so
+// the one bundle a plugin ships evaluates in both realms without the worker
+// fetching the UI graph. agent-docs/reference/EAGER_BUNDLE.md
+import coreWorkerModules from './coreWorkerModules.generated.js';
+import frameworkWorkerModules from './frameworkWorkerModules.generated.js';
 const libs = {
-    ...Object.fromEntries(reExportsList.map(name => [
-        name,
-        name in WORKER_NAMESPACE_NAMES
-            ? uiNamespace(WORKER_NAMESPACE_NAMES[name])
-            : uiStub,
-    ])),
-    ...sharedModules,
+    ...frameworkWorkerModules,
+    ...coreWorkerModules,
 };
 export default libs;

package/esm/TextSearch/TextSearchManager.d.ts

@@ -9,18 +9,9 @@ export default class TextSearchManager {
     constructor(pluginManager: PluginManager);
     clearCache(): void;
     loadTextSearchAdapters(assemblyName: string): Promise<BaseTextSearchAdapter[]>;
-    relevantAdapters(assemblyName: string): (import("@jbrowse/mobx-state-tree").ModelInstanceTypeProps<Record<string, any>> & {
-        setSubschema(slotName: string, data: Record<string, unknown>): any;
-        setSlot(slotName: string, value: unknown): void;
-    } & import("@jbrowse/mobx-state-tree").IStateTreeNode<import("../configuration/types.ts").AnyConfigurationSchemaType>)[];
-    getAdaptersWithAssembly(matches: (names: string[] | undefined) => boolean, confs: AnyConfigurationModel[]): (import("@jbrowse/mobx-state-tree").ModelInstanceTypeProps<Record<string, any>> & {
-        setSubschema(slotName: string, data: Record<string, unknown>): any;
-        setSlot(slotName: string, value: unknown): void;
-    } & import("@jbrowse/mobx-state-tree").IStateTreeNode<import("../configuration/types.ts").AnyConfigurationSchemaType>)[];
-    getTrackAdaptersWithAssembly(matches: (names: string[] | undefined) => boolean, confs: AnyConfigurationModel[]): (import("@jbrowse/mobx-state-tree").ModelInstanceTypeProps<Record<string, any>> & {
-        setSubschema(slotName: string, data: Record<string, unknown>): any;
-        setSlot(slotName: string, value: unknown): void;
-    } & import("@jbrowse/mobx-state-tree").IStateTreeNode<import("../configuration/types.ts").AnyConfigurationSchemaType>)[];
+    relevantAdapters(assemblyName: string): AnyConfigurationModel[];
+    getAdaptersWithAssembly(matches: (names: string[] | undefined) => boolean, confs: AnyConfigurationModel[]): AnyConfigurationModel[];
+    getTrackAdaptersWithAssembly(matches: (names: string[] | undefined) => boolean, confs: AnyConfigurationModel[]): AnyConfigurationModel[];
     search(args: BaseTextSearchArgs, assemblyName: string): Promise<BaseResult[]>;
     sortResults({ results, args, }: {
         results: BaseResult[];

package/esm/TextSearch/TextSearchManager.js

@@ -1,7 +1,7 @@
-import { readConfObject } from '../configuration/index.js';
+import { isStateTreeNode } from '@jbrowse/mobx-state-tree';
+import { hydrateTrackConfig, readConfObject } from '../configuration/index.js';
 import QuickLRU from '../util/QuickLRU/index.js';
-import { isAbortException } from '../util/aborting.js';
-import { checkStopToken } from '../util/stopToken.js';
+import { checkAbortSignal, isAbortException } from '../util/aborting.js';
 import { canonicalAssemblyNames } from '../util/tracks.js';
 // A misconfigured or unreachable index (a 404 .ix, a config missing
 // ixFilePath) must not take down search as a whole: the remaining indexes, and
@@ -75,12 +75,24 @@ export default class TextSearchManager {
     }
     getTrackAdaptersWithAssembly(matches, confs) {
         return confs
-            .filter(conf => matches(readConfObject(conf, [
-            'textSearching',
-            'textSearchAdapter',
-            'assemblyNames',
-        ])))
-            .map(conf => conf.textSearching.textSearchAdapter);
+            .filter(conf => {
+            const indexNames = readConfObject(conf, [
+                'textSearching',
+                'textSearchAdapter',
+                'assemblyNames',
+            ]);
+            return (!!readConfObject(conf, ['textSearching', 'textSearchAdapter']) &&
+                matches(indexNames?.length
+                    ? indexNames
+                    : readConfObject(conf, 'assemblyNames')));
+        })
+            .map(conf => {
+            const live = isStateTreeNode(conf)
+                ? conf
+                : hydrateTrackConfig(this.pluginManager, conf);
+            return live?.textSearching.textSearchAdapter;
+        })
+            .filter(conf => conf !== undefined);
     }
     async search(args, assemblyName) {
         const adapters = await this.loadTextSearchAdapters(assemblyName);
@@ -91,7 +103,7 @@ export default class TextSearchManager {
         // deliberately drops a failing adapter and carries on, so an abort thrown
         // by one of them would otherwise still land here as "no results from that
         // index" and rank the rest
-        checkStopToken(args.stopToken);
+        checkAbortSignal(args.signal);
         return await this.sortResults({ args, results: results.flat() });
     }
     // Ranks, never filters: the adapters have already decided what matches, and

package/esm/assemblyManager/assembly.d.ts

@@ -316,21 +316,17 @@ export default function assemblyFactory(assemblyConfigType: IAnyType, pluginMana
      *
      * The load reports progress (the adapter's index download, or for an
      * in-memory adapter the whole file) through the `statusCallback` of
-     * whichever caller started it. The others await it silently, and that is
-     * deliberate rather than a gap worth plumbing around: the callers sharing
-     * an entry are almost always the N displayed regions of ONE display, so
-     * their callbacks all write into that display's aggregated status bar and
-     * the first one is already reporting on behalf of the rest. The costs of
-     * getting this "right" — a listener set per key, registration, and
-     * deregistration on settle — buy visibility only for a second display on
-     * the same file, and for a first caller torn down mid-load, which is a
-     * no-op rather than a hazard because the callbacks are `isAlive`-guarded
-     * at the display end.
+     * whichever caller started it. The other callers get no progress
+     * updates. The callers sharing an entry are almost always the N
+     * displayed regions of one display, so their callbacks all write into
+     * that display's aggregated status bar, where the first caller already
+     * reports for the rest. A listener set per key, with registration and
+     * deregistration on settle, would add progress only for a second display
+     * on the same file and for a first caller torn down mid-load. The latter
+     * is a no-op because the display guards its callbacks with `isAlive`.
      *
-     * If that ever stops being enough, the fix is not a subscription list
-     * bolted on here: it is for the assembly to hold the in-flight status as
-     * observable state that consumers read, which is what this model is
-     * already made of.
+     * If per-caller progress is ever needed, the assembly should hold the
+     * in-flight status as observable state that consumers read.
      */
     getRefNameMapForAdapter(adapterConf: AdapterConf, options: BaseOptions): Promise<RefNameAliases>;
     /**

package/esm/assemblyManager/assembly.js

@@ -569,21 +569,17 @@ export default function assemblyFactory(assemblyConfigType, pluginManager) {
          *
          * The load reports progress (the adapter's index download, or for an
          * in-memory adapter the whole file) through the `statusCallback` of
-         * whichever caller started it. The others await it silently, and that is
-         * deliberate rather than a gap worth plumbing around: the callers sharing
-         * an entry are almost always the N displayed regions of ONE display, so
-         * their callbacks all write into that display's aggregated status bar and
-         * the first one is already reporting on behalf of the rest. The costs of
-         * getting this "right" — a listener set per key, registration, and
-         * deregistration on settle — buy visibility only for a second display on
-         * the same file, and for a first caller torn down mid-load, which is a
-         * no-op rather than a hazard because the callbacks are `isAlive`-guarded
-         * at the display end.
+         * whichever caller started it. The other callers get no progress
+         * updates. The callers sharing an entry are almost always the N
+         * displayed regions of one display, so their callbacks all write into
+         * that display's aggregated status bar, where the first caller already
+         * reports for the rest. A listener set per key, with registration and
+         * deregistration on settle, would add progress only for a second display
+         * on the same file and for a first caller torn down mid-load. The latter
+         * is a no-op because the display guards its callbacks with `isAlive`.
          *
-         * If that ever stops being enough, the fix is not a subscription list
-         * bolted on here: it is for the assembly to hold the in-flight status as
-         * observable state that consumers read, which is what this model is
-         * already made of.
+         * If per-caller progress is ever needed, the assembly should hold the
+         * in-flight status as observable state that consumers read.
          */
         getRefNameMapForAdapter(adapterConf, options) {
             if (!options.sessionId) {

package/esm/assemblyManager/assemblyConfigSchema.d.ts

@@ -100,102 +100,44 @@ export { expandAssemblySequenceAdapter, expandAssemblyShorthand, } from './expan
  * ```
  */
 declare function assemblyConfigSchema(pluginManager: PluginManager): import("../configuration/configurationSchema.ts").ConfigurationSchemaType<{
-    /**
-     * #slot
-     * aliases are "reference name aliases" e.g. aliases for hg38 might be
-     * "GRCh38"
-     */
     readonly aliases: {
-        readonly type: "stringArray";
-        readonly defaultValue: readonly [];
-        readonly description: "Other possible names for the assembly";
+        type: "stringArray";
+    } & {
+        defaultValue: unknown;
     };
-    /**
-     * #slot
-     * sequence refers to a reference sequence track that has an adapter
-     * containing, importantly, a sequence adapter such as
-     * IndexedFastaAdapter
-     */
     readonly sequence: import("../configuration/types.ts").AnyConfigurationSchemaType;
-    /**
-     * #slot
-     */
     readonly refNameColors: {
-        readonly type: "stringArray";
-        readonly defaultValue: readonly [];
-        readonly description: "Define custom colors for each reference sequence. Will cycle through this list if there are not enough colors for every sequence.";
+        type: "stringArray";
+    } & {
+        defaultValue: unknown;
     };
-    /**
-     * #slot
-     * Maps a reference sequence name to an NCBI genetic-code (translation
-     * table) id for sequences that don't use the standard code, e.g.
-     * `{ "chrM": 2 }` for the vertebrate mitochondrial code or
-     * `{ "chrPltd": 11 }` for a plastid. Drives the reference sequence track's
-     * translation rows; unlisted refNames use the standard code (1). CDS-level
-     * translation reads the GFF `transl_table` attribute directly and ignores
-     * this.
-     *
-     * #example
-     * Mitochondrial contig translated with the vertebrate mitochondrial code
-     * (NCBI table 2), a plastid contig with table 11; keys are matched through
-     * refName aliasing:
-     * ```js
-     * { chrM: 2, chrPltd: 11 }
-     * ```
-     */
     readonly geneticCodes: {
-        readonly type: "frozen";
-        readonly defaultValue: {};
-        readonly description: "Map of reference sequence name to NCBI genetic-code (translation table) id for sequences not using the standard code, e.g. { \"chrM\": 2 }";
+        type: "frozen";
+    } & {
+        defaultValue: unknown;
     };
-    /**
-     * #slot
-     * Optional file (tab-separated `refName<TAB>geneticCodeId`, `#` comments
-     * allowed) to load the same refName-to-genetic-code mapping from, instead
-     * of inlining it — useful when a config generator emits a sidecar rather
-     * than inlining per assembly. Entries in the inline `geneticCodes` slot
-     * take precedence over the file.
-     *
-     * #example
-     * The TSV is `refName<TAB>geneticCodeId` with optional `#` comment lines:
-     * ```js
-     * { uri: 'https://example.com/hg38.genetic_codes.tsv' }
-     * ```
-     */
     readonly geneticCodesLocation: {
-        readonly type: "fileLocation";
-        readonly defaultValue: {
-            readonly uri: "";
-            readonly locationType: "UriLocation";
-        };
-        readonly description: "Optional TSV file of refName<TAB>geneticCodeId, an alternative to inlining the geneticCodes map";
+        type: "fileLocation";
+    } & {
+        defaultValue: unknown;
     };
     readonly refNameAliases: import("../configuration/configurationSchema.ts").ConfigurationSchemaType<{
-        /**
-         * #slot refNameAliases.adapter
-         * refNameAliases help resolve e.g. chr1 and 1 as the same entity the
-         * data for refNameAliases are fetched from an adapter, that is
-         * commonly a tsv like chromAliases.txt from UCSC or similar
-         */
         readonly adapter: import("@jbrowse/mobx-state-tree").IAnyType;
-    }, import("../configuration/configurationSchema.ts").ConfigurationSchemaOptions<undefined, undefined>>;
+    }, import("../configuration/configurationSchema.ts").ConfigurationSchemaOptions<undefined, undefined, undefined, import("../configuration/requirements.ts").ConfigurationSchemaRequirement<Partial<Record<string, string[]>>, string>>>;
     readonly cytobands: import("../configuration/configurationSchema.ts").ConfigurationSchemaType<{
-        /**
-         * #slot cytobands.adapter
-         * cytoband data is fetched from an adapter, and can be displayed by
-         * a view type as ideograms
-         */
         readonly adapter: import("@jbrowse/mobx-state-tree").IAnyType;
-    }, import("../configuration/configurationSchema.ts").ConfigurationSchemaOptions<undefined, undefined>>;
-    /**
-     * #slot
-     */
+    }, import("../configuration/configurationSchema.ts").ConfigurationSchemaOptions<undefined, undefined, undefined, import("../configuration/requirements.ts").ConfigurationSchemaRequirement<Partial<Record<string, string[]>>, string>>>;
     readonly displayName: {
-        readonly type: "string";
-        readonly defaultValue: "";
-        readonly description: "A human readable display name for the assembly e.g. \"Homo sapiens (hg38)\" while the assembly name may just be \"hg38\"";
+        type: "string";
+    } & {
+        defaultValue: string;
     };
-}, import("../configuration/configurationSchema.ts").ConfigurationSchemaOptions<undefined, "name">>;
+    name: {
+        type: "string";
+    } & {
+        defaultValue: string;
+    };
+}, import("../configuration/configurationSchema.ts").ConfigurationSchemaOptions<undefined, "name", undefined, import("../configuration/requirements.ts").ConfigurationSchemaRequirement<Partial<Record<string, string[]>>, string>>>;
 export default assemblyConfigSchema;
 /** the assembly config schema IType (use with `getConf`, `ConfigurationReference`, etc.) */
 export type BaseAssemblyConfigSchema = ReturnType<typeof assemblyConfigSchema>;

package/esm/assemblyManager/assemblyManager.d.ts

@@ -1,12 +1,12 @@
 import type PluginManager from '../PluginManager.ts';
+import type { AnyConfigurationModel } from '../configuration/index.ts';
 import type RpcManager from '../rpc/RpcManager.ts';
 import type { StatusCallback } from '../util/progress.ts';
-import type { StopToken } from '../util/stopToken.ts';
 import type { Assembly } from './assembly.ts';
 import type { IAnyType } from '@jbrowse/mobx-state-tree';
 type AdapterConf = Record<string, unknown>;
 export interface AssemblyBaseOpts {
-    stopToken?: StopToken;
+    signal?: AbortSignal;
     sessionId: string;
     statusCallback?: StatusCallback;
 }
@@ -578,10 +578,7 @@ declare function assemblyManagerFactory(conf: IAnyType, pm: PluginManager): impo
      * combined jbrowse.assemblies, session.sessionAssemblies, and
      * session.temporaryAssemblies
      */
-    readonly assemblyList: (import("@jbrowse/mobx-state-tree").ModelInstanceTypeProps<Record<string, any>> & {
-        setSubschema(slotName: string, data: Record<string, unknown>): any;
-        setSlot(slotName: string, value: unknown): void;
-    } & import("@jbrowse/mobx-state-tree").IStateTreeNode<import("../configuration/types.ts").AnyConfigurationSchemaType>)[];
+    readonly assemblyList: AnyConfigurationModel[];
     readonly rpcManager: RpcManager;
 } & {
     /**
@@ -753,18 +750,15 @@ declare function assemblyManagerFactory(conf: IAnyType, pm: PluginManager): impo
      * {@link waitForAssembly}, but a name that cannot be resolved is an error
      * rather than an `undefined` for the caller to interpret.
      *
-     * For callers whose result is silently *wrong* without the assembly, not
-     * merely absent: a refName map is the obvious one, since an empty map
-     * means an adapter gets queried with un-renamed refNames, finds nothing,
-     * and the track draws blank with nothing to say why. Failing here instead
-     * puts the name in front of the user, who is the only one who can add the
+     * Use it where a missing assembly produces a wrong result with no error.
+     * A refName map is one case: an empty map means an adapter gets queried
+     * with un-renamed refNames, finds nothing, and the track draws blank.
+     * Throwing here shows the assembly name to the user, who can add the
      * assembly or fix the track.
      *
-     * Worth using only because the wait is causal now. It used to give up
-     * after a fixed ten seconds, where "not resolved" could equally mean "not
-     * resolved yet" and throwing would have been a race; today it returns
-     * only once every handler and connection that could supply the name has
-     * finished, so there is a real answer to report.
+     * `waitForAssembly` returns only once every handler and connection that
+     * could supply the name has finished, so an unresolved name here is
+     * final and throwing does not race a late load.
      */
     requireAssembly(assemblyName: string): Promise<import("@jbrowse/mobx-state-tree").ModelInstanceTypeProps<{
         configuration: import("@jbrowse/mobx-state-tree").IMaybe<import("@jbrowse/mobx-state-tree").IReferenceType<IAnyType>>;

package/esm/assemblyManager/assemblyManager.js

@@ -343,18 +343,15 @@ function assemblyManagerFactory(conf, pm) {
          * {@link waitForAssembly}, but a name that cannot be resolved is an error
          * rather than an `undefined` for the caller to interpret.
          *
-         * For callers whose result is silently *wrong* without the assembly, not
-         * merely absent: a refName map is the obvious one, since an empty map
-         * means an adapter gets queried with un-renamed refNames, finds nothing,
-         * and the track draws blank with nothing to say why. Failing here instead
-         * puts the name in front of the user, who is the only one who can add the
+         * Use it where a missing assembly produces a wrong result with no error.
+         * A refName map is one case: an empty map means an adapter gets queried
+         * with un-renamed refNames, finds nothing, and the track draws blank.
+         * Throwing here shows the assembly name to the user, who can add the
          * assembly or fix the track.
          *
-         * Worth using only because the wait is causal now. It used to give up
-         * after a fixed ten seconds, where "not resolved" could equally mean "not
-         * resolved yet" and throwing would have been a race; today it returns
-         * only once every handler and connection that could supply the name has
-         * finished, so there is a real answer to report.
+         * `waitForAssembly` returns only once every handler and connection that
+         * could supply the name has finished, so an unresolved name here is
+         * final and throwing does not race a late load.
          */
         async requireAssembly(assemblyName) {
             const assembly = await this.waitForAssembly(assemblyName);

package/esm/assemblyManager/loadRefNameMap.js

@@ -27,10 +27,10 @@ export async function loadRefNameMap(assembly, adapterConfig, options) {
         adapterConfig: adapterConfig,
         assemblyName: assembly.name,
         sequenceAdapter,
-        // stopToken intentionally not passed, fixes issues like #2221.
+        // signal intentionally not passed, fixes issues like #2221.
         // alternative fix #2540 was proposed but non-working currently
-        stopToken: undefined,
-        // Forwarded rather than dropped (unlike stopToken above), because the
+        signal: undefined,
+        // Forwarded rather than dropped (unlike signal above), because the
         // adapter's index download happens here during refname mapping
         // (getRefNames -> setup) and this is the only place its "Downloading
         // index" progress can surface. For an in-memory adapter it is not an