@jbrowse/core 4.1.13 → 4.1.15

package/esm/BaseFeatureWidget/index.d.ts

@@ -1,2 +1,3 @@
 export { configSchema } from './configSchema.ts';
+export type { MaybeSerializedFeat } from './types.tsx';
 export { stateModelFactory } from './stateModelFactory.ts';

package/esm/BaseFeatureWidget/util.d.ts

@@ -6,6 +6,7 @@ export interface Feat {
     type?: string;
     name?: string;
     id?: string;
+    phase?: number;
 }
 export interface ParentFeat extends Feat {
     uniqueId: string;
@@ -33,6 +34,7 @@ export declare function revlist(list: Feat[], seqlen: number): {
     type?: string;
     name?: string;
     id?: string;
+    phase?: number;
 }[];
 export declare function calculateUTRs(cds: Feat[], exons: Feat[]): {
     type: string;
@@ -40,6 +42,7 @@ export declare function calculateUTRs(cds: Feat[], exons: Feat[]): {
     end: number;
     name?: string;
     id?: string;
+    phase?: number;
 }[];
 export declare function calculateUTRs2(cds: Feat[], parentFeat: Feat): {
     type: string;

package/esm/TextSearch/TextSearchManager.d.ts

@@ -12,6 +12,7 @@ export default class TextSearchManager {
     pluginManager: PluginManager;
     adapterCache: QuickLRU<string, BaseTextSearchAdapter>;
     constructor(pluginManager: PluginManager);
+    clearCache(): void;
     loadTextSearchAdapters(searchScope: SearchScope): Promise<BaseTextSearchAdapter[]>;
     relevantAdapters(searchScope: SearchScope): ({
         [x: string]: any;

package/esm/TextSearch/TextSearchManager.js

@@ -9,6 +9,9 @@ export default class TextSearchManager {
     constructor(pluginManager) {
         this.pluginManager = pluginManager;
     }
+    clearCache() {
+        this.adapterCache.clear();
+    }
     loadTextSearchAdapters(searchScope) {
         return Promise.all(this.relevantAdapters(searchScope).map(async (conf) => {
             const adapterId = readConfObject(conf, 'textSearchAdapterId');

package/esm/assemblyManager/index.d.ts

@@ -1,3 +1,4 @@
 export { default } from './assemblyManager.ts';
+export type { AssemblyBaseOpts } from './assemblyManager.ts';
 export { default as assemblyConfigSchemaFactory } from './assemblyConfigSchema.ts';
 export type { BaseAssemblyConfigSchema } from './assemblyConfigSchema.ts';

package/esm/ui/DOMPurifySanitizedHTML.d.ts

@@ -0,0 +1,4 @@
+export default function DOMPurifySanitizedHTML({ value, className, }: {
+    value: string;
+    className?: string;
+}): import("react/jsx-runtime").JSX.Element;

package/esm/ui/DOMPurifySanitizedHTML.js

@@ -0,0 +1,16 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useLayoutEffect, useRef } from 'react';
+import dompurify from 'dompurify';
+export default function DOMPurifySanitizedHTML({ value, className, }) {
+    const spanRef = useRef(null);
+    useLayoutEffect(() => {
+        const el = spanRef.current;
+        if (el) {
+            for (const a of el.querySelectorAll('a')) {
+                a.setAttribute('rel', 'noopener noreferrer');
+                a.setAttribute('target', '_blank');
+            }
+        }
+    }, [value]);
+    return (_jsx("span", { ref: spanRef, className: className, dangerouslySetInnerHTML: { __html: dompurify.sanitize(value) } }));
+}

package/esm/ui/DropDownMenu.js

@@ -19,6 +19,6 @@ function ButtonComponent(props) {
     return (_jsx(Button, { ...props, className: classes.buttonRoot, children: props.children }));
 }
 const DropDownMenu = observer(function DropDownMenu({ menuTitle, menuItems, }) {
-    return (_jsxs(CascadingMenuButton, { menuItems: menuItems, color: "inherit", ButtonComponent: ButtonComponent, children: [menuTitle, _jsx(ArrowDropDown, {})] }));
+    return (_jsxs(CascadingMenuButton, { menuItems: menuItems, color: "inherit", ButtonComponent: ButtonComponent, anchorOrigin: { vertical: 'bottom', horizontal: 'left' }, transformOrigin: { vertical: 'top', horizontal: 'left' }, children: [menuTitle, _jsx(ArrowDropDown, {})] }));
 });
 export default DropDownMenu;

package/esm/ui/MenuTypes.d.ts

@@ -1,4 +1,3 @@
-import type { SvgIconProps } from '@mui/material';
 export interface MenuDivider {
     priority?: number;
     type: 'divider';
@@ -13,7 +12,7 @@ export interface BaseMenuItem {
     label: React.ReactNode;
     priority?: number;
     subLabel?: string;
-    icon?: React.ComponentType<SvgIconProps>;
+    icon?: React.ElementType;
     disabled?: boolean;
     helpText?: string;
 }

package/esm/ui/SanitizedHTML.js

@@ -1,6 +1,5 @@
 import { jsx as _jsx } from "react/jsx-runtime";
-import { useEffect } from 'react';
-import dompurify from 'dompurify';
+import { Suspense, lazy, useLayoutEffect, useRef } from 'react';
 import escapeHTML from 'escape-html';
 import { linkify } from "../util/index.js";
 const htmlTags = [
@@ -36,26 +35,42 @@ const htmlTags = [
     'u',
     'ul',
 ];
-let added = false;
+const DOMPurifySanitizedHTML = lazy(() => import("./DOMPurifySanitizedHTML.js"));
 const full = new RegExp(htmlTags.map(tag => String.raw `<${tag}\b[^>]*>`).join('|'), 'i');
 function isHTML(str) {
     return full.test(str);
 }
-export default function SanitizedHTML({ html: pre, className, }) {
-    const html = linkify(`${pre}`);
-    const value = isHTML(html) ? html : escapeHTML(html);
-    useEffect(() => {
-        if (!added) {
-            added = true;
-            dompurify.addHook('afterSanitizeAttributes', node => {
-                if (node.tagName === 'A') {
-                    node.setAttribute('rel', 'noopener noreferrer');
-                    node.setAttribute('target', '_blank');
+function needsSanitization(str) {
+    return str.includes('<') || str.includes('://');
+}
+function SetHTML({ value, className }) {
+    const spanRef = useRef(null);
+    useLayoutEffect(() => {
+        const el = spanRef.current;
+        if (el) {
+            try {
+                el.setHTML(value);
+                for (const a of el.querySelectorAll('a')) {
+                    a.setAttribute('rel', 'noopener noreferrer');
+                    a.setAttribute('target', '_blank');
                 }
-            });
+            }
+            catch (e) {
+                console.error(e);
+            }
         }
-    }, []);
-    return (_jsx("span", { className: className, dangerouslySetInnerHTML: {
-            __html: dompurify.sanitize(value),
-        } }));
+    }, [value]);
+    return _jsx("span", { ref: spanRef, className: className });
+}
+export default function SanitizedHTML({ html: pre, className, }) {
+    const str = `${pre}`;
+    if (!needsSanitization(str)) {
+        return _jsx("span", { className: className, children: str });
+    }
+    const html = linkify(str);
+    const value = isHTML(html) ? html : escapeHTML(html);
+    if (typeof Element !== 'undefined' && Element.prototype.setHTML) {
+        return _jsx(SetHTML, { value: value, className: className });
+    }
+    return (_jsx(Suspense, { fallback: _jsx("span", { className: className }), children: _jsx(DOMPurifySanitizedHTML, { value: value, className: className }) }));
 }

package/esm/util/IntervalTree.js

@@ -107,13 +107,7 @@ export class IntervalTree {
         const searchNode = new Node(interval);
         const resultNodes = [];
         this.treeSearchInterval(this.root, searchNode, resultNodes);
-        const results = [];
-        for (const node of resultNodes) {
-            for (const v of node.values) {
-                results.push(v);
-            }
-        }
-        return results;
+        return resultNodes.flatMap(node => node.values);
     }
     recalcMax(node) {
         let current = node;

package/esm/util/convertCodingSequenceToPeptides.js

@@ -1,8 +1,9 @@
 import { stitch } from "../BaseFeatureWidget/util.js";
 export function convertCodingSequenceToPeptides({ cds, sequence, codonTable, }) {
+    const phase = cds[0]?.phase ?? 0;
     const str = stitch(cds, sequence);
-    let protein = '';
-    for (let i = 0; i < str.length; i += 3) {
+    let protein = phase > 0 ? '&' : '';
+    for (let i = phase; i < str.length; i += 3) {
         protein += codonTable[str.slice(i, i + 3)] || '&';
     }
     return protein;

package/esm/util/index.d.ts

@@ -23,7 +23,7 @@ export declare function useWidthSetter(view: {
     setWidth: (arg: number) => void;
 }, padding: string): React.RefObject<HTMLDivElement | null>;
 export declare function useDebouncedCallback<T>(callback: (...args: T[]) => void, wait?: number): (...args: T[]) => void;
-export declare function findParentThat(node: IAnyStateTreeNode, predicate: (thing: IAnyStateTreeNode) => boolean): IStateTreeNode<IAnyStateTreeNode>;
+export declare function findParentThat(node: IAnyStateTreeNode, predicate: (thing: IAnyStateTreeNode) => boolean): (object & IStateTreeNode<import("@jbrowse/mobx-state-tree").IAnyComplexType>) | IStateTreeNode<IAnyStateTreeNode>;
 export declare function springAnimate(fromValue: number, toValue: number, setValue: (value: number) => void, onFinish?: () => void, precision?: number, tension?: number, friction?: number, clamp?: boolean): (() => void)[];
 export declare function findParentThatIs<T extends (a: IAnyStateTreeNode) => boolean>(node: IAnyStateTreeNode, predicate: T): TypeTestedByPredicate<T>;
 export declare function getSession(node: IAnyStateTreeNode): AbstractSessionModel;
@@ -55,7 +55,7 @@ export declare function calculateLayoutBounds(featureStart: number, featureEnd:
 export declare function iterMap<T, U>(iter: Iterable<T>, func: (arg: T) => U, sizeHint?: number): U[];
 export declare function findLastIndex<T>(array: T[], predicate: (value: T, index: number, obj: T[]) => boolean): number;
 export declare function findLast<T>(array: T[], predicate: (value: T, index: number, obj: T[]) => boolean): T | undefined;
-export declare function renameRegionIfNeeded(refNameMap: Record<string, string> | undefined, region: Region | Instance<typeof MUIRegion>): Region & {
+export declare function renameRegionIfNeeded(refNameMap: Record<string, string> | undefined, region: Region | Instance<typeof MUIRegion>, getSeqAdapterRefName?: (refName: string) => string): Region & {
     originalRefName?: string;
 };
 export declare function renameRegionsIfNeeded<ARGTYPE extends {

package/esm/util/index.js

@@ -336,22 +336,17 @@ export function findLast(array, predicate) {
     }
     return undefined;
 }
-export function renameRegionIfNeeded(refNameMap, region) {
+export function renameRegionIfNeeded(refNameMap, region, getSeqAdapterRefName) {
     if (isStateTreeNode(region) && !isAlive(region)) {
         return region;
     }
-    if (refNameMap?.[region.refName]) {
-        region = isStateTreeNode(region)
-            ? { ...getSnapshot(region) }
-            : { ...region };
-        const newRef = refNameMap[region.refName];
-        if (newRef) {
-            return {
-                ...region,
-                refName: newRef,
-                originalRefName: region.refName,
-            };
-        }
+    const newRef = refNameMap?.[region.refName];
+    if (newRef) {
+        return {
+            ...(isStateTreeNode(region) ? getSnapshot(region) : region),
+            refName: newRef,
+            originalRefName: getSeqAdapterRefName?.(region.refName) ?? region.refName,
+        };
     }
     return region;
 }
@@ -360,16 +355,21 @@ export async function renameRegionsIfNeeded(assemblyManager, args) {
     if (!args.sessionId) {
         throw new Error('sessionId is required');
     }
-    const assemblyNames = regions.map(region => region.assemblyName);
-    const assemblyMaps = Object.fromEntries(await Promise.all([...new Set(assemblyNames)].map(async (assemblyName) => {
-        return [
-            assemblyName,
-            await assemblyManager.getRefNameMapForAdapter(adapterConfig, assemblyName, args),
-        ];
-    })));
+    const assemblyNames = regions.map(r => r.assemblyName);
+    const uniqueAssemblyNames = [...new Set(assemblyNames)];
+    const assemblyData = Object.fromEntries(await Promise.all(uniqueAssemblyNames.map(async (name) => [
+        name,
+        {
+            refNameMap: await assemblyManager.getRefNameMapForAdapter(adapterConfig, name, args),
+            assembly: assemblyManager.get(name),
+        },
+    ])));
     return {
         ...args,
-        regions: regions.map((region, i) => renameRegionIfNeeded(assemblyMaps[assemblyNames[i]], region)),
+        regions: regions.map((region, i) => {
+            const { refNameMap, assembly } = assemblyData[assemblyNames[i]];
+            return renameRegionIfNeeded(refNameMap, region, assembly ? r => assembly.getSeqAdapterRefName(r) : undefined);
+        }),
     };
 }
 export function minmax(a, b) {

package/esm/util/io/RemoteFileWithRangeCache.d.ts

@@ -1,15 +1,7 @@
 import { RemoteFile } from 'generic-filehandle2';
-export interface BinaryRangeResponse {
-    headers: Record<string, string>;
-    requestDate: Date;
-    responseDate: Date;
-    buffer: Uint8Array;
-}
 export declare function clearCache(): void;
 export declare class RemoteFileWithRangeCache extends RemoteFile {
+    private fetchRange;
+    private getCachedRange;
     fetch(url: string | RequestInfo, init?: RequestInit): Promise<Response>;
-    fetchBinaryRange(url: string, start: number, end: number, options?: {
-        headers?: HeadersInit;
-        stopToken?: string;
-    }): Promise<BinaryRangeResponse>;
 }

package/esm/util/io/RemoteFileWithRangeCache.js

@@ -1,71 +1,119 @@
-import { HttpRangeFetcher } from '@gmod/http-range-fetcher';
 import { RemoteFile } from 'generic-filehandle2';
-const fetchers = {};
-function binaryRangeFetch(url, start, end, options = {}) {
-    const fetcher = fetchers[url];
-    if (!fetcher) {
-        throw new Error(`fetch not registered for ${url}`);
+const MAX_CACHE_ENTRIES = 2000;
+const CHUNK_SIZE = 256 * 1024;
+const MAX_CONCURRENT = 20;
+let cache = new Map();
+let activeCount = 0;
+const queue = [];
+function getCached(key) {
+    return cache.get(key);
+}
+function putCached(key, buffer) {
+    if (cache.size >= MAX_CACHE_ENTRIES) {
+        const firstKey = cache.keys().next().value;
+        if (firstKey !== undefined) {
+            cache.delete(firstKey);
+        }
     }
-    return fetcher(url, start, end, options);
+    cache.set(key, buffer);
 }
-const globalRangeCache = new HttpRangeFetcher({
-    fetch: binaryRangeFetch,
-    size: 500 * 1024 ** 2,
-    chunkSize: 128 * 1024,
-    maxFetchSize: 100 * 1024 ** 2,
-    minimumTTL: 24 * 60 * 60 * 1000,
-});
 export function clearCache() {
-    globalRangeCache.reset();
+    cache = new Map();
 }
-export class RemoteFileWithRangeCache extends RemoteFile {
-    async fetch(url, init) {
-        const str = String(url);
-        if (!fetchers[str]) {
-            fetchers[str] = this.fetchBinaryRange.bind(this);
+function runNext() {
+    if (queue.length > 0 && activeCount < MAX_CONCURRENT) {
+        activeCount++;
+        const next = queue.shift();
+        next();
+    }
+}
+function limitConcurrency(fn) {
+    return new Promise((resolve, reject) => {
+        function run() {
+            fn().then(val => {
+                activeCount--;
+                resolve(val);
+                runNext();
+            }, (err) => {
+                activeCount--;
+                reject(err);
+                runNext();
+            });
         }
-        const range = new Headers(init?.headers).get('range');
-        if (range) {
-            const rangeParse = /bytes=(\d+)-(\d+)/.exec(range);
-            if (rangeParse) {
-                const [, start, end] = rangeParse;
-                const s = Number.parseInt(start, 10);
-                const e = Number.parseInt(end, 10);
-                const len = e - s;
-                const { buffer, headers } = (await globalRangeCache.getRange(`${url}`, s, len + 1));
-                return new Response(buffer, {
-                    status: 206,
-                    headers,
-                });
-            }
+        if (activeCount < MAX_CONCURRENT) {
+            activeCount++;
+            run();
         }
-        return super.fetch(url, init);
-    }
-    async fetchBinaryRange(url, start, end, options = {}) {
-        const requestDate = new Date();
+        else {
+            queue.push(run);
+        }
+    });
+}
+function cacheKey(url, chunkIndex) {
+    return `${url}:${chunkIndex}`;
+}
+export class RemoteFileWithRangeCache extends RemoteFile {
+    async fetchRange(url, start, end, signal) {
         const res = await super.fetch(url, {
-            ...options,
-            headers: {
-                ...options.headers,
-                range: `bytes=${start}-${end}`,
-            },
+            signal: signal ?? undefined,
+            headers: { range: `bytes=${start}-${end}` },
         });
-        const responseDate = new Date();
         if (!res.ok) {
             const errorMessage = `HTTP ${res.status} fetching ${url} bytes ${start}-${end}`;
             const hint = ' (should be 206 for range requests)';
             throw new Error(`${errorMessage}${res.status === 200 ? hint : ''}`);
         }
-        const headers = {};
-        for (const [k, v] of res.headers.entries()) {
-            headers[k] = v;
+        return new Uint8Array(await res.arrayBuffer());
+    }
+    async getCachedRange(url, start, length, signal) {
+        const startChunk = Math.floor(start / CHUNK_SIZE);
+        const endChunk = Math.floor((start + length - 1) / CHUNK_SIZE);
+        const chunkCount = endChunk - startChunk + 1;
+        const chunks = await Promise.all(Array.from({ length: chunkCount }, (_, i) => {
+            const idx = startChunk + i;
+            const key = cacheKey(url, idx);
+            const existing = getCached(key);
+            if (existing) {
+                return Promise.resolve(existing);
+            }
+            return limitConcurrency(async () => {
+                const alreadyCached = getCached(key);
+                if (alreadyCached) {
+                    return alreadyCached;
+                }
+                const chunkStart = idx * CHUNK_SIZE;
+                const chunkEnd = chunkStart + CHUNK_SIZE - 1;
+                const data = await this.fetchRange(url, chunkStart, chunkEnd, signal);
+                putCached(key, data);
+                return data;
+            });
+        }));
+        const offsetInFirstChunk = start - startChunk * CHUNK_SIZE;
+        const result = new Uint8Array(length);
+        let written = 0;
+        for (const [i, chunk_] of chunks.entries()) {
+            const chunk = chunk_;
+            const sourceStart = i === 0 ? offsetInFirstChunk : 0;
+            const available = chunk.length - sourceStart;
+            const needed = length - written;
+            const copyLen = Math.min(available, needed);
+            result.set(chunk.subarray(sourceStart, sourceStart + copyLen), written);
+            written += copyLen;
+        }
+        return result.subarray(0, written);
+    }
+    async fetch(url, init) {
+        const range = new Headers(init?.headers).get('range');
+        if (range) {
+            const rangeParse = /bytes=(\d+)-(\d+)/.exec(range);
+            if (rangeParse) {
+                const [, startStr, endStr] = rangeParse;
+                const s = Number.parseInt(startStr, 10);
+                const e = Number.parseInt(endStr, 10);
+                const buffer = await this.getCachedRange(String(url), s, e - s + 1, init?.signal);
+                return new Response(buffer, { status: 206 });
+            }
         }
-        const arrayBuffer = await res.arrayBuffer();
-        return {
-            headers,
-            requestDate,
-            responseDate,
-            buffer: new Uint8Array(arrayBuffer),
-        };
+        return super.fetch(url, init);
     }
 }

package/esm/util/types/index.d.ts

@@ -7,10 +7,10 @@ import type { BaseInternetAccountModel } from '../../pluggableElementTypes/model
 import type RpcManager from '../../rpc/RpcManager.ts';
 import type { MenuItem } from '../../ui/index.ts';
 import type { Feature } from '../simpleFeature.ts';
-import type { IAnyStateTreeNode, IStateTreeNode, IType, Instance, SnapshotIn } from '@jbrowse/mobx-state-tree';
+import type { IAnyStateTreeNode, IStateTreeNode, Instance, SnapshotIn } from '@jbrowse/mobx-state-tree';
 import type { ThemeOptions } from '@mui/material';
 export * from './util.ts';
-export interface AbstractViewContainer extends IStateTreeNode<IType<any, any, any>> {
+export interface AbstractViewContainer extends IStateTreeNode {
     views: AbstractViewModel[];
     removeView(view: AbstractViewModel): void;
     addView(typeName: string, initialState?: Record<string, unknown>): AbstractViewModel;
@@ -70,11 +70,11 @@ export interface AbstractSessionModel extends AbstractViewContainer {
     getTrackActionMenuItems?: (config: AnyConfigurationModel, extraTrackActions?: MenuItem[]) => MenuItem[];
     getTrackActions?: (arg: AnyConfigurationModel) => MenuItem[];
     getTrackListMenuItems?: (arg: AnyConfigurationModel) => MenuItem[];
-    addAssembly?: Function;
-    removeAssembly?: Function;
+    addAssembly?: (conf: Record<string, unknown>) => void;
+    removeAssembly?: (name: string) => void;
     textSearchManager?: TextSearchManager;
     connections: AnyConfigurationModel[];
-    deleteConnection?: Function;
+    deleteConnection?: (arg: AnyConfigurationModel) => void;
     temporaryAssemblies?: unknown[];
     addTemporaryAssembly?: (arg: Record<string, unknown>) => void;
     removeTemporaryAssembly?: (arg: string) => void;
@@ -85,14 +85,16 @@ export interface AbstractSessionModel extends AbstractViewContainer {
         tracks: AnyConfigurationModel[];
         configuration: AnyConfigurationModel;
     }[];
-    makeConnection?: Function;
-    breakConnection?: Function;
-    prepareToBreakConnection?: (arg: AnyConfigurationModel) => any;
+    makeConnection?: (arg: AnyConfigurationModel) => void;
+    breakConnection?: (arg: AnyConfigurationModel) => void;
+    prepareToBreakConnection?: (arg: AnyConfigurationModel) => [() => void, Record<string, number>] | undefined;
     adminMode?: boolean;
-    showWidget?: Function;
-    addWidget?: Function;
+    showWidget?: (widget: unknown) => void;
+    addWidget?: (typeName: string, id: string, initialState?: Record<string, unknown>, configuration?: {
+        type: string;
+    }) => Widget;
     DialogComponent?: DialogComponentType;
-    DialogProps: any;
+    DialogProps: Record<string, unknown> | undefined;
     queueDialog<T extends DialogComponentType>(callback: (doneCallback: () => void) => [T, React.ComponentProps<T>]): void;
     name: string;
     id?: string;
@@ -156,8 +158,8 @@ export interface SessionWithConnectionEditing {
 export declare function isSessionModelWithConnectionEditing(thing: unknown): thing is SessionWithConnectionEditing;
 export interface SessionWithSessionPlugins extends AbstractSessionModel {
     sessionPlugins: JBrowsePlugin[];
-    addSessionPlugin: Function;
-    removeSessionPlugin: Function;
+    addSessionPlugin: (plugin: BasePlugin) => void;
+    removeSessionPlugin: (plugin: Record<string, unknown> | undefined) => void;
 }
 export declare function isSessionWithSessionPlugins(thing: unknown): thing is SessionWithSessionPlugins;
 export interface SelectionContainer extends AbstractSessionModel {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jbrowse/core",
-  "version": "4.1.13",
+  "version": "4.1.15",
   "type": "module",
   "description": "JBrowse 2 core libraries used by plugins",
   "keywords": [
@@ -476,30 +476,30 @@
     "@emotion/react": "^11.14.0",
     "@emotion/serialize": "^1.3.3",
     "@emotion/utils": "^1.4.2",
-    "@floating-ui/react": "^0.27.18",
+    "@floating-ui/react": "^0.27.19",
     "@gmod/abortable-promise-cache": "^3.0.4",
-    "@gmod/bgzf-filehandle": "^6.0.12",
+    "@gmod/bgzf-filehandle": "^6.0.18",
     "@gmod/http-range-fetcher": "^5.0.7",
-    "@jbrowse/jexl": "^3.0.1",
-    "@jbrowse/mobx-state-tree": "^5.5.0",
+    "@jbrowse/jexl": "^3.0.2",
+    "@jbrowse/mobx-state-tree": "^5.6.0",
     "@jbrowse/quick-lru": "^7.3.5",
     "@leeoniya/ufuzzy": "^1.0.19",
-    "@mui/icons-material": "^7.3.8",
-    "@mui/material": "^7.3.8",
-    "@mui/system": "^7.3.8",
-    "@mui/types": "^7.4.11",
-    "@mui/x-data-grid": "^8.27.1",
+    "@mui/icons-material": "^7.3.9",
+    "@mui/material": "^7.3.9",
+    "@mui/system": "^7.3.9",
+    "@mui/types": "^7.4.12",
+    "@mui/x-data-grid": "^8.28.2",
     "@types/file-saver-es": "^2.0.3",
     "canvas-sequencer-ts": "^3.1.3",
     "canvas2svg": "^1.0.16",
     "copy-to-clipboard": "^3.3.3",
     "deepmerge": "^4.3.1",
     "detect-node": "^2.1.0",
-    "dompurify": "^3.3.1",
+    "dompurify": "^3.3.3",
     "escape-html": "^1.0.3",
     "fast-deep-equal": "^3.1.3",
     "file-saver-es": "^2.0.5",
-    "generic-filehandle2": "^2.0.18",
+    "generic-filehandle2": "^2.1.4",
     "idb": "^8.0.3",
     "librpc-web-mod": "^2.1.1",
     "mobx": "^6.15.0",