@jbrowse/core 4.3.0 → 5.0.0-beta.10

package/esm/rpc/WebWorkerRpcDriver.d.ts

@@ -1,31 +1,85 @@
 import BaseRpcDriver from './BaseRpcDriver.ts';
-import type { RpcDriverConstructorArgs } from './BaseRpcDriver.ts';
-import type { PluginDefinition } from '../PluginLoader.ts';
-interface WebWorkerRpcDriverConstructorArgs extends RpcDriverConstructorArgs {
-    makeWorkerInstance: () => Worker;
+import type PluginManager from '../PluginManager.ts';
+import type { AnyConfigurationModel } from '../configuration/index.ts';
+import type RpcMethodType from '../pluggableElementTypes/RpcMethodType.ts';
+import type { PluginDefinition } from '../pluginDefinitions.ts';
+import type { StatusCallback } from '../util/progress.ts';
+import type { RpcHandles } from './RpcRegistry.ts';
+export interface WorkerHandle {
+    destroy(): void;
+    onError?(callback: () => void): void;
+    on?(eventName: string, listener: (data: unknown) => void): void;
+    postMessage?(message: unknown): void;
+    call(functionName: string, args?: unknown, options?: {
+        statusCallback?: StatusCallback;
+        signal?: AbortSignal;
+    }): Promise<unknown>;
 }
-interface Options {
-    statusCallback?: (arg0: unknown) => void;
-    rpcDriverClassName: string;
+declare module '@jbrowse/core/PluginManager' {
+    interface ExtensionPointRegistry {
+        'Core-extendWorker': {
+            args: WorkerHandle;
+            result: WorkerHandle;
+        };
+    }
 }
-declare class WebWorkerHandle {
-    worker: Worker;
-    private client;
-    constructor(worker: Worker);
-    destroy(): void;
-    call(funcName: string, args: Record<string, unknown>, opts: Options): Promise<unknown>;
+export interface WebWorkerRpcDriverOptions {
+    makeWorkerInstance: () => Worker;
+    plugins: PluginDefinition[];
+    windowHref: string;
+    numberGrouping: boolean;
 }
+/**
+ * Runs RPC methods in a pool of lazily-booted web workers, with our own
+ * state-group-aware round-robin assignment (one sticky worker per session) so a
+ * session's calls land on the same worker and can share cached adapters.
+ *
+ * The pool is here rather than in a `WorkerPoolRpcDriver` above it: that base
+ * abstracted `makeWorker`, which has one implementation. It is a plain
+ * overridable method now, which is all the seam was ever used for. ADR-086.
+ */
 export default class WebWorkerRpcDriver extends BaseRpcDriver {
-    workerBootConfiguration: {
-        plugins: PluginDefinition[];
-        windowHref: string;
-    };
+    private options;
     name: string;
-    makeWorkerInstance: () => Worker;
-    constructor(args: WebWorkerRpcDriverConstructorArgs, workerBootConfiguration: {
-        plugins: PluginDefinition[];
-        windowHref: string;
-    });
-    makeWorker(): Promise<WebWorkerHandle>;
+    private lastWorkerAssignment;
+    private workerAssignments;
+    private workerPool?;
+    private destroyed;
+    constructor(pluginManager: PluginManager, config: AnyConfigurationModel, options: WebWorkerRpcDriverOptions);
+    /**
+     * Free the session on the worker it was assigned to, and drop the assignment
+     * so it doesn't accumulate for the life of the driver.
+     *
+     * A session with no assignment never dispatched anything, so there is nothing
+     * cached anywhere to free — and no pool to build in order to find that out.
+     */
+    freeSession(sessionId: string): Promise<void>;
+    destroy(): void;
+    private createWorkerPool;
+    private getWorkerPool;
+    /**
+     * Boot the first worker now rather than on the first call, so its bundle and
+     * runtime plugins load while the page builds the session. The first session
+     * is assigned to that worker.
+     */
+    warmUp(): void;
+    getWorker(sessionId: string): Promise<WorkerHandle>;
+    /**
+     * Hand a freshly booted worker to whatever plugins want to extend it, and use
+     * whatever comes back as the pooled handle.
+     *
+     * Called from {@link LazyWorker.getWorker} rather than from `makeWorker`,
+     * which subclasses override — a seam that skipped the fold would silently
+     * un-extend every worker. It answers "what is this worker", not "what is this
+     * call", so folding at dispatch needed a WeakMap to stop rebuilding a
+     * plugin's wrapper per RPC; once per boot has nothing to memoize.
+     */
+    extendsWorkers(): boolean;
+    extendWorker(worker: WorkerHandle): WorkerHandle;
+    protected transport(sessionId: string, rpcMethod: RpcMethodType, serializedArgs: Record<string, unknown>, handles: RpcHandles): Promise<unknown>;
+    /**
+     * Boot one worker and run the configuration handshake. Overridable so a test
+     * can hand the pool a fake handle without a `Worker`; nothing in the app does.
+     */
+    makeWorker(onHandle?: (handle: WorkerHandle) => void): Promise<WorkerHandle>;
 }
-export {};

package/esm/rpc/WebWorkerRpcDriver.js

@@ -1,77 +1,358 @@
-import BaseRpcDriver from "./BaseRpcDriver.js";
-import { RpcClient, deserializeError } from "../util/librpc.js";
-import { nanoid } from "../util/nanoid.js";
+import { readConfObject } from '../configuration/index.js';
+import { clamp } from '../util/index.js';
+import BaseRpcDriver, { CORE_FREE_RESOURCES } from './BaseRpcDriver.js';
+import RpcClient from './RpcClient.js';
+import { deserializeError } from './serializeError/index.js';
+function detectHardwareConcurrency() {
+    // fall back to 1 if navigator.hardwareConcurrency is absent, else clamp()
+    // sees NaN and collapses the pool to zero workers
+    return typeof navigator === 'undefined'
+        ? 1
+        : navigator.hardwareConcurrency || 1;
+}
 class WebWorkerHandle {
     worker;
     client;
+    // a counter, not a nanoid: the listener map a channel keys into is this
+    // handle's own client, so that is the only scope uniqueness is needed in, and
+    // the nanoid was a crypto.getRandomValues per reporting call
+    channelCount = 0;
     constructor(worker) {
         this.worker = worker;
         this.client = new RpcClient(worker);
+        // Listen for worker errors that might not be caught by RpcClient
         this.client.on('error', error => {
             console.error('[WebWorker RPC Error]', error);
         });
     }
     destroy() {
+        // reject in-flight calls before terminating, else they wait on a reply the
+        // dead worker can never send
+        this.client.destroy();
         this.worker.terminate();
     }
-    async call(funcName, args, opts) {
-        const { statusCallback, rpcDriverClassName } = opts;
-        const channel = `message-${nanoid()}`;
+    // lets the pool discard this handle once the worker throws a fatal error
+    onError(callback) {
+        this.client.on('error', callback);
+    }
+    // the two halves of {@link WorkerHandle}'s plugin-facing pair
+    on(eventName, listener) {
+        this.client.on(eventName, listener);
+    }
+    postMessage(message) {
+        this.worker.postMessage(message);
+    }
+    /**
+     * A `channel` only when the caller asked for status, so that "no
+     * statusCallback" survives the worker boundary.
+     *
+     * It did not. The channel was minted unconditionally, and `wrapForRpc` builds
+     * the worker's `statusCallback` from whatever channel it is handed — so every
+     * method in every worker ran with a live status handle whoever called it had
+     * declined, and `MainThreadRpcDriver` (which passes the caller's own
+     * `undefined` straight through) answered the same question differently. That
+     * asymmetry is the one {@link RpcManager}'s `call` docstring already records
+     * in the other direction.
+     *
+     * The absence is not cosmetic — it is a documented branch. `downloadStatus`
+     * hands the reader no `onProgress` without a callback, `createProgressReporter`
+     * skips its emit, and every status the worker did send crossed a postMessage
+     * to reach a listener that dropped it.
+     *
+     * The postMessage traffic and the symmetry are the whole case; the read speed
+     * is not. `res.bytes()` is the SLOWER of the two reads under ~10MB —
+     * agent-docs/measurements/download-read-path.json — and an earlier revision of
+     * this comment claimed the opposite because four other places in the tree did.
+     */
+    async call(funcName, args, 
+    // defaulted, not required: {@link WorkerHandle} declares it optional, and a
+    // `Core-extendWorker` wrapper written against that interface may well call
+    // `worker.call(name, args)` — which destructured `undefined` and threw
+    opts = {}) {
+        const { statusCallback, signal } = opts;
+        if (!statusCallback) {
+            return this.client.call(funcName, args, signal);
+        }
+        const channel = `message-${++this.channelCount}`;
+        // RpcClient is a generic event emitter (it also carries 'error' events), so
+        // its listeners see `unknown`. This channel is dedicated to one method's
+        // status emits, which the worker only ever posts as RpcStatus (see
+        // wrapForRpc in rpcWorker.ts), so narrowing to RpcStatus here is sound.
         const listener = (message) => {
-            statusCallback?.(message);
+            statusCallback(message);
         };
         this.client.on(channel, listener);
         try {
-            const result = await this.client.call(funcName, {
-                ...args,
-                channel,
-                rpcDriverClassName,
-            });
-            return result;
+            return await this.client.call(funcName, { ...args, channel }, signal);
         }
         finally {
             this.client.off(channel, listener);
         }
     }
 }
+class LazyWorker {
+    driver;
+    /**
+     * The handle this slot booted, and what the pool drives the worker's LIFE on
+     * — the error hook and the termination.
+     *
+     * Kept apart from {@link workerP} because a `Core-extendWorker` plugin only
+     * has to forward `call`: `WorkerHandle` makes `onError` and the rest
+     * optional, so a conforming wrapper (a spread plus a `call`, which is the
+     * obvious way to write one) drops them. Driving the re-boot through such a
+     * wrapper means a dead worker is never noticed and the slot never re-boots.
+     */
+    bootP;
+    /** What `Core-extendWorker` returned for it: where calls go. */
+    workerP;
+    constructor(driver) {
+        this.driver = driver;
+    }
+    async getWorker() {
+        if (!this.workerP) {
+            let early;
+            const booted = this.driver.makeWorker(handle => {
+                early = handle;
+            });
+            this.bootP = booted;
+            // A booting worker holds the calls it is sent, so with nothing to extend
+            // them a call goes out now rather than when the page gets round to the
+            // worker's 'ready'. A boot that fails rejects those calls with the
+            // handle. An extended worker is extended once booted, as promised.
+            this.workerP =
+                early && !this.driver.extendsWorkers()
+                    ? Promise.resolve(early)
+                    : // once per booted worker by construction, rather than per dispatch
+                        // behind a memo
+                        booted.then(worker => this.driver.extendWorker(worker));
+            // drop this slot so the next getWorker re-boots, whether the boot failed
+            // or the booted worker later died (a dead worker never replies)
+            const invalidate = () => {
+                if (this.bootP === booted) {
+                    this.bootP = undefined;
+                    this.workerP = undefined;
+                }
+            };
+            booted
+                .then(worker => {
+                worker.onError?.(() => {
+                    invalidate();
+                    worker.destroy();
+                });
+            })
+                .catch(invalidate);
+        }
+        return this.workerP;
+    }
+    destroy() {
+        // terminate the underlying worker once it resolves; a worker that never
+        // booted (rejected promise) has nothing to terminate, so swallow that
+        this.bootP
+            ?.then(worker => {
+            worker.destroy();
+        })
+            .catch(() => { });
+        this.bootP = undefined;
+        this.workerP = undefined;
+    }
+    /**
+     * Drop a session's cached adapters on this slot's worker, and never boot one
+     * to do it. A slot that never booted has no cache to free, and booting one
+     * there costs a whole worker bundle and every runtime plugin to say so.
+     *
+     * Through the extended handle, because it is a `call`: a plugin that wraps
+     * calls should see this one.
+     *
+     * Awaited rather than fire-and-forget, because a caller can be waiting to
+     * know the adapter is gone; a slot still booting frees once it lands.
+     */
+    async freeSession(sessionId) {
+        const worker = await this.workerP?.catch(() => undefined);
+        await worker?.call(CORE_FREE_RESOURCES, { sessionId });
+    }
+}
+/**
+ * Runs RPC methods in a pool of lazily-booted web workers, with our own
+ * state-group-aware round-robin assignment (one sticky worker per session) so a
+ * session's calls land on the same worker and can share cached adapters.
+ *
+ * The pool is here rather than in a `WorkerPoolRpcDriver` above it: that base
+ * abstracted `makeWorker`, which has one implementation. It is a plain
+ * overridable method now, which is all the seam was ever used for. ADR-086.
+ */
 export default class WebWorkerRpcDriver extends BaseRpcDriver {
-    workerBootConfiguration;
+    options;
     name = 'WebWorkerRpcDriver';
-    makeWorkerInstance;
-    constructor(args, workerBootConfiguration) {
-        super(args);
-        this.workerBootConfiguration = workerBootConfiguration;
-        this.makeWorkerInstance = args.makeWorkerInstance;
-    }
-    async makeWorker() {
-        const instance = this.makeWorkerInstance();
+    lastWorkerAssignment = -1;
+    // sessionId -> worker number
+    workerAssignments = new Map();
+    workerPool;
+    // `destroy` is terminal: `getWorkerPool` refuses rather than letting its `??=`
+    // build a second pool for a driver whose teardown already ran. ADR-086.
+    destroyed = false;
+    constructor(pluginManager, config, options) {
+        super(pluginManager, config);
+        this.options = options;
+    }
+    /**
+     * Free the session on the worker it was assigned to, and drop the assignment
+     * so it doesn't accumulate for the life of the driver.
+     *
+     * A session with no assignment never dispatched anything, so there is nothing
+     * cached anywhere to free — and no pool to build in order to find that out.
+     */
+    async freeSession(sessionId) {
+        const workerNumber = this.workerAssignments.get(sessionId);
+        this.workerAssignments.delete(sessionId);
+        if (workerNumber !== undefined) {
+            await this.workerPool?.[workerNumber]?.freeSession(sessionId);
+        }
+    }
+    // terminate every pooled worker and reset assignment bookkeeping; call when
+    // discarding the driver so its worker threads don't outlive it
+    destroy() {
+        this.destroyed = true;
+        for (const worker of this.workerPool ?? []) {
+            worker.destroy();
+        }
+        this.workerPool = undefined;
+        this.workerAssignments.clear();
+        this.lastWorkerAssignment = -1;
+    }
+    createWorkerPool() {
+        // workerCount 0 (the config default) means "decide from hardware"
+        const workerCount = readConfObject(this.config, 'workerCount') ||
+            clamp(detectHardwareConcurrency() - 1, 1, 5);
+        return Array.from({ length: workerCount }, () => new LazyWorker(this));
+    }
+    getWorkerPool() {
+        if (this.destroyed) {
+            throw new Error(`${this.name} was destroyed`);
+        }
+        return (this.workerPool ??= this.createWorkerPool());
+    }
+    /**
+     * Boot the first worker now rather than on the first call, so its bundle and
+     * runtime plugins load while the page builds the session. The first session
+     * is assigned to that worker.
+     */
+    warmUp() {
+        if (!this.destroyed) {
+            this.getWorkerPool()[0]
+                ?.getWorker()
+                .catch(() => { });
+        }
+    }
+    async getWorker(sessionId) {
+        const workers = this.getWorkerPool();
+        let workerNumber = this.workerAssignments.get(sessionId);
+        if (workerNumber === undefined) {
+            workerNumber = (this.lastWorkerAssignment + 1) % workers.length;
+            this.workerAssignments.set(sessionId, workerNumber);
+            this.lastWorkerAssignment = workerNumber;
+        }
+        return workers[workerNumber].getWorker();
+    }
+    /**
+     * Hand a freshly booted worker to whatever plugins want to extend it, and use
+     * whatever comes back as the pooled handle.
+     *
+     * Called from {@link LazyWorker.getWorker} rather than from `makeWorker`,
+     * which subclasses override — a seam that skipped the fold would silently
+     * un-extend every worker. It answers "what is this worker", not "what is this
+     * call", so folding at dispatch needed a WeakMap to stop rebuilding a
+     * plugin's wrapper per RPC; once per boot has nothing to memoize.
+     */
+    extendsWorkers() {
+        return (this.pluginManager.extensionPointCallbackCount('Core-extendWorker') > 0);
+    }
+    extendWorker(worker) {
+        return this.pluginManager.evaluateExtensionPoint(
+        /** #extensionPoint Core-extendWorker | sync | Take a booted RPC web worker: subscribe to the events it emits, post to it, or wrap its `call`. Fired once per booted worker, not per call */
+        'Core-extendWorker', worker);
+    }
+    // get this session's sticky worker and hand off the already-serialized args
+    async transport(sessionId, rpcMethod, serializedArgs, handles) {
+        const worker = await this.getWorker(sessionId);
+        return worker.call(rpcMethod.name, serializedArgs, handles);
+    }
+    /**
+     * Boot one worker and run the configuration handshake. Overridable so a test
+     * can hand the pool a fake handle without a `Worker`; nothing in the app does.
+     */
+    async makeWorker(onHandle) {
+        // one RpcClient per worker so we can do our own state-group-aware load
+        // balancing across the pool
+        const instance = this.options.makeWorkerInstance();
         const handle = new WebWorkerHandle(instance);
         const isSafari = /^((?!chrome|android).)*safari/i.test(navigator.userAgent);
         if (isSafari) {
+            // xref https://github.com/GMOD/jbrowse-components/issues/3245
+            // eslint-disable-next-line no-console
             console.log('console logging the webworker handle avoids the track going into an infinite loading state, this is a hacky workaround for safari', instance);
         }
+        // send the worker its boot configuration using info from the pluginManager
         return new Promise((resolve, reject) => {
-            const listener = (e) => {
+            const cleanup = () => {
+                instance.removeEventListener('message', onMessage);
+                instance.removeEventListener('error', onError);
+            };
+            // the pool discards this slot and re-boots on the next call, so terminate
+            // the half-booted worker rather than orphaning its thread
+            const fail = (error) => {
+                cleanup();
+                handle.destroy();
+                reject(error);
+            };
+            // The worker waits in receiveConfiguration(), which has no timeout, so an
+            // unclonable boot configuration has to fail the boot rather than leave
+            // both sides waiting.
+            const sendConfig = () => {
+                try {
+                    const { plugins, windowHref, numberGrouping } = this.options;
+                    instance.postMessage({
+                        message: 'config',
+                        config: { plugins, windowHref, numberGrouping },
+                    });
+                }
+                catch (e) {
+                    fail(new Error(`could not send the worker its boot configuration`, {
+                        cause: e,
+                    }));
+                }
+            };
+            const onMessage = (e) => {
                 switch (e.data.message) {
                     case 'ready': {
+                        cleanup();
                         resolve(handle);
-                        instance.removeEventListener('message', listener);
                         break;
                     }
                     case 'readyForConfig': {
-                        instance.postMessage({
-                            message: 'config',
-                            config: this.workerBootConfiguration,
-                        });
+                        sendConfig();
                         break;
                     }
                     case 'error': {
-                        reject(deserializeError(e.data.error));
+                        fail(deserializeError(e.data.error));
                         break;
                     }
+                    // No default
                 }
             };
-            instance.addEventListener('message', listener);
+            // a worker that throws while loading its script posts no message, so
+            // reject on the raw ErrorEvent too, else the boot promise hangs forever
+            const onError = (e) => {
+                fail(new Error(e.message || 'worker failed to load'));
+            };
+            instance.addEventListener('message', onMessage);
+            instance.addEventListener('error', onError);
+            // A dedicated worker holds what it is sent until its script has run, and
+            // receiveConfiguration listens from that run, so the config can go now,
+            // and a worker created before this driver needs no readyForConfig. It is
+            // sent again on readyForConfig for a worker whose startup awaits chunks
+            // and so would drop this one; the worker keeps the first.
+            sendConfig();
+            onHandle?.(handle);
         });
     }
 }

package/esm/rpc/byteBudget.d.ts

@@ -0,0 +1,64 @@
+import type { StatusCallback } from '../util/progress.ts';
+import type { AugmentedRegion } from '../util/types/data.ts';
+/**
+ * Which question a byte budget asks of a region set: the gate's per-region
+ * budget, or the save dialog's bound on the whole download.
+ */
+export type ByteEstimateScope = 'largestRegion' | 'wholeRequest';
+/**
+ * The one spelling of a gated feature RPC's budget argument: the number the
+ * worker measures against, undefined when the gate declined to act and nothing
+ * is measured. A call-site argument, never part of `rpcProps`, because it
+ * swings at 20kb and on force-load.
+ */
+export interface GatedFetchArgs {
+    byteLimit?: number;
+}
+export interface ByteMeasurableAdapter {
+    getRegionByteSize: (regions: AugmentedRegion[], opts?: {
+        signal?: AbortSignal;
+        statusCallback?: StatusCallback;
+    }) => Promise<number | undefined>;
+}
+/**
+ * What a gated fetch RPC answers instead of a payload when a region is over
+ * budget on either axis, carrying everything measured on the way: the byte
+ * stage runs first, so a density refusal still has `bytes`.
+ */
+export interface RegionTooLargeResult {
+    regionTooLarge: true;
+    featureCount?: number;
+    bytes?: number;
+    /** `bytes` is the max over the regions that reported — {@link measurementPartial} */
+    partial?: boolean;
+}
+export declare function isRegionRefused(result: unknown): result is RegionTooLargeResult;
+/** Undefined, never 0, when no region could be measured. */
+export declare function largestRegionBytes(perRegion: (number | undefined)[]): number | undefined;
+/** A non-positive declared limit means "no opinion" (htsget reports 0). */
+export declare function adapterByteLimit(declared: unknown, fallback: number): number;
+export declare function overByteBudget(bytes: number | undefined, byteLimit: number | undefined): bytes is number;
+/** The bytes a fetch result reports, payload or refusal; absent means unmeasured. */
+export declare function measuredBytes(result: unknown): number | undefined;
+/**
+ * Whether a result's `bytes` covers the whole region set it was asked about. A
+ * fan-out that stops at its first refusal reports whichever regions won the
+ * race, and `nextByteEstimate` takes no zoom evidence from one.
+ */
+export declare function measurementPartial(result: unknown): boolean;
+/**
+ * The first await of every gated feature fetch: each region's index-only byte
+ * estimate, judged by the largest because the budget is per region. `bytes`
+ * comes back either way; when `tooLarge` is set the caller returns it and
+ * fetches nothing. No budget means no measurement.
+ */
+export declare function measureRegionBytes({ dataAdapter, regions, byteLimit, signal, statusCallback, }: {
+    dataAdapter: ByteMeasurableAdapter;
+    regions: AugmentedRegion[];
+    byteLimit: number | undefined;
+    signal?: AbortSignal;
+    statusCallback?: StatusCallback;
+}): Promise<{
+    bytes?: number;
+    tooLarge?: RegionTooLargeResult;
+}>;

package/esm/rpc/byteBudget.js

@@ -0,0 +1,61 @@
+import { checkAbortSignal } from '../util/aborting.js';
+import { updateStatus } from '../util/progress.js';
+export function isRegionRefused(result) {
+    return (typeof result === 'object' && result !== null && 'regionTooLarge' in result);
+}
+/** Undefined, never 0, when no region could be measured. */
+export function largestRegionBytes(perRegion) {
+    let largest;
+    for (const bytes of perRegion) {
+        if (bytes !== undefined && (largest === undefined || bytes > largest)) {
+            largest = bytes;
+        }
+    }
+    return largest;
+}
+/** A non-positive declared limit means "no opinion" (htsget reports 0). */
+export function adapterByteLimit(declared, fallback) {
+    return typeof declared === 'number' && declared > 0 ? declared : fallback;
+}
+export function overByteBudget(bytes, byteLimit) {
+    return bytes !== undefined && byteLimit !== undefined && bytes > byteLimit;
+}
+/** The bytes a fetch result reports, payload or refusal; absent means unmeasured. */
+export function measuredBytes(result) {
+    return typeof result === 'object' &&
+        result !== null &&
+        'bytes' in result &&
+        typeof result.bytes === 'number'
+        ? result.bytes
+        : undefined;
+}
+/**
+ * Whether a result's `bytes` covers the whole region set it was asked about. A
+ * fan-out that stops at its first refusal reports whichever regions won the
+ * race, and `nextByteEstimate` takes no zoom evidence from one.
+ */
+export function measurementPartial(result) {
+    return (typeof result === 'object' &&
+        result !== null &&
+        'partial' in result &&
+        result.partial === true);
+}
+/**
+ * The first await of every gated feature fetch: each region's index-only byte
+ * estimate, judged by the largest because the budget is per region. `bytes`
+ * comes back either way; when `tooLarge` is set the caller returns it and
+ * fetches nothing. No budget means no measurement.
+ */
+export async function measureRegionBytes({ dataAdapter, regions, byteLimit, signal, statusCallback, }) {
+    if (byteLimit === undefined) {
+        return {};
+    }
+    const bytes = largestRegionBytes(await updateStatus('Downloading index', statusCallback, () => Promise.all(regions.map(region => dataAdapter.getRegionByteSize([region], {
+        signal,
+        statusCallback,
+    })))));
+    checkAbortSignal(signal);
+    return overByteBudget(bytes, byteLimit)
+        ? { bytes, tooLarge: { regionTooLarge: true, bytes } }
+        : { bytes };
+}

package/esm/rpc/configSchema.d.ts

@@ -1,9 +1,17 @@
+/**
+ * #config RpcOptions
+ * #category root
+ */
 declare const _default: import("../configuration/configurationSchema.ts").ConfigurationSchemaType<{
-    defaultDriver: {
-        type: string;
-        description: string;
+    readonly defaultDriver: {
+        type: "string";
+    } & {
         defaultValue: string;
     };
-    drivers: import("@jbrowse/mobx-state-tree").IOptionalIType<import("@jbrowse/mobx-state-tree").IMapType<import("@jbrowse/mobx-state-tree").ITypeUnion<import("@jbrowse/mobx-state-tree").ModelCreationType<import("@jbrowse/mobx-state-tree/dist/internal").ExtractCFromProps<Record<string, any>>> | undefined, import("@jbrowse/mobx-state-tree").ModelSnapshotType<Record<string, any>>, ({} & Partial<import("@jbrowse/mobx-state-tree/dist/internal").ExtractCFromProps<Record<string, any>>> & import("@jbrowse/mobx-state-tree/dist/internal").NonEmptyObject) | undefined>>, [undefined]>;
-}, import("../configuration/configurationSchema.ts").ConfigurationSchemaOptions<undefined, undefined>>;
+    readonly workerCount: {
+        type: "number";
+    } & {
+        defaultValue: number;
+    };
+}, import("../configuration/configurationSchema.ts").ConfigurationSchemaOptions<undefined, undefined, undefined, import("../configuration/requirements.ts").ConfigurationSchemaRequirement<Partial<Record<string, string[]>>, string>, any>>;
 export default _default;