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

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/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/tracks.js

@@ -693,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.

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/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 {};

package/esm/util/windowStep.js

@@ -0,0 +1,153 @@
+// The `window` step, Vega-Lite's window transform over a group's rows in
+// start order. Imported by relative path only.
+import { aggregateFieldName } from './aggregateFieldName.js';
+import { numberReaderOf, readerOf, withColumns } from './featureTable.js';
+import { isPlainFieldRef } from './fieldReader.js';
+import { groupRows, isWeighted, sortByStart, stepNumberReader, stepReader, } from './stepTables.js';
+export const DEFAULT_WINDOW_FRAME = [-10, 10];
+// The rows grouped, groups in the order first met and so sections outermost,
+// each group's rows in start order, an unreadable start sorting last; and
+// where each group's rows begin.
+function windowOrder(table, groupOf, groups) {
+    const n = table.length;
+    const groupStart = new Uint32Array(groups + 1);
+    for (let i = 0; i < n; i++) {
+        groupStart[groupOf[i] + 1]++;
+    }
+    for (let g = 0; g < groups; g++) {
+        groupStart[g + 1] += groupStart[g];
+    }
+    const order = new Uint32Array(n);
+    const next = groupStart.slice(0, groups);
+    for (let i = 0; i < n; i++) {
+        order[next[groupOf[i]]++] = i;
+    }
+    const readStart = numberReaderOf(table.column('start'));
+    const starts = new Float64Array(n);
+    for (let i = 0; i < n; i++) {
+        const s = readStart(i);
+        starts[i] = Number.isNaN(s) ? Infinity : s;
+    }
+    for (let g = 0; g < groups; g++) {
+        const rows = order.subarray(groupStart[g], groupStart[g + 1]);
+        let sorted = true;
+        for (let k = 1; k < rows.length && sorted; k++) {
+            sorted = starts[rows[k]] >= starts[rows[k - 1]];
+        }
+        if (!sorted) {
+            sortByStart(rows, starts);
+        }
+    }
+    return { order, groupStart };
+}
+// The rows `[first, last]` of a group of `m` around its row `j`, empty where
+// `first` passes `last`.
+function frameAt([before, after], j, m) {
+    return [
+        before === null ? 0 : Math.max(0, j + before),
+        after === null ? m - 1 : Math.min(m - 1, j + after),
+    ];
+}
+// A sum, count or mean over each frame from running totals, which answer an
+// empty frame exactly 0, since the totals hold one value across it.
+function totalsOver(op, values, weights, frame, lo, hi, out) {
+    const m = hi - lo;
+    const weightTotal = new Float64Array(m + 1);
+    const sumTotal = new Float64Array(m + 1);
+    for (let j = 0; j < m; j++) {
+        const v = values[lo + j];
+        const w = weights[lo + j];
+        const counted = Number.isFinite(v) && Number.isFinite(w);
+        weightTotal[j + 1] = weightTotal[j] + (counted ? w : 0);
+        sumTotal[j + 1] = sumTotal[j] + (counted ? v * w : 0);
+    }
+    for (let j = 0; j < m; j++) {
+        const [a, b] = frameAt(frame, j, m);
+        const weight = a > b ? 0 : weightTotal[b + 1] - weightTotal[a];
+        const sum = a > b ? 0 : sumTotal[b + 1] - sumTotal[a];
+        out[lo + j] =
+            op === 'count'
+                ? weight
+                : op === 'sum'
+                    ? sum
+                    : weight === 0
+                        ? Number.NaN
+                        : sum / weight;
+    }
+}
+// A min or max over each frame through a monotonic queue of row positions,
+// which holds because neither end of a frame ever moves back.
+function extremeOver(op, values, frame, lo, hi, out) {
+    const m = hi - lo;
+    const queue = new Uint32Array(m);
+    let head = 0;
+    let tail = 0;
+    let added = 0;
+    for (let j = 0; j < m; j++) {
+        const [a, b] = frameAt(frame, j, m);
+        for (; added <= b; added++) {
+            const v = values[lo + added];
+            if (!Number.isFinite(v)) {
+                continue;
+            }
+            while (tail > head &&
+                (op === 'min'
+                    ? values[lo + queue[tail - 1]] >= v
+                    : values[lo + queue[tail - 1]] <= v)) {
+                tail--;
+            }
+            queue[tail++] = added;
+        }
+        while (head < tail && queue[head] < a) {
+            head++;
+        }
+        out[lo + j] = head < tail ? values[lo + queue[head]] : Number.NaN;
+    }
+}
+function windowColumn(table, agg, order, groupStart, frame) {
+    const { op, field, weight } = agg;
+    if (op !== 'count' && field === undefined) {
+        throw new Error(`a window ${op} needs a field`);
+    }
+    const n = order.length;
+    const readValue = field === undefined || op === 'count'
+        ? () => 0
+        : stepNumberReader(table, field, 'a window');
+    const readWeight = weight !== undefined && isWeighted(agg)
+        ? stepNumberReader(table, weight, 'a window')
+        : () => 1;
+    const values = new Float64Array(n);
+    const weights = new Float64Array(n);
+    for (let k = 0; k < n; k++) {
+        values[k] = readValue(order[k]);
+        weights[k] = readWeight(order[k]);
+    }
+    const out = new Float64Array(n);
+    for (let g = 0; g + 1 < groupStart.length; g++) {
+        const lo = groupStart[g];
+        const hi = groupStart[g + 1];
+        if (op === 'min' || op === 'max') {
+            extremeOver(op, values, frame, lo, hi, out);
+        }
+        else {
+            totalsOver(op, values, weights, frame, lo, hi, out);
+        }
+    }
+    return op === 'count' || op === 'sum'
+        ? { kind: 'number', values: out, at: undefined }
+        : { kind: 'number', values: out, at: undefined, nanIsAbsent: true };
+}
+export function windowStep({ table, bounds }, step) {
+    const { groupby = [], ops, frame = DEFAULT_WINDOW_FRAME } = step;
+    const keyed = groupby.some(field => !isPlainFieldRef(field));
+    const reads = groupby.map(field => keyed
+        ? stepReader(table, field, 'a window')
+        : readerOf(table.column(field)));
+    const { groupOf, firstRow } = groupRows(table.length, bounds, reads, !keyed);
+    const { order, groupStart } = windowOrder(table, groupOf, firstRow.length);
+    const written = new Map(ops.map(agg => [
+        aggregateFieldName(agg),
+        windowColumn(table, agg, order, groupStart, frame),
+    ]));
+    return { table: withColumns(table, written, order), bounds };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jbrowse/core",
-  "version": "5.0.0-beta.13",
+  "version": "5.0.0-beta.14",
   "type": "module",
   "description": "JBrowse 2 core libraries used by plugins",
   "keywords": [
@@ -33,6 +33,7 @@
     "./PluginManager": "./esm/PluginManager.js",
     "./ReExports/list": "./esm/ReExports/list.js",
     "./ReExports/modules": "./esm/ReExports/modules.js",
+    "./ReExports/names": "./esm/ReExports/names.js",
     "./ReExports/registry": "./esm/ReExports/registry.js",
     "./ReExports/uiStub": "./esm/ReExports/uiStub.js",
     "./ReExports/workerModules": "./esm/ReExports/workerModules.js",
@@ -42,6 +43,8 @@
     "./assemblyManager": "./esm/assemblyManager/index.js",
     "./assemblyManager/assembly": "./esm/assemblyManager/assembly.js",
     "./assemblyManager/assemblyConfigSchema": "./esm/assemblyManager/assemblyConfigSchema.js",
+    "./assemblyManager/expandAssemblyConfigShorthand": "./esm/assemblyManager/expandAssemblyConfigShorthand.js",
+    "./assemblyManager/refNameMaps": "./esm/assemblyManager/refNameMaps.js",
     "./checkPlugins": "./esm/checkPlugins.js",
     "./configuration": "./esm/configuration/index.js",
     "./configuration/configurationSchema": "./esm/configuration/configurationSchema.js",
@@ -97,6 +100,7 @@
     "./ui/CascadingMenuButton": "./esm/ui/CascadingMenuButton.js",
     "./ui/ColorPicker": "./esm/ui/ColorPicker.js",
     "./ui/ConfirmDialog": "./esm/ui/ConfirmDialog.js",
+    "./ui/ContextMenu": "./esm/ui/ContextMenu.js",
     "./ui/DataGridFlexContainer": "./esm/ui/DataGridFlexContainer.js",
     "./ui/Dialog": "./esm/ui/Dialog.js",
     "./ui/DraggableDialog": "./esm/ui/DraggableDialog.js",
@@ -145,6 +149,7 @@
     "./ui/multiTrackMenuItems": "./esm/ui/multiTrackMenuItems.js",
     "./ui/palette": "./esm/ui/palette.js",
     "./ui/persistentScrollbarStyle": "./esm/ui/persistentScrollbarStyle.js",
+    "./ui/rampKey": "./esm/ui/rampKey.js",
     "./ui/scrollZoomLabels": "./esm/ui/scrollZoomLabels.js",
     "./ui/showSubMenu": "./esm/ui/showSubMenu.js",
     "./ui/styleTheme": "./esm/ui/styleTheme.js",
@@ -241,9 +246,11 @@
     "./util/numericUtils": "./esm/util/numericUtils.js",
     "./util/offscreenCanvasPonyfill": "./esm/util/offscreenCanvasPonyfill.js",
     "./util/openViews": "./esm/util/openViews.js",
+    "./util/originCut": "./esm/util/originCut.js",
     "./util/paintLayer": "./esm/util/paintLayer.js",
     "./util/parseLineByLine": "./esm/util/parseLineByLine.js",
     "./util/preloadComponent": "./esm/util/preloadComponent.js",
+    "./util/pressOwner": "./esm/util/pressOwner.js",
     "./util/progress": "./esm/util/progress.js",
     "./util/quantileExtent": "./esm/util/quantileExtent.js",
     "./util/range": "./esm/util/range.js",
@@ -260,6 +267,7 @@
     "./util/simpleFeature": "./esm/util/simpleFeature.js",
     "./util/starFusion": "./esm/util/starFusion.js",
     "./util/stats": "./esm/util/stats.js",
+    "./util/stepOutputs": "./esm/util/stepOutputs.js",
     "./util/svAlt": "./esm/util/svAlt.js",
     "./util/svgColorProps": "./esm/util/svgColorProps.js",
     "./util/systemColorScheme": "./esm/util/systemColorScheme.js",
@@ -300,29 +308,29 @@
     "@emotion/serialize": "^1.3.3",
     "@emotion/utils": "^1.4.2",
     "@floating-ui/react": "^0.27.20",
-    "@gmod/bgzf-filehandle": "^6.7.0",
-    "@gmod/range-cache-filehandle": "^1.5.0",
-    "@gmod/shared-read-cache": "^1.7.2",
-    "@gmod/vcf": "^7.2.0",
+    "@gmod/bgzf-filehandle": "^6.8.0",
+    "@gmod/range-cache-filehandle": "^1.5.2",
+    "@gmod/shared-read-cache": "^2.1.0",
+    "@gmod/vcf": "^7.4.0",
     "@jbrowse/jexl": "^6.0.0",
-    "@jbrowse/mobx-state-tree": "^6.7.0",
+    "@jbrowse/mobx-state-tree": "^6.9.0",
     "@jbrowse/quick-lru": "^8.0.0",
     "@leeoniya/ufuzzy": "^1.0.19",
-    "@mui/icons-material": "^9.4.0",
-    "@mui/material": "^9.4.0",
-    "@mui/system": "^9.4.0",
-    "@mui/x-data-grid": "^9.14.0",
+    "@mui/icons-material": "^9.5.0",
+    "@mui/material": "^9.5.0",
+    "@mui/system": "^9.5.0",
+    "@mui/x-data-grid": "^9.15.0",
     "canvas-sequencer-ts": "^3.1.3",
     "compare-versions": "^6.1.1",
-    "dompurify": "^3.4.16",
-    "generic-filehandle2": "^2.5.0",
-    "idb": "^8.0.3",
+    "dompurify": "^3.4.17",
+    "generic-filehandle2": "^2.5.1",
+    "idb": "^8.0.4",
     "mobx": "^7.0.6",
     "mobx-react": "^10.0.2",
     "rxjs": "^7.8.2",
     "source-map-js": "^1.2.2",
-    "@jbrowse/add-track-core": "^5.0.0-beta.13",
-    "@jbrowse/render-core": "^5.0.0-beta.13"
+    "@jbrowse/add-track-core": "^5.0.0-beta.14",
+    "@jbrowse/render-core": "^5.0.0-beta.14"
   },
   "peerDependencies": {
     "react": ">=19.0.0",