@jbrowse/core 4.3.0 → 5.0.0-beta.2

package/esm/rpc/WebWorkerRpcDriver.js

@@ -1,32 +1,93 @@
-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 { registerStopTokenBroadcaster } from '../util/stopToken.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);
+    }
+    notifyStopToken(id) {
+        this.client.notifyStopToken(id);
+    }
+    // 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 } = opts;
+        if (!statusCallback) {
+            return this.client.call(funcName, args);
+        }
+        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,
-            });
+            const result = await this.client.call(funcName, { ...args, channel });
             return result;
         }
         finally {
@@ -34,44 +95,268 @@ class WebWorkerHandle {
         }
     }
 }
+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) {
+            const booted = this.driver.makeWorker();
+            this.bootP = booted;
+            // once per booted worker by construction, rather than per dispatch behind
+            // a memo
+            this.workerP = 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;
+    }
+    /**
+     * Forward a stopped token id, but never boot a worker to do it: an unbooted
+     * slot is running nothing to cancel. Routed through the same promise the
+     * dispatching call awaits, so a stop issued while this slot is still booting
+     * still lands after the call it means to cancel rather than ahead of the
+     * worker's message listener existing.
+     */
+    notifyStopToken(id) {
+        this.bootP
+            ?.then(worker => {
+            worker.notifyStopToken?.(id);
+        })
+            .catch(() => { });
+    }
+    /**
+     * Drop a session's cached adapters on this slot's worker — and, like
+     * {@link notifyStopToken}, 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;
+    lastWorkerAssignment = -1;
+    // sessionId -> worker number
+    workerAssignments = new Map();
+    workerPool;
+    // a stopped token has to reach the thread actually running the work, and this
+    // is the seam that carries it. Broadcast rather than routed per call: one
+    // token is commonly in flight on several calls at once, and a worker holding
+    // nothing under that id ignores the frame.
+    //
+    // Registered with the POOL, not in the constructor, so that a driver which
+    // never boots a worker stays out of the module-global broadcaster set — and
+    // registered only once the pool exists to receive the broadcast, since a
+    // `createWorkerPool` that threw after registering left an entry no `destroy`
+    // could ever reach.
+    unregisterBroadcaster = () => { };
+    // `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;
+        this.unregisterBroadcaster();
+        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);
+        const pool = Array.from({ length: workerCount }, () => new LazyWorker(this));
+        this.unregisterBroadcaster = registerStopTokenBroadcaster(id => {
+            for (const worker of pool) {
+                worker.notifyStopToken(id);
+            }
+        });
+        return pool;
+    }
+    getWorkerPool() {
+        if (this.destroyed) {
+            throw new Error(`${this.name} was destroyed`);
+        }
+        return (this.workerPool ??= this.createWorkerPool());
+    }
+    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.
+     */
+    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, statusCallback) {
+        const worker = await this.getWorker(sessionId);
+        return worker.call(rpcMethod.name, serializedArgs, { statusCallback });
+    }
+    /**
+     * 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() {
-        const instance = this.makeWorkerInstance();
+        // 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);
+            };
+            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,
-                        });
+                        // The worker is waiting in receiveConfiguration(), which has no
+                        // timeout, and this listener's throw would escape before cleanup or
+                        // fail could run — so an unclonable boot configuration left both
+                        // sides waiting forever rather than reporting anything.
+                        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,
+                            }));
+                        }
                         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);
         });
     }
 }

package/esm/rpc/byteBudget.d.ts

@@ -0,0 +1,58 @@
+import type { StatusCallback } from '../util/progress.ts';
+import type { StopToken, StopTokenChecker } from '../util/stopToken.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?: {
+        stopToken?: StopToken;
+        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;
+}
+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;
+/**
+ * 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, stopToken, statusCallback, stopTokenCheck, }: {
+    dataAdapter: ByteMeasurableAdapter;
+    regions: AugmentedRegion[];
+    byteLimit: number | undefined;
+    stopToken?: StopToken;
+    statusCallback?: StatusCallback;
+    stopTokenCheck?: StopTokenChecker;
+}): Promise<{
+    bytes?: number;
+    tooLarge?: RegionTooLargeResult;
+}>;

package/esm/rpc/byteBudget.js

@@ -0,0 +1,50 @@
+import { updateStatus } from '../util/progress.js';
+import { checkStopTokenThrottled } from '../util/stopToken.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;
+}
+/**
+ * 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, stopToken, statusCallback, stopTokenCheck, }) {
+    if (byteLimit === undefined) {
+        return {};
+    }
+    const bytes = largestRegionBytes(await updateStatus('Checking region size', statusCallback, () => Promise.all(regions.map(region => dataAdapter.getRegionByteSize([region], {
+        stopToken,
+        statusCallback,
+    })))));
+    checkStopTokenThrottled(stopTokenCheck);
+    return overByteBudget(bytes, byteLimit)
+        ? { bytes, tooLarge: { regionTooLarge: true, bytes } }
+        : { bytes };
+}

package/esm/rpc/configSchema.d.ts

@@ -1,9 +1,31 @@
+/**
+ * #config RpcOptions
+ * #category root
+ */
 declare const _default: import("../configuration/configurationSchema.ts").ConfigurationSchemaType<{
-    defaultDriver: {
-        type: string;
-        description: string;
-        defaultValue: string;
+    /**
+     * #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.
+     */
+    readonly defaultDriver: {
+        readonly type: "string";
+        readonly description: "the RPC driver to run data fetching on: MainThreadRpcDriver or WebWorkerRpcDriver. Leave empty to use the default for this application";
+        readonly defaultValue: "";
+        readonly advanced: true;
+    };
+    /**
+     * #slot
+     * number of web workers to spawn for the web worker RPC driver. 0 lets
+     * JBrowse pick based on hardware concurrency.
+     */
+    readonly workerCount: {
+        readonly type: "number";
+        readonly description: "The number of workers to use. If 0 (the default) JBrowse will decide how many workers to use.";
+        readonly defaultValue: 0;
+        readonly advanced: true;
     };
-    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>>;
 export default _default;

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,10 @@
 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 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 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,10 @@
-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 CoreGetSequence } from './methods/CoreGetSequence.js';
+export { default as CoreFreeResources } from './methods/CoreFreeResources.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';