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

package/esm/rpc/RpcClient.js

@@ -1,7 +1,9 @@
+import { makeAbortError } from '../util/aborting.js';
 import { deserializeError } from './serializeError/index.js';
 export default class RpcClient {
     worker;
     pending = new Map();
+    destroyed = false;
     events = new Map();
     counter = 0;
     constructor(worker) {
@@ -39,10 +41,9 @@ export default class RpcClient {
             if (idx !== -1) {
                 listeners.splice(idx, 1);
             }
-            // drop the emptied key, not just the listener: every RPC call mints its
-            // own `message-<nanoid>` status channel (WebWorkerHandle.call), so a
-            // retained empty array is one dead Map entry per call for the life of the
-            // page — six figures of them in a long session
+            // drop the emptied key, not just the listener: every reporting call
+            // mints its own status channel (WebWorkerHandle.call), so a retained
+            // empty array is one dead Map entry per call for the life of the page
             if (listeners.length === 0) {
                 this.events.delete(event);
             }
@@ -90,6 +91,7 @@ export default class RpcClient {
     // never arrive, so reject it here instead of leaving the caller's promise (and
     // everything its continuation holds) unsettled forever
     destroy() {
+        this.destroyed = true;
         this.rejectAllPending(new Error('RPC worker was terminated'));
         this.events.clear();
     }
@@ -125,28 +127,61 @@ export default class RpcClient {
         }
     }
     /**
-     * Tell this worker that a stop token has been stopped, so the calls running
-     * there see it at their next await boundary and drop their in-flight reads.
-     * Fire-and-forget: it settles no pending call, and a worker holding nothing
-     * under that id ignores it.
+     * Abort the call `uid`, so the signal it runs under in the worker aborts.
+     * Fire-and-forget: it settles no pending call, and a worker no longer running
+     * that call ignores it.
      */
-    notifyStopToken(id) {
-        this.worker.postMessage({ stopToken: id, libRpc: true });
+    abort(uid) {
+        this.worker.postMessage({ abort: uid, libRpc: true });
     }
-    // No transfer list: transferables flow only worker → main, in a reply's
-    // rpcResult wrapper. Transferring an argument would neuter the main thread's
-    // own buffer — this took an option for one and nothing ever passed it.
-    call(method, data) {
+    /**
+     * No transfer list: transferables flow only worker → main, in a reply's
+     * rpcResult wrapper. Transferring an argument would neuter the main thread's
+     * own buffer — this took an option for one and nothing ever passed it.
+     *
+     * With a `signal`, the worker runs the method under a signal of its own and
+     * aborts it when this one aborts. The uid is the call's identity on both
+     * sides, so the abort frame needs nothing else; the listener is attached
+     * before the call frame is posted and removed when the call settles, so an
+     * abort in between reaches a worker still running the call, and one after
+     * reaches nothing.
+     */
+    call(method, data, signal) {
         const uid = String(++this.counter);
         return new Promise((resolve, reject) => {
-            this.pending.set(uid, { resolve, reject });
+            if (this.destroyed) {
+                reject(new Error('RPC worker was terminated'));
+                return;
+            }
+            if (signal?.aborted) {
+                reject(makeAbortError());
+                return;
+            }
+            const onAbort = () => {
+                this.abort(uid);
+            };
+            signal?.addEventListener('abort', onAbort, { once: true });
+            const detach = () => {
+                signal?.removeEventListener('abort', onAbort);
+            };
+            this.pending.set(uid, {
+                resolve: value => {
+                    detach();
+                    resolve(value);
+                },
+                reject: error => {
+                    detach();
+                    reject(error);
+                },
+            });
             try {
-                this.worker.postMessage({ method, uid, data, libRpc: true }, []);
+                this.worker.postMessage({ method, uid, data, libRpc: true, abortable: signal !== undefined }, []);
             }
             catch (e) {
                 // a non-cloneable payload throws here, which rejects this promise; drop
                 // the entry that is now waiting on a reply the worker never received
                 this.pending.delete(uid);
+                detach();
                 throw e;
             }
         });

package/esm/rpc/RpcManager.d.ts

@@ -9,18 +9,16 @@ export interface RpcManagerOptions {
 export default class RpcManager {
     static configSchema: import("../configuration/configurationSchema.ts").ConfigurationSchemaType<{
         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;
+            type: "string";
+        } & {
+            defaultValue: string;
         };
         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;
+            type: "number";
+        } & {
+            defaultValue: number;
         };
-    }, import("../configuration/configurationSchema.ts").ConfigurationSchemaOptions<undefined, undefined>>;
+    }, import("../configuration/configurationSchema.ts").ConfigurationSchemaOptions<undefined, undefined, undefined, import("../configuration/requirements.ts").ConfigurationSchemaRequirement<Partial<Record<string, string[]>>, string>, any>>;
     private pluginManager;
     private mainConfiguration;
     private hostDriverName;
@@ -60,7 +58,7 @@ export default class RpcManager {
     private makeDriver;
     /**
      * `args` carries the method's data and the caller's handles on the operation —
-     * the stop token and the status callback. Both handles are always accepted,
+     * the signal and the status callback. Both handles are always accepted,
      * for every method, because {@link RpcHandles} is part of `RpcCallArgs` rather
      * than of any registry entry.
      *
@@ -121,4 +119,10 @@ export default class RpcManager {
      * second driver and a second pool that nothing will ever destroy. ADR-086.
      */
     destroy(): void;
+    /**
+     * Build the driver and let it start what the first call would wait for — a
+     * web worker's bundle and runtime plugins — while the host is still building
+     * its session.
+     */
+    warmUp(): void;
 }

package/esm/rpc/RpcManager.js

@@ -82,7 +82,7 @@ export default class RpcManager {
     }
     /**
      * `args` carries the method's data and the caller's handles on the operation —
-     * the stop token and the status callback. Both handles are always accepted,
+     * the signal and the status callback. Both handles are always accepted,
      * for every method, because {@link RpcHandles} is part of `RpcCallArgs` rather
      * than of any registry entry.
      *
@@ -187,4 +187,14 @@ export default class RpcManager {
         this.driver?.destroy();
         this.driver = undefined;
     }
+    /**
+     * Build the driver and let it start what the first call would wait for — a
+     * web worker's bundle and runtime plugins — while the host is still building
+     * its session.
+     */
+    warmUp() {
+        if (!this.destroyed) {
+            this.getDriver().warmUp();
+        }
+    }
 }

package/esm/rpc/RpcRegistry.d.ts

@@ -1,10 +1,11 @@
+import type { FeatureDensity } from '../data_adapters/BaseAdapter/featureDensity.ts';
+import type { CoreGetEncodedLayersArgs, EncodedLayersResult } from '../util/markEncodingTypes.ts';
 import type { StatusCallback } from '../util/progress.ts';
 import type { UnwrapRpcResult } from '../util/rpc.ts';
 import type { Feature, SimpleFeatureSerialized } from '../util/simpleFeature.ts';
-import type { StopToken } from '../util/stopToken.ts';
 import type { NoAssemblyRegion } from '../util/types/data.ts';
 import type { RpcResult } from './RpcServer.ts';
-import type { ByteEstimateScope } from './byteBudget.ts';
+import type { ByteEstimateScope, RegionTooLargeResult } from './byteBudget.ts';
 export interface RegionLike {
     refName: string;
     start: number;
@@ -15,8 +16,8 @@ export interface RpcRegistry {
     CoreGetRefNames: {
         args: {
             adapterConfig: Record<string, unknown>;
-            sequenceAdapter?: Record<string, unknown>;
             assemblyName?: string;
+            haplotypes?: string[];
         };
         return: string[];
     };
@@ -37,12 +38,23 @@ export interface RpcRegistry {
         args: {
             regions: RegionLike[];
             adapterConfig: Record<string, unknown>;
-            sequenceAdapter?: Record<string, unknown>;
             opts?: Record<string, unknown>;
         };
         return: Feature[];
         wire: SimpleFeatureSerialized[];
     };
+    CoreGetEncodedLayers: {
+        args: CoreGetEncodedLayersArgs;
+        return: EncodedLayersResult | RegionTooLargeResult;
+        transferables: EncodedLayersResult;
+    };
+    CoreGetEncodedFeature: {
+        args: Omit<CoreGetEncodedLayersArgs, 'byteLimit'> & {
+            layer: number;
+            featureIndex: number;
+        };
+        return: SimpleFeatureSerialized | undefined;
+    };
     CoreGetRegionByteEstimate: {
         args: {
             adapterConfig: Record<string, unknown>;
@@ -52,9 +64,20 @@ export interface RpcRegistry {
         };
         return: number | undefined;
     };
+    CoreGetFeatureDensity: {
+        args: {
+            adapterConfig: Record<string, unknown>;
+            regions: RegionLike[];
+            bpPerPx: number;
+            headers?: Record<string, string>;
+        };
+        return: FeatureDensity[] | undefined;
+    };
     CoreGetInfo: {
         args: {
             adapterConfig: Record<string, unknown>;
+            haplotypes?: string[];
+            assemblyName?: string;
         };
         return: unknown;
     };
@@ -77,6 +100,12 @@ export interface RpcRegistry {
         args: Record<string, unknown>;
         return: void;
     };
+    CoreLoadAdapterCode: {
+        args: {
+            adapterTypes: string[];
+        };
+        return: void;
+    };
 }
 export type RpcMethodName = keyof RpcRegistry;
 export type RpcArgs<M extends RpcMethodName> = RpcRegistry[M]['args'];
@@ -104,12 +133,15 @@ export type RpcReturn<M extends RpcMethodName> = RpcRegistry[M]['return'];
  * the pattern the type exists to support.
  */
 export type RpcHandles = {
-    stopToken?: StopToken;
+    signal?: AbortSignal;
     statusCallback?: StatusCallback;
 };
 export type RpcSession = {
     sessionId: string;
 };
+export type RpcReference = {
+    sequenceAdapter?: Record<string, unknown>;
+};
 export type RpcCallContext = RpcSession & RpcHandles;
 /**
  * What {@link RpcExecuteArgs} and {@link RpcWireReturn} resolve to for a method
@@ -136,7 +168,8 @@ export interface NotInRpcRegistry<M extends string> {
 }
 /**
  * What a registered method's `execute` actually receives: its declared args,
- * plus the session it is pinned to, plus the handles the driver merged in.
+ * plus the session it is pinned to, the handles the driver merged in and the
+ * reference renaming added.
  *
  * Derived rather than hand-written, for the reason {@link RpcWireReturn} is:
  * the return type has been checked against the registry for a while and the
@@ -144,7 +177,7 @@ export interface NotInRpcRegistry<M extends string> {
  * parameterized with its own name (`RpcMethodType<'CoreGetSequence'>`) gets
  * both ends checked.
  */
-export type RpcExecuteArgs<M extends string> = M extends RpcMethodName ? RpcArgs<M & RpcMethodName> & RpcCallContext : string extends M ? unknown : NotInRpcRegistry<M>;
+export type RpcExecuteArgs<M extends string> = M extends RpcMethodName ? RpcArgs<M & RpcMethodName> & RpcCallContext & RpcReference : string extends M ? unknown : NotInRpcRegistry<M>;
 /**
  * What a CALLER passes to `rpcManager.call`: the method's own data, plus the
  * {@link RpcHandles} every method takes. No {@link RpcSession} — that one is

package/esm/rpc/RpcServer.d.ts

@@ -12,11 +12,13 @@ interface RpcMessageData {
     uid: string;
     libRpc?: true;
     data: unknown;
-    stopToken?: string;
+    abortable?: boolean;
+    abort?: string;
 }
 export default class RpcServer {
     protected methods: Record<string, Procedure>;
     private self;
+    private aborters;
     constructor(methods: Record<string, Procedure>);
     handler(e: MessageEvent<RpcMessageData>): void;
     private post;

package/esm/rpc/RpcServer.js

@@ -1,5 +1,4 @@
 import { isRpcResult } from '../util/rpc.js';
-import { markStopTokenStopped } from '../util/stopToken.js';
 import { bufferPaths, containerEntries, explainTransferError, } from './explainTransferError.js';
 import { serializeError } from './serializeError/index.js';
 // `self` is a DedicatedWorkerGlobalScope in the worker, but the DOM lib types the
@@ -126,6 +125,7 @@ export function rpcResultWithArrayBuffers(value) {
 export default class RpcServer {
     methods;
     self;
+    aborters = new Map();
     constructor(methods) {
         if (!workerSelf) {
             throw new Error('RpcServer must be constructed in a worker global scope');
@@ -143,31 +143,38 @@ export default class RpcServer {
         });
     }
     handler(e) {
-        const { libRpc, method, uid, data, stopToken } = e.data;
+        const { libRpc, method, uid, data, abort, abortable } = e.data;
         if (!libRpc) {
             return;
         }
-        if (stopToken !== undefined) {
-            // Every in-flight method holding this token now sees it as stopped at its
-            // next await boundary, and any AbortSignal taken against it aborts, so a
-            // canceled read drops off the socket. Handled ahead of the method lookup:
-            // this frame has no method name and would otherwise land in the unknown
-            // method branch with no uid to reply to.
-            markStopTokenStopped(stopToken);
+        if (abort !== undefined) {
+            // Handled ahead of the method lookup: this frame has no method name and
+            // would otherwise land in the unknown method branch with no uid to reply
+            // to. A call that already settled left no controller, so a late abort is
+            // a no-op.
+            this.aborters.get(abort)?.abort();
             return;
         }
         const methodFn = Object.hasOwn(this.methods, method)
             ? this.methods[method]
             : undefined;
         if (methodFn) {
-            // wrap so a synchronous throw inside methodFn still routes to .throw()
-            ;
-            (async () => methodFn(data))()
+            const controller = abortable ? new AbortController() : undefined;
+            if (controller) {
+                this.aborters.set(uid, controller);
+            }
+            const args = controller
+                ? { ...data, signal: controller.signal }
+                : data;
+            (async () => methodFn(args))()
                 .then(response => {
                 this.reply(uid, response, method);
             })
                 .catch((error) => {
                 this.throw(uid, serializeError(error));
+            })
+                .finally(() => {
+                this.aborters.delete(uid);
             });
         }
         else {

package/esm/rpc/WebWorkerRpcDriver.d.ts

@@ -4,14 +4,15 @@ 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;
-    notifyStopToken?(id: string): 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>;
 }
 declare module '@jbrowse/core/PluginManager' {
@@ -43,7 +44,6 @@ export default class WebWorkerRpcDriver extends BaseRpcDriver {
     private lastWorkerAssignment;
     private workerAssignments;
     private workerPool?;
-    private unregisterBroadcaster;
     private destroyed;
     constructor(pluginManager: PluginManager, config: AnyConfigurationModel, options: WebWorkerRpcDriverOptions);
     /**
@@ -57,6 +57,12 @@ export default class WebWorkerRpcDriver extends BaseRpcDriver {
     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
@@ -68,11 +74,12 @@ export default class WebWorkerRpcDriver extends BaseRpcDriver {
      * 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>, statusCallback: StatusCallback | undefined): Promise<unknown>;
+    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(): Promise<WorkerHandle>;
+    makeWorker(onHandle?: (handle: WorkerHandle) => void): Promise<WorkerHandle>;
 }

package/esm/rpc/WebWorkerRpcDriver.js

@@ -1,6 +1,5 @@
 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';
@@ -36,9 +35,6 @@ class WebWorkerHandle {
     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);
@@ -73,9 +69,9 @@ class WebWorkerHandle {
     // `Core-extendWorker` wrapper written against that interface may well call
     // `worker.call(name, args)` — which destructured `undefined` and threw
     opts = {}) {
-        const { statusCallback } = opts;
+        const { statusCallback, signal } = opts;
         if (!statusCallback) {
-            return this.client.call(funcName, args);
+            return this.client.call(funcName, args, signal);
         }
         const channel = `message-${++this.channelCount}`;
         // RpcClient is a generic event emitter (it also carries 'error' events), so
@@ -87,8 +83,7 @@ class WebWorkerHandle {
         };
         this.client.on(channel, listener);
         try {
-            const result = await this.client.call(funcName, { ...args, channel });
-            return result;
+            return await this.client.call(funcName, { ...args, channel }, signal);
         }
         finally {
             this.client.off(channel, listener);
@@ -115,11 +110,21 @@ class LazyWorker {
     }
     async getWorker() {
         if (!this.workerP) {
-            const booted = this.driver.makeWorker();
+            let early;
+            const booted = this.driver.makeWorker(handle => {
+                early = handle;
+            });
             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));
+            // 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 = () => {
@@ -151,24 +156,9 @@ class LazyWorker {
         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.
+     * 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.
@@ -197,17 +187,6 @@ export default class WebWorkerRpcDriver extends BaseRpcDriver {
     // 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;
@@ -233,7 +212,6 @@ export default class WebWorkerRpcDriver extends BaseRpcDriver {
     // 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();
         }
@@ -245,13 +223,7 @@ export default class WebWorkerRpcDriver extends BaseRpcDriver {
         // 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;
+        return Array.from({ length: workerCount }, () => new LazyWorker(this));
     }
     getWorkerPool() {
         if (this.destroyed) {
@@ -259,6 +231,18 @@ export default class WebWorkerRpcDriver extends BaseRpcDriver {
         }
         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);
@@ -279,21 +263,24 @@ export default class WebWorkerRpcDriver extends BaseRpcDriver {
      * 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, statusCallback) {
+    async transport(sessionId, rpcMethod, serializedArgs, handles) {
         const worker = await this.getWorker(sessionId);
-        return worker.call(rpcMethod.name, serializedArgs, { statusCallback });
+        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() {
+    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();
@@ -317,6 +304,23 @@ export default class WebWorkerRpcDriver extends BaseRpcDriver {
                 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': {
@@ -325,22 +329,7 @@ export default class WebWorkerRpcDriver extends BaseRpcDriver {
                         break;
                     }
                     case 'readyForConfig': {
-                        // 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,
-                            }));
-                        }
+                        sendConfig();
                         break;
                     }
                     case 'error': {
@@ -357,6 +346,13 @@ export default class WebWorkerRpcDriver extends BaseRpcDriver {
             };
             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);
         });
     }
 }