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

package/esm/ReExports/modules.js

@@ -1,168 +1,13 @@
-// eslint-disable-next-line no-restricted-imports
-import * as React from 'react';
-import * as mst from '@jbrowse/mobx-state-tree';
-import { alpha, createTheme, useTheme } from '@mui/material';
-import SvgIcon, { createSvgIcon } from '@mui/material/SvgIcon';
-import * as MUIUtils from '@mui/material/utils';
-import * as mobx from 'mobx';
-import * as mxreact from 'mobx-react';
-import * as ReactDom from 'react-dom';
-import * as ReactDomClient from 'react-dom/client';
-import * as ReactJSXRuntime from 'react/jsx-runtime';
-import Plugin from '../Plugin.js';
-import * as Configuration from '../configuration/index.js';
-import * as BaseAdapterExports from '../data_adapters/BaseAdapter/index.js';
-import * as dataAdapterCache from '../data_adapters/dataAdapterCache.js';
-import AdapterType from '../pluggableElementTypes/AdapterType.js';
-import DisplayType from '../pluggableElementTypes/DisplayType.js';
-import TrackType from '../pluggableElementTypes/TrackType.js';
-import ViewType from '../pluggableElementTypes/ViewType.js';
-import WidgetType from '../pluggableElementTypes/WidgetType.js';
-import * as pluggableElementTypes from '../pluggableElementTypes/index.js';
-import * as pluggableElementTypeModels from '../pluggableElementTypes/models/index.js';
-import * as coreUi from '../ui/index.js';
-import * as corePalette from '../ui/palette.js';
-import * as coreTheme from '../ui/theme.js';
-import Base1DView from '../util/Base1DViewModel.js';
-import * as coreColor from '../util/color/index.js';
-import * as coreIo from '../util/io/index.js';
-import * as coreLayouts from '../util/layouts/index.js';
-import * as coreMstReflection from '../util/mst-reflection.js';
-import * as rxjs from '../util/rxjs.js';
-import * as trackUtils from '../util/tracks.js';
-import { cx, keyframes, makeStyles } from '../util/tss-react/index.js';
-import * as mstTypes from '../util/types/mst.js';
-import { BaseFeatureDetail } from './BaseFeatureDetails.js';
-import { DataGridEntries } from './MuiDataGridReExports.js';
-import { Entries } from './MuiReExports.js';
-import { MUIStyles } from './MuiStylesReExports.js';
-import { lazyMap } from './lazify.js';
-import reExportsList from './list.js';
-import * as coreUtil from './publicUtil.js';
-function makeLegacyMakeStyles() {
-    return (args) => {
-        const useStyles = makeStyles()(args);
-        return () => useStyles().classes;
-    };
-}
-const tssReact = { cx, keyframes, makeStyles };
-const legacyMakeStyles = makeLegacyMakeStyles();
+// The runtime plugin ABI @jbrowse/core alone can serve, on the main thread: the
+// framework singletons and Material UI from frameworkModules.ts, and every
+// subpath core's exports map publishes from the generated half. A product
+// spreads this under the packages it bundles beyond core — see each
+// product's reExports.generated.ts, and scripts/generateReExports.ts for how
+// both halves and list.ts are derived.
+import coreModules from './coreModules.generated.js';
+import frameworkModules from './frameworkModules.js';
 const libs = {
-    mobx,
-    '@jbrowse/mobx-state-tree': mst,
-    'mobx-state-tree': mst,
-    react: React,
-    'react/jsx-runtime': ReactJSXRuntime,
-    'react-dom': ReactDom,
-    'react-dom/client': ReactDomClient,
-    'mobx-react': mxreact,
-    // Only lazy component entries are re-exported. The grid *hooks*
-    // (useGridApiContext/useGridApiRef/useGridRootProps) are intentionally left
-    // out: statically importing them here pulled the entire ~1.2 MB
-    // @mui/x-data-grid package into the eager first-paint graph, defeating the
-    // lazy import('@mui/x-data-grid') in MuiDataGridReExports. First-party code
-    // that needs the hooks imports them directly from '@mui/x-data-grid'.
-    '@mui/x-data-grid': {
-        ...lazyMap(DataGridEntries),
-    },
-    '@mui/material/utils': MUIUtils,
-    '@material-ui/core/utils': MUIUtils,
-    'tss-react': tssReact,
-    'tss-react/mui': tssReact,
-    '@material-ui/core': {
-        ...lazyMap(Entries),
-        useTheme,
-        alpha,
-        makeStyles: legacyMakeStyles,
-    },
-    '@mui/material': {
-        ...lazyMap(Entries),
-        alpha,
-        useTheme,
-        createTheme,
-    },
-    ...lazyMap(Entries, '@mui/material/'),
-    ...lazyMap(Entries, '@material-ui/core/'),
-    // @mui/icons-material — bundled into external plugins — reads the
-    // `createSvgIcon` *named* export from @mui/material/SvgIcon, but lazyMap
-    // exposes only the component (its default). SvgIcon is a primitive that's
-    // eagerly loaded in practice, so expose it directly with createSvgIcon
-    // attached: a default import still lands on a usable component (rollup-plugin-
-    // external-globals substitutes the value itself, esbuild's globalExternals
-    // reads `.default`), while the named import and icons-material's CJS
-    // `require(...).createSvgIcon` both find the util. A shallow copy carries the
-    // forwardRef's $$typeof/render so the shared SvgIcon export isn't mutated.
-    // Overrides the lazy entry above; verified against both bundlers.
-    // GMOD/jbrowse-components#5606.
-    '@mui/material/SvgIcon': Object.assign({}, SvgIcon, { createSvgIcon }),
-    '@mui/material/styles': {
-        ...MUIStyles,
-        makeStyles: legacyMakeStyles,
-    },
-    '@material-ui/core/styles': {
-        ...MUIStyles,
-        makeStyles: legacyMakeStyles,
-    },
-    // these are core in @mui/material, but used to be in @material-ui/lab
-    '@material-ui/lab/ToggleButton': Entries.ToggleButton,
-    '@material-ui/lab/ToggleButtonGroup': Entries.ToggleButtonGroup,
-    '@material-ui/lab/Autocomplete': Entries.Autocomplete,
-    '@material-ui/lab/Alert': Entries.Alert,
-    '@material-ui/lab': {
-        Alert: Entries.Alert,
-        Autocomplete: Entries.Autocomplete,
-        ToggleButton: Entries.ToggleButton,
-        ToggleButtonGroup: Entries.ToggleButtonGroup,
-    },
-    '@jbrowse/core/Plugin': Plugin,
-    '@jbrowse/core/configuration': Configuration,
-    '@jbrowse/core/util/types/mst': mstTypes,
-    '@jbrowse/core/ui': coreUi,
-    '@jbrowse/core/ui/theme': coreTheme,
-    '@jbrowse/core/ui/palette': corePalette,
-    // BaseTooltip is deliberately absent from the '@jbrowse/core/ui' barrel: the
-    // re-export alone held @floating-ui (~266KB) on the startup path, since eager
-    // plugin entries import that barrel. Serving it as its own module behind
-    // React.lazy keeps it off that path while leaving external plugins a way to
-    // reach it -- published apollo deep-imports this exact path, and react-msaview
-    // (bundled by tview and msaview) reads it too, so dropping it from the barrel
-    // with no ABI home is what broke them.
-    ...lazyMap({ BaseTooltip: React.lazy(() => import('../ui/BaseTooltip.js')) }, '@jbrowse/core/ui/'),
-    '@jbrowse/core/util': coreUtil,
-    '@jbrowse/core/util/color': coreColor,
-    '@jbrowse/core/util/layouts': coreLayouts,
-    '@jbrowse/core/util/tracks': trackUtils,
-    '@jbrowse/core/util/Base1DViewModel': Base1DView,
-    '@jbrowse/core/util/io': coreIo,
-    '@jbrowse/core/util/mst-reflection': coreMstReflection,
-    '@jbrowse/core/util/rxjs': rxjs,
-    '@jbrowse/core/pluggableElementTypes': pluggableElementTypes,
-    '@jbrowse/core/pluggableElementTypes/ViewType': ViewType,
-    '@jbrowse/core/pluggableElementTypes/AdapterType': AdapterType,
-    '@jbrowse/core/pluggableElementTypes/DisplayType': DisplayType,
-    '@jbrowse/core/pluggableElementTypes/TrackType': TrackType,
-    '@jbrowse/core/pluggableElementTypes/WidgetType': WidgetType,
-    '@jbrowse/core/pluggableElementTypes/models': pluggableElementTypeModels,
-    '@jbrowse/core/BaseFeatureWidget/BaseFeatureDetail': BaseFeatureDetail,
-    '@jbrowse/core/data_adapters/BaseAdapter': BaseAdapterExports,
-    // `adapterCache` is module-level state, so a plugin that bundles its own copy
-    // of this file gets a second cache in the RPC worker — and `freeAdapterResources`,
-    // which CoreFreeResources calls on the host's copy when the last track using
-    // an adapter config closes, never sees it. The cache is the only strong
-    // reference to an adapter (see the comment on that function), so those
-    // adapters and everything they hold live as long as the worker. Serving the
-    // module is what makes an external RPC method share the host's cache.
-    '@jbrowse/core/data_adapters/dataAdapterCache': dataAdapterCache,
+    ...frameworkModules,
+    ...coreModules,
 };
-const libsList = Object.keys(libs);
-// make sure that all the items in the ReExports/list array (used by build
-// systems and such) are included here, and vice versa
-const inLibsOnly = libsList.filter(mod => !reExportsList.includes(mod));
-if (inLibsOnly.length > 0) {
-    throw new Error(`The following modules are in the modules libs, but not the re-exports list: ${inLibsOnly.join(', ')}`);
-}
-const inReExportsOnly = reExportsList.filter(mod => !libsList.includes(mod));
-if (inReExportsOnly.length) {
-    throw new Error(`The following modules are in the re-exports list, but not the modules libs: ${inReExportsOnly.join(', ')}`);
-}
 export default libs;

package/esm/ReExports/registry.d.ts

@@ -1,2 +1,3 @@
 export declare function setReExportRegistry(libs: Record<string, unknown>): void;
 export declare function getReExportRegistry(): Record<string, unknown>;
+export declare function loudOnMissingModule(libs: Record<string, unknown>): Record<string, unknown>;

package/esm/ReExports/registry.js

@@ -3,11 +3,11 @@
  * a runtime plugin.
  *
  * `ReExports/modules.ts` is the ABI external plugins link against, and it
- * reaches it by spreading `import * as` namespaces of `@jbrowse/core/ui`,
- * `configuration`, `util` and a dozen more into one object. A namespace spread
- * *names every export*, so nothing downstream of those barrels can be
- * tree-shaken — and the module also throws at top level if `libs` and `list.ts`
- * disagree, so it cannot be dropped either. `PluginManager` used to import it
+ * reaches it by spreading `import * as` namespaces of every subpath core
+ * publishes into one object, as each product's `reExports.generated.ts` does
+ * for every package it bundles. A namespace spread *names every export*, so
+ * nothing downstream of those modules can be tree-shaken. `PluginManager` used
+ * to import it
  * statically for `jbrequire`, which put the whole surface — most of
  * `@jbrowse/core/ui` and, behind it, ~400 KB of Material UI — into the eager
  * first-paint graph of **every** host, including embedded ones that load no
@@ -26,3 +26,21 @@ export function setReExportRegistry(libs) {
 export function getReExportRegistry() {
     return registry;
 }
+// A bundle built against another @jbrowse/core, or against a package this host
+// does not bundle, reads a key the map lacks — at module scope, so what it then
+// throws is `Cannot read properties of undefined` with no module named. A
+// plugin's own build tool only ever externalizes a key `ReExports/list.ts`
+// names, so every scoped-or-slashed read that misses is that case, and this
+// names it. Anything else missing reads `undefined` as it always did.
+export function loudOnMissingModule(libs) {
+    return new Proxy(libs, {
+        get(target, key, receiver) {
+            if (typeof key === 'string' &&
+                !(key in target) &&
+                (key.startsWith('@') || key.includes('/'))) {
+                throw new Error(`This JBrowse does not serve '${key}' to plugins: the plugin was built against an older or newer @jbrowse/core, or against a package this host does not bundle`);
+            }
+            return Reflect.get(target, key, receiver);
+        },
+    });
+}

package/esm/ReExports/uiStub.d.ts

@@ -0,0 +1,3 @@
+export declare const uiStub: unknown;
+export declare function uiNamespace(names: readonly string[], esModule?: boolean): Record<string, unknown>;
+export declare const REACT_INTERNAL_KEYS: Set<string>;

package/esm/ReExports/uiStub.js

@@ -0,0 +1,33 @@
+// The RPC worker's stand-in for a UI entry of the plugin ABI; why, and why a
+// namespace gets real own keys: agent-docs/reference/EAGER_BUNDLE.md.
+export const uiStub = new Proxy(function stubTarget() { }, {
+    get: (_, key) => key === 'then' ? undefined : key === Symbol.toPrimitive ? () => '' : uiStub,
+    has: () => true,
+    apply: () => uiStub,
+    construct: () => uiStub,
+});
+// `esModule` mirrors the `__esModule` the main thread sets on a namespace that
+// carries a default export beside named ones, so a bundler's interop reads the
+// stub's `default` the same way in both realms.
+export function uiNamespace(names, esModule = false) {
+    return {
+        ...(esModule ? { __esModule: true } : {}),
+        ...Object.fromEntries(names.map(name => [name, uiStub])),
+    };
+}
+// Own keys React puts on a component object, which are not export names and
+// so do not survive into a stub or the manifest.
+export const REACT_INTERNAL_KEYS = new Set([
+    '$$typeof',
+    '_debugInfo',
+    '_init',
+    '_payload',
+    'compare',
+    'contextTypes',
+    'defaultProps',
+    'displayName',
+    'muiName',
+    'propTypes',
+    'render',
+    'type',
+]);

package/esm/ReExports/workerModules.d.ts

@@ -0,0 +1,2 @@
+declare const libs: Record<string, unknown>;
+export default libs;

package/esm/ReExports/workerModules.js

@@ -0,0 +1,11 @@
+// Same keys as modules.ts, as the RPC worker serves them: a module a plugin
+// reads only to render is a stub carrying the main thread's export names, so
+// the one bundle a plugin ships evaluates in both realms without the worker
+// fetching the UI graph. agent-docs/reference/EAGER_BUNDLE.md
+import coreWorkerModules from './coreWorkerModules.generated.js';
+import frameworkWorkerModules from './frameworkWorkerModules.generated.js';
+const libs = {
+    ...frameworkWorkerModules,
+    ...coreWorkerModules,
+};
+export default libs;

package/esm/TextSearch/TextSearchManager.d.ts

@@ -3,25 +3,39 @@ import type PluginManager from '../PluginManager.ts';
 import type { AnyConfigurationModel } from '../configuration/index.ts';
 import type { BaseTextSearchAdapter, BaseTextSearchArgs } from '../data_adapters/BaseAdapter/index.ts';
 import type BaseResult from './BaseResults.ts';
+export interface SearchIndex {
+    conf: AnyConfigurationModel;
+    /** the track a per-track index belongs to */
+    trackId?: string;
+}
+export interface TextSearchReport {
+    results: BaseResult[];
+    /** the indexes covering the assembly, zero when it has none to search */
+    indexCount: number;
+    /** what each index that could not answer threw */
+    failures: unknown[];
+}
 export default class TextSearchManager {
     pluginManager: PluginManager;
     adapterCache: QuickLRU<string, BaseTextSearchAdapter>;
     constructor(pluginManager: PluginManager);
     clearCache(): void;
-    loadTextSearchAdapters(assemblyName: string): Promise<BaseTextSearchAdapter[]>;
-    relevantAdapters(assemblyName: string): (import("@jbrowse/mobx-state-tree").ModelInstanceTypeProps<Record<string, any>> & {
-        setSubschema(slotName: string, data: Record<string, unknown>): any;
-        setSlot(slotName: string, value: unknown): void;
-    } & import("@jbrowse/mobx-state-tree").IStateTreeNode<import("../configuration/types.ts").AnyConfigurationSchemaType>)[];
-    getAdaptersWithAssembly(matches: (names: string[] | undefined) => boolean, confs: AnyConfigurationModel[]): (import("@jbrowse/mobx-state-tree").ModelInstanceTypeProps<Record<string, any>> & {
-        setSubschema(slotName: string, data: Record<string, unknown>): any;
-        setSlot(slotName: string, value: unknown): void;
-    } & import("@jbrowse/mobx-state-tree").IStateTreeNode<import("../configuration/types.ts").AnyConfigurationSchemaType>)[];
-    getTrackAdaptersWithAssembly(matches: (names: string[] | undefined) => boolean, confs: AnyConfigurationModel[]): (import("@jbrowse/mobx-state-tree").ModelInstanceTypeProps<Record<string, any>> & {
-        setSubschema(slotName: string, data: Record<string, unknown>): any;
-        setSlot(slotName: string, value: unknown): void;
-    } & import("@jbrowse/mobx-state-tree").IStateTreeNode<import("../configuration/types.ts").AnyConfigurationSchemaType>)[];
+    loadTextSearchAdapters(assemblyName: string): Promise<{
+        values: {
+            adapter: BaseTextSearchAdapter;
+            trackId: string | undefined;
+        }[];
+        failures: unknown[];
+    }>;
+    relevantAdapters(assemblyName: string): AnyConfigurationModel[];
+    relevantIndexes(assemblyName: string): SearchIndex[];
+    getAdaptersWithAssembly(matches: (names: string[] | undefined) => boolean, confs: AnyConfigurationModel[]): AnyConfigurationModel[];
+    getTrackAdaptersWithAssembly(matches: (names: string[] | undefined) => boolean, confs: AnyConfigurationModel[]): {
+        conf: AnyConfigurationModel;
+        trackId: string;
+    }[];
     search(args: BaseTextSearchArgs, assemblyName: string): Promise<BaseResult[]>;
+    searchIndexes(args: BaseTextSearchArgs, assemblyName: string): Promise<TextSearchReport>;
     sortResults({ results, args, }: {
         results: BaseResult[];
         args: BaseTextSearchArgs;

package/esm/TextSearch/TextSearchManager.js

@@ -1,25 +1,29 @@
-import { readConfObject } from '../configuration/index.js';
+import { getSnapshot, isStateTreeNode } from '@jbrowse/mobx-state-tree';
+import { hydrateTrackConfig, readConfObject } from '../configuration/index.js';
+import { adapterConfigCacheKey } from '../data_adapters/dataAdapterCache.js';
 import QuickLRU from '../util/QuickLRU/index.js';
-import { isAbortException } from '../util/aborting.js';
-import { checkStopToken } from '../util/stopToken.js';
-import { canonicalAssemblyNames } from '../util/tracks.js';
+import { checkAbortSignal, isAbortException } from '../util/aborting.js';
+import { allSessionTracks, canonicalAssemblyNames } from '../util/tracks.js';
 // A misconfigured or unreachable index (a 404 .ix, a config missing
 // ixFilePath) must not take down search as a whole: the remaining indexes, and
-// the refName results the caller merges in afterwards, are still useful. Log
-// the failures and keep going rather than rejecting. An abort is not a failure
-// — every keystroke supersedes the previous query, so logging those would turn
-// normal typing into console spam.
-async function keepFulfilled(promises, message) {
-    const out = [];
+// the refName results the caller merges in afterwards, are still useful. The
+// failures are logged and handed back, so a miss can say an index failed rather
+// than that the name is absent. An abort is not a failure — every keystroke
+// supersedes the previous query, so logging those would turn normal typing
+// into console spam.
+async function settle(promises, message) {
+    const values = [];
+    const failures = [];
     for (const settled of await Promise.allSettled(promises)) {
         if (settled.status === 'fulfilled') {
-            out.push(settled.value);
+            values.push(settled.value);
         }
         else if (!isAbortException(settled.reason)) {
             console.error(message, settled.reason);
+            failures.push(settled.reason);
         }
     }
-    return out;
+    return { values, failures };
 }
 export default class TextSearchManager {
     pluginManager;
@@ -33,22 +37,25 @@ export default class TextSearchManager {
         this.adapterCache.clear();
     }
     loadTextSearchAdapters(assemblyName) {
-        return keepFulfilled(this.relevantAdapters(assemblyName).map(async (conf) => {
-            const adapterId = readConfObject(conf, 'textSearchAdapterId');
-            const r = this.adapterCache.get(adapterId);
-            if (r) {
-                return r;
+        return settle(this.relevantIndexes(assemblyName).map(async ({ conf, trackId }) => {
+            const key = adapterConfigCacheKey(getSnapshot(conf));
+            const cached = this.adapterCache.get(key);
+            if (cached) {
+                return { adapter: cached, trackId };
             }
             else {
                 const adapterType = this.pluginManager.getTextSearchAdapterType(conf.type);
                 const AdapterClass = await adapterType.getAdapterClass();
-                const adapterInstance = new AdapterClass(conf, undefined, this.pluginManager);
-                this.adapterCache.set(adapterId, adapterInstance);
-                return adapterInstance;
+                const adapter = new AdapterClass(conf, undefined, this.pluginManager);
+                this.adapterCache.set(key, adapter);
+                return { adapter, trackId };
             }
         }), 'failed to load text search adapter');
     }
     relevantAdapters(assemblyName) {
+        return this.relevantIndexes(assemblyName).map(index => index.conf);
+    }
+    relevantIndexes(assemblyName) {
         const { rootModel } = this.pluginManager;
         // jbrowse is typed as a bare state tree node, so its config slots need a
         // shape assertion; both it and the session are absent until a session is
@@ -65,9 +72,10 @@ export default class TextSearchManager {
             : names.filter(name => !!name);
         const [wanted] = canonical([assemblyName]);
         const matches = (names) => !!wanted && !!names && canonical(names).includes(wanted);
+        const session = rootModel?.session;
         return [
-            ...this.getAdaptersWithAssembly(matches, aggregateTextSearchAdapters),
-            ...this.getTrackAdaptersWithAssembly(matches, rootModel?.session?.tracks ?? []),
+            ...this.getAdaptersWithAssembly(matches, aggregateTextSearchAdapters).map(conf => ({ conf })),
+            ...this.getTrackAdaptersWithAssembly(matches, session ? allSessionTracks(session) : []),
         ];
     }
     getAdaptersWithAssembly(matches, confs) {
@@ -75,24 +83,57 @@ export default class TextSearchManager {
     }
     getTrackAdaptersWithAssembly(matches, confs) {
         return confs
-            .filter(conf => matches(readConfObject(conf, [
-            'textSearching',
-            'textSearchAdapter',
-            'assemblyNames',
-        ])))
-            .map(conf => conf.textSearching.textSearchAdapter);
+            .filter(conf => {
+            const indexNames = readConfObject(conf, [
+                'textSearching',
+                'textSearchAdapter',
+                'assemblyNames',
+            ]);
+            return (!!readConfObject(conf, ['textSearching', 'textSearchAdapter']) &&
+                matches(indexNames?.length
+                    ? indexNames
+                    : readConfObject(conf, 'assemblyNames')));
+        })
+            .flatMap(track => {
+            const live = isStateTreeNode(track)
+                ? track
+                : hydrateTrackConfig(this.pluginManager, track);
+            const conf = live?.textSearching.textSearchAdapter;
+            return conf
+                ? [{ conf, trackId: readConfObject(track, 'trackId') }]
+                : [];
+        });
     }
     async search(args, assemblyName) {
-        const adapters = await this.loadTextSearchAdapters(assemblyName);
-        const results = await keepFulfilled(adapters.map(a => a.searchIndex(args)), 'text search adapter failed');
+        return (await this.searchIndexes(args, assemblyName)).results;
+    }
+    async searchIndexes(args, assemblyName) {
+        const loaded = await this.loadTextSearchAdapters(assemblyName);
+        const searched = await settle(loaded.values.map(async ({ adapter, trackId }) => {
+            const found = await adapter.searchIndex(args);
+            // a per-track index answers for its track, whether or not its records
+            // name it — a UCSC hub's index holds only feature names
+            if (trackId) {
+                for (const result of found) {
+                    result.trackId ??= trackId;
+                }
+            }
+            return found;
+        }), 'text search adapter failed');
         // the ranking below is the expensive half — a dynamic import plus a fuzzy
         // sort over every hit — and a superseded keystroke has no use for it.
-        // Checked here rather than only inside the adapters because keepFulfilled
-        // deliberately drops a failing adapter and carries on, so an abort thrown
-        // by one of them would otherwise still land here as "no results from that
-        // index" and rank the rest
-        checkStopToken(args.stopToken);
-        return await this.sortResults({ args, results: results.flat() });
+        // Checked here rather than only inside the adapters because settle drops an
+        // abort thrown by one of them, which would otherwise land here as "no
+        // results from that index" and rank the rest
+        checkAbortSignal(args.signal);
+        return {
+            results: await this.sortResults({
+                args,
+                results: searched.values.flat(),
+            }),
+            indexCount: loaded.values.length + loaded.failures.length,
+            failures: [...loaded.failures, ...searched.failures],
+        };
     }
     // Ranks, never filters: the adapters have already decided what matches, and
     // they match against attributes the display string does not always carry (a

package/esm/TextSearch/places.d.ts

@@ -0,0 +1,12 @@
+import type { Assembly } from '../assemblyManager/assembly.ts';
+import type BaseResult from './BaseResults.ts';
+export declare function canonicalLocString(locString: string, assembly: Assembly): string;
+/**
+ * Hits grouped by the place they go, groups and members in the order given.
+ * Hits are one place when they carry one name and either the same location or
+ * overlapping spans on one sequence: two gene tracks drawing one gene with
+ * slightly different ends answer one place, not a choice. A hit with no
+ * location, or one the assembly cannot yet resolve into a span, joins only an
+ * identical locstring.
+ */
+export declare function groupByPlace(results: BaseResult[], assembly?: Assembly): BaseResult[][];

package/esm/TextSearch/places.js

@@ -0,0 +1,94 @@
+import { assembleLocString, parseLocString } from '../util/index.js';
+// One spelling of a locstring, so two indexes that answer `chr1:1-100` and
+// `1:1..100` are recognised as one place. An unparseable string is compared
+// raw, which can only split a group that would otherwise have merged.
+export function canonicalLocString(locString, assembly) {
+    try {
+        const loc = parseLocString(locString, refName => assembly.isValidRefName(refName));
+        return assembleLocString({
+            ...loc,
+            refName: assembly.getCanonicalRefName2(loc.refName),
+        });
+    }
+    catch (e) {
+        console.warn('failed to parse location string', locString, e);
+        return locString;
+    }
+}
+function spanOf(locString, assembly) {
+    try {
+        const { refName, start, end } = parseLocString(locString, r => assembly.isValidRefName(r));
+        return start === undefined || end === undefined
+            ? undefined
+            : { refName: assembly.getCanonicalRefName2(refName), start, end };
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Hits grouped by the place they go, groups and members in the order given.
+ * Hits are one place when they carry one name and either the same location or
+ * overlapping spans on one sequence: two gene tracks drawing one gene with
+ * slightly different ends answer one place, not a choice. A hit with no
+ * location, or one the assembly cannot yet resolve into a span, joins only an
+ * identical locstring.
+ */
+export function groupByPlace(results, assembly) {
+    const root = results.map((_, i) => i);
+    const find = (i) => root[i] === i ? i : (root[i] = find(root[i]));
+    const join = (a, b) => {
+        const ra = find(a);
+        const rb = find(b);
+        root[Math.max(ra, rb)] = Math.min(ra, rb);
+    };
+    const resolved = !!assembly?.initialized;
+    const firstAt = new Map();
+    const spans = [];
+    for (const [i, result] of results.entries()) {
+        const locString = result.getLocation();
+        if (locString) {
+            const name = result.getDisplayString();
+            const key = [
+                name,
+                resolved ? canonicalLocString(locString, assembly) : locString,
+            ].join('\u0000');
+            const seen = firstAt.get(key);
+            if (seen === undefined) {
+                firstAt.set(key, i);
+            }
+            else {
+                join(seen, i);
+            }
+            const span = resolved ? spanOf(locString, assembly) : undefined;
+            if (span) {
+                spans.push({ i, seq: [name, span.refName].join('\u0000'), ...span });
+            }
+        }
+    }
+    spans.sort((a, b) => a.seq === b.seq ? a.start - b.start : a.seq < b.seq ? -1 : 1);
+    let run;
+    let runEnd = 0;
+    for (const span of spans) {
+        if (run?.seq === span.seq && span.start < runEnd) {
+            join(run.i, span.i);
+            runEnd = Math.max(runEnd, span.end);
+        }
+        else {
+            run = span;
+            runEnd = span.end;
+        }
+    }
+    const groups = new Map();
+    for (const [i, result] of results.entries()) {
+        const r = find(i);
+        const group = groups.get(r);
+        if (group) {
+            group.push(result);
+        }
+        else {
+            groups.set(r, [result]);
+        }
+    }
+    return [...groups.values()];
+}