@jbrowse/core 4.3.0 → 5.0.0-beta.10

package/esm/rpc/configSchema.js

@@ -1,22 +1,46 @@
-import { types } from '@jbrowse/mobx-state-tree';
-import MainThreadRpcDriverConfigSchema from "./mainThreadRpcConfig.js";
-import WebWorkerRpcDriverConfigSchema from "./webWorkerRpcConfig.js";
-import { ConfigurationSchema } from "../configuration/index.js";
-function x() { }
+import { ConfigurationSchema } from '../configuration/index.js';
+/**
+ * #config RpcOptions
+ * #category root
+ */
 export default ConfigurationSchema('RpcOptions', {
+    /**
+     * #slot
+     * which RPC backend to use. Empty means "use the host application's
+     * default" (web/desktop default to the web worker driver, embedded/headless
+     * to the main thread). Every call in the session runs on the driver this
+     * names; there is no per-track or per-call override.
+     */
     defaultDriver: {
         type: 'string',
-        description: 'the RPC driver to use for tracks and tasks that are not configured to use a specific RPC backend',
-        defaultValue: 'MainThreadRpcDriver',
+        description: 'the RPC driver to run data fetching on: MainThreadRpcDriver or WebWorkerRpcDriver. Leave empty to use the default for this application',
+        defaultValue: '',
+        advanced: true,
+    },
+    /**
+     * #slot
+     * number of web workers to spawn for the web worker RPC driver. 0 lets
+     * JBrowse pick based on hardware concurrency.
+     */
+    workerCount: {
+        type: 'number',
+        description: 'The number of workers to use. If 0 (the default) JBrowse will decide how many workers to use.',
+        defaultValue: 0,
+        advanced: true,
     },
-    drivers: types.optional(types.map(types.union(MainThreadRpcDriverConfigSchema, WebWorkerRpcDriverConfigSchema)), {
-        MainThreadRpcDriver: { type: 'MainThreadRpcDriver' },
-        WebWorkerRpcDriver: { type: 'WebWorkerRpcDriver' },
-    }),
 }, {
-    actions: (self) => ({
-        addDriverConfig(configName, configSnapshot) {
-            self.drivers.set(configName, configSnapshot);
-        },
-    }),
+    // legacy sessions stored per-driver config under a `drivers` map
+    // (`{ WebWorkerRpcDriver: { workerCount } }`); hoist any saved workerCount
+    // to the flat slot and drop the map so the snapshot validates.
+    preProcessSnapshot(snapshot) {
+        if ('drivers' in snapshot) {
+            const { drivers, ...rest } = snapshot;
+            const legacyWorkerCount = drivers?.WebWorkerRpcDriver?.workerCount ??
+                drivers?.MainThreadRpcDriver?.workerCount;
+            return rest.workerCount === undefined && legacyWorkerCount !== undefined
+                ? { ...rest, workerCount: legacyWorkerCount }
+                : rest;
+        }
+        return snapshot;
+    },
 });

package/esm/rpc/coreRpcMethods.d.ts

@@ -1,12 +1,13 @@
 export { default as CoreGetRefNames } from './methods/CoreGetRefNames.ts';
-export { default as CoreGetFeatureDetails } from './methods/CoreGetFeatureDetails.ts';
 export { default as CoreGetMetadata } from './methods/CoreGetMetadata.ts';
-export { default as CoreGetFileInfo } from './methods/CoreGetFileInfo.ts';
+export { default as CoreGetInfo } from './methods/CoreGetInfo.ts';
 export { default as CoreGetFeatures } from './methods/CoreGetFeatures.ts';
+export { default as CoreGetEncodedLayers } from './methods/CoreGetEncodedLayers.ts';
+export { default as CoreGetEncodedFeature } from './methods/CoreGetEncodedFeature.ts';
 export { default as CoreGetSequence } from './methods/CoreGetSequence.ts';
-export { default as CoreRender } from './methods/CoreRender.ts';
 export { default as CoreFreeResources } from './methods/CoreFreeResources.ts';
-export { default as CoreGetFeatureDensityStats } from './methods/CoreGetFeatureDensityStats.ts';
+export { default as CoreLoadAdapterCode } from './methods/CoreLoadAdapterCode.ts';
+export { default as CoreGetRegionByteEstimate } from './methods/CoreGetRegionByteEstimate.ts';
+export { default as CoreGetFeatureDensity } from './methods/CoreGetFeatureDensity.ts';
 export { default as CoreGetRegions } from './methods/CoreGetRegions.ts';
 export { default as CoreGetExportData } from './methods/CoreGetExportData.ts';
-export { type RenderArgs } from './methods/util.ts';

package/esm/rpc/coreRpcMethods.js

@@ -1,12 +1,13 @@
-export { default as CoreGetRefNames } from "./methods/CoreGetRefNames.js";
-export { default as CoreGetFeatureDetails } from "./methods/CoreGetFeatureDetails.js";
-export { default as CoreGetMetadata } from "./methods/CoreGetMetadata.js";
-export { default as CoreGetFileInfo } from "./methods/CoreGetFileInfo.js";
-export { default as CoreGetFeatures } from "./methods/CoreGetFeatures.js";
-export { default as CoreGetSequence } from "./methods/CoreGetSequence.js";
-export { default as CoreRender } from "./methods/CoreRender.js";
-export { default as CoreFreeResources } from "./methods/CoreFreeResources.js";
-export { default as CoreGetFeatureDensityStats } from "./methods/CoreGetFeatureDensityStats.js";
-export { default as CoreGetRegions } from "./methods/CoreGetRegions.js";
-export { default as CoreGetExportData } from "./methods/CoreGetExportData.js";
-export {} from "./methods/util.js";
+export { default as CoreGetRefNames } from './methods/CoreGetRefNames.js';
+export { default as CoreGetMetadata } from './methods/CoreGetMetadata.js';
+export { default as CoreGetInfo } from './methods/CoreGetInfo.js';
+export { default as CoreGetFeatures } from './methods/CoreGetFeatures.js';
+export { default as CoreGetEncodedLayers } from './methods/CoreGetEncodedLayers.js';
+export { default as CoreGetEncodedFeature } from './methods/CoreGetEncodedFeature.js';
+export { default as CoreGetSequence } from './methods/CoreGetSequence.js';
+export { default as CoreFreeResources } from './methods/CoreFreeResources.js';
+export { default as CoreLoadAdapterCode } from './methods/CoreLoadAdapterCode.js';
+export { default as CoreGetRegionByteEstimate } from './methods/CoreGetRegionByteEstimate.js';
+export { default as CoreGetFeatureDensity } from './methods/CoreGetFeatureDensity.js';
+export { default as CoreGetRegions } from './methods/CoreGetRegions.js';
+export { default as CoreGetExportData } from './methods/CoreGetExportData.js';

package/esm/rpc/explainTransferError.d.ts

@@ -0,0 +1,35 @@
+/**
+ * What a container holds, as `[path, value]` — the one place that knows a Map
+ * and a Set carry payload the way an object's fields do.
+ *
+ * `Object.entries` yields `[]` for both, so a matrix keyed by sample name read
+ * as an EMPTY payload to every walk in this file. That is the shape
+ * `MultiWiggleGetScoreMatrix` and `MultiSampleVariantGetGenotypeMatrix` return,
+ * and it failed in both directions at once: the wiggle matrix's hand-built list
+ * is correct and `checkTransferList` reported every entry of it as "not in the
+ * payload" — the exact wording {@link bufferPaths} exists to avoid — while the
+ * variant matrix transfers nothing and no check could say so.
+ *
+ * A Map's key is worth printing (`rows.HG002` names the sample); a Set has no
+ * name for its members, so they get their position.
+ */
+export declare function containerEntries(obj: object, prefix: string): Generator<[string, unknown]>;
+/**
+ * Every payload field each transferred buffer is reachable by.
+ *
+ * Several fields can name one buffer, so this collects all of them rather than
+ * the first: subarrays of a shared allocation are exactly how a duplicate entry
+ * gets into a hand-built list, and naming both ends is what makes that
+ * actionable.
+ */
+export declare function bufferPaths(value: unknown): Map<ArrayBufferLike, string[]>;
+/**
+ * The error to send when `postMessage` rejects a reply, with the transfer-list
+ * entry it blamed named by field.
+ *
+ * Returns the original error untouched when the message addresses no index: an
+ * unserializable payload ("() => {} could not be cloned") reports that way and
+ * has nothing to do with the transfer list, so a report about transfers would
+ * point at the wrong thing entirely.
+ */
+export declare function explainTransferError(error: unknown, value: unknown, transferables: readonly Transferable[], method?: string): unknown;

package/esm/rpc/explainTransferError.js

@@ -0,0 +1,158 @@
+// `postMessage` addresses a bad transfer-list entry by index and nothing else.
+// Measured in a real worker (Chrome 152), which is where these are read:
+//
+//   ArrayBuffer at index 19 is already detached.
+//   ArrayBuffer at index 2 is a duplicate of an earlier ArrayBuffer.
+//   Value at index 0 does not have a transferable type.
+//
+// So it names the CAUSE, in its own words, and separates the three. What it
+// never names is the FIELD — and the list is assembled by hand at each call
+// site, so acting on "index 19" means re-deriving that list's layout from
+// source. The synteny list's layout moves with the track's attribute-channel
+// count, so that answer is not even stable across tracks. Supplying the field
+// is the whole job here; do not re-derive the cause, which is already in the
+// sentence this appends to.
+//
+// Only runs on the error path.
+// The deepest RPC result in the tree is the regular multi-sample variant one:
+// `perRegionCellData.0.featureGenotypeMap.<featureId>.genotypeCodes` — four
+// containers down. The alignments result is three (`groups.3.data.mismatchStarts`),
+// synteny two (`instanceData.bp1`, `attributes.identity`) and most are one. The
+// walk is capped rather than unbounded because a payload also carries plain data
+// — a featureIds array of half a million strings — and there is no reason to
+// descend past where buffers are known to live.
+//
+// A cap that is too SHORT fails silently and expensively: it reports the blamed
+// entry as "not in the payload", which reads as a bug in the transfer list. That
+// is how this number was found to be wrong twice, so it is stated with the shape
+// it has to cover rather than left as a bare 2.
+const MAX_DEPTH = 4;
+// The allocation a payload node names, whether it is a view or the buffer.
+function bufferOf(node) {
+    return ArrayBuffer.isView(node)
+        ? node.buffer
+        : node instanceof ArrayBuffer
+            ? node
+            : undefined;
+}
+/**
+ * What a container holds, as `[path, value]` — the one place that knows a Map
+ * and a Set carry payload the way an object's fields do.
+ *
+ * `Object.entries` yields `[]` for both, so a matrix keyed by sample name read
+ * as an EMPTY payload to every walk in this file. That is the shape
+ * `MultiWiggleGetScoreMatrix` and `MultiSampleVariantGetGenotypeMatrix` return,
+ * and it failed in both directions at once: the wiggle matrix's hand-built list
+ * is correct and `checkTransferList` reported every entry of it as "not in the
+ * payload" — the exact wording {@link bufferPaths} exists to avoid — while the
+ * variant matrix transfers nothing and no check could say so.
+ *
+ * A Map's key is worth printing (`rows.HG002` names the sample); a Set has no
+ * name for its members, so they get their position.
+ */
+export function* containerEntries(obj, prefix) {
+    const join = (key) => (prefix ? `${prefix}.${key}` : key);
+    if (obj instanceof Map) {
+        for (const [key, value] of obj) {
+            yield [join(String(key)), value];
+        }
+    }
+    else if (obj instanceof Set) {
+        let i = 0;
+        for (const value of obj) {
+            yield [join(`<${i++}>`), value];
+        }
+    }
+    else {
+        for (const [key, value] of Object.entries(obj)) {
+            yield [join(key), value];
+        }
+    }
+}
+/**
+ * Every payload field each transferred buffer is reachable by.
+ *
+ * Several fields can name one buffer, so this collects all of them rather than
+ * the first: subarrays of a shared allocation are exactly how a duplicate entry
+ * gets into a hand-built list, and naming both ends is what makes that
+ * actionable.
+ */
+export function bufferPaths(value) {
+    const paths = new Map();
+    const seen = new WeakSet();
+    const visit = (node, prefix, depth) => {
+        if (!node || typeof node !== 'object' || depth > MAX_DEPTH) {
+            return;
+        }
+        // A result can BE a buffer rather than hold one — `rpcResult(buf, [buf])`.
+        // Without this the root has no fields to walk, so the entry blamed by index
+        // reads as "not in the payload", which is the one wording that sends the
+        // reader looking for a list bug that isn't there.
+        const root = bufferOf(node);
+        if (root) {
+            paths.set(root, [...(paths.get(root) ?? []), prefix || '<result>']);
+            return;
+        }
+        // structuredClone accepts a cyclic payload, so the walk over one has to
+        // terminate on its own
+        if (seen.has(node)) {
+            return;
+        }
+        seen.add(node);
+        for (const [path, child] of containerEntries(node, prefix)) {
+            const buffer = bufferOf(child);
+            if (buffer) {
+                paths.set(buffer, [...(paths.get(buffer) ?? []), path]);
+            }
+            else {
+                visit(child, path, depth + 1);
+            }
+        }
+    };
+    visit(value, '', 0);
+    return paths;
+}
+/**
+ * The error to send when `postMessage` rejects a reply, with the transfer-list
+ * entry it blamed named by field.
+ *
+ * Returns the original error untouched when the message addresses no index: an
+ * unserializable payload ("() => {} could not be cloned") reports that way and
+ * has nothing to do with the transfer list, so a report about transfers would
+ * point at the wrong thing entirely.
+ */
+export function explainTransferError(error, value, transferables, method) {
+    if (!(error instanceof Error)) {
+        return error;
+    }
+    const index = Number(/ at index (\d+)/.exec(error.message)?.[1]);
+    const entry = transferables[index];
+    if (entry === undefined) {
+        return error;
+    }
+    const paths = bufferPaths(value);
+    const fields = (entry instanceof ArrayBuffer ? paths.get(entry) : undefined)?.join(', ');
+    // A buffer the walk cannot reach is reported with the two counts, because
+    // together they say which of the two things went wrong: "n-1 of n" means the
+    // list names a buffer the result does not carry — the transfer is giving away
+    // something the worker still owns, which is a bug in the list and not in the
+    // walk. A low count means the payload is a shape this walk does not cover, and
+    // the layout has to come from source after all.
+    const reachable = transferables.filter(t => t instanceof ArrayBuffer && paths.has(t)).length;
+    const at = fields ??
+        `not in the payload (${reachable} of ${transferables.length} entries are)`;
+    const first = transferables.indexOf(entry);
+    const detail = first < index
+        ? `index ${index} repeats index ${first} — one allocation, reached by ${at}`
+        : `index ${index} is ${at}`;
+    // Which method built the list is the other half of "which field", and it is
+    // not on the stack: the post happens in a `.then` off the method's promise,
+    // so the trace is `post` / `reply` and nothing above.
+    const where = method ? `${method}: ` : '';
+    const annotated = new Error(`${error.message} — ${where}${detail}`);
+    // the throw site and the browser's own error name, both of which a plain
+    // rethrow would drop
+    annotated.stack = error.stack;
+    annotated.name = error.name;
+    return annotated;
+}

package/esm/rpc/methods/CoreFreeResources.d.ts

@@ -1,6 +1,21 @@
 import RpcMethodType from '../../pluggableElementTypes/RpcMethodType.ts';
-export default class CoreFreeResources extends RpcMethodType {
-    name: string;
-    execute(args: Record<string, unknown>): Promise<void>;
-    serializeArguments(args: Record<string, unknown>, _rpcDriver: string): Promise<Record<string, unknown>>;
+import type { RpcExecuteArgs } from '../RpcRegistry.ts';
+/**
+ * Drop cached data adapters associated with the given session.
+ *
+ * Reached from `releaseAdapterSession` (`data_adapters/adapterSessionRefcount`)
+ * when the last track model holding an rpcSessionId is destroyed — closing a
+ * track, closing its view, or switching session. It counts the holders because
+ * an rpcSessionId is derived from the adapter config and so is shared by every
+ * track configured alike; the cache entry's own `sessionIds` refcount then keeps
+ * an adapter alive for any *other* session still using it, which is what makes a
+ * shared sub-adapter safe.
+ *
+ * This does not bound the cache, and is not meant to: an adapter whose track is
+ * open stays cached however long that takes.
+ */
+export default class CoreFreeResources extends RpcMethodType<'CoreFreeResources'> {
+    name: 'CoreFreeResources';
+    execute(args: RpcExecuteArgs<'CoreFreeResources'>): Promise<void>;
+    serializeArguments(args: Record<string, unknown>): Promise<Record<string, unknown>>;
 }

package/esm/rpc/methods/CoreFreeResources.js

@@ -1,14 +1,25 @@
-import { freeAdapterResources } from "../../data_adapters/dataAdapterCache.js";
-import RpcMethodType from "../../pluggableElementTypes/RpcMethodType.js";
+import { freeAdapterResources } from '../../data_adapters/dataAdapterCache.js';
+import RpcMethodType from '../../pluggableElementTypes/RpcMethodType.js';
+/**
+ * Drop cached data adapters associated with the given session.
+ *
+ * Reached from `releaseAdapterSession` (`data_adapters/adapterSessionRefcount`)
+ * when the last track model holding an rpcSessionId is destroyed — closing a
+ * track, closing its view, or switching session. It counts the holders because
+ * an rpcSessionId is derived from the adapter config and so is shared by every
+ * track configured alike; the cache entry's own `sessionIds` refcount then keeps
+ * an adapter alive for any *other* session still using it, which is what makes a
+ * shared sub-adapter safe.
+ *
+ * This does not bound the cache, and is not meant to: an adapter whose track is
+ * open stays cached however long that takes.
+ */
 export default class CoreFreeResources extends RpcMethodType {
     name = 'CoreFreeResources';
     async execute(args) {
         await freeAdapterResources(args);
-        for (const renderer of this.pluginManager.getRendererTypes()) {
-            renderer.freeResources(args);
-        }
     }
-    async serializeArguments(args, _rpcDriver) {
+    async serializeArguments(args) {
         return args;
     }
 }

package/esm/rpc/methods/CoreGetEncodedFeature.d.ts

@@ -0,0 +1,13 @@
+import RpcMethodTypeWithRenameRegion from '../../pluggableElementTypes/RpcMethodTypeWithRenameRegion.ts';
+import type { RpcExecuteArgs } from '../RpcRegistry.ts';
+/**
+ * The feature behind one instance of a `CoreGetEncodedLayers` answer: the same
+ * request run again, and the row of `layer`'s table the instance's
+ * `featureIndex` names. A display holds channels and no records, and two reads
+ * sharing a span, a run counted inside one facet section or a mark whose `x` is
+ * not `start` are each a feature no coordinate lookup finds.
+ */
+export default class CoreGetEncodedFeature extends RpcMethodTypeWithRenameRegion<'CoreGetEncodedFeature'> {
+    name: 'CoreGetEncodedFeature';
+    execute(args: RpcExecuteArgs<'CoreGetEncodedFeature'>): Promise<import("../../util/simpleFeature.ts").SimpleFeatureSerialized | undefined>;
+}

package/esm/rpc/methods/CoreGetEncodedFeature.js

@@ -0,0 +1,32 @@
+import { getFeatureAdapterOrThrow } from '../../data_adapters/getFeatureAdapter.js';
+import RpcMethodTypeWithRenameRegion from '../../pluggableElementTypes/RpcMethodTypeWithRenameRegion.js';
+import { layerFeatures } from './layerFeatures.js';
+/**
+ * The feature behind one instance of a `CoreGetEncodedLayers` answer: the same
+ * request run again, and the row of `layer`'s table the instance's
+ * `featureIndex` names. A display holds channels and no records, and two reads
+ * sharing a span, a run counted inside one facet section or a mark whose `x` is
+ * not `start` are each a feature no coordinate lookup finds.
+ */
+export default class CoreGetEncodedFeature extends RpcMethodTypeWithRenameRegion {
+    name = 'CoreGetEncodedFeature';
+    async execute(args) {
+        const { layer, featureIndex } = args;
+        const asked = args.layers[layer];
+        if (!asked) {
+            return undefined;
+        }
+        const { pluginManager } = this;
+        const dataAdapter = await getFeatureAdapterOrThrow({
+            ...args,
+            pluginManager,
+        });
+        // A layer's list does not depend on its neighbours, so only the one asked
+        // about runs its steps.
+        const { layers } = await layerFeatures(dataAdapter, { ...args, layers: [asked] }, pluginManager.jexl);
+        const table = layers[0]?.table;
+        return table && featureIndex < table.length
+            ? table.row(featureIndex).toJSON()
+            : undefined;
+    }
+}

package/esm/rpc/methods/CoreGetEncodedLayers.d.ts

@@ -0,0 +1,16 @@
+import RpcMethodTypeWithRenameRegion from '../../pluggableElementTypes/RpcMethodTypeWithRenameRegion.ts';
+import type { EncodedLayersResult } from '../../util/markEncoding.ts';
+import type { RpcExecuteArgs } from '../RpcRegistry.ts';
+/**
+ * Fetch a region's features once, run the shared transform steps over them,
+ * split them by the facet where the request names one, run each layer's own
+ * steps (per section, under a facet), and evaluate the layer's encoding over
+ * what is left in the worker, where the `Feature` objects are, filling the
+ * lanes its mark reads. The colours come back packed, the scale tables
+ * resolved, and the main thread reads the same table for its legend that the
+ * colours were drawn from.
+ */
+export default class CoreGetEncodedLayers extends RpcMethodTypeWithRenameRegion<'CoreGetEncodedLayers'> {
+    name: 'CoreGetEncodedLayers';
+    execute(args: RpcExecuteArgs<'CoreGetEncodedLayers'>): Promise<import("../byteBudget.ts").RegionTooLargeResult | import("../RpcServer.ts").RpcResult<EncodedLayersResult>>;
+}

package/esm/rpc/methods/CoreGetEncodedLayers.js

@@ -0,0 +1,59 @@
+import { getFeatureAdapterOrThrow } from '../../data_adapters/getFeatureAdapter.js';
+import RpcMethodTypeWithRenameRegion from '../../pluggableElementTypes/RpcMethodTypeWithRenameRegion.js';
+import { rpcResult } from '../../util/librpc.js';
+import { encodeFeatures, encodedChannelTransferables, } from '../../util/markEncoding.js';
+import { createProgressReporter } from '../../util/progress.js';
+import { measureRegionBytes } from '../byteBudget.js';
+import { layerFeatures } from './layerFeatures.js';
+/**
+ * Fetch a region's features once, run the shared transform steps over them,
+ * split them by the facet where the request names one, run each layer's own
+ * steps (per section, under a facet), and evaluate the layer's encoding over
+ * what is left in the worker, where the `Feature` objects are, filling the
+ * lanes its mark reads. The colours come back packed, the scale tables
+ * resolved, and the main thread reads the same table for its legend that the
+ * colours were drawn from.
+ */
+export default class CoreGetEncodedLayers extends RpcMethodTypeWithRenameRegion {
+    name = 'CoreGetEncodedLayers';
+    async execute(args) {
+        const { region, layers: requested, byteLimit, signal, statusCallback, } = args;
+        const { pluginManager } = this;
+        const dataAdapter = await getFeatureAdapterOrThrow({
+            ...args,
+            pluginManager,
+        });
+        const { bytes, tooLarge } = await measureRegionBytes({
+            dataAdapter,
+            regions: [region],
+            byteLimit,
+            signal,
+            statusCallback,
+        });
+        if (tooLarge) {
+            return tooLarge;
+        }
+        const { jexl } = pluginManager;
+        const { layers: layered, sections, zoomRange, notices, } = await layerFeatures(dataAdapter, args, jexl);
+        const layers = requested.map((request, i) => {
+            const { table, row } = layered[i];
+            return encodeFeatures(table, { ...request.encoding, row }, request.lanes, {
+                jexl,
+                report: createProgressReporter({
+                    label: 'Processing features',
+                    total: table.length,
+                    statusCallback,
+                    signal,
+                }),
+            });
+        });
+        const result = {
+            layers,
+            facet: sections,
+            bytes,
+            zoomRange,
+            ...(notices.length > 0 ? { notices } : {}),
+        };
+        return rpcResult(result, layers.flatMap(l => encodedChannelTransferables(l)));
+    }
+}

package/esm/rpc/methods/CoreGetExportData.d.ts

@@ -1,19 +1,6 @@
-import RpcMethodType from '../../pluggableElementTypes/RpcMethodType.ts';
-import type { Region } from '../../util/index.ts';
-export default class CoreGetExportData extends RpcMethodType {
-    name: string;
-    serializeArguments(args: {
-        sessionId: string;
-        regions: Region[];
-        adapterConfig: Record<string, unknown>;
-        formatType: string;
-        opts?: any;
-    }, rpcDriver: string): Promise<Record<string, unknown>>;
-    execute(args: {
-        sessionId: string;
-        regions: Region[];
-        adapterConfig: Record<string, unknown>;
-        formatType: string;
-        opts?: any;
-    }, rpcDriver: string): Promise<string>;
+import RpcMethodTypeWithRenameRegions from '../../pluggableElementTypes/RpcMethodTypeWithRenameRegions.ts';
+import type { RpcExecuteArgs } from '../RpcRegistry.ts';
+export default class CoreGetExportData extends RpcMethodTypeWithRenameRegions<'CoreGetExportData'> {
+    name: 'CoreGetExportData';
+    execute(args: RpcExecuteArgs<'CoreGetExportData'>): Promise<string | undefined>;
 }

package/esm/rpc/methods/CoreGetExportData.js

@@ -1,18 +1,28 @@
-import { getAdapter } from "../../data_adapters/dataAdapterCache.js";
-import RpcMethodType from "../../pluggableElementTypes/RpcMethodType.js";
-import { renameRegionsIfNeeded } from "../../util/index.js";
-export default class CoreGetExportData extends RpcMethodType {
+import { getFeatureAdapterOrThrow } from '../../data_adapters/getFeatureAdapter.js';
+import RpcMethodTypeWithRenameRegions from '../../pluggableElementTypes/RpcMethodTypeWithRenameRegions.js';
+export default class CoreGetExportData extends RpcMethodTypeWithRenameRegions {
     name = 'CoreGetExportData';
-    async serializeArguments(args, rpcDriver) {
-        const { rootModel } = this.pluginManager;
-        const assemblyManager = rootModel.session.assemblyManager;
-        const renamedArgs = await renameRegionsIfNeeded(assemblyManager, args);
-        return super.serializeArguments(renamedArgs, rpcDriver);
-    }
-    async execute(args, rpcDriver) {
-        const { sessionId, adapterConfig, regions, formatType, opts } = await this.deserializeArguments(args, rpcDriver);
-        const dataAdapter = (await getAdapter(this.pluginManager, sessionId, adapterConfig)).dataAdapter;
-        const result = await dataAdapter.getExportData(regions, formatType, opts);
-        return result || '';
+    async execute(args) {
+        const { regions, formatType, opts, signal, statusCallback } = args;
+        const dataAdapter = await getFeatureAdapterOrThrow({
+            ...args,
+            pluginManager: this.pluginManager,
+        });
+        // The handles go down to the adapter, which is the whole point of the
+        // Save-track-data dialog having a cancel button and a progress label: an
+        // export of the visible region on a deep track is the same read the display
+        // does. They arrived on every call and were dropped here, so both were
+        // decorative on this branch — the one taken by any adapter with its own
+        // exporter.
+        //
+        // undefined travels: it is the adapter saying it does not write this
+        // format, which is a different answer from an empty region, and the caller
+        // falls back to reading features. Coercing it to '' here handed the user an
+        // empty file instead.
+        return dataAdapter.getExportData(regions, formatType, {
+            ...opts,
+            signal,
+            statusCallback,
+        });
     }
 }

package/esm/rpc/methods/CoreGetFeatureDensity.d.ts

@@ -0,0 +1,11 @@
+import RpcMethodTypeWithRenameRegions from '../../pluggableElementTypes/RpcMethodTypeWithRenameRegions.ts';
+import type { RpcExecuteArgs } from '../RpcRegistry.ts';
+/**
+ * The density tier's read: features per bin at the view's bp/px for regions the
+ * region-too-large gate refused. Answers `undefined` for an adapter with no
+ * density source, and the display keeps the banner.
+ */
+export default class CoreGetFeatureDensity extends RpcMethodTypeWithRenameRegions<'CoreGetFeatureDensity'> {
+    name: 'CoreGetFeatureDensity';
+    execute(args: RpcExecuteArgs<'CoreGetFeatureDensity'>): Promise<import("../../data_adapters/BaseAdapter/featureDensity.ts").FeatureDensity[] | undefined>;
+}

package/esm/rpc/methods/CoreGetFeatureDensity.js

@@ -0,0 +1,22 @@
+import { isFeatureAdapter } from '../../data_adapters/BaseAdapter/index.js';
+import { getAdapter } from '../../data_adapters/dataAdapterCache.js';
+import RpcMethodTypeWithRenameRegions from '../../pluggableElementTypes/RpcMethodTypeWithRenameRegions.js';
+/**
+ * The density tier's read: features per bin at the view's bp/px for regions the
+ * region-too-large gate refused. Answers `undefined` for an adapter with no
+ * density source, and the display keeps the banner.
+ */
+export default class CoreGetFeatureDensity extends RpcMethodTypeWithRenameRegions {
+    name = 'CoreGetFeatureDensity';
+    async execute(args) {
+        const { adapterConfig, sessionId, regions, bpPerPx, signal } = args;
+        const { dataAdapter } = await getAdapter(this.pluginManager, sessionId, adapterConfig, args.sequenceAdapter);
+        return isFeatureAdapter(dataAdapter)
+            ? dataAdapter.getFeatureDensity(regions, {
+                bpPerPx,
+                signal,
+                statusCallback: args.statusCallback,
+            })
+            : undefined;
+    }
+}

package/esm/rpc/methods/CoreGetFeatures.d.ts

@@ -1,18 +1,9 @@
-import RpcMethodType from '../../pluggableElementTypes/RpcMethodType.ts';
+import RpcMethodTypeWithRenameRegions from '../../pluggableElementTypes/RpcMethodTypeWithRenameRegions.ts';
 import SimpleFeature from '../../util/simpleFeature.ts';
-import type { RenderArgs } from './util.ts';
-import type { Region } from '../../util/index.ts';
 import type { SimpleFeatureSerialized } from '../../util/simpleFeature.ts';
-export default class CoreGetFeatures extends RpcMethodType {
-    name: string;
-    deserializeReturn(feats: SimpleFeatureSerialized[], args: unknown, rpcDriver: string): Promise<SimpleFeature[]>;
-    serializeArguments(args: RenderArgs, rpcDriver: string): Promise<RenderArgs>;
-    execute(args: {
-        sessionId: string;
-        regions: Region[];
-        adapterConfig: Record<string, unknown>;
-        statusCallback: (arg: string) => void;
-        stopToken?: string;
-        opts?: any;
-    }, rpcDriver: string): Promise<SimpleFeatureSerialized[]>;
+import type { RpcExecuteArgs } from '../RpcRegistry.ts';
+export default class CoreGetFeatures extends RpcMethodTypeWithRenameRegions<'CoreGetFeatures'> {
+    name: 'CoreGetFeatures';
+    deserializeReturn(feats: SimpleFeatureSerialized[], _args: unknown): Promise<SimpleFeature[]>;
+    execute(args: RpcExecuteArgs<'CoreGetFeatures'>): Promise<SimpleFeatureSerialized[]>;
 }