@jbrowse/plugin-linear-genome-view 5.0.0-beta.17 → 5.0.0-beta.19

package/esm/TrackModifiers/index.js

@@ -0,0 +1,212 @@
+import { mergeConfSettings } from '@jbrowse/core/configuration';
+import { getEnv, getSession } from '@jbrowse/core/util';
+import { basePaintedAt } from '@jbrowse/core/util/Base1DUtils';
+import { predicatesOf, testsSomething, withFields, } from '@jbrowse/core/util/fieldPredicate';
+import { normalizeTrackInit, trackDisplayType } from '@jbrowse/core/util/tracks';
+import { buildDisplaySnapshot, displayCategory, memberPatch, memberWrites, mergeSettings, requestedDisplayType, } from '@jbrowse/launch-args/displaySettings';
+import { getSnapshot, getType, isArrayType, isStateTreeNode, } from '@jbrowse/mobx-state-tree';
+/**
+ * The display a linear view opens `conf` as, read off the display picker so it
+ * follows `display:` and the adapter rather than a list of track types.
+ */
+function displayTypeOf(pluginManager, conf, modifiers, displayType) {
+    return trackDisplayType(pluginManager, conf, 'LinearGenomeView', requestedDisplayType(modifiers) ?? displayType);
+}
+/**
+ * `displayTypeOf` for a track the session holds, undefined for one it does
+ * not; `displayType` is the display the caller opens it as when no
+ * `display:` modifier names one.
+ */
+export function openedDisplayType(session, trackId, modifiers, displayType) {
+    const conf = session.getTrackById(trackId);
+    return conf
+        ? displayTypeOf(getEnv(session).pluginManager, (isStateTreeNode(conf) ? getSnapshot(conf) : conf), modifiers, displayType)
+        : undefined;
+}
+const consoleWarn = (message) => {
+    console.warn(`Warning: ${message}`);
+};
+function modifierLaunch(displayType, modifiers, warn = consoleWarn) {
+    return {
+        displayType,
+        settings: buildDisplaySnapshot(displayType, modifiers, warn),
+        members: memberWrites(displayType, modifiers),
+    };
+}
+// the entries grouped by field, as `setFilterFields` takes them: a field whose
+// entries are all bare is `[]`, which clears it, defaults included
+function filterPatch(entries) {
+    const patch = {};
+    for (const p of entries) {
+        patch[p.field] = [
+            ...(patch[p.field] ?? []),
+            ...(testsSomething(p) ? [p] : []),
+        ];
+    }
+    return patch;
+}
+// the display snapshot a track opens with. `filter` stays out of it:
+// `writeFilter` writes it once the track is open, since the list in a
+// snapshot would replace the configured one
+function launchSnapshot({ settings }) {
+    const { snap, displayType } = settings;
+    const { filter: _filter, ...unfiltered } = snap;
+    return {
+        ...unfiltered,
+        ...(displayType ? { type: displayType } : {}),
+    };
+}
+/**
+ * Write the `filter` of `trackId`'s `settings` onto its display open in
+ * `view`, by field over the configured filter, as the track menu would.
+ * Returns the display's filter as written, which reopens the track as drawn,
+ * or undefined when the settings write no filter.
+ */
+export function writeFilter(view, trackId, settings) {
+    const { filter } = settings.snap;
+    const track = view.tracks.find(t => t.configuration.trackId === trackId);
+    if (!filter || !track) {
+        return undefined;
+    }
+    const patch = filterPatch(filter);
+    const display = track.displays[0];
+    if (display?.setFilterFields) {
+        display.setFilterFields(patch);
+        return display.writtenFilter;
+    }
+    const written = withFields(predicatesOf(track.activeDisplay.configuration.filter), patch);
+    view.showTrack(trackId, {}, { filter: written });
+    return written;
+}
+/**
+ * @deprecated `writeFilter`, which every display category takes. This one
+ * writes an alignments `display`'s filter only.
+ */
+export function writeReadFilter(display, displayType, settings) {
+    const { filter } = settings.snap;
+    if (displayCategory(displayType) !== 'alignments' || !filter) {
+        return undefined;
+    }
+    const filterDisplay = display;
+    filterDisplay?.setFilterFields?.(filterPatch(filter));
+    return filterDisplay?.writtenFilter;
+}
+// the pivot is the base under the view's center, which a view has only once
+// it shows a region
+function centerSort(view, trackId, field, warn) {
+    const center = view.centerLineInfo;
+    if (center && !center.oob) {
+        return {
+            field,
+            pos: basePaintedAt(center, center.offset),
+            refName: center.refName ?? '',
+        };
+    }
+    else {
+        warn(`sort:${field} on "${trackId}" ignored — the view has no center position to sort at (pass --loc)`);
+        return undefined;
+    }
+}
+// The modifiers' settings written over the entry's own as a settings bag
+// writes them (`mergeConfSettings`): a namespace such as `pileup` member by
+// member, a bare value lifted first, and a channel such as `encoding.color`
+// whole, so a `color:` modifier is not mixed into the entry's color by field.
+// Plain JSON where no registered display type says which is which.
+function overEntry(view, displayType, entry, over) {
+    const pluginManager = isStateTreeNode(view)
+        ? getEnv(view).pluginManager
+        : undefined;
+    return displayType && pluginManager?.displayTypes.has(displayType)
+        ? mergeConfSettings(pluginManager.getDisplayType(displayType).configSchema, entry, over)
+        : mergeSettings(structuredClone(entry), over);
+}
+/**
+ * Open `trackId` in `view` with its command-line modifiers applied, and return
+ * the session-spec track entry that reopens it as drawn, or undefined when the
+ * open fails, which `launchTrack` reports to the session.
+ */
+export async function launchTrackWithModifiers(view, trackId, displayType, modifiers, { displaySnapshot = {}, trackSnapshot = {}, adjust, warn = consoleWarn, } = {}) {
+    const launch = modifierLaunch(displayType, modifiers, warn);
+    const { snap, sort } = launch.settings;
+    const at = sort && centerSort(view, trackId, sort.field, warn);
+    if (at) {
+        snap.sort = at;
+    }
+    adjust?.(launch.settings);
+    const launched = overEntry(view, displayType, displaySnapshot, launchSnapshot(launch));
+    const opened = await view.launchTrack(trackId, trackSnapshot, launched);
+    if (!opened) {
+        return undefined;
+    }
+    const drawnFilter = writeFilter(view, trackId, launch.settings);
+    const members = writeMembers(view, trackId, launch.members);
+    return {
+        trackId,
+        ...launched,
+        ...(drawnFilter ? { filter: drawnFilter } : {}),
+        ...members,
+    };
+}
+/**
+ * Open a session spec's track entry in a navigated `view`, its `modifiers`
+ * written over its display settings. When a modifier or the open fails, the
+ * session's snackbar says why and the track opens with its own settings.
+ */
+export async function launchTrackInit(view, t) {
+    const { trackId, trackSnapshot, displaySnapshot, modifiers } = normalizeTrackInit(t);
+    if (modifiers.length === 0) {
+        await view.launchTrack(trackId, trackSnapshot, displaySnapshot);
+        return;
+    }
+    const session = getSession(view);
+    const { type } = displaySnapshot;
+    const notes = [];
+    try {
+        await launchTrackWithModifiers(view, trackId, openedDisplayType(session, trackId, modifiers, typeof type === 'string' ? type : undefined), modifiers, {
+            trackSnapshot,
+            displaySnapshot,
+            warn: message => notes.push(message),
+        });
+    }
+    catch (e) {
+        console.error(e);
+        session.notifyError(`"${trackId}" ${modifiers.join(' ')}: ${e}`, e);
+    }
+    // launchTrack reports its own failure, such as a display:
+    // the track cannot open as
+    if (!view.tracks.some(t => t.configuration.trackId === trackId)) {
+        await view.launchTrack(trackId, trackSnapshot, displaySnapshot);
+    }
+    if (notes.length) {
+        session.notify(notes.join('; '), 'warning');
+    }
+}
+/**
+ * Write a track's `memberWrites` onto what its display in `view` already has,
+ * after every other modifier, so a member write keeps the rest of the setting
+ * whatever order the command line gives them in. A display replaces a color
+ * or facet object whole, which is why these cannot ride in on the launch
+ * snapshot.
+ */
+export function writeMembers(view, trackId, members) {
+    if (members.length === 0) {
+        return {};
+    }
+    const track = view.tracks.find(t => t.configuration.trackId === trackId);
+    if (!track) {
+        throw new Error(`"${trackId}" is not open, so ${members.join(' ')} has nothing to write to`);
+    }
+    const { configuration } = track.activeDisplay;
+    const configured = getSnapshot(configuration);
+    const patch = memberPatch(members, root => {
+        // a list at a default the snapshot strips, Manhattan's marks, still seeds
+        // the write, so `marks.0.mark=bar` edits the mark drawn
+        const member = configuration[root];
+        return (configured[root] ??
+            (isStateTreeNode(member) && isArrayType(getType(member))
+                ? getSnapshot(member)
+                : undefined));
+    });
+    view.showTrack(trackId, {}, patch);
+    return patch;
+}

package/esm/displayKitTests/perRegionTestEnv.d.ts

@@ -31,7 +31,7 @@ export interface PerRegionTestControl {
      */
     estimateBytes: number;
     estimateCalls: number;
-    /** the display's own density verdict, canvas's second too-large axis */
+    /** the display's own density verdict, the feature display's second too-large axis */
     densityTooLarge: boolean;
     /**
      * What the next fetch stores, so a test can tell the payload a refetch
@@ -45,7 +45,7 @@ export interface PerRegionTestControl {
  * displays compose this foundation, and every one of them adds a plugin's worth
  * of behavior on top — so a test that boots one is testing that plugin as much
  * as the foundation, which is how the foundation's own autoruns came to be
- * pinned only by canvas's suite.
+ * pinned only by the feature display's suite.
  */
 /** Which of the gate's opt-in hooks this display overrides. */
 export interface GateOptIns {
@@ -266,7 +266,9 @@ declare function makeStateModel(control: PerRegionTestControl, gate: GateOptIns,
     readonly plotKeys: string[];
     readonly plot: import("@jbrowse/core/configuration").Plot;
     readonly configNotices: string[];
+} & {
     readonly notices: string[];
+} & {
     readonly cornerNotices: string[];
     readonly plotExamples: readonly import("@jbrowse/core/configuration").PlotExample[];
     readonly configDocsUrl: string;
@@ -498,12 +500,12 @@ export declare function createPerRegionTestEnvironment({ measuresBytes, gate, es
      */
     estimateBytes?: number;
 }): {
-    createDisplay: ({ displayedRegions, displaySnapshot, skipWidth, regionsInSnapshot, }?: {
+    createDisplay: (args_0?: {
         displayedRegions?: import("@jbrowse/core/util").Region[];
         displaySnapshot?: Record<string, unknown>;
         skipWidth?: boolean;
         regionsInSnapshot?: boolean;
-    }) => {
+    } | undefined) => {
         session: import("@jbrowse/mobx-state-tree").ModelInstanceTypeProps<{
             name: import("@jbrowse/mobx-state-tree").IType<string | undefined, string, string>;
             view: import("@jbrowse/mobx-state-tree").IMaybe<import("@jbrowse/mobx-state-tree").IAnyModelType>;
@@ -804,7 +806,9 @@ export declare function createPerRegionTestEnvironment({ measuresBytes, gate, es
             readonly plotKeys: string[];
             readonly plot: import("@jbrowse/core/configuration").Plot;
             readonly configNotices: string[];
+        } & {
             readonly notices: string[];
+        } & {
             readonly cornerNotices: string[];
             readonly plotExamples: readonly import("@jbrowse/core/configuration").PlotExample[];
             readonly configDocsUrl: string;
@@ -1231,7 +1235,9 @@ export declare function createPerRegionTestEnvironment({ measuresBytes, gate, es
             readonly plotKeys: string[];
             readonly plot: import("@jbrowse/core/configuration").Plot;
             readonly configNotices: string[];
+        } & {
             readonly notices: string[];
+        } & {
             readonly cornerNotices: string[];
             readonly plotExamples: readonly import("@jbrowse/core/configuration").PlotExample[];
             readonly configDocsUrl: string;

package/esm/index.d.ts

@@ -29,12 +29,14 @@ export { searchBoxMenuItems, useSearchBoxPrefs, } from './LinearGenomeView/compo
 export type { SearchBoxPrefs } from './LinearGenomeView/components/useSearchBoxPrefs.ts';
 export { normalizeTrackInit } from '@jbrowse/core/util/tracks';
 export { applyInitHighlights } from './LinearGenomeView/afterAttach.ts';
+export { launchTrackInit, launchTrackWithModifiers, openedDisplayType, writeFilter, writeMembers, writeReadFilter, } from './TrackModifiers/index.ts';
+export type { ModifierView } from './TrackModifiers/index.ts';
 export { MultiLevelRubberband, multiLevelRowClickMenuItems, multiLevelRowMenuItems, rowLabels, } from './MultiLevelRubberband/index.ts';
 export { fetchResults, SearchResultsNotFoundError } from './searchUtils.ts';
 export type { LaunchLinearGenomeViewArgs } from './LaunchLinearGenomeView/index.ts';
 export type { BpOffset, ExportSvgOptions, HighlightInput, HighlightType, InitState, LinearGenomeViewLaunchProps, NavLocation, TrackLabelMode, ViewTrackLabelMode, VolatileGuide, } from './LinearGenomeView/types.ts';
 export type { ScalebarRefNameLabel } from './LinearGenomeView/util.ts';
-export type { HighlightRegion, SearchPickerRow, SearchPickerState, } from './LinearGenomeView/model.ts';
+export type { HighlightRegion, SearchHits, SearchPickerRow, SearchPickerState, } from './LinearGenomeView/model.ts';
 export type { RegionsOrientation } from './LinearGenomeView/util.ts';
 export type { RegionEdit } from './LinearGenomeView/util.ts';
 export { makeTicks } from './LinearGenomeView/util.ts';

package/esm/index.js

@@ -4,7 +4,6 @@ import { isAbstractMenuManager } from '@jbrowse/core/util';
 import { VIEW_TRACK_LABEL_MODES } from '@jbrowse/display-kit/types';
 import { types } from '@jbrowse/mobx-state-tree';
 import LineStyleIcon from '@mui/icons-material/LineStyle';
-import FeatureTrackF from './FeatureTrack/index.js';
 import LaunchLinearGenomeViewF from './LaunchLinearGenomeView/index.js';
 import SequenceFeatureHoverHighlightExtensionF from './LinearGenomeView/components/SequenceFeatureHoverHighlightExtension.js';
 import LinearGenomeViewF from './LinearGenomeView/index.js';
@@ -33,7 +32,6 @@ export default class LinearGenomeViewPlugin extends Plugin {
         },
     });
     install(pluginManager) {
-        FeatureTrackF(pluginManager);
         LinearGenomeViewF(pluginManager);
         LaunchLinearGenomeViewF(pluginManager);
         SequenceFeatureHoverHighlightExtensionF(pluginManager);
@@ -71,6 +69,7 @@ export { default as HeaderSearchBoxRow } from './LinearGenomeView/components/Hea
 export { searchBoxMenuItems, useSearchBoxPrefs, } from './LinearGenomeView/components/useSearchBoxPrefs.js';
 export { normalizeTrackInit } from '@jbrowse/core/util/tracks';
 export { applyInitHighlights } from './LinearGenomeView/afterAttach.js';
+export { launchTrackInit, launchTrackWithModifiers, openedDisplayType, writeFilter, writeMembers, writeReadFilter, } from './TrackModifiers/index.js';
 export { MultiLevelRubberband, multiLevelRowClickMenuItems, multiLevelRowMenuItems, rowLabels, } from './MultiLevelRubberband/index.js';
 export { fetchResults, SearchResultsNotFoundError } from './searchUtils.js';
 // The scalebar's grid, published because it is a contract other views draw

package/esm/searchUtils.d.ts

@@ -3,7 +3,7 @@ import type BaseResult from '@jbrowse/core/TextSearch/BaseResults';
 import type TextSearchManager from '@jbrowse/core/TextSearch/TextSearchManager';
 import type { Assembly } from '@jbrowse/core/assemblyManager/assembly';
 import type { SearchType } from '@jbrowse/core/data_adapters/BaseAdapter';
-import type { AssemblyHost, NotificationSink, TrackCatalog } from '@jbrowse/core/util';
+import type { AbstractSessionModel, AssemblyHost, NotificationSink, TrackCatalog } from '@jbrowse/core/util';
 declare module '@jbrowse/core/PluginManager' {
     interface ExtensionPointRegistry {
         'LinearGenomeView-searchResultSelected': {
@@ -67,7 +67,19 @@ interface SearchArgs {
     assembly?: Assembly;
     signal?: AbortSignal;
 }
-export declare function fetchResults(args: SearchArgs): Promise<BaseResult[]>;
+interface SessionSearchArgs {
+    session: Pick<AbstractSessionModel, 'assemblyManager' | 'textSearchManager'>;
+    queryString: string;
+    assemblyName: string;
+    searchType?: SearchType;
+    signal?: AbortSignal;
+}
+/**
+ * The search box's hits for a query: refNames and text-index results, merged.
+ * Pass the session and the function finds the index manager and the assembly
+ * itself; passing `textSearchManager` and `assembly` is the older form.
+ */
+export declare function fetchResults(args: SessionSearchArgs | SearchArgs): Promise<BaseResult[]>;
 export declare function nameNotFound(input: string, assemblyName: string, { indexCount, failures }: {
     indexCount: number;
     failures: unknown[];

package/esm/searchUtils.js

@@ -1,11 +1,11 @@
 import { RefSequenceResult } from '@jbrowse/core/TextSearch/BaseResults';
-import { groupByPlace } from '@jbrowse/core/TextSearch/places';
-import { dedupe, getEnv, getNotificationSink, getSession, matchRefNames, MAX_GLOB_REGIONS, UnknownRefNameError, } from '@jbrowse/core/util';
+import { groupByPlace, landsInAssembly } from '@jbrowse/core/TextSearch/places';
+import { dedupe, getEnv, getNotificationSink, getSession, matchRefNames, MAX_GLOB_REGIONS, rankRefNames, UnknownRefNameError, } from '@jbrowse/core/util';
 import { isAlive } from '@jbrowse/mobx-state-tree';
 import { parseLocStrings } from './LinearGenomeView/util.js';
 // Budget for refName suggestions from a query. Deliberately far below the
-// autocomplete's ~100-row display cap: refNames are returned ahead of the text
-// search hits, so a scaffold-heavy assembly would otherwise fill every row with
+// autocomplete's ~100-row display cap: exact and prefix refName hits are
+// returned ahead of the text search hits, so a scaffold-heavy assembly would otherwise fill every row with
 // scaffolds and push the gene hits out of the list entirely. Raising this to
 // match the display cap looks like a consistency fix and is not one.
 const MAX_REFNAME_HITS = 10;
@@ -274,16 +274,20 @@ export async function handleSelectedRegion({ input, model, assemblyName, grow, s
         }
         else {
             // no search hits: still try to resolve the input as a locstring (bare
-            // refname, "ref start end" triplet, etc). if that also can't find a
-            // refname AND the input is a single bare token (a plausible gene name),
-            // reframe the unknown-ref error as a name miss; keep the specific ref
-            // error for coordinate/multi-part queries
+            // refname, "ref start end" triplet, etc). If that also can't find a
+            // refname and the input names no sequence and no coordinate — a gene
+            // name, or a phrase like "breast cancer" — reframe the unknown-ref error
+            // as a name miss; keep the specific ref error for coordinate-shaped input
             try {
                 await navToLocstrings();
                 return true;
             }
             catch (e) {
-                const isPlainName = !input.includes(':') && !input.includes(' ');
+                const isPlainName = !input.includes(':') &&
+                    input
+                        .trim()
+                        .split(/\s+/)
+                        .every(token => !isRef(token) && !/^\d[\d,]*$/.test(token));
                 if (e instanceof UnknownRefNameError && isPlainName) {
                     throw nameNotFound(input, assemblyName, found);
                 }
@@ -308,17 +312,39 @@ async function searchNames({ queryString, searchType, assemblyName, textSearchMa
     // not itself kick off the lazy load. A load failure just leaves allRefNames
     // undefined, so this still returns whatever the text search turned up
     await assembly?.load().catch(() => { });
-    const refNameResults = assembly
+    const { strong, weak } = assembly
         ? searchRefNames(assembly, queryString, searchType)
-        : [];
+        : { strong: [], weak: [] };
     return {
-        results: dedupe([...refNameResults, ...(report?.results ?? [])], elt => elt.getId()),
+        results: dedupe([
+            ...strong,
+            ...(report?.results ?? []).filter(r => landsInAssembly(r, assembly)),
+            ...weak,
+        ], elt => elt.getId()),
         indexCount: report?.indexCount ?? 0,
         failures: report?.failures ?? [],
     };
 }
+/**
+ * The search box's hits for a query: refNames and text-index results, merged.
+ * Pass the session and the function finds the index manager and the assembly
+ * itself; passing `textSearchManager` and `assembly` is the older form.
+ */
 export async function fetchResults(args) {
-    return (await searchNames(args)).results;
+    if ('session' in args) {
+        const { session, ...rest } = args;
+        const assembly = await session.assemblyManager
+            .waitForAssembly(args.assemblyName)
+            .catch(() => undefined);
+        return (await searchNames({
+            ...rest,
+            textSearchManager: session.textSearchManager,
+            assembly,
+        })).results;
+    }
+    else {
+        return (await searchNames(args)).results;
+    }
 }
 // A miss says when an index could not answer: with none answering it is a
 // failure, and with some answering it is still a miss, naming what failed
@@ -333,30 +359,24 @@ export function nameNotFound(input, assemblyName, { indexCount, failures }) {
             })
             : new SearchResultsNotFoundError(`${miss} (a search index failed: ${failure})`, { cause: failure });
 }
-// Scan assembly refnames for query matches, resolving aliases (e.g. 'contigB')
-// to the canonical refname ('ctgB') so the dropdown shows the name that matches
-// the FASTA / displayed regions. allRefNames can hold ~10^6 entries, so stop
-// once enough unique canonical hits accumulate rather than lowercasing and
-// scanning the entire list on every keystroke.
+// The refNames a query names, through the same ranking the dropdown's fallback
+// list uses. A refName the query is only a substring of is the weakest kind of
+// hit, so it goes behind the text-search results rather than ahead of them
 function searchRefNames(assembly, queryString, searchType) {
-    const q = queryString.toLowerCase();
-    // canonical name -> whether any alias of it matched the query exactly, so
-    // "contigb" is an exact hit on ctgB even though the canonical name is not
-    // the query. Same collapsing as before, now carrying the flag through it
-    const canonicalHits = new Map();
-    for (const ref of assembly.allRefNames ?? []) {
-        const lower = ref.toLowerCase();
-        const exact = lower === q;
-        const isMatch = searchType === 'exact' ? exact : lower.startsWith(q);
-        if (isMatch) {
-            const canonical = assembly.getCanonicalRefName2(ref);
-            canonicalHits.set(canonical, exact || !!canonicalHits.get(canonical));
-            if (canonicalHits.size >= MAX_REFNAME_HITS) {
-                break;
-            }
-        }
-    }
-    return [...canonicalHits].map(([r, exact]) => new RefSequenceResult({ label: r, refName: r, exact }));
+    const hits = rankRefNames(assembly, queryString, MAX_REFNAME_HITS)
+        .filter(({ tier }) => searchType !== 'exact' || tier === 'exact')
+        .map(({ refName, tier }) => ({
+        tier,
+        result: new RefSequenceResult({
+            label: refName,
+            refName,
+            exact: tier === 'exact',
+        }),
+    }));
+    return {
+        strong: hits.filter(h => h.tier !== 'substring').map(h => h.result),
+        weak: hits.filter(h => h.tier === 'substring').map(h => h.result),
+    };
 }
 // splits on the last instance of a character
 export function splitLast(str, split) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jbrowse/plugin-linear-genome-view",
-  "version": "5.0.0-beta.17",
+  "version": "5.0.0-beta.19",
   "type": "module",
   "description": "JBrowse 2 linear genome view",
   "keywords": [
@@ -21,15 +21,16 @@
     "esm"
   ],
   "dependencies": {
-    "@jbrowse/mobx-state-tree": "^6.9.0",
+    "@jbrowse/mobx-state-tree": "^6.10.0",
     "@mui/icons-material": "^9.5.0",
     "@mui/material": "^9.5.0",
-    "mobx": "^7.0.6",
-    "mobx-react": "^10.0.2",
-    "@jbrowse/core": "^5.0.0-beta.17",
-    "@jbrowse/display-ui": "^5.0.0-beta.17",
-    "@jbrowse/render-core": "^5.0.0-beta.17",
-    "@jbrowse/display-kit": "^5.0.0-beta.17"
+    "mobx": "^7.1.3",
+    "mobx-react": "^10.0.3",
+    "@jbrowse/core": "^5.0.0-beta.19",
+    "@jbrowse/display-kit": "^5.0.0-beta.19",
+    "@jbrowse/launch-args": "^5.0.0-beta.19",
+    "@jbrowse/display-ui": "^5.0.0-beta.19",
+    "@jbrowse/render-core": "^5.0.0-beta.19"
   },
   "peerDependencies": {
     "react": ">=19.0.0",
@@ -40,7 +41,7 @@
   },
   "sideEffects": false,
   "devDependencies": {
-    "@jbrowse/display-test-utils": "^5.0.0-beta.17"
+    "@jbrowse/display-test-utils": "^5.0.0-beta.19"
   },
   "scripts": {
     "prebuild": "pnpm clean",