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

package/esm/util/locString.js

@@ -36,12 +36,12 @@ export function parseLocStringOneBased(locString, isValidRefName) {
         throw new Error('no location string provided, could not parse');
     }
     // handle reverse strand notation e.g. "chr1:1-100[rev]"
+    locString = locString.replaceAll(/\s/g, '');
     let reversed = false;
     if (locString.endsWith('[rev]')) {
         reversed = true;
         locString = locString.slice(0, -5);
     }
-    locString = locString.replaceAll(/\s/g, '');
     // extract optional assembly name in braces e.g. "{hg19}chr1:1-100"
     const assemblyMatch = ASSEMBLY_REGEX.exec(locString);
     if (!assemblyMatch) {
@@ -174,7 +174,10 @@ function assembleLocStringWith(region, cb = (n) => n) {
     }
     let endString;
     if (end !== undefined) {
-        endString = start !== undefined && start + 1 === end ? '' : `..${cb(end)}`;
+        endString =
+            start !== undefined && (start + 1 === end || start === end)
+                ? ''
+                : `..${cb(end)}`;
     }
     else {
         endString = start !== undefined ? '..' : '';

package/esm/util/markEncoding.js

@@ -51,6 +51,22 @@ function channelReader(table, ref, jexl) {
     const read = fieldReader(ref, jexl);
     return i => read(table.row(i));
 }
+// A text channel's reader, printing a float32 lane's value at the digits the
+// lane holds rather than the double it widens to: 0.3865, not 0.3865000009.
+function textChannelReader(table, ref, jexl) {
+    const read = channelReader(table, ref, jexl);
+    const column = typeof ref !== 'function' && isPlainFieldRef(ref)
+        ? table.column(ref)
+        : undefined;
+    return column?.kind === 'number' && column.values instanceof Float32Array
+        ? i => {
+            const v = read(i);
+            return typeof v === 'number' && !Number.isInteger(v)
+                ? String(Number(v.toPrecision(7)))
+                : valueText(v);
+        }
+        : i => valueText(read(i));
+}
 function numberChannelReader(table, ref, jexl) {
     if (typeof ref !== 'function' && isPlainFieldRef(ref)) {
         return numberReaderOf(table.column(ref));
@@ -457,10 +473,10 @@ export function encodeFeatures(input, encoding, lanes, ctx = {}) {
             text.fill('');
         }
         else {
-            const read = channelReader(table, textEncoding, jexl);
+            const read = textChannelReader(table, textEncoding, jexl);
             for (let k = 0; k < count; k++) {
                 report?.(k);
-                text[k] = valueText(read(rowAt(k)));
+                text[k] = read(rowAt(k));
             }
         }
     }
@@ -519,30 +535,47 @@ export function encodeFeatures(input, encoding, lanes, ctx = {}) {
             ? y
             : new Float32Array(count)
         : undefined;
-    const paintsColor = has('color') && !colorValue;
+    const colorKey = declaredScale?.scale === 'categorical' && has('colorKey')
+        ? new Uint32Array(count)
+        : undefined;
+    const paintsColor = has('color') && !colorValue && !colorKey;
     const unscaled = paintsColor && declaredScale?.scale !== 'categorical' && !quantitative
         ? unscaledColor(table, colorEncoding, jexl)
         : undefined;
     const color = paintsColor && typeof unscaled !== 'number'
         ? new Uint32Array(count)
         : undefined;
-    const scaled = paintsColor || colorValue ? declaredScale : undefined;
+    const scaled = paintsColor || colorValue || colorKey ? declaredScale : undefined;
+    const categoryLane = colorKey ?? color;
     let scale;
     let missingMet = false;
     let notNumberMet = false;
-    if (scaled?.scale === 'categorical' && color) {
+    if (scaled?.scale === 'categorical' && categoryLane) {
         const colorField = categoricalField(scaled.field, {
             domain: scaled.domain?.map(String),
             range: scaled.range,
         });
-        const entries = paintCategories(table, scaled.field, jexl, colorField, { kept, count, report }, color, key => cssColorToABGR(colorField.color(key)), abgr => abgr);
+        let resolved = 0;
+        const entries = paintCategories(table, scaled.field, jexl, colorField, { kept, count, report }, categoryLane, key => ({
+            color: cssColorToABGR(colorField.color(key)),
+            order: resolved++,
+        }), entry => (colorKey ? entry.order : entry.color));
+        if (colorKey) {
+            const position = new Uint32Array(resolved);
+            for (const [i, e] of entries.entries()) {
+                position[e.entry.order] = i;
+            }
+            for (let k = 0; k < count; k++) {
+                colorKey[k] = position[colorKey[k]];
+            }
+        }
         scale = {
             kind: 'categorical',
             field: scaled.field,
             domain: [...colorField.domain],
             ...(scaled.range ? { range: [...scaled.range] } : {}),
             ...(keysAreNumeric(entries) ? { numericKeys: true } : {}),
-            entries: entries.map(e => ({ value: e.value, color: e.entry })),
+            entries: entries.map(e => ({ value: e.value, color: e.entry.color })),
         };
     }
     else if (scaled && quantitative) {
@@ -570,10 +603,13 @@ export function encodeFeatures(input, encoding, lanes, ctx = {}) {
             const cuts = thresholdCuts(thresholdEncoding.domain ?? []);
             if (color) {
                 const binColors = Uint32Array.from(thresholdPalette(cuts.length + 1, thresholdEncoding.range), c => cssColorToABGR(c));
+                // in float32 on both sides, as the shader and the key compare, so a
+                // value off a float32 lane sits at a cut like 0.7 rather than under it
+                const cuts32 = cuts.map(cut => Math.fround(cut));
                 for (let k = 0; k < count; k++) {
                     report?.(k);
                     const v = read(rowAt(k));
-                    const bin = thresholdIndex(v, cuts);
+                    const bin = thresholdIndex(Math.fround(numericValue(v)), cuts32);
                     if (bin >= 0) {
                         color[k] = binColors[bin];
                     }
@@ -656,6 +692,9 @@ export function encodeFeatures(input, encoding, lanes, ctx = {}) {
         // the y view itself where the colour reads y, so a reader can tell
         encoded.colorValue = colorValue;
     }
+    if (colorKey) {
+        encoded.colorKey = colorKey;
+    }
     if (glyph) {
         encoded.glyph = glyph;
     }
@@ -830,6 +869,7 @@ export function encodedChannelTransferables(c) {
         c.row,
         typeof c.color === 'number' ? undefined : c.color,
         c.colorValue,
+        c.colorKey,
         c.glyph,
         c.size,
         c.x2Ref,

package/esm/util/markEncodingTypes.d.ts

@@ -149,7 +149,7 @@ export interface MarkEncoding {
  * allocated nor transferred, and a caller that never hovers declines the
  * index, which is most of the encoder's cost after the walk.
  */
-export type LaneName = 'y' | 'color' | 'colorValue' | 'glyph' | 'row' | 'text' | 'size' | 'x2Ref' | 'index';
+export type LaneName = 'y' | 'color' | 'colorValue' | 'colorKey' | 'glyph' | 'row' | 'text' | 'size' | 'x2Ref' | 'index';
 /**
  * #api
  * The scale a colour channel was resolved through, as the legend reads it —
@@ -318,6 +318,13 @@ export interface EncodedChannels {
      * colour reads the field `y` plots, this IS the `y` array, not a copy.
      */
     colorValue?: Float32Array;
+    /**
+     * Each instance's index into `scale.entries` under a categorical colour, for
+     * a caller that named the `colorKey` lane in place of `color`: the display
+     * then paints each key through its own `domain` and `range`, which never
+     * reach the worker.
+     */
+    colorKey?: Uint32Array;
     /** The point painter's code for each feature's `shape`. */
     glyph?: Uint8Array;
     row?: Uint32Array;
@@ -456,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/springAnimate.js

@@ -61,7 +61,7 @@ export function springAnimate({ from, to, write, read, onFinish = () => { }, pre
             animationFrameId = requestAnimationFrame(() => {
                 update({
                     lastPosition: position,
-                    lastTime: time,
+                    lastTime: lastTime + numSteps,
                     lastVelocity: velocity,
                 });
             });

package/esm/util/stepTables.d.ts

@@ -1,3 +1,4 @@
+import { DerivedTable } from './featureTable.ts';
 import type { Column, FeatureTable, MadeRows } from './featureTable.ts';
 import type { AggregateOp, AggregateStep, BinStep } from './markEncodingTypes.ts';
 import type { Feature, SimpleFeatureSerialized } from './simpleFeature.ts';
@@ -15,6 +16,19 @@ export interface Staged {
     table: FeatureTable;
     bounds: Bounds;
 }
+export declare function boundsThrough(bounds: Bounds, parentRow: Uint32Array): Bounds;
+/**
+ * The entries a `flatten` fanned out, one row each over the container row it
+ * came from. A container kept with nothing to fan out is a row of its own
+ * that reads everything off itself.
+ */
+export declare abstract class FannedTable extends DerivedTable {
+    get madeFrom(): boolean;
+    /** A container kept with nothing to fan out: the row is the container. */
+    abstract isKept(i: number): boolean;
+    abstract get hasKept(): boolean;
+    row(i: number): Feature;
+}
 export declare function stepReader(table: FeatureTable, ref: string, step: string): (i: number) => unknown;
 export declare function stepNumberReader(table: FeatureTable, ref: string, step: string): (i: number) => number;
 export declare function groupKey(value: unknown): unknown;

package/esm/util/stepTables.js

@@ -1,14 +1,48 @@
-// The pieces of the transform steps that the fused bin-and-aggregate kernel
-// shares with the steps themselves. Imported by relative path only, so none
-// of it is a package subpath or part of the plugin ABI.
+// The pieces of the transform steps that the fused kernels share with the
+// steps themselves. Imported by relative path only, so none of it is a
+// package subpath or part of the plugin ABI.
 import { aggregateFieldName } from './aggregateFieldName.js';
-import { NO_COLUMN, TableRow, numberReaderOf, readerOf, valueAt, } from './featureTable.js';
+import { DerivedTable, NO_COLUMN, TableRow, numberReaderOf, readerOf, valueAt, } from './featureTable.js';
 import { fieldReader, isPlainFieldRef } from './fieldReader.js';
 import { isJexl } from './jexlStrings.js';
 import { numericValue } from './numericValue.js';
 export const DEFAULT_BIN_AS = ['start', 'end'];
 /** What a `bin` over `fields` writes on each piece: the bases of its interval inside its bin. */
 export const BIN_OVERLAP_FIELD = 'overlap';
+// Section starts through a step whose rows came from its input's in order:
+// each section starts at the first row whose parent row is in it.
+export function boundsThrough(bounds, parentRow) {
+    const out = new Uint32Array(bounds.length);
+    let lo = 0;
+    for (let s = 0; s < bounds.length; s++) {
+        const edge = bounds[s];
+        let hi = parentRow.length;
+        while (lo < hi) {
+            const mid = (lo + hi) >>> 1;
+            if (parentRow[mid] < edge) {
+                lo = mid + 1;
+            }
+            else {
+                hi = mid;
+            }
+        }
+        out[s] = lo;
+    }
+    return out;
+}
+/**
+ * The entries a `flatten` fanned out, one row each over the container row it
+ * came from. A container kept with nothing to fan out is a row of its own
+ * that reads everything off itself.
+ */
+export class FannedTable extends DerivedTable {
+    get madeFrom() {
+        return true;
+    }
+    row(i) {
+        return this.isKept(i) ? this.parent.row(this.parentOf(i)) : super.row(i);
+    }
+}
 // A step reads a name or a dotted path. A plain name reads the table's column;
 // a path walks each row, chosen once per step. A computed field is a `formula`
 // step's to make.

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

@@ -90,7 +90,9 @@ export declare function readTabixLinesRedispatched(file: TabixLineSource, query:
  * structural for the same reason as {@link TabixLineSource}.
  */
 interface TabixHeaderSource {
-    getHeaderLines(): Promise<string[]>;
+    getHeaderLines(opts?: {
+        signal?: AbortSignal;
+    }): Promise<string[]>;
 }
 /**
  * The header lines of a tabix-indexed file, however that file kept them.
@@ -111,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.
  *
@@ -121,5 +123,7 @@ interface TabixHeaderSource {
  * commented block and then the counted rows used to fetch and decompress the
  * same bytes twice, which every bare-header file did on every call.
  */
-export declare function readTabixHeaderLines(file: TabixHeaderSource): Promise<string[]>;
+export declare function readTabixHeaderLines(file: TabixHeaderSource, opts?: {
+    signal?: AbortSignal;
+}): Promise<string[]>;
 export {};

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.
  *
@@ -143,6 +143,6 @@ function mergeTabixLines(...groups) {
  * commented block and then the counted rows used to fetch and decompress the
  * same bytes twice, which every bare-header file did on every call.
  */
-export function readTabixHeaderLines(file) {
-    return file.getHeaderLines();
+export function readTabixHeaderLines(file, opts) {
+    return file.getHeaderLines(opts);
 }

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

@@ -1,7 +1,10 @@
 export { getFileName } from './getFileName.ts';
 export { getRpcSessionId } from './parentWalk.ts';
+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';
@@ -65,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.
@@ -77,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.
@@ -132,23 +140,6 @@ export declare function restoreFileHandlesFromSnapshot(sessionSnapshot: unknown,
     success: false;
     error: unknown;
 })[]>;
-/**
- * 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 declare function makeIndex(location: FileLocation, suffix: string): BlobLocation | FileHandleLocation | {
-    uri: string;
-    locationType: string;
-    baseUri?: string | undefined;
-    localPath?: undefined;
-} | {
-    localPath: string;
-    locationType: string;
-};
 /**
  * constructs a potential index file (with suffix) from the provided file name
  *
@@ -227,12 +218,6 @@ export declare function addTrackTypeGuesser(pluginManager: PluginManager, guess:
 export declare function stripFileExtension(name: string): string;
 export declare function guessAdapter(file: FileLocation, index: FileLocation | undefined, adapterHint?: string, model?: IAnyStateTreeNode): AdapterConfig;
 export declare function guessTrackType(adapterType: string, model?: IAnyStateTreeNode, file?: FileLocation): string;
-export interface LooseTrackInput {
-    uri: string;
-    index?: string;
-    baseUri?: string;
-    [key: string]: unknown;
-}
 /**
  * Expand a loose track description — a bare data-file URI, or an object with
  * `uri` (and optional `index`) plus any extra config keys — into a full track
@@ -268,13 +253,6 @@ export declare function guessTrackConfForLocation(file: FileLocation, index: Fil
     assemblyNames: string[];
     adapter: AdapterConfig;
 };
-/**
- * Whether a track snapshot is the loose `{ uri, ... }` form — a data file with
- * no `adapter` — that {@link expandLooseTrackConfig} expands.
- */
-export declare function isLooseTrackConfig(snap: unknown): snap is LooseTrackInput & {
-    trackId?: string;
-};
 /**
  * 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:
@@ -304,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>>>;
@@ -374,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
@@ -435,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;
@@ -473,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
@@ -486,7 +469,7 @@ export declare function allSessionTracks(session: {
  * range query.
  */
 export declare function annotationTrackIds(session: {
-    tracks: AnyConfigurationModel[];
+    tracks: TrackConfigEntry[];
     connectionInstances?: {
         tracks: AnyConfigurationModel[];
     }[];