@jbrowse/core 5.0.0-beta.10 → 5.0.0-beta.13

package/esm/util/tracks.js

@@ -8,12 +8,16 @@ export { getFileName } from './getFileName.js';
 // it. `fetchContext.ts` takes it from mstUtils instead, which is what keeps the
 // configuration schemas this file pulls in out of the fetch harness's graph.
 export { getRpcSessionId } from './parentWalk.js';
+export { makeIndex } from './formatGuessers.js';
+export { isLooseTrackConfig, } from '@jbrowse/add-track-core';
+import { isLooseTrackConfig, } from '@jbrowse/add-track-core';
 import { asModelType, getParent, getSnapshot, getType, hasParent, isAlive, isStateTreeNode, } from '@jbrowse/mobx-state-tree';
 import { observable, runInAction, untracked } from 'mobx';
-import { readConfObject } from '../configuration/index.js';
+import { isConfigurationModel, readConfObject } from '../configuration/index.js';
 import { adapterConfigCacheKey } from '../data_adapters/dataAdapterCache.js';
 import { displayCandidates, displayTypesFedBy, } from '../pluggableElementTypes/models/baseTrackConfig.js';
 import { getFileHandle, storeFileHandle, verifyPermission, } from './fileHandleStore.js';
+import { makeIndex } from './formatGuessers.js';
 import { getFileName } from './getFileName.js';
 import { getContainingView, getEnv, getSession, objectHash, } from './mstUtils.js';
 import { isViewModel } from './types/index.js';
@@ -86,8 +90,14 @@ export function isSameAssemblyName(a, b, assemblyManager) {
  * copy a non-admin's edits would go to, ADR-032). `hasParent` is the guard:
  * without it the walk raises MST's "Failed to find the parent" from a helper
  * whose other two failure modes are a plain `undefined`.
+ *
+ * A frozen {@link TrackConfigEntry} omits a slot at its default, so one
+ * without `assemblyNames` names the slot's default, `[]`.
  */
 function confAssemblyNames(conf) {
+    if (!isConfigurationModel(conf)) {
+        return conf.assemblyNames ?? [];
+    }
     const trackAssemblyNames = readConfObject(conf, 'assemblyNames');
     if (trackAssemblyNames) {
         return trackAssemblyNames;
@@ -121,6 +131,13 @@ export function getConfAssemblyNames(conf) {
 export function getConfAssemblyNamesOrNone(conf) {
     return confAssemblyNames(conf) ?? [];
 }
+/**
+ * A track config as a frozen entry: `conf` itself, or a live node's snapshot.
+ * Either way a slot at its default is absent, so a read supplies the default.
+ */
+export function toTrackConfigEntry(conf) {
+    return isStateTreeNode(conf) ? getSnapshot(conf) : conf;
+}
 /**
  * The RPC session id a track's own requests go out under, from its config:
  * what `BaseTrackModel.rpcSessionId` computes, for a caller holding no model.
@@ -279,34 +296,6 @@ export function findFileHandleIds(obj) {
 export async function restoreFileHandlesFromSnapshot(sessionSnapshot, requestPermission = false) {
     return restoreFileHandles([...findFileHandleIds(sessionSnapshot)], requestPermission);
 }
-/**
- * creates a new location from the provided location including the appropriate
- * suffix and location type
- *
- * @param location - the FileLocation
- * @param suffix - the file suffix (e.g. .bam)
- * @returns the constructed location object from the provided parameters
- */
-export function makeIndex(location, suffix) {
-    if ('uri' in location) {
-        return {
-            uri: location.uri + suffix,
-            locationType: 'UriLocation',
-            // carry the parent's baseUri so a derived sibling index resolves against
-            // the same config location as the file it indexes
-            ...(location.baseUri ? { baseUri: location.baseUri } : {}),
-        };
-    }
-    else if ('localPath' in location) {
-        return {
-            localPath: location.localPath + suffix,
-            locationType: 'LocalPathLocation',
-        };
-    }
-    else {
-        return location;
-    }
-}
 /**
  * constructs a potential index file (with suffix) from the provided file name
  *
@@ -450,17 +439,6 @@ export function guessTrackConfForLocation(file, index, pluginManager, assemblyNa
         adapter,
     };
 }
-/**
- * Whether a track snapshot is the loose `{ uri, ... }` form — a data file with
- * no `adapter` — that {@link expandLooseTrackConfig} expands.
- */
-export function isLooseTrackConfig(snap) {
-    return (typeof snap === 'object' &&
-        snap !== null &&
-        !Array.isArray(snap) &&
-        typeof snap.uri === 'string' &&
-        !('adapter' in snap));
-}
 /**
  * Expand a loose track config into a full one and leave any other snapshot
  * untouched, so it can sit on every path a track snapshot enters the tree by:
@@ -498,21 +476,16 @@ export function generateUnknownTrackConf(trackName, trackUrl, categories) {
     return generateProblemTrackConf(trackName, categories, 'Unknown', `Could not determine track type for "${trackUrl}"`);
 }
 export function getTrackName(conf, session) {
-    const isMst = isStateTreeNode(conf);
-    const trackName = isMst
+    const trackName = isConfigurationModel(conf)
         ? readConfObject(conf, 'name')
         : (conf.name ?? '');
-    const trackType = isMst ? readConfObject(conf, 'type') : conf.type;
-    if (!trackName && trackType === 'ReferenceSequenceTrack') {
+    if (!trackName && conf.type === 'ReferenceSequenceTrack') {
         const asm = session.assemblies.find(a => a.sequence === conf);
         return asm
             ? `Reference sequence (${readConfObject(asm, 'displayName') || readConfObject(asm, 'name')})`
             : 'Reference sequence';
     }
-    const trackId = isMst
-        ? readConfObject(conf, 'trackId')
-        : (conf.trackId ?? '');
-    return trackName || trackId;
+    return trackName || (conf.trackId ?? '');
 }
 // The first-show path spreads the same settings into the display's `create()`
 // snapshot, so a DECLARED PROP (`resolution` on the wiggle displays) has
@@ -649,12 +622,11 @@ export function filterTracks(tracks, self) {
     const viewAssemblyNames = canonical(self.assemblyNames);
     const viewDisplays = viewDisplayNames(pluginManager, view.type);
     return tracks.filter(c => {
-        const trackAssemblyNames = readConfObject(c, 'assemblyNames');
         return (
         // a view that declares no assemblies (one still initializing) constrains
         // nothing; otherwise the track must cover every one of them
         (viewAssemblyNames.length === 0 ||
-            containsAll(trackAssemblyNames && canonical(trackAssemblyNames), viewAssemblyNames)) &&
+            containsAll(canonical(getConfAssemblyNamesOrNone(c)), viewAssemblyNames)) &&
             viewCanDisplayTrack(pluginManager, viewDisplays, {
                 type: c.type,
                 adapter: c.adapter,
@@ -740,6 +712,43 @@ export function normalizeTrackInit(t) {
         };
     }
 }
+/**
+ * The display a view of `viewType` opens `conf` as, chosen from the displays the
+ * track's adapter feeds and the view draws. `requested` is the display type a
+ * caller asks for; a name no display answers to leaves `picked` undefined.
+ * Aliases resolve first, so a caller or a config naming a pre-consolidation
+ * display type (`LinearPileupDisplay`) reaches the type that replaced it.
+ */
+function pickTrackDisplay(pluginManager, conf, viewTypeName, requested) {
+    const viewType = pluginManager.getViewType(viewTypeName);
+    const candidates = displayCandidates(pluginManager, conf);
+    const viewDisplayTypes = viewType.displayTypes.map(d => d.name);
+    const canonical = (name) => pluginManager.resolveDisplayTypeRecord(name)?.name ?? name;
+    const declaredDisplays = conf.displays ?? [];
+    const picked = pickDisplayForView({
+        candidates,
+        declaredDisplays: declaredDisplays.map(d => ({
+            ...d,
+            type: canonical(d.type),
+        })),
+        requestedType: requested === undefined ? undefined : canonical(requested),
+        viewDisplayTypes,
+        preferredDisplayTypes: new Set(viewType.displayTypes
+            .filter(d => d.viewType === viewTypeName)
+            .map(d => d.name)),
+    });
+    return { picked, candidates, viewDisplayTypes };
+}
+/**
+ * The display type a view of `viewType` opens the track `rawConf` as, the one
+ * `showTrack` picks, or undefined when the view draws none of the track's
+ * displays. For a caller that needs to know the display before the view exists,
+ * such as a CLI choosing which settings to write.
+ */
+export function trackDisplayType(pluginManager, rawConf, viewType, requested) {
+    const conf = pluginManager.evaluateExtensionPoint('Core-preProcessTrackConfig', structuredClone(rawConf));
+    return pickTrackDisplay(pluginManager, conf, viewType, requested).picked?.type;
+}
 function resolveTrackDisplayChoice(self, trackId, displayInitialSnapshot, inlineConf) {
     const { pluginManager } = getEnv(self);
     const session = getSession(self);
@@ -782,27 +791,8 @@ function resolveTrackDisplayChoice(self, trackId, displayInitialSnapshot, inline
     // display choice from the view it sits in, which is the same node
     // getContainingView already resolves to for everything else beneath it.
     const view = isViewModel(self) ? self : getContainingView(self);
-    const viewType = pluginManager.getViewType(view.type);
-    const candidates = displayCandidates(pluginManager, conf);
-    const viewDisplayTypes = viewType.displayTypes.map(d => d.name);
-    // Aliases resolve first, so a caller or a config naming a pre-consolidation
-    // display type (`LinearPileupDisplay`) reaches the type that replaced it; a
-    // name no display answers to stays as written, for the refusal to quote.
-    const canonical = (name) => pluginManager.resolveDisplayTypeRecord(name)?.name ?? name;
     const requested = displayInitialSnapshot.type;
-    const declaredDisplays = conf.displays ?? [];
-    const picked = pickDisplayForView({
-        candidates,
-        declaredDisplays: declaredDisplays.map(d => ({
-            ...d,
-            type: canonical(d.type),
-        })),
-        requestedType: requested === undefined ? undefined : canonical(requested),
-        viewDisplayTypes,
-        preferredDisplayTypes: new Set(viewType.displayTypes
-            .filter(d => d.viewType === view.type)
-            .map(d => d.name)),
-    });
+    const { picked, candidates, viewDisplayTypes } = pickTrackDisplay(pluginManager, conf, view.type, requested);
     if (!picked) {
         const drawable = candidates.filter(name => viewDisplayTypes.includes(name));
         throw new Error(requested === undefined
@@ -933,11 +923,9 @@ export function warmTrackDisplayGeneric(self, trackId, displayInitialSnapshot =
     const { pluginManager } = getEnv(self);
     try {
         const { picked } = resolveTrackDisplayChoice(self, trackId, displayInitialSnapshot);
-        pluginManager
-            .resolveDisplayTypeRecord(picked.type)
-            ?.loadStateModel()
-            .catch(() => { });
-        warmTrackAdapter(self, trackId, assemblyName);
+        const display = pluginManager.resolveDisplayTypeRecord(picked.type);
+        display?.loadStateModel().catch(() => { });
+        warmTrackAdapter(self, trackId, display?.rpcMethods ?? [], assemblyName);
     }
     catch {
         // the launch reports an unresolvable track
@@ -956,8 +944,8 @@ function adapterTypesIn(value, pluginManager, found = new Set()) {
     return found;
 }
 /**
- * Load the track's adapter code and read its index in the worker, beside the
- * assembly load the track's first request waits for.
+ * Load the track's adapter code and its display's RPC code, and read its index,
+ * in the worker, beside the assembly load the track's first request waits for.
  *
  * Sent under the id the track's own requests will use, so it reaches, and
  * boots, the worker that serves them. That id hashes the adapter config as the
@@ -977,7 +965,7 @@ function declaresLanes(adapterConfig, pluginManager) {
             .getAdapterType(type)
             .adapterCapabilities.includes('headerLanes'));
 }
-function warmTrackAdapter(self, trackId, assemblyName) {
+function warmTrackAdapter(self, trackId, rpcMethods, assemblyName) {
     const { pluginManager } = getEnv(self);
     const session = getSession(self);
     const raw = session.getTrackById(trackId);
@@ -993,8 +981,9 @@ function warmTrackAdapter(self, trackId, assemblyName) {
         const sessionId = getConfRpcSessionId(conf);
         session.rpcManager
             // eslint-disable-next-line no-restricted-syntax -- a code download the track's first request would make anyway: nothing to show, and nothing a user can move on from
-            .call(sessionId, 'CoreLoadAdapterCode', {
+            .call(sessionId, 'CoreLoadTrackCode', {
             adapterTypes: [...adapterTypesIn(adapterConfig, pluginManager)],
+            rpcMethods: [...rpcMethods],
         })
             .catch(() => { });
         // a source that declares its lanes reads an index per lane asked about,
@@ -1081,9 +1070,9 @@ export function allSessionTracks(session) {
  * range query.
  */
 export function annotationTrackIds(session, assemblyName) {
-    return allSessionTracks(session).flatMap(track => readConfObject(track, 'type') === 'FeatureTrack' &&
-        readConfObject(track, 'assemblyNames').some(name => isSameAssemblyName(name, assemblyName, session.assemblyManager))
-        ? [readConfObject(track, 'trackId')]
+    return allSessionTracks(session).flatMap(track => track.type === 'FeatureTrack' &&
+        getConfAssemblyNamesOrNone(track).some(name => isSameAssemblyName(name, assemblyName, session.assemblyManager))
+        ? [track.trackId]
         : []);
 }
 function isNavigableView(view) {

package/esm/util/types/index.d.ts

@@ -1,6 +1,6 @@
 import type { ViewSnapshotInput } from '../../PluginManager.ts';
 import type TextSearchManager from '../../TextSearch/TextSearchManager.ts';
-import type { AnyConfigurationModel } from '../../configuration/index.ts';
+import type { AnyConfigurationModel, AnyTrackConfig, TrackConfigEntry } from '../../configuration/index.ts';
 import type { BaseInternetAccountModel, BaseTrackConfig } from '../../pluggableElementTypes/models/index.ts';
 import type { PluginDefinition } from '../../pluginDefinitions.ts';
 import type RpcManager from '../../rpc/RpcManager.ts';
@@ -53,17 +53,17 @@ export type AnimationMode = 'system' | 'enabled' | 'disabled';
  * in `./services.ts`, which is the file that stays cheap to name.
  */
 export interface TrackCatalog {
-    tracks: AnyConfigurationModel[];
+    tracks: TrackConfigEntry[];
     assemblies: AnyConfigurationModel[];
     connectionInstances?: {
         tracks: AnyConfigurationModel[];
     }[];
-    getTrackById: (id: string) => AnyConfigurationModel | undefined;
+    getTrackById: (id: string) => AnyTrackConfig | undefined;
 }
 /** minimum interface that all session state models must implement */
 export interface AbstractSessionModel extends AbstractViewContainer, RenderingServices, NotificationSink, DialogHost, TrackCatalog {
     /** @deprecated prefer the per-id reactive `getTrackById(id)` */
-    getTracksById: () => Record<string, AnyConfigurationModel>;
+    getTracksById: () => Record<string, AnyTrackConfig>;
     jbrowse: IAnyStateTreeNode;
     drawerPosition?: DrawerPosition;
     stickyViewHeaders?: boolean;
@@ -112,8 +112,8 @@ export interface AbstractSessionModel extends AbstractViewContainer, RenderingSe
         config: BaseTrackConfig;
         view?: TrackActionView;
     }) => MenuItem[];
-    getTrackActions?: (arg: BaseTrackConfig, view?: TrackActionView) => MenuItem[];
-    getTrackListMenuItems?: (arg: BaseTrackConfig, view?: TrackActionView) => MenuItem[];
+    getTrackActions?: (arg: AnyTrackConfig, view?: TrackActionView) => MenuItem[];
+    getTrackListMenuItems?: (arg: AnyTrackConfig, view?: TrackActionView) => MenuItem[];
     addAssembly?: (conf: Record<string, unknown>) => void;
     addSessionAssembly?: (conf: Record<string, unknown>) => void;
     sessionAssemblies?: AnyConfigurationModel[];
@@ -184,6 +184,14 @@ export interface SessionWithEditableTrackConfig extends AbstractSessionModel {
     getEditableTrackConfig(trackId: string, schemaType: IAnyType): AnyConfigurationModel | undefined;
 }
 export declare function isSessionWithEditableTrackConfig(t: unknown): t is SessionWithEditableTrackConfig;
+/**
+ * The working copy `trackId` resolves to (ADR-032), through its track type's
+ * own schema, which is the one a shown track's `configuration` reference
+ * holds, so both reach one node. Re-resolves on every read: an undo or a
+ * session restore replaces the working copy. Undefined when the session keeps
+ * no working copies or nothing answers the id.
+ */
+export declare function getEditableTrackConfigById(session: unknown, trackId: string): AnyConfigurationModel | undefined;
 /**
  * abstract interface for a session that keeps a list of views, so that `addView`
  * appends and the view a launch came out of survives it.
@@ -304,7 +312,7 @@ export interface SessionWithAddAssembly extends AbstractSessionModel {
 export declare function isSessionWithAddAssembly(t: unknown): t is SessionWithAddAssembly;
 /** abstract interface for a session that allows deleting track configs */
 export interface SessionWithDeleteTrackConf extends AbstractSessionModel {
-    deleteTrackConf(configuration: AnyConfigurationModel): void;
+    deleteTrackConf(configuration: AnyTrackConfig): void;
 }
 export declare function isSessionWithDeleteTrackConf(t: unknown): t is SessionWithDeleteTrackConf;
 /** abstract interface for a session allows adding tracks */

package/esm/util/types/index.js

@@ -1,4 +1,4 @@
-import { isStateTreeNode } from '@jbrowse/mobx-state-tree';
+import { getEnv, isStateTreeNode } from '@jbrowse/mobx-state-tree';
 import { isSessionServices } from './services.js';
 export { isSessionServices } from './services.js';
 // The plain-data half of this file's former self, kept re-exported here so
@@ -24,6 +24,23 @@ export function isSessionWithBaseTrackConfig(t) {
 export function isSessionWithEditableTrackConfig(t) {
     return isSessionModel(t) && 'getEditableTrackConfig' in t;
 }
+/**
+ * The working copy `trackId` resolves to (ADR-032), through its track type's
+ * own schema, which is the one a shown track's `configuration` reference
+ * holds, so both reach one node. Re-resolves on every read: an undo or a
+ * session restore replaces the working copy. Undefined when the session keeps
+ * no working copies or nothing answers the id.
+ */
+export function getEditableTrackConfigById(session, trackId) {
+    if (!isSessionWithEditableTrackConfig(session)) {
+        return undefined;
+    }
+    const type = session.getTrackById(trackId)?.type;
+    const schema = typeof type === 'string'
+        ? getEnv(session).pluginManager.getTrackType(type).configSchema
+        : undefined;
+    return schema ? session.getEditableTrackConfig(trackId, schema) : undefined;
+}
 export function isSessionWithMultipleViews(t) {
     return isSessionModel(t) && isStateTreeNode(t.views);
 }
@@ -106,7 +123,9 @@ export function isSessionModelWithConnections(thing) {
     return isSessionModel(thing) && 'makeConnection' in thing;
 }
 export function isSessionModelWithConnectionEditing(thing) {
-    return isSessionModel(thing) && 'addConnectionConf' in thing;
+    return (isSessionModel(thing) &&
+        'addConnectionConf' in thing &&
+        !('disableAddTracks' in thing && thing.disableAddTracks));
 }
 export function isSessionWithSessionPlugins(thing) {
     return isSessionModel(thing) && 'sessionPlugins' in thing;

package/esm/util/unknownSnapshotKeys.d.ts

@@ -25,7 +25,9 @@ export declare function displaySetterName(key: string): string;
 export declare function setterOnlyMessage(label: string, keys: string[]): string;
 /**
  * Name the keys a view was handed and could not place, from the partition
- * `withLaunchInput` runs on the snapshot.
+ * `withLaunchInput` runs on the snapshot. The console alone, like
+ * `reportLegacyInit`: the view opened without them, and the keys are usually a
+ * v4 session's retired state that a visitor holding the link cannot act on.
  */
 export declare function reportUnknownKeys(self: IStateTreeNode, keys: string[]): void;
 /**

package/esm/util/unknownSnapshotKeys.js

@@ -28,19 +28,13 @@ export function setterOnlyMessage(label, keys) {
 }
 /**
  * Name the keys a view was handed and could not place, from the partition
- * `withLaunchInput` runs on the snapshot.
+ * `withLaunchInput` runs on the snapshot. The console alone, like
+ * `reportLegacyInit`: the view opened without them, and the keys are usually a
+ * v4 session's retired state that a visitor holding the link cannot act on.
  */
 export function reportUnknownKeys(self, keys) {
-    if (!keys.length) {
-        return;
-    }
-    const message = unknownKeysMessage(viewLabel(self), keys);
-    console.warn(message);
-    try {
-        getNotificationSink(self).notify(message, 'warning');
-    }
-    catch {
-        // a view built outside a session has nowhere to put it
+    if (keys.length) {
+        console.warn(unknownKeysMessage(viewLabel(self), keys));
     }
 }
 /**

package/esm/util/usePanZoom.js

@@ -113,6 +113,9 @@ export function usePanZoom(ref, view, { touchAction = 'none', } = {}) {
         };
     }, [ref, touchAction]);
     function endDrag(event) {
+        if (dragRef.current?.pointerId !== event.pointerId) {
+            return;
+        }
         dragRef.current = undefined;
         // release only what the move handler took — a press that stayed under the
         // threshold never captured anything
@@ -131,7 +134,7 @@ export function usePanZoom(ref, view, { touchAction = 'none', } = {}) {
                 // lands on an icon inside the control. Shift is left alone too: it is
                 // what a range-select of the host's own would want, and it is what
                 // JBrowse's own view uses it for.
-                if (event.button !== 0 || event.shiftKey) {
+                if (!event.isPrimary || event.button !== 0 || event.shiftKey) {
                     return;
                 }
                 if (event.target instanceof Element &&
@@ -139,11 +142,15 @@ export function usePanZoom(ref, view, { touchAction = 'none', } = {}) {
                     return;
                 }
                 // Note what this does *not* do: capture the pointer. See onPointerMove.
-                dragRef.current = { x: event.clientX, panning: false };
+                dragRef.current = {
+                    x: event.clientX,
+                    panning: false,
+                    pointerId: event.pointerId,
+                };
             },
             onPointerMove(event) {
                 const drag = dragRef.current;
-                if (!drag) {
+                if (!drag || drag.pointerId !== event.pointerId) {
                     return;
                 }
                 if (!drag.panning) {

package/esm/util/useRafCommit.js

@@ -18,6 +18,7 @@ export function useRafCommit(commit) {
         const pending = pendingRef.current;
         if (pending) {
             cancelAnimationFrame(pending.id);
+            pendingRef.current = undefined;
         }
     }, []);
     const schedule = useCallback((value) => {

package/esm/util/useRowVirtualScroll.d.ts

@@ -1,4 +1,5 @@
 import type { RowResizeTarget } from './applyRowResizeWheel.ts';
+export type { RowResizeTarget } from './applyRowResizeWheel.ts';
 /**
  * Wheel gestures over a **row-stack** panel — the multi-sample variant displays
  * and MAF: `shift`+wheel resizes the rows, keeping the row under the cursor

package/esm/util/withFeatureDetails.js

@@ -1,4 +1,5 @@
 import { isAlive } from '@jbrowse/mobx-state-tree';
+import { isAbortException } from './aborting.js';
 import { notifyFeatureDetailsMiss } from './openFeatureWidget.js';
 import { getNotificationSink } from './sessionServices.js';
 /**
@@ -48,6 +49,9 @@ export async function withFeatureDetails(self, fetch, onFeat, onMiss = () => {
         }
     }
     catch (e) {
+        if (isAbortException(e)) {
+            return;
+        }
         // Logged whatever happened, and only toasted while the display is still
         // there: `getSession` throws on a detached node, and a message naming a
         // track the user has already closed is noise they cannot act on.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jbrowse/core",
-  "version": "5.0.0-beta.10",
+  "version": "5.0.0-beta.13",
   "type": "module",
   "description": "JBrowse 2 core libraries used by plugins",
   "keywords": [
@@ -130,6 +130,7 @@
     "./ui/Snackbar": "./esm/ui/Snackbar.js",
     "./ui/SnackbarModel": "./esm/ui/SnackbarModel.js",
     "./ui/StackTraceButton": "./esm/ui/StackTraceButton.js",
+    "./ui/SubmitDialog": "./esm/ui/SubmitDialog.js",
     "./ui/SvgColorLegend": "./esm/ui/SvgColorLegend.js",
     "./ui/VerticalScrollbar": "./esm/ui/VerticalScrollbar.js",
     "./ui/buildExtraTrackMenuItems": "./esm/ui/buildExtraTrackMenuItems.js",
@@ -161,11 +162,13 @@
     "./util/adapterMetadata": "./esm/util/adapterMetadata.js",
     "./util/addRelativeUris": "./esm/util/addRelativeUris.js",
     "./util/aggregateFieldName": "./esm/util/aggregateFieldName.js",
+    "./util/alignedBytes": "./esm/util/alignedBytes.js",
     "./util/analytics": "./esm/util/analytics.js",
     "./util/animationAllowed": "./esm/util/animationAllowed.js",
     "./util/assemblyConfigUtils": "./esm/util/assemblyConfigUtils.js",
     "./util/bandHeight": "./esm/util/bandHeight.js",
     "./util/bandLayout": "./esm/util/bandLayout.js",
+    "./util/baseDisplayConfig": "./esm/util/baseDisplayConfig.js",
     "./util/bgzfWorkerPool": "./esm/util/bgzfWorkerPool.js",
     "./util/blockTypes": "./esm/util/blockTypes.js",
     "./util/cacheBudgets": "./esm/util/cacheBudgets.js",
@@ -216,6 +219,7 @@
     "./util/io/RemoteFileWithRangeCache": "./esm/util/io/RemoteFileWithRangeCache.js",
     "./util/isDataCurrent": "./esm/util/isDataCurrent.js",
     "./util/isTextEntryFocused": "./esm/util/isTextEntryFocused.js",
+    "./util/isoformRank": "./esm/util/isoformRank.js",
     "./util/jexl": "./esm/util/jexl.js",
     "./util/jexlFilters": "./esm/util/jexlFilters.js",
     "./util/jexlStrings": "./esm/util/jexlStrings.js",
@@ -297,12 +301,12 @@
     "@emotion/utils": "^1.4.2",
     "@floating-ui/react": "^0.27.20",
     "@gmod/bgzf-filehandle": "^6.7.0",
-    "@gmod/range-cache-filehandle": "^1.4.0",
+    "@gmod/range-cache-filehandle": "^1.5.0",
     "@gmod/shared-read-cache": "^1.7.2",
     "@gmod/vcf": "^7.2.0",
     "@jbrowse/jexl": "^6.0.0",
-    "@jbrowse/mobx-state-tree": "^6.6.1",
-    "@jbrowse/quick-lru": "^7.3.5",
+    "@jbrowse/mobx-state-tree": "^6.7.0",
+    "@jbrowse/quick-lru": "^8.0.0",
     "@leeoniya/ufuzzy": "^1.0.19",
     "@mui/icons-material": "^9.4.0",
     "@mui/material": "^9.4.0",
@@ -311,14 +315,14 @@
     "canvas-sequencer-ts": "^3.1.3",
     "compare-versions": "^6.1.1",
     "dompurify": "^3.4.16",
-    "generic-filehandle2": "^2.4.0",
+    "generic-filehandle2": "^2.5.0",
     "idb": "^8.0.3",
-    "mobx": "^7.0.5",
+    "mobx": "^7.0.6",
     "mobx-react": "^10.0.2",
     "rxjs": "^7.8.2",
-    "source-map-js": "^1.2.1",
-    "@jbrowse/add-track-core": "^5.0.0-beta.10",
-    "@jbrowse/render-core": "^5.0.0-beta.10"
+    "source-map-js": "^1.2.2",
+    "@jbrowse/add-track-core": "^5.0.0-beta.13",
+    "@jbrowse/render-core": "^5.0.0-beta.13"
   },
   "peerDependencies": {
     "react": ">=19.0.0",

package/esm/rpc/methods/CoreLoadAdapterCode.d.ts

@@ -1,13 +0,0 @@
-import RpcMethodType from '../../pluggableElementTypes/RpcMethodType.ts';
-import type { RpcExecuteArgs } from '../RpcRegistry.ts';
-/**
- * Load these adapter types' code in the worker a track is about to use. An
- * adapter's class arrives by dynamic import on the track's first request
- * otherwise, and that download waits for the view to lay out and the assembly
- * to load.
- */
-export default class CoreLoadAdapterCode extends RpcMethodType<'CoreLoadAdapterCode'> {
-    name: 'CoreLoadAdapterCode';
-    execute({ adapterTypes }: RpcExecuteArgs<'CoreLoadAdapterCode'>): Promise<void>;
-    serializeArguments(args: Record<string, unknown>): Promise<Record<string, unknown>>;
-}

package/esm/rpc/methods/CoreLoadAdapterCode.js

@@ -1,16 +0,0 @@
-import RpcMethodType from '../../pluggableElementTypes/RpcMethodType.js';
-/**
- * Load these adapter types' code in the worker a track is about to use. An
- * adapter's class arrives by dynamic import on the track's first request
- * otherwise, and that download waits for the view to lay out and the assembly
- * to load.
- */
-export default class CoreLoadAdapterCode extends RpcMethodType {
-    name = 'CoreLoadAdapterCode';
-    async execute({ adapterTypes }) {
-        await Promise.all(adapterTypes.map(type => this.pluginManager.getAdapterType(type).getAdapterClass()));
-    }
-    async serializeArguments(args) {
-        return args;
-    }
-}