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

package/esm/util/isoformRank.js

@@ -0,0 +1,118 @@
+export const featureIsoformReader = {
+    type: f => f.get('type'),
+    start: f => f.get('start'),
+    end: f => f.get('end'),
+    subfeatures: f => f.get('subfeatures') ?? [],
+    attribute: (f, field) => f.get(field),
+};
+export const serializedIsoformReader = {
+    type: f => f.type,
+    start: f => f.start,
+    end: f => f.end,
+    subfeatures: f => f.subfeatures ?? [],
+    attribute: (f, field) => f[field],
+};
+export const DEFAULT_CANONICAL_TRANSCRIPTS = {
+    field: 'tag',
+    tags: [
+        'MANE Select',
+        'MANE_Select',
+        'RefSeq Select',
+        'Ensembl_canonical',
+        'MANE Plus Clinical',
+        'MANE_Plus_Clinical',
+    ],
+};
+function isCDSType(type) {
+    return type?.toLowerCase() === 'cds';
+}
+// The feature itself counts, because an isoform can BE the CDS: a viral
+// polyprotein hangs its cleavage products off its CDS, not off further CDSs.
+export function isCodingIsoform(read, feature) {
+    return (isCDSType(read.type(feature)) ||
+        read.subfeatures(feature).some(sub => isCodingIsoform(read, sub)));
+}
+// "Longest coding" is the longest protein — summed CDS length, not the widest
+// genomic footprint an isoform with a large intron could win. A duplicated CDS
+// row is a real GFF3 quirk that would otherwise inflate one isoform past a
+// genuinely longer protein, so equal spans count once.
+function codingLength(read, feature) {
+    const spans = [];
+    const walk = (f) => {
+        for (const sub of read.subfeatures(f)) {
+            if (isCDSType(read.type(sub))) {
+                spans.push([read.start(sub), read.end(sub)]);
+            }
+            else {
+                walk(sub);
+            }
+        }
+    };
+    walk(feature);
+    if (spans.length === 0) {
+        return isCDSType(read.type(feature))
+            ? read.end(feature) - read.start(feature)
+            : 0;
+    }
+    spans.sort((a, b) => a[0] - b[0] || a[1] - b[1]);
+    let sum = 0;
+    for (const [i, span] of spans.entries()) {
+        const prev = spans[i - 1];
+        if (!prev || prev[0] !== span[0] || prev[1] !== span[1]) {
+            sum += span[1] - span[0];
+        }
+    }
+    return sum;
+}
+// A position in the tag list rather than a boolean, because the default list
+// holds two tags one gene can carry at once and flattening them to "tagged"
+// leaves the coding-length tiebreak to pick between them. A GFF3 attribute
+// holding a comma list arrives as an array, hence both shapes.
+function canonicalRank(value, wanted) {
+    const values = Array.isArray(value)
+        ? value.map(v => String(v).toLowerCase())
+        : typeof value === 'string'
+            ? [value.toLowerCase()]
+            : [];
+    let best = Infinity;
+    for (const v of values) {
+        const rank = wanted.indexOf(v);
+        if (rank !== -1 && rank < best) {
+            best = rank;
+        }
+    }
+    return best;
+}
+export function isoformScorer(read, { field, tags }) {
+    const wanted = tags.map(t => t.toLowerCase());
+    return (feature) => {
+        const coding = isCodingIsoform(read, feature);
+        return {
+            canonical: wanted.length
+                ? canonicalRank(read.attribute(feature, field), wanted)
+                : Infinity,
+            coding,
+            size: coding
+                ? codingLength(read, feature)
+                : read.end(feature) - read.start(feature),
+        };
+    };
+}
+// Best first. A curated tag outranks every measurement, because for a gene whose
+// longest protein is a minor variant it is the only thing that picks the right
+// isoform. A coding-length tie resolves to the LATER isoform, which a stable
+// sort would break the other way — hence the explicit index term.
+export function rankIsoforms(isoforms, scoreOf) {
+    return isoforms
+        .map((feature, index) => ({ feature, index, ...scoreOf(feature) }))
+        .sort((a, b) => a.canonical - b.canonical ||
+        Number(b.coding) - Number(a.coding) ||
+        b.size - a.size ||
+        b.index - a.index)
+        .map(s => s.feature);
+}
+export function isCanonicalTranscriptsHost(thing) {
+    return (typeof thing === 'object' &&
+        thing !== null &&
+        'canonicalTranscripts' in thing);
+}

package/esm/util/markEncodingTypes.d.ts

@@ -463,7 +463,9 @@ export interface AggregateStep {
  * #api
  * Replace the features with runs of constant depth: how many of them overlap
  * each stretch of the region, in a field `as` (`coverage` by default), with
- * the stretches nothing overlaps left out.
+ * the stretches nothing overlaps left out. A read counts across its whole
+ * span, deletions and introns included; gap-aware depth stays the alignments
+ * display's (ADR-118).
  */
 export interface CoverageStep {
     type: 'coverage';

package/esm/util/quantileExtent.d.ts

@@ -1,5 +1,7 @@
 /** The quantile "Clip outliers" clips at on a scale whose own default is the extremes. */
 export declare const DEFAULT_CLIP_QUANTILE = 0.99;
+/** The lowest `domainQuantile` a scale reads, where its two ends meet; one below reads as this. */
+export declare const MIN_DOMAIN_QUANTILE = 0.5;
 /**
  * #api
  * The quantile a clip toggle writes: a scale's declared default where that
@@ -37,8 +39,28 @@ export declare function quantileOf(a: Float32Array, n: number, quantile: number)
  * where the ends meet rather than cross. `scales.y.domainQuantile` and a
  * colour's `domainQuantile` both name it. `[Infinity, -Infinity]` where
  * nothing is finite.
+ *
+ * Nearest rank keeps ties: where one value holds the rank, as on a segmented
+ * copy-number track, a ramp clipped below 1 paints nearly every value one
+ * colour. A value axis fences instead ({@link fenceOutliers}); a ramp takes
+ * the same fence once a colour default below 1 meets tied data.
  */
 export declare function quantileExtent(values: ArrayLike<number>, count: number, quantile?: number): [number, number];
+/**
+ * #api
+ * Where a value axis's open ends stand below a `domainQuantile` of 1: at the
+ * `extremes`, unless one would stretch the axis past twice the span the
+ * {@link quantileExtent} ends `quantiles` draw, 0 included where the axis
+ * reaches it (`zero`); that end stops at the fence. So a plot with no spike
+ * shows every value and cuts none, and a spike leaves the values under it at
+ * least half the axis. Quantiles that meet span their own size, as a flat
+ * domain widens in `getNiceDomain`.
+ */
+export declare function fenceOutliers({ extremes, quantiles, zero, }: {
+    extremes: readonly [number, number];
+    quantiles: readonly [number, number];
+    zero: boolean;
+}): [number, number];
 /**
  * #api
  * {@link quantileExtent} as a scale's open ends read it: over every finite

package/esm/util/quantileExtent.js

@@ -1,5 +1,7 @@
 /** The quantile "Clip outliers" clips at on a scale whose own default is the extremes. */
 export const DEFAULT_CLIP_QUANTILE = 0.99;
+/** The lowest `domainQuantile` a scale reads, where its two ends meet; one below reads as this. */
+export const MIN_DOMAIN_QUANTILE = 0.5;
 /**
  * #api
  * The quantile a clip toggle writes: a scale's declared default where that
@@ -111,12 +113,17 @@ function lowQuantileOf(a, n, quantile) {
  * where the ends meet rather than cross. `scales.y.domainQuantile` and a
  * colour's `domainQuantile` both name it. `[Infinity, -Infinity]` where
  * nothing is finite.
+ *
+ * Nearest rank keeps ties: where one value holds the rank, as on a segmented
+ * copy-number track, a ramp clipped below 1 paints nearly every value one
+ * colour. A value axis fences instead ({@link fenceOutliers}); a ramp takes
+ * the same fence once a colour default below 1 meets tied data.
  */
 export function quantileExtent(values, count, quantile = 1) {
     if (!(quantile < 1)) {
         return finiteExtremes(values, count);
     }
-    const q = Math.max(0.5, quantile);
+    const q = Math.max(MIN_DOMAIN_QUANTILE, quantile);
     const positive = new Float32Array(count);
     const negative = new Float32Array(count);
     let np = 0;
@@ -139,6 +146,22 @@ export function quantileExtent(values, count, quantile = 1) {
     const high = np > 0 ? quantileOf(positive, np, q) : quantileOf(negative, nn, q);
     return [Math.min(low, high), high];
 }
+/**
+ * #api
+ * Where a value axis's open ends stand below a `domainQuantile` of 1: at the
+ * `extremes`, unless one would stretch the axis past twice the span the
+ * {@link quantileExtent} ends `quantiles` draw, 0 included where the axis
+ * reaches it (`zero`); that end stops at the fence. So a plot with no spike
+ * shows every value and cuts none, and a spike leaves the values under it at
+ * least half the axis. Quantiles that meet span their own size, as a flat
+ * domain widens in `getNiceDomain`.
+ */
+export function fenceOutliers({ extremes, quantiles, zero, }) {
+    const lo = zero ? Math.min(0, quantiles[0]) : quantiles[0];
+    const hi = zero ? Math.max(0, quantiles[1]) : quantiles[1];
+    const span = hi - lo || Math.abs(hi) || 1;
+    return [Math.max(extremes[0], lo - span), Math.min(extremes[1], hi + span)];
+}
 /**
  * #api
  * {@link quantileExtent} as a scale's open ends read it: over every finite

package/esm/util/systemColorScheme.d.ts

@@ -10,3 +10,7 @@ export declare function prefersDarkColorScheme(): boolean;
  * one preference, and a second spelling of the query is a second answer.
  */
 export declare function onColorSchemeChange(listener: () => void): () => void;
+/** Whether Dark Reader darkens the page around canvases it leaves light. */
+export declare function darkReaderIsDark(): boolean;
+/** Call `listener` whenever Dark Reader's scheme mark changes, and return the unsubscribe. */
+export declare function onDarkReaderChange(listener: () => void): () => void;

package/esm/util/systemColorScheme.js

@@ -25,3 +25,24 @@ export function onColorSchemeChange(listener) {
         media?.removeEventListener('change', listener);
     };
 }
+const DARK_READER_ATTRIBUTE = 'data-darkreader-scheme';
+/** Whether Dark Reader darkens the page around canvases it leaves light. */
+export function darkReaderIsDark() {
+    return (typeof document !== 'undefined' &&
+        document.documentElement.getAttribute(DARK_READER_ATTRIBUTE) === 'dark');
+}
+/** Call `listener` whenever Dark Reader's scheme mark changes, and return the unsubscribe. */
+export function onDarkReaderChange(listener) {
+    if (typeof MutationObserver !== 'function' ||
+        typeof document === 'undefined') {
+        return () => { };
+    }
+    const observer = new MutationObserver(listener);
+    observer.observe(document.documentElement, {
+        attributes: true,
+        attributeFilter: [DARK_READER_ATTRIBUTE],
+    });
+    return () => {
+        observer.disconnect();
+    };
+}

package/esm/util/tabix.d.ts

@@ -113,7 +113,7 @@ interface TabixHeaderSource {
  * An adapter that stops at `getHeader()` therefore cannot tell "this file has
  * no header" from "this file's header is not commented", and quietly falls back
  * to an assumed column layout. That has cost real information more than once: a
- * PLINK LD file lost its D' column, so `ldMetric: 'dprime'` silently served r²,
+ * PLINK LD file lost its D' column, so `color.field: 'dprime'` silently served r²,
  * and a bedGraph loses the names of its value columns. Nothing errors, because
  * the assumed layout parses.
  *

package/esm/util/tabix.js

@@ -133,7 +133,7 @@ function mergeTabixLines(...groups) {
  * An adapter that stops at `getHeader()` therefore cannot tell "this file has
  * no header" from "this file's header is not commented", and quietly falls back
  * to an assumed column layout. That has cost real information more than once: a
- * PLINK LD file lost its D' column, so `ldMetric: 'dprime'` silently served r²,
+ * PLINK LD file lost its D' column, so `color.field: 'dprime'` silently served r²,
  * and a bedGraph loses the names of its value columns. Nothing errors, because
  * the assumed layout parses.
  *

package/esm/util/temporaryAssembly.d.ts

@@ -1,4 +1,4 @@
-import type { AnyConfigurationModel } from '../configuration/index.ts';
+import type { AnyConfiguration } from '../configuration/index.ts';
 /**
  * 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
@@ -18,4 +18,4 @@ import type { AnyConfigurationModel } from '../configuration/index.ts';
  * answer is yes. A second copy of the predicate is the thing to avoid — a copied
  * guard is where the escape clause gets added to only one of them.
  */
-export declare function namesTemporaryAssembly(session: unknown, trackConf: AnyConfigurationModel | Record<string, unknown>): boolean;
+export declare function namesTemporaryAssembly(session: unknown, trackConf: AnyConfiguration): boolean;

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/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,
@@ -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) {