@jbrowse/core 4.3.0 → 5.0.0-beta.1

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/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,29 @@
-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 { sessionId, adapterConfig, regions, formatType, opts, stopToken, statusCallback, } = args;
+        const dataAdapter = await getFeatureAdapterOrThrow({
+            pluginManager: this.pluginManager,
+            sessionId,
+            adapterConfig,
+        });
+        // 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,
+            stopToken,
+            statusCallback,
+        });
     }
 }

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[]>;
 }

package/esm/rpc/methods/CoreGetFeatures.js

@@ -1,24 +1,22 @@
 import { firstValueFrom } from 'rxjs';
 import { toArray } from 'rxjs/operators';
-import { getAdapter } from "../../data_adapters/dataAdapterCache.js";
-import RpcMethodType from "../../pluggableElementTypes/RpcMethodType.js";
-import { renameRegionsIfNeeded } from "../../util/index.js";
-import SimpleFeature from "../../util/simpleFeature.js";
-export default class CoreGetFeatures extends RpcMethodType {
+import { getFeatureAdapterOrThrow } from '../../data_adapters/getFeatureAdapter.js';
+import RpcMethodTypeWithRenameRegions from '../../pluggableElementTypes/RpcMethodTypeWithRenameRegions.js';
+import { unwrapRpcResult } from '../../util/rpc.js';
+import SimpleFeature from '../../util/simpleFeature.js';
+export default class CoreGetFeatures extends RpcMethodTypeWithRenameRegions {
     name = 'CoreGetFeatures';
-    async deserializeReturn(feats, args, rpcDriver) {
-        const superDeserialized = (await super.deserializeReturn(feats, args, rpcDriver));
-        return superDeserialized.map(feat => new SimpleFeature(feat));
+    async deserializeReturn(feats, _args) {
+        return unwrapRpcResult(feats).map(feat => new SimpleFeature(feat));
     }
-    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 { stopToken, statusCallback, sessionId, adapterConfig, regions, opts, } = await this.deserializeArguments(args, rpcDriver);
-        const dataAdapter = (await getAdapter(this.pluginManager, sessionId, adapterConfig)).dataAdapter;
+    async execute(args) {
+        const { stopToken, statusCallback, sessionId, adapterConfig, sequenceAdapter, regions, opts, } = args;
+        const dataAdapter = await getFeatureAdapterOrThrow({
+            pluginManager: this.pluginManager,
+            sessionId,
+            adapterConfig,
+            sequenceAdapter,
+        });
         const r = await firstValueFrom(dataAdapter
             .getFeaturesInMultipleRegions(regions, {
             ...opts,

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

@@ -0,0 +1,6 @@
+import RpcMethodType from '../../pluggableElementTypes/RpcMethodType.ts';
+import type { RpcExecuteArgs } from '../RpcRegistry.ts';
+export default class CoreGetInfo extends RpcMethodType<'CoreGetInfo'> {
+    name: 'CoreGetInfo';
+    execute(args: RpcExecuteArgs<'CoreGetInfo'>): Promise<unknown>;
+}

package/esm/rpc/methods/CoreGetInfo.js

@@ -0,0 +1,12 @@
+import { isFeatureAdapter } from '../../data_adapters/BaseAdapter/index.js';
+import { getAdapter } from '../../data_adapters/dataAdapterCache.js';
+import RpcMethodType from '../../pluggableElementTypes/RpcMethodType.js';
+export default class CoreGetInfo extends RpcMethodType {
+    name = 'CoreGetInfo';
+    async execute(args) {
+        const pm = this.pluginManager;
+        const { sessionId, adapterConfig } = args;
+        const { dataAdapter } = await getAdapter(pm, sessionId, adapterConfig);
+        return isFeatureAdapter(dataAdapter) ? dataAdapter.getHeader(args) : null;
+    }
+}

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

@@ -1,9 +1,6 @@
 import RpcMethodType from '../../pluggableElementTypes/RpcMethodType.ts';
-export default class CoreGetMetadata extends RpcMethodType {
-    name: string;
-    execute(args: {
-        sessionId: string;
-        stopToken?: string;
-        adapterConfig: Record<string, unknown>;
-    }, rpcDriver: string): Promise<unknown>;
+import type { RpcExecuteArgs } from '../RpcRegistry.ts';
+export default class CoreGetMetadata extends RpcMethodType<'CoreGetMetadata'> {
+    name: 'CoreGetMetadata';
+    execute(args: RpcExecuteArgs<'CoreGetMetadata'>): Promise<unknown>;
 }

package/esm/rpc/methods/CoreGetMetadata.js

@@ -1,15 +1,12 @@
-import { isFeatureAdapter } from "../../data_adapters/BaseAdapter/index.js";
-import { getAdapter } from "../../data_adapters/dataAdapterCache.js";
-import RpcMethodType from "../../pluggableElementTypes/RpcMethodType.js";
+import { isFeatureAdapter } from '../../data_adapters/BaseAdapter/index.js';
+import { getAdapter } from '../../data_adapters/dataAdapterCache.js';
+import RpcMethodType from '../../pluggableElementTypes/RpcMethodType.js';
 export default class CoreGetMetadata extends RpcMethodType {
     name = 'CoreGetMetadata';
-    async execute(args, rpcDriver) {
+    async execute(args) {
         const pm = this.pluginManager;
-        const deserializedArgs = await this.deserializeArguments(args, rpcDriver);
-        const { sessionId, adapterConfig } = deserializedArgs;
+        const { sessionId, adapterConfig } = args;
         const { dataAdapter } = await getAdapter(pm, sessionId, adapterConfig);
-        return isFeatureAdapter(dataAdapter)
-            ? dataAdapter.getMetadata(deserializedArgs)
-            : null;
+        return isFeatureAdapter(dataAdapter) ? dataAdapter.getMetadata(args) : null;
     }
 }

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

@@ -1,10 +1,6 @@
 import RpcMethodType from '../../pluggableElementTypes/RpcMethodType.ts';
-export default class CoreGetRefNames extends RpcMethodType {
-    name: string;
-    execute(args: {
-        sessionId: string;
-        stopToken?: string;
-        adapterConfig: Record<string, unknown>;
-        sequenceAdapter?: Record<string, unknown>;
-    }, rpcDriver: string): Promise<string[]>;
+import type { RpcExecuteArgs } from '../RpcRegistry.ts';
+export default class CoreGetRefNames extends RpcMethodType<'CoreGetRefNames'> {
+    name: 'CoreGetRefNames';
+    execute(args: RpcExecuteArgs<'CoreGetRefNames'>): Promise<string[] | never[]>;
 }

package/esm/rpc/methods/CoreGetRefNames.js

@@ -1,19 +1,30 @@
-import { isFeatureAdapter } from "../../data_adapters/BaseAdapter/index.js";
-import { getAdapter } from "../../data_adapters/dataAdapterCache.js";
-import RpcMethodType from "../../pluggableElementTypes/RpcMethodType.js";
+import { isFeatureAdapter, isRefNameSource, } from '../../data_adapters/BaseAdapter/util.js';
+import { getAdapter } from '../../data_adapters/dataAdapterCache.js';
+import RpcMethodType from '../../pluggableElementTypes/RpcMethodType.js';
 export default class CoreGetRefNames extends RpcMethodType {
     name = 'CoreGetRefNames';
-    async execute(args, rpcDriver) {
-        const pm = this.pluginManager;
-        const deserializedArgs = await this.deserializeArguments(args, rpcDriver);
-        const { sessionId, adapterConfig, sequenceAdapter } = deserializedArgs;
-        const { dataAdapter } = await getAdapter(pm, sessionId, adapterConfig);
-        if (!isFeatureAdapter(dataAdapter)) {
-            return [];
-        }
-        if (sequenceAdapter && !dataAdapter.sequenceAdapterConfig) {
+    async execute(args) {
+        const { sessionId, adapterConfig, sequenceAdapter } = args;
+        const { dataAdapter } = await getAdapter(this.pluginManager, sessionId, adapterConfig);
+        // Primes BEFORE it asks: a ReferenceScanAdapter answers `getRefNames` by
+        // asking the reference, and this line is what tells it where that is.
+        // Pinned by sequenceAdapterPriming.test.ts, because reversing the two left
+        // 3,015 tests green.
+        //
+        // The one call that still passes `sequenceAdapter` by hand — it is what
+        // `renameRegionsIfNeeded` CALLS, so the derivation cannot reach it.
+        if (isFeatureAdapter(dataAdapter)) {
             dataAdapter.setSequenceAdapterConfig(sequenceAdapter);
         }
-        return dataAdapter.getRefNames(deserializedArgs);
+        // Gated on isRefNameSource rather than isFeatureAdapter: any adapter that
+        // can name its own contigs needs them reconciled with the assembly's,
+        // whether or not it serves features. PlinkLDTabixAdapter serves precomputed
+        // LD pairs, so it failed a feature-adapter check and reported *zero*
+        // refNames; that made the refName map empty, which made renaming a silent
+        // no-op, which left every record dropped by a later exact-match refName
+        // test. The symptom was a blank LD track with no error whenever the file's
+        // contig names differed from the assembly's canonical ones (an Ensembl-named
+        // .ld file against a UCSC-named hub, say).
+        return isRefNameSource(dataAdapter) ? dataAdapter.getRefNames(args) : [];
     }
 }

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

@@ -0,0 +1,6 @@
+import RpcMethodTypeWithRenameRegions from '../../pluggableElementTypes/RpcMethodTypeWithRenameRegions.ts';
+import type { RpcExecuteArgs } from '../RpcRegistry.ts';
+export default class CoreGetRegionByteEstimate extends RpcMethodTypeWithRenameRegions<'CoreGetRegionByteEstimate'> {
+    name: 'CoreGetRegionByteEstimate';
+    execute(args: RpcExecuteArgs<'CoreGetRegionByteEstimate'>): Promise<number | undefined>;
+}

package/esm/rpc/methods/CoreGetRegionByteEstimate.js

@@ -0,0 +1,19 @@
+import { isFeatureAdapter } from '../../data_adapters/BaseAdapter/index.js';
+import { getAdapter } from '../../data_adapters/dataAdapterCache.js';
+import RpcMethodTypeWithRenameRegions from '../../pluggableElementTypes/RpcMethodTypeWithRenameRegions.js';
+import { largestRegionBytes } from '../byteBudget.js';
+export default class CoreGetRegionByteEstimate extends RpcMethodTypeWithRenameRegions {
+    name = 'CoreGetRegionByteEstimate';
+    async execute(args) {
+        const { adapterConfig, sessionId, regions, scope } = args;
+        const { dataAdapter } = await getAdapter(this.pluginManager, sessionId, adapterConfig);
+        // "Unmeasurable", not an error: the gate reads undefined as "no byte axis".
+        if (!isFeatureAdapter(dataAdapter)) {
+            return undefined;
+        }
+        if (scope === 'wholeRequest') {
+            return dataAdapter.getRegionByteSize(regions, args);
+        }
+        return largestRegionBytes(await Promise.all(regions.map(region => dataAdapter.getRegionByteSize([region], args))));
+    }
+}

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

@@ -1,8 +1,6 @@
 import RpcMethodType from '../../pluggableElementTypes/RpcMethodType.ts';
-export default class CoreGetRegions extends RpcMethodType {
-    name: string;
-    execute(args: {
-        sessionId: string;
-        adapterConfig: Record<string, unknown>;
-    }, rpcDriver: string): Promise<never[] | import("../../util/index.ts").NoAssemblyRegion[]>;
+import type { RpcExecuteArgs } from '../RpcRegistry.ts';
+export default class CoreGetRegions extends RpcMethodType<'CoreGetRegions'> {
+    name: 'CoreGetRegions';
+    execute(args: RpcExecuteArgs<'CoreGetRegions'>): Promise<never[] | import("../../util/index.ts").NoAssemblyRegion[]>;
 }

package/esm/rpc/methods/CoreGetRegions.js

@@ -1,15 +1,12 @@
-import { isRegionsAdapter } from "../../data_adapters/BaseAdapter/index.js";
-import { getAdapter } from "../../data_adapters/dataAdapterCache.js";
-import RpcMethodType from "../../pluggableElementTypes/RpcMethodType.js";
+import { isRegionsAdapter } from '../../data_adapters/BaseAdapter/index.js';
+import { getAdapter } from '../../data_adapters/dataAdapterCache.js';
+import RpcMethodType from '../../pluggableElementTypes/RpcMethodType.js';
 export default class CoreGetRegions extends RpcMethodType {
     name = 'CoreGetRegions';
-    async execute(args, rpcDriver) {
+    async execute(args) {
         const pm = this.pluginManager;
-        const deserializedArgs = await this.deserializeArguments(args, rpcDriver);
-        const { sessionId, adapterConfig } = deserializedArgs;
+        const { sessionId, adapterConfig } = args;
         const { dataAdapter } = await getAdapter(pm, sessionId, adapterConfig);
-        return isRegionsAdapter(dataAdapter)
-            ? dataAdapter.getRegions(deserializedArgs)
-            : [];
+        return isRegionsAdapter(dataAdapter) ? dataAdapter.getRegions(args) : [];
     }
 }

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

@@ -1,13 +1,6 @@
 import RpcMethodType from '../../pluggableElementTypes/RpcMethodType.ts';
-import type { RenderArgs } from './util.ts';
-import type { Region } from '../../util/index.ts';
-export default class CoreGetSequence extends RpcMethodType {
-    name: string;
-    serializeArguments(args: RenderArgs, rpcDriver: string): Promise<RenderArgs>;
-    execute(args: {
-        sessionId: string;
-        region: Region;
-        adapterConfig: Record<string, unknown>;
-        stopToken?: string;
-    }, rpcDriver: string): Promise<string | undefined>;
+import type { RpcExecuteArgs } from '../RpcRegistry.ts';
+export default class CoreGetSequence extends RpcMethodType<'CoreGetSequence'> {
+    name: 'CoreGetSequence';
+    execute(args: RpcExecuteArgs<'CoreGetSequence'>): Promise<string | undefined>;
 }

package/esm/rpc/methods/CoreGetSequence.js

@@ -1,17 +1,16 @@
-import { getAdapter } from "../../data_adapters/dataAdapterCache.js";
-import RpcMethodType from "../../pluggableElementTypes/RpcMethodType.js";
-import { renameRegionsIfNeeded } from "../../util/index.js";
+import { isSequenceAdapter } from '../../data_adapters/BaseAdapter/index.js';
+import { getAdapter } from '../../data_adapters/dataAdapterCache.js';
+import RpcMethodType from '../../pluggableElementTypes/RpcMethodType.js';
+// CoreGetSequence takes a single region whose refName fetchSeq() has already
+// resolved to the sequence adapter's name, so no region renaming is needed here
 export default class CoreGetSequence extends RpcMethodType {
     name = 'CoreGetSequence';
-    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 { stopToken, sessionId, adapterConfig, region } = await this.deserializeArguments(args, rpcDriver);
-        const dataAdapter = (await getAdapter(this.pluginManager, sessionId, adapterConfig)).dataAdapter;
-        return dataAdapter.getSequence(region, { stopToken });
+    async execute(args) {
+        const { stopToken, statusCallback, sessionId, adapterConfig, region } = args;
+        const { dataAdapter } = await getAdapter(this.pluginManager, sessionId, adapterConfig);
+        if (!isSequenceAdapter(dataAdapter)) {
+            throw new Error('Adapter does not support retrieving sequences');
+        }
+        return dataAdapter.getSequence(region, { stopToken, statusCallback });
     }
 }