@jbrowse/core 5.0.0-beta.11 → 5.0.0-beta.14

package/esm/util/temporaryAssembly.js

@@ -1,4 +1,4 @@
-import { readConfObject } from '../configuration/index.js';
+import { getConfAssemblyNamesOrNone } from './tracks.js';
 /**
  * Whether a track config names an assembly the session holds as **temporary** —
  * the read-vs-ref pair a comparative view synthesizes, which goes away when that
@@ -24,6 +24,5 @@ export function namesTemporaryAssembly(session, trackConf) {
     if (!temporary?.length) {
         return false;
     }
-    const names = readConfObject(trackConf, 'assemblyNames');
-    return !!names?.some(name => temporary.some(a => a.name === name));
+    return getConfAssemblyNamesOrNone(trackConf).some(name => temporary.some(a => a.name === name));
 }

package/esm/util/thresholdScale.d.ts

@@ -27,7 +27,7 @@ export declare function thresholdCuts(domain: readonly (string | number)[]): num
 export declare function thresholdIndex(value: unknown, domain: readonly number[]): number;
 /**
  * #api
- * The colour of each interval, in order: the declared palette, and the
+ * The color of each interval, in order: the declared palette, and the
  * default categorical palette where it runs out.
  */
 export declare function thresholdPalette(bins: number, palette?: readonly string[]): string[];

package/esm/util/thresholdScale.js

@@ -46,7 +46,7 @@ export function thresholdIndex(value, domain) {
 }
 /**
  * #api
- * The colour of each interval, in order: the declared palette, and the
+ * The color of each interval, in order: the declared palette, and the
  * default categorical palette where it runs out.
  */
 export function thresholdPalette(bins, palette = []) {

package/esm/util/trackConfigDelta.d.ts

@@ -53,7 +53,7 @@ export declare function diffTrackConfig(base: Record<string, unknown>, edited: R
  * longer has is dropped, so no `null` member reaches the config a track
  * hydrates from.
  */
-export declare function mergeTrackConfig(base: Record<string, unknown>, delta: Record<string, unknown>): Record<string, unknown>;
+export declare function mergeTrackConfig<BASE extends Record<string, unknown>>(base: BASE, delta: Record<string, unknown>): BASE;
 /**
  * A single overridden slot: the dotted `path`, its base `from` and edited `to`,
  * which is `undefined` for a reset.

package/esm/util/tracks.d.ts

@@ -4,7 +4,7 @@ export { makeIndex } from './formatGuessers.ts';
 export { isLooseTrackConfig, type LooseTrackInput, } from '@jbrowse/add-track-core';
 import { type LooseTrackInput } from '@jbrowse/add-track-core';
 import type PluginManager from '../PluginManager.ts';
-import type { AnyConfigurationModel } from '../configuration/index.ts';
+import type { AnyConfiguration, AnyConfigurationModel, AnyTrackConfig, TrackConfigEntry } from '../configuration/index.ts';
 import type { BlobLocation, FileHandleLocation, FileLocation, PreFileLocation } from './types/data.ts';
 import type { AbstractViewContainer } from './types/index.ts';
 import type { IAnyStateTreeNode, IAnyType, IStateTreeNode, Instance, types } from '@jbrowse/mobx-state-tree';
@@ -68,7 +68,7 @@ export declare function canonicalAssemblyNames(names: string[], assemblyManager:
  * to compare equal to themselves.
  */
 export declare function isSameAssemblyName(a: string | undefined, b: string | undefined, assemblyManager: AssemblyNameResolver): boolean;
-export declare function getConfAssemblyNames(conf: AnyConfigurationModel): string[];
+export declare function getConfAssemblyNames(conf: AnyConfiguration): string[];
 /**
  * {@link getConfAssemblyNames} for a caller that cannot afford its throw — a
  * config answering neither way leaves the question unanswered instead.
@@ -80,7 +80,12 @@ export declare function getConfAssemblyNames(conf: AnyConfigurationModel): strin
  * answers `[]` for a ReferenceSequenceTrack whose assembly this already knows
  * how to name.
  */
-export declare function getConfAssemblyNamesOrNone(conf: AnyConfigurationModel): string[];
+export declare function getConfAssemblyNamesOrNone(conf: AnyConfiguration): string[];
+/**
+ * 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 declare function toTrackConfigEntry(conf: AnyTrackConfig): TrackConfigEntry;
 /**
  * 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.
@@ -277,11 +282,7 @@ export declare function generateUnknownTrackConf(trackName: string, trackUrl: st
     category: string[] | undefined;
     trackId: string;
 };
-export declare function getTrackName(conf: AnyConfigurationModel | {
-    name?: string;
-    type?: string;
-    trackId?: string;
-}, session: {
+export declare function getTrackName(conf: AnyConfiguration, session: {
     assemblies: AnyConfigurationModel[];
 }): string;
 type MSTArray<T extends IAnyType> = Instance<ReturnType<typeof types.array<T>>>;
@@ -347,22 +348,22 @@ export declare function viewCanDisplayTrack(pluginManager: PluginManager, viewDi
  * and every other picker that opens a track into a view read this one answer,
  * or one of them offers a track the next hides.
  */
-export declare function filterTracks(tracks: AnyConfigurationModel[], self: {
+export declare function filterTracks<T extends AnyTrackConfig>(tracks: T[], self: {
     view?: IStateTreeNode & {
         type: string;
     };
     assemblyNames: string[];
-}): AnyConfigurationModel[];
+}): T[];
 /**
  * Every track config a view can be offered, each assembly's sequence track
  * first and then {@link filterTracks} over the list handed in.
  */
-export declare function offeredTracks(tracks: AnyConfigurationModel[], self: {
+export declare function offeredTracks(tracks: AnyTrackConfig[], self: {
     view?: IStateTreeNode & {
         type: string;
     };
     assemblyNames: string[];
-}): AnyConfigurationModel[];
+}): AnyTrackConfig[];
 /**
  * Which display a track opens with in a given view, and the declared entry
  * that configures it: `{ type, conf }`, or undefined when the view draws none
@@ -408,6 +409,15 @@ export declare function normalizeTrackInit(t: TrackInit): {
         [x: string]: unknown;
     };
 };
+/**
+ * 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 declare function trackDisplayType(pluginManager: PluginManager, rawConf: {
+    type: string;
+}, viewType: string, requested?: string): string | undefined;
 export declare function showTrackGeneric(self: GenericView, trackId: string, initialSnapshot?: object, displayInitialSnapshot?: DisplayInitialSnapshot, inlineConf?: Record<string, unknown>): any;
 export interface DisplaySnapshot {
     id: string;
@@ -446,11 +456,11 @@ export declare function launchToggleTrackGeneric(self: GenericView, trackId: str
  * yields every session track twice.
  */
 export declare function allSessionTracks(session: {
-    tracks: AnyConfigurationModel[];
+    tracks: TrackConfigEntry[];
     connectionInstances?: {
         tracks: AnyConfigurationModel[];
     }[];
-}): AnyConfigurationModel[];
+}): AnyTrackConfig[];
 /**
  * The session's annotation for `assemblyName`, as trackIds: what a view opened
  * on another genome starts with. Only FeatureTracks, not everything configured
@@ -459,7 +469,7 @@ export declare function allSessionTracks(session: {
  * range query.
  */
 export declare function annotationTrackIds(session: {
-    tracks: AnyConfigurationModel[];
+    tracks: TrackConfigEntry[];
     connectionInstances?: {
         tracks: AnyConfigurationModel[];
     }[];

package/esm/util/tracks.js

@@ -13,7 +13,7 @@ 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';
@@ -90,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;
@@ -125,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.
@@ -463,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
@@ -614,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,
@@ -686,7 +693,7 @@ export function pickDisplayForView({ candidates, declaredDisplays, requestedType
 // displaySnapshot) triple that `showTrackGeneric` expects. Display props written
 // inline on the track object (everything except trackId/trackSnapshot/
 // displaySnapshot) fold into the display snapshot, so a spec can write
-// `{ trackId, showDescriptions: false }` instead of nesting under
+// `{ trackId, showLabels: 'name' }` instead of nesting under
 // `displaySnapshot`. An explicit `displaySnapshot` still wins over an inline
 // key of the same name, and the older nested form keeps working unchanged.
 // `showTrackGeneric` then routes any inline key that is a real config slot (e.g.
@@ -705,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);
@@ -747,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
@@ -898,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
@@ -921,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
@@ -942,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);
@@ -958,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,
@@ -1046,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/usePanZoom.js

@@ -23,6 +23,7 @@
 // tooltip is also where ctrl/⌘+scroll — which zooms whatever the preference
 // says — is named.
 import { useEffect, useRef } from 'react';
+import { isClaimedPress } from './pressOwner.js';
 import { createWheelZoomController } from './wheelZoom.js';
 /**
  * Wheel zoom and side-scroll, bound to `ref` for as long as the component
@@ -126,19 +127,12 @@ export function usePanZoom(ref, view, { touchAction = 'none', } = {}) {
     return {
         containerProps: {
             onPointerDown(event) {
-                // Leave the press alone when something else owns it: a control that
-                // claimed it (`[data-gesture-owner]`, JBrowse's marker on the parts
-                // that drag on their own — a display's vertical scrollbar, a resize
-                // handle), a button (the track-sizing button a display draws in its own
-                // corner), or a draggable element. `closest`, because the press usually
-                // 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.
+                // Shift is left alone: 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.isPrimary || event.button !== 0 || event.shiftKey) {
                     return;
                 }
-                if (event.target instanceof Element &&
-                    event.target.closest('button, [data-gesture-owner], [draggable="true"]')) {
+                if (isClaimedPress(event)) {
                     return;
                 }
                 // Note what this does *not* do: capture the pointer. See onPointerMove.

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/windowStep.d.ts

@@ -0,0 +1,6 @@
+import type { WindowStep } from './markEncodingTypes.ts';
+import type { Staged } from './stepTables.ts';
+type Frame = NonNullable<WindowStep['frame']>;
+export declare const DEFAULT_WINDOW_FRAME: Frame;
+export declare function windowStep({ table, bounds }: Staged, step: WindowStep): Staged;
+export {};