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

package/esm/util/sessionActivity.d.ts

@@ -0,0 +1,36 @@
+export interface ActivitySession {
+    sessionTracks: {
+        type: string;
+    }[];
+    views: {
+        type: string;
+        tracks?: readonly object[];
+    }[];
+    widgets?: {
+        values(): Iterable<{
+            type: string;
+        }>;
+    };
+}
+export interface SessionShape {
+    viewTypes: string[];
+    trackTypes: string[];
+    widgetTypes: string[];
+}
+export declare function describeSession(session: ActivitySession | undefined): SessionShape;
+export declare function tallyTypes(types: string[]): string;
+export declare function createSessionActivity(): {
+    watch(getSession: () => ActivitySession | undefined): void;
+    stop(): void;
+    readonly watching: boolean;
+    stats(): {
+        'view-types': string;
+        'open-track-types': string;
+        'seen-view-types': string;
+        'seen-track-types': string;
+        'seen-widget-types': string;
+        'max-open-views': number;
+        'max-open-tracks': number;
+    };
+};
+export type SessionActivity = ReturnType<typeof createSessionActivity>;

package/esm/util/sessionActivity.js

@@ -0,0 +1,88 @@
+import { autorun } from 'mobx';
+export function describeSession(session) {
+    const shape = { viewTypes: [], trackTypes: [], widgetTypes: [] };
+    if (session) {
+        for (const view of session.views) {
+            shape.viewTypes.push(view.type);
+            for (const track of view.tracks ?? []) {
+                if ('type' in track && typeof track.type === 'string') {
+                    shape.trackTypes.push(track.type);
+                }
+            }
+        }
+        for (const widget of session.widgets?.values() ?? []) {
+            shape.widgetTypes.push(widget.type);
+        }
+    }
+    return shape;
+}
+// `LinearGenomeView:2,DotplotView:1`, sorted so equal sessions give equal text
+export function tallyTypes(types) {
+    const counts = new Map();
+    for (const type of types) {
+        counts.set(type, (counts.get(type) ?? 0) + 1);
+    }
+    return [...counts]
+        .sort(([a], [b]) => a.localeCompare(b))
+        .map(([type, count]) => `${type}:${count}`)
+        .join(',');
+}
+// Accumulates what a page load's sessions held at any point, so the end report
+// can say what was opened during use and not only what is open at the end.
+export function createSessionActivity() {
+    const seen = {
+        viewTypes: new Set(),
+        trackTypes: new Set(),
+        widgetTypes: new Set(),
+    };
+    let maxOpenViews = 0;
+    let maxOpenTracks = 0;
+    let current = describeSession(undefined);
+    let stopWatching;
+    function record(shape) {
+        current = shape;
+        maxOpenViews = Math.max(maxOpenViews, shape.viewTypes.length);
+        maxOpenTracks = Math.max(maxOpenTracks, shape.trackTypes.length);
+        for (const key of ['viewTypes', 'trackTypes', 'widgetTypes']) {
+            for (const type of shape[key]) {
+                seen[key].add(type);
+            }
+        }
+    }
+    return {
+        // jbrowse-web rebuilds the root model when plugins change and Desktop
+        // builds one per session opened, so each call replaces the previous watch.
+        // A root model that has left its state tree throws when read; the watch
+        // then keeps what it last saw.
+        watch(getSession) {
+            stopWatching?.();
+            stopWatching = autorun(() => {
+                try {
+                    record(describeSession(getSession()));
+                }
+                catch {
+                    // dead state tree
+                }
+            });
+        },
+        stop() {
+            stopWatching?.();
+            stopWatching = undefined;
+        },
+        get watching() {
+            return stopWatching !== undefined;
+        },
+        stats() {
+            const list = (types) => [...types].sort().join(',');
+            return {
+                'view-types': tallyTypes(current.viewTypes),
+                'open-track-types': tallyTypes(current.trackTypes),
+                'seen-view-types': list(seen.viewTypes),
+                'seen-track-types': list(seen.trackTypes),
+                'seen-widget-types': list(seen.widgetTypes),
+                'max-open-views': maxOpenViews,
+                'max-open-tracks': maxOpenTracks,
+            };
+        },
+    };
+}

package/esm/util/stepOutputs.d.ts

@@ -0,0 +1,165 @@
+/**
+ * What each transform step does to the rows it reads, stated once for the
+ * runtime's facet split, the validator, the field pickers and the channels a
+ * mark adopts by default. Imports nothing, so the validator's copy of the mark
+ * rule list carries it unchanged.
+ *
+ * Every step type answers three things:
+ * - `rowwise`: it answers each row from that row alone and in order, so a
+ *   facet split may run ahead of it.
+ * - `replacesRows`: it makes its rows anew (an aggregate, a coverage), so a
+ *   field survives it only where it writes that field or keeps it as a group.
+ * - `writes`: the fields it sets, each with the kind of value it holds and the
+ *   channel a mark leaving that channel unwritten reads it through.
+ */
+/** The field an aggregate op writes: `as` where named, else `count` for a count, else `<op>_<field>`. */
+export declare function aggregateFieldName({ op, field, as, }: {
+    op: string;
+    field?: string;
+    as?: string;
+}): string;
+export declare const DEFAULT_FORMULA_AS = "value";
+export declare const DEFAULT_COVERAGE_AS = "coverage";
+export declare const DEFAULT_PILEUP_AS = "row";
+export declare const DEFAULT_AGGREGATE_OP = "count";
+export declare const DEFAULT_BIN_AS: readonly [string, string];
+/** What a `bin` over `fields` writes on each piece: the bases of its interval inside its bin. */
+export declare const BIN_OVERLAP_FIELD = "overlap";
+/** What a `cells` step writes: `state` on every cell, `base` on a mismatch or an insertion, `match` off a gap or a reference `N`, `length` on an insertion. */
+export declare const CELLS_FIELDS: readonly ['state', 'base', 'match', 'length'];
+/** What a `mate` step writes on every feature it answers. */
+export declare const MATE_FIELDS: readonly ['mate.refName', 'mate.start', 'mate.end', 'mate.mateDirection', 'mateDirection', 'alt', 'svType'];
+/** Where a row stands, which every row keeps through every step. */
+export declare const POSITION_FIELDS: readonly ['refName', 'start', 'end'];
+/** The kind of value a step writes into a field; `unknown` keeps whatever the field held. */
+export type FieldKind = 'numeric' | 'categorical' | 'unknown';
+/** A channel a step's output fills where a mark leaves it unwritten. */
+export type FilledChannel = 'y' | 'row' | 'x2';
+export interface WrittenField {
+    field: string;
+    kind: FieldKind;
+    fills?: FilledChannel;
+}
+/** A step as a config node, a snapshot or a worker request holds it, any default unwritten. */
+export interface StepOutline {
+    type: string;
+    as?: string | readonly string[];
+    ops?: readonly {
+        op?: string;
+        field?: string;
+        as?: string;
+    }[];
+    groupby?: readonly string[];
+    fields?: readonly string[];
+    index?: string;
+    key?: string;
+}
+export interface StepOutput {
+    rowwise: boolean;
+    replacesRows: boolean;
+    /** `edges` are the fields the last `bin` before this step wrote its edges to. */
+    writes: (step: StepOutline, edges: readonly string[]) => WrittenField[];
+}
+declare function summaries(step: StepOutline): WrittenField[];
+export declare const STEP_OUTPUTS: {
+    filter: {
+        rowwise: true;
+        replacesRows: false;
+        writes: () => never[];
+    };
+    formula: {
+        rowwise: true;
+        replacesRows: false;
+        writes: (step: StepOutline) => {
+            field: string;
+            kind: "numeric";
+        }[];
+    };
+    bin: {
+        rowwise: true;
+        replacesRows: false;
+        writes: (step: StepOutline) => {
+            field: string;
+            kind: 'numeric';
+        }[];
+    };
+    cells: {
+        rowwise: true;
+        replacesRows: false;
+        writes: () => ({
+            field: string;
+            kind: "numeric";
+        } | {
+            field: string;
+            kind: "categorical";
+        })[];
+    };
+    aggregate: {
+        rowwise: false;
+        replacesRows: true;
+        writes: (step: StepOutline, edges: readonly string[]) => WrittenField[];
+    };
+    window: {
+        rowwise: false;
+        replacesRows: false;
+        writes: typeof summaries;
+    };
+    coverage: {
+        rowwise: false;
+        replacesRows: true;
+        writes: (step: StepOutline) => {
+            field: string;
+            kind: "numeric";
+            fills: "y";
+        }[];
+    };
+    pileup: {
+        rowwise: false;
+        replacesRows: false;
+        writes: (step: StepOutline) => {
+            field: string;
+            kind: "numeric";
+            fills: "row";
+        }[];
+    };
+    flatten: {
+        rowwise: false;
+        replacesRows: false;
+        writes: (step: StepOutline) => ({
+            field: string;
+            kind: 'numeric';
+        } | {
+            field: string;
+            kind: 'categorical';
+        })[];
+    };
+    mate: {
+        rowwise: false;
+        replacesRows: false;
+        writes: () => {
+            field: "alt" | "mate.end" | "mate.mateDirection" | "mate.refName" | "mate.start" | "mateDirection" | "svType";
+            kind: "categorical" | "numeric";
+            fills?: "x2" | undefined;
+        }[];
+    };
+};
+export type StepType = keyof typeof STEP_OUTPUTS;
+/**
+ * The fields one step writes. A step this table does not know writes nothing
+ * it can name.
+ */
+export declare function stepWrites(step: StepOutline, edges?: readonly string[]): WrittenField[];
+/** Whether a step answers each row from that row alone, in order. */
+export declare function isRowwise(step: StepOutline): boolean;
+/**
+ * What a run of steps leaves: every field written, the last write of each
+ * winning, and, where a step made the rows anew, the only fields that survive
+ * it (`undefined` while the input's own fields all do). `channels` are what
+ * the output fills where a mark leaves them unwritten.
+ */
+export declare function stepsOutput(steps: readonly (StepOutline | undefined)[]): {
+    written: WrittenField[];
+    surviving: Set<string> | undefined;
+    channels: Map<FilledChannel, string>;
+};
+export {};

package/esm/util/stepOutputs.js

@@ -0,0 +1,201 @@
+/**
+ * What each transform step does to the rows it reads, stated once for the
+ * runtime's facet split, the validator, the field pickers and the channels a
+ * mark adopts by default. Imports nothing, so the validator's copy of the mark
+ * rule list carries it unchanged.
+ *
+ * Every step type answers three things:
+ * - `rowwise`: it answers each row from that row alone and in order, so a
+ *   facet split may run ahead of it.
+ * - `replacesRows`: it makes its rows anew (an aggregate, a coverage), so a
+ *   field survives it only where it writes that field or keeps it as a group.
+ * - `writes`: the fields it sets, each with the kind of value it holds and the
+ *   channel a mark leaving that channel unwritten reads it through.
+ */
+/** The field an aggregate op writes: `as` where named, else `count` for a count, else `<op>_<field>`. */
+export function aggregateFieldName({ op, field, as, }) {
+    return as || (op === 'count' || !field ? op : `${op}_${field}`);
+}
+export const DEFAULT_FORMULA_AS = 'value';
+export const DEFAULT_COVERAGE_AS = 'coverage';
+export const DEFAULT_PILEUP_AS = 'row';
+export const DEFAULT_AGGREGATE_OP = 'count';
+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';
+/** What a `cells` step writes: `state` on every cell, `base` on a mismatch or an insertion, `match` off a gap or a reference `N`, `length` on an insertion. */
+export const CELLS_FIELDS = ['state', 'base', 'match', 'length'];
+/** What a `mate` step writes on every feature it answers. */
+export const MATE_FIELDS = [
+    'mate.refName',
+    'mate.start',
+    'mate.end',
+    'mate.mateDirection',
+    'mateDirection',
+    'alt',
+    'svType',
+];
+/** Where a row stands, which every row keeps through every step. */
+export const POSITION_FIELDS = ['refName', 'start', 'end'];
+function named(as, fallback) {
+    return typeof as === 'string' && as !== '' ? as : fallback;
+}
+function binEdges(step) {
+    const { as } = step;
+    return Array.isArray(as) && as.length === 2 ? as : DEFAULT_BIN_AS;
+}
+// A single op names the `y` its mark reads; two leave the mark to choose.
+function summaries(step) {
+    const ops = step.ops ?? [];
+    return ops.map(({ op = DEFAULT_AGGREGATE_OP, field, as }) => ({
+        field: aggregateFieldName({ op, field, as }),
+        kind: 'numeric',
+        ...(ops.length === 1 ? { fills: 'y' } : {}),
+    }));
+}
+const kept = (field) => ({ field, kind: 'unknown' });
+export const STEP_OUTPUTS = {
+    filter: { rowwise: true, replacesRows: false, writes: () => [] },
+    formula: {
+        rowwise: true,
+        replacesRows: false,
+        writes: step => [
+            { field: named(step.as, DEFAULT_FORMULA_AS), kind: 'numeric' },
+        ],
+    },
+    bin: {
+        rowwise: true,
+        replacesRows: false,
+        writes: step => [
+            ...binEdges(step).map(field => ({ field, kind: 'numeric' })),
+            ...(step.fields?.length === 2
+                ? [{ field: BIN_OVERLAP_FIELD, kind: 'numeric' }]
+                : []),
+        ],
+    },
+    cells: {
+        rowwise: true,
+        replacesRows: false,
+        writes: () => [
+            { field: 'start', kind: 'numeric' },
+            { field: 'end', kind: 'numeric' },
+            { field: 'state', kind: 'categorical' },
+            { field: 'base', kind: 'categorical' },
+            { field: 'match', kind: 'numeric' },
+            { field: 'length', kind: 'numeric' },
+        ],
+    },
+    aggregate: {
+        rowwise: false,
+        replacesRows: true,
+        writes: (step, edges) => [
+            ...(step.groupby?.length ? step.groupby : edges).map(kept),
+            ...summaries(step),
+        ],
+    },
+    window: { rowwise: false, replacesRows: false, writes: summaries },
+    coverage: {
+        rowwise: false,
+        replacesRows: true,
+        writes: step => [
+            {
+                field: named(step.as, DEFAULT_COVERAGE_AS),
+                kind: 'numeric',
+                fills: 'y',
+            },
+        ],
+    },
+    pileup: {
+        rowwise: false,
+        replacesRows: false,
+        writes: step => [
+            {
+                field: named(step.as, DEFAULT_PILEUP_AS),
+                kind: 'numeric',
+                fills: 'row',
+            },
+        ],
+    },
+    flatten: {
+        rowwise: false,
+        replacesRows: false,
+        writes: step => [
+            ...(step.index ? [{ field: step.index, kind: 'numeric' }] : []),
+            ...(step.key ? [{ field: step.key, kind: 'categorical' }] : []),
+        ],
+    },
+    mate: {
+        rowwise: false,
+        replacesRows: false,
+        writes: () => MATE_FIELDS.map(field => ({
+            field,
+            kind: field === 'mate.start' || field === 'mate.end'
+                ? 'numeric'
+                : 'categorical',
+            ...(field === 'mate.refName' ? { fills: 'x2' } : {}),
+        })),
+    },
+};
+function outputOf(step) {
+    return Object.hasOwn(STEP_OUTPUTS, step.type)
+        ? STEP_OUTPUTS[step.type]
+        : undefined;
+}
+/**
+ * The fields one step writes. A step this table does not know writes nothing
+ * it can name.
+ */
+export function stepWrites(step, edges = DEFAULT_BIN_AS) {
+    return outputOf(step)?.writes(step, edges) ?? [];
+}
+/** Whether a step answers each row from that row alone, in order. */
+export function isRowwise(step) {
+    return outputOf(step)?.rowwise ?? false;
+}
+/**
+ * What a run of steps leaves: every field written, the last write of each
+ * winning, and, where a step made the rows anew, the only fields that survive
+ * it (`undefined` while the input's own fields all do). `channels` are what
+ * the output fills where a mark leaves them unwritten.
+ */
+export function stepsOutput(steps) {
+    let edges = DEFAULT_BIN_AS;
+    let surviving;
+    const written = new Map();
+    let channels = new Map();
+    for (const step of steps) {
+        const output = step && outputOf(step);
+        if (!step || !output) {
+            continue;
+        }
+        const writes = output.writes(step, edges);
+        if (output.replacesRows) {
+            surviving = new Set(POSITION_FIELDS);
+            for (const [field] of written) {
+                if (!writes.some(w => w.field === field)) {
+                    written.delete(field);
+                }
+            }
+            for (const w of writes) {
+                surviving.add(w.field);
+            }
+            channels = new Map([...channels].filter(([, f]) => surviving.has(f)));
+        }
+        else {
+            for (const w of writes) {
+                surviving?.add(w.field);
+            }
+        }
+        for (const w of writes) {
+            const held = written.get(w.field);
+            written.set(w.field, w.kind === 'unknown' && held ? { ...held, field: w.field } : w);
+            if (w.fills) {
+                channels.set(w.fills, w.field);
+            }
+        }
+        if (step.type === 'bin') {
+            edges = binEdges(step);
+        }
+    }
+    return { written: [...written.values()], surviving, channels };
+}

package/esm/util/stepTables.d.ts

@@ -2,9 +2,7 @@ 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';
-export declare const DEFAULT_BIN_AS: [string, string];
-/** What a `bin` over `fields` writes on each piece: the bases of its interval inside its bin. */
-export declare const BIN_OVERLAP_FIELD = "overlap";
+export { BIN_OVERLAP_FIELD, DEFAULT_BIN_AS } from './stepOutputs.ts';
 /**
  * A table's rows split into sections, each a contiguous range: `bounds[s]` is
  * where section `s` starts and `bounds[s + 1]` where it ends. A step keeps
@@ -94,3 +92,9 @@ export declare class OpSums {
     add(g: number, v: number, w: number): void;
     column(groups: number): Column;
 }
+export declare function sortByStart(rows: Uint32Array, starts: Float64Array): void;
+export declare function groupRows(n: number, bounds: Bounds, reads: readonly ((i: number) => unknown)[], normalize: boolean): {
+    groupOf: Uint32Array<ArrayBuffer>;
+    firstRow: number[];
+    sectionOf: number[];
+};

package/esm/util/stepTables.js

@@ -6,9 +6,7 @@ import { DerivedTable, NO_COLUMN, TableRow, numberReaderOf, readerOf, valueAt, }
 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';
+export { BIN_OVERLAP_FIELD, DEFAULT_BIN_AS } from './stepOutputs.js';
 // 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) {
@@ -275,3 +273,88 @@ export class OpSums {
         return { kind: 'number', values, at: undefined, nanIsAbsent: true };
     }
 }
+// Rows in start order, ties in the order they came: a start and a row packed
+// into one double and sorted without a comparator, which leaves the typed
+// sort's fast path only where the packing could not be exact.
+export function sortByStart(rows, starts) {
+    const n = rows.length;
+    let lo = Infinity;
+    let hi = -Infinity;
+    let whole = true;
+    for (let k = 0; k < n; k++) {
+        const v = starts[rows[k]];
+        if (v < lo) {
+            lo = v;
+        }
+        if (v > hi) {
+            hi = v;
+        }
+        whole &&= Number.isInteger(v);
+    }
+    if (whole && (hi - lo + 1) * n < Number.MAX_SAFE_INTEGER) {
+        const keys = new Float64Array(n);
+        for (let k = 0; k < n; k++) {
+            keys[k] = (starts[rows[k]] - lo) * n + k;
+        }
+        keys.sort();
+        const placed = Uint32Array.from(rows);
+        for (let k = 0; k < n; k++) {
+            rows[k] = placed[keys[k] % n];
+        }
+    }
+    else {
+        rows.sort((a, b) => starts[a] - starts[b] || a - b);
+    }
+}
+// Each row's group, numbered in the order groups are first met, a section
+// being the outermost level: the groups keyed by their raw values, one Map
+// level per groupby field, where a string key built per row was the
+// aggregate's whole cost.
+export function groupRows(n, bounds, reads, normalize) {
+    const groupOf = new Uint32Array(n);
+    const firstRow = [];
+    const sectionOf = [];
+    const last = reads.length - 1;
+    for (let s = 0; s + 1 < bounds.length; s++) {
+        const root = new Map();
+        for (let i = bounds[s]; i < bounds[s + 1]; i++) {
+            let g;
+            if (reads.length === 0) {
+                g =
+                    firstRow.length > 0 && sectionOf.at(-1) === s
+                        ? firstRow.length - 1
+                        : -1;
+                if (g < 0) {
+                    g = firstRow.length;
+                    firstRow.push(i);
+                    sectionOf.push(s);
+                }
+            }
+            else {
+                let node = root;
+                for (let l = 0; l < last; l++) {
+                    const raw = reads[l](i);
+                    const v = normalize && typeof raw !== 'object' ? raw : groupKey(raw);
+                    let next = node.get(v);
+                    if (!next) {
+                        next = new Map();
+                        node.set(v, next);
+                    }
+                    node = next;
+                }
+                const raw = reads[last](i);
+                const v = normalize && typeof raw !== 'object' ? raw : groupKey(raw);
+                let at = node.get(v);
+                if (at === undefined) {
+                    at = firstRow.length;
+                    node.set(v, at);
+                    firstRow.push(i);
+                    sectionOf.push(s);
+                }
+                g = at;
+            }
+            groupOf[i] = g;
+        }
+    }
+    return { groupOf, firstRow, sectionOf };
+}

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;