@jbrowse/core 5.0.0-beta.8 → 5.0.0-beta.9

package/esm/pluggableElementTypes/models/expandTrackConfigShorthand.js

@@ -1,43 +1,47 @@
 import { getConfigurationSchemaMetadata } from '../../configuration/schemaRegistry.js';
-function schemaSlotNames(schema) {
-    const meta = getConfigurationSchemaMetadata(schema);
-    return new Set(meta ? Object.keys(meta.definition) : []);
+import { slotValueRefusal } from '../../configuration/slotFacade.js';
+function declares(schema, key) {
+    return !!getConfigurationSchemaMetadata(schema)?.definition[key];
 }
 function isPlainObject(v) {
     return typeof v === 'object' && v !== null && !Array.isArray(v);
 }
-/** display type name → its config slot names, for one track type. */
-function trackDisplaySlots(trackType) {
-    const displaySlots = new Map();
-    for (const d of trackType.displayTypes) {
-        displaySlots.set(d.name, schemaSlotNames(d.configSchema));
-    }
-    return displaySlots;
-}
 /**
- * Pure: route each shorthand `displayDefaults: {...}` setting to the display
- * types that define it. A setting goes to every display type whose config schema
- * has that slot, so slot names disambiguate across displays on their own (e.g.
- * `color` → LinearVariantDisplay, `strokeColor` → ChordVariantDisplay). Keys no
- * display defines are returned as `unknownKeys` for the caller to surface.
+ * Route each shorthand `displayDefaults: {...}` setting to the display types
+ * whose slot of that name takes its value, so slot names disambiguate across
+ * displays (`color` → LinearVariantDisplay, `strokeColor` →
+ * ChordVariantDisplay) and so do the values: `displayMode: 'compact'` on a
+ * FeatureTrack reaches the feature display and not the arc display, whose
+ * `displayMode` is `arcs | semicircles`. A key no display declares is an `unknownKeys`
+ * entry, and one every declaring display refuses a `refused` entry carrying
+ * each display's reason.
  */
-export function collectDisplayOverrides(displaySettings, displaySlots) {
+export function collectDisplayOverrides(displaySettings, displaySchemas) {
     const overrides = new Map();
     const unknownKeys = [];
+    const refused = [];
     for (const [key, value] of Object.entries(displaySettings)) {
-        const targets = [...displaySlots]
-            .filter(([, slots]) => slots.has(key))
-            .map(([name]) => name);
-        if (targets.length) {
-            for (const name of targets) {
-                overrides.set(name, { ...overrides.get(name), [key]: value });
-            }
-        }
-        else {
+        const verdicts = [...displaySchemas]
+            .filter(([, schema]) => declares(schema, key))
+            .map(([name, schema]) => ({
+            name,
+            refusal: slotValueRefusal(schema, key, value),
+        }));
+        const targets = verdicts.filter(v => v.refusal === undefined);
+        if (verdicts.length === 0) {
             unknownKeys.push(key);
         }
+        else if (targets.length === 0) {
+            refused.push({
+                key,
+                reasons: verdicts.map(v => `${v.name}: ${v.refusal}`),
+            });
+        }
+        for (const { name } of targets) {
+            overrides.set(name, { ...overrides.get(name), [key]: value });
+        }
     }
-    return { overrides, unknownKeys };
+    return { overrides, unknownKeys, refused };
 }
 /**
  * Pure: fold per-display override props into a `displays` array, creating an
@@ -61,7 +65,7 @@ export function mergeOverridesIntoDisplays(displays, overrides, trackId) {
  * Expands the shorthand `displayDefaults` **object** into the explicit `displays`
  * **array**, so users can set display settings without naming the display type
  * or nesting in `displays:[{type,...}]`. `displayDefaults:{color:'green'}` routes
- * each setting to the display type(s) that define that slot, folding them into
+ * each setting to the display type(s) whose slot takes it, folding them into
  * whatever `displays` array the track already has (explicit entries win).
  *
  * `displayDefaults` is kept separate from `displays` (rather than overloading
@@ -101,10 +105,15 @@ export function expandTrackConfigShorthand(input, pluginManager) {
     if (!trackType.displayTypes.length) {
         return snap;
     }
-    const { overrides, unknownKeys } = collectDisplayOverrides(shorthand, trackDisplaySlots(trackType));
+    const { overrides, unknownKeys, refused } = collectDisplayOverrides(shorthand, new Map(trackType.displayTypes.map(d => [d.name, d.configSchema])));
     for (const key of unknownKeys) {
         console.warn(`Track "${trackId}": display setting "${key}" is not a slot on any display of a ${type}`);
     }
+    if (refused.length > 0) {
+        throw new Error(refused
+            .map(({ key, reasons }) => `Track "${trackId}": no display of a ${type} takes displayDefaults.${key} (${reasons.join('; ')})`)
+            .join('\n'));
+    }
     const displays = Array.isArray(rest.displays)
         ? rest.displays
         : [];

package/esm/pluggableElementTypes/models/index.d.ts

@@ -2,7 +2,6 @@ export { default as baseConnectionConfig } from './baseConnectionConfig.ts';
 export { default as BaseConnectionModelFactory } from './BaseConnectionModelFactory.ts';
 export { default as BaseViewModel } from './BaseViewModel.ts';
 export type { IBaseViewModel } from './BaseViewModel.ts';
-export { default as HighlightsMixin } from './HighlightsMixin.ts';
 export { BaseDisplay } from './BaseDisplayModel.tsx';
 export type { BaseDisplayModel, BaseDisplayStateModel, DisplayModel, } from './BaseDisplayModel.tsx';
 export { InternetAccount } from './InternetAccountModel.ts';
@@ -10,7 +9,7 @@ export type { BaseInternetAccountModel, BaseInternetAccountStateModel, } from '.
 export { BaseInternetAccountConfig } from './baseInternetAccountConfig.ts';
 export { createBaseTrackModel } from './BaseTrackModel.ts';
 export type { BaseTrackModel, BaseTrackStateModel } from './BaseTrackModel.ts';
-export { createBaseTrackConfig, preprocessTrackConfigSnapshot, trackConfigActions, } from './baseTrackConfig.ts';
+export { createBaseTrackConfig, preprocessTrackConfigSnapshot, } from './baseTrackConfig.ts';
 export type { BaseTrackConfig } from './baseTrackConfig.ts';
 export { addDisplayConfigMigration } from './migrateTrackConfig.ts';
 export type { TrackConfigSnapshot } from './migrateTrackConfig.ts';

package/esm/pluggableElementTypes/models/index.js

@@ -1,10 +1,9 @@
 export { default as baseConnectionConfig } from './baseConnectionConfig.js';
 export { default as BaseConnectionModelFactory } from './BaseConnectionModelFactory.js';
 export { default as BaseViewModel } from './BaseViewModel.js';
-export { default as HighlightsMixin } from './HighlightsMixin.js';
 export { BaseDisplay } from './BaseDisplayModel.js';
 export { InternetAccount } from './InternetAccountModel.js';
 export { BaseInternetAccountConfig } from './baseInternetAccountConfig.js';
 export { createBaseTrackModel } from './BaseTrackModel.js';
-export { createBaseTrackConfig, preprocessTrackConfigSnapshot, trackConfigActions, } from './baseTrackConfig.js';
+export { createBaseTrackConfig, preprocessTrackConfigSnapshot, } from './baseTrackConfig.js';
 export { addDisplayConfigMigration } from './migrateTrackConfig.js';

package/esm/pluggableElementTypes/models/saveTrackFileTypes/genbank.d.ts

@@ -1,13 +1,13 @@
-import type { AbstractSessionModel, Feature, StatusCallback, StopToken } from '../../../util/index.ts';
+import type { AbstractSessionModel, Feature, StatusCallback } from '../../../util/index.ts';
 export declare function formatFeatWithSubfeatures({ feature, minPos, geneName, }: {
     feature: Feature;
     minPos: number;
     geneName?: string;
 }): string;
-export declare function stringifyGBK({ features, assemblyName, session, stopToken, statusCallback, }: {
+export declare function stringifyGBK({ features, assemblyName, session, signal, statusCallback, }: {
     assemblyName: string;
     session: AbstractSessionModel;
     features: Feature[];
-    stopToken?: StopToken;
+    signal?: AbortSignal;
     statusCallback?: StatusCallback;
 }): Promise<string>;

package/esm/pluggableElementTypes/models/saveTrackFileTypes/genbank.js

@@ -148,7 +148,7 @@ function formatHeader({ refName, region, assemblyName, length, }) {
 // One LOCUS..ORIGIN..// record, spanning the features on a single reference
 // sequence. GenBank has no way to express a span that crosses one, which is why
 // this takes a refName rather than deriving it.
-async function formatRecord({ refName, features, assemblyName, session, stopToken, statusCallback, }) {
+async function formatRecord({ refName, features, assemblyName, session, signal, statusCallback, }) {
     const minPos = min(features.map(f => f.get('start')));
     const maxPos = max(features.map(f => f.get('end')));
     const length = maxPos - minPos;
@@ -159,14 +159,14 @@ async function formatRecord({ refName, features, assemblyName, session, stopToke
         start: minPos,
         end: maxPos,
         refName,
-        stopToken,
+        signal,
         statusCallback,
     });
     const header = formatHeader({ refName, region, assemblyName, length });
     const body = features.map(feat => formatFeatWithSubfeatures({ feature: feat, minPos }));
     return [...header, ...body, ...formatOrigin(contig)].join('\n');
 }
-export async function stringifyGBK({ features, assemblyName, session, stopToken, statusCallback, }) {
+export async function stringifyGBK({ features, assemblyName, session, signal, statusCallback, }) {
     // A record per reference sequence, which is what GenBank is: a multi-region
     // view used to take min(start)/max(end) across every feature and label the
     // result with the first one's refName, so two contigs on screen produced one
@@ -182,7 +182,7 @@ export async function stringifyGBK({ features, assemblyName, session, stopToken,
         features: feats,
         assemblyName,
         session,
-        stopToken,
+        signal,
         statusCallback: slot(),
     })));
     return records.join('\n');

package/esm/pluggableElementTypes/models/saveTrackFileTypes/types.d.ts

@@ -1,10 +1,10 @@
-import type { AbstractSessionModel, Feature, StatusCallback, StopToken } from '@jbrowse/core/util';
+import type { AbstractSessionModel, Feature, StatusCallback } from '@jbrowse/core/util';
 export interface FileTypeExporter {
     name: string;
     extension: string;
     helpText?: string;
     /**
-     * The stop token and status callback are the pair every RPC on the export
+     * The signal and status callback are the pair every RPC on the export
      * path already carries. Most writers are string assembly and ignore both;
      * GenBank fetches the ORIGIN sequence, and without them closing the dialog
      * left a whole-gene read running with nothing waiting on it.
@@ -13,7 +13,7 @@ export interface FileTypeExporter {
         features: Feature[];
         session: AbstractSessionModel;
         assemblyName: string;
-        stopToken?: StopToken;
+        signal?: AbortSignal;
         statusCallback?: StatusCallback;
     }) => Promise<string> | string;
 }

package/esm/rpc/BaseRpcDriver.d.ts

@@ -1,7 +1,6 @@
 import type PluginManager from '../PluginManager.ts';
 import type { AnyConfigurationModel } from '../configuration/index.ts';
 import type RpcMethodType from '../pluggableElementTypes/RpcMethodType.ts';
-import type { StatusCallback } from '../util/progress.ts';
 import type { RpcHandles } from './RpcRegistry.ts';
 /**
  * The method that drops a session's cached adapters, named once because
@@ -28,5 +27,5 @@ export default abstract class BaseRpcDriver {
     freeSession(sessionId: string): Promise<void>;
     destroy(): void;
     call(sessionId: string, functionName: string, args: Record<string, unknown> & RpcHandles): Promise<unknown>;
-    protected abstract transport(sessionId: string, rpcMethod: RpcMethodType, serializedArgs: Record<string, unknown>, statusCallback: StatusCallback | undefined): Promise<unknown>;
+    protected abstract transport(sessionId: string, rpcMethod: RpcMethodType, serializedArgs: Record<string, unknown>, handles: RpcHandles): Promise<unknown>;
 }

package/esm/rpc/BaseRpcDriver.js

@@ -1,4 +1,4 @@
-import { isStopToken, withStopTokenCheck } from '../util/stopToken.js';
+import { checkAbortSignal, withAbortCheck } from '../util/aborting.js';
 /**
  * The method that drops a session's cached adapters, named once because
  * {@link BaseRpcDriver.freeSession} is the only thing that dispatches it.
@@ -44,40 +44,33 @@ export default class BaseRpcDriver {
         // "which plugin is missing" answer. No `undefined` check belongs here; one
         // was added and lint called it dead, correctly.
         const rpcMethod = this.pluginManager.getRpcMethodType(functionName);
-        // statusCallback is an out-of-band progress handle, not data: each transport
-        // wires up its own channel for it, so it must not reach the serialized
-        // payload. Everything that does must be structured-cloneable; the worker
-        // postMessage clones it and throws on anything that isn't, surfacing bad data
+        // The two handles are out of band, not data: each transport wires its own
+        // channel for them, and neither survives structured clone. The worker
+        // postMessage throws on anything that isn't cloneable, surfacing bad data
         // at the boundary instead of silently dropping it.
         //
-        // Stripped on the way OUT rather than on the way in, so `serializeArguments`
-        // can see it. That is not cosmetic: serialization is where the refName map
-        // is resolved, and resolving one downloads the adapter's index (and for an
-        // in-memory adapter, the whole file). Destructuring the callback off first
-        // left that download with nothing to report through — `loadRefNameMap`
-        // forwards a `statusCallback` for exactly this and, for every RPC, was
-        // handed undefined. The wire payload is identical either way.
+        // The callback is stripped on the way OUT rather than on the way in, so
+        // `serializeArguments` can see it. That is not cosmetic: serialization is
+        // where the refName map is resolved, and resolving one downloads the
+        // adapter's index (and for an in-memory adapter, the whole file).
+        // Destructuring the callback off first left that download with nothing to
+        // report through — `loadRefNameMap` forwards a `statusCallback` for exactly
+        // this and, for every RPC, was handed undefined.
         //
         // Serialization is the one long await here, and it is wrapped rather than
         // fenced by hand-placed checks so the check on the FAR side comes with the
-        // near one — that is the whole point of `withStopTokenCheck`, and the far
-        // one is what was missing. A call whose token was already stopped has
-        // nothing to deliver to, so refuse it rather than serializing args, waking a
-        // worker and racing a stop notification against the call it means to cancel;
-        // and a stop landing DURING serialization had nowhere to be seen at all,
-        // because the broadcast it fires reaches only *booted* workers and on a
-        // driver's first call `LazyWorker.workerP` is undefined until `transport`
-        // reaches `getWorker`. The worker never learned the token was stopped and
-        // ground the fetch to completion. SharedArrayBuffer tokens see the stop
-        // through shared memory regardless; this is the string-token path, which is
-        // every deployment we ship — `stopToken.ts`, "Which path runs where".
-        //
-        // Callers already treat an abort as the ordinary outcome of a superseded
-        // fetch.
-        const stopToken = isStopToken(args.stopToken) ? args.stopToken : undefined;
-        const { statusCallback } = args;
-        const { statusCallback: _outOfBand, ...serializedArgs } = await withStopTokenCheck(stopToken, () => rpcMethod.serializeArguments(args));
-        const result = await this.transport(sessionId, rpcMethod, serializedArgs, statusCallback);
+        // near one. A call already aborted has nothing to deliver to, so refuse it
+        // rather than serializing args and waking a worker; an abort landing DURING
+        // serialization used to go unseen and the worker ground the fetch to
+        // completion. Callers already treat an abort as the ordinary outcome of a
+        // superseded fetch.
+        const { signal, ...rest } = args;
+        checkAbortSignal(signal);
+        const { statusCallback: _outOfBand, ...serializedArgs } = await withAbortCheck(signal, () => rpcMethod.serializeArguments(rest));
+        const result = await this.transport(sessionId, rpcMethod, serializedArgs, {
+            statusCallback: rest.statusCallback,
+            signal,
+        });
         return rpcMethod.deserializeReturn(result, args);
     }
 }

package/esm/rpc/MainThreadRpcDriver.d.ts

@@ -1,6 +1,6 @@
 import BaseRpcDriver from './BaseRpcDriver.ts';
 import type RpcMethodType from '../pluggableElementTypes/RpcMethodType.ts';
-import type { StatusCallback } from '../util/progress.ts';
+import type { RpcHandles } from './RpcRegistry.ts';
 /**
  * RPC driver that runs RPC functions in-band on the main thread. It owns no
  * worker pool, so `destroy` stays the BaseRpcDriver no-op and `freeSession`
@@ -9,5 +9,5 @@ import type { StatusCallback } from '../util/progress.ts';
  */
 export default class MainThreadRpcDriver extends BaseRpcDriver {
     name: string;
-    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>, { statusCallback, signal }: RpcHandles): Promise<unknown>;
 }

package/esm/rpc/MainThreadRpcDriver.js

@@ -7,16 +7,21 @@ import BaseRpcDriver from './BaseRpcDriver.js';
  */
 export default class MainThreadRpcDriver extends BaseRpcDriver {
     name = 'MainThreadRpcDriver';
-    async transport(_sessionId, rpcMethod, serializedArgs, statusCallback) {
-        // re-attach the out-of-band statusCallback that BaseRpcDriver.call split off,
-        // mirroring how the worker re-wires it on the far side of postMessage —
-        // including the case where there is none, which `wrapForRpc` answers by
-        // adding no key at all. Spreading `statusCallback: undefined` in would leave
-        // the two drivers handing `execute` bags that differ by a key, which is the
-        // kind of difference nothing tests and something eventually reads.
+    async transport(_sessionId, rpcMethod, serializedArgs, { statusCallback, signal }) {
+        // re-attach the out-of-band handles that BaseRpcDriver.call split off,
+        // mirroring how the worker re-wires them on the far side of postMessage —
+        // including the case where there is none, which `wrapForRpc` and
+        // `RpcServer` answer by adding no key at all. Spreading `statusCallback:
+        // undefined` in would leave the two drivers handing `execute` bags that
+        // differ by a key, which is the kind of difference nothing tests and
+        // something eventually reads.
         //
         // `invoke`, not `execute` — it is the entry point that deserializes the
         // arguments first, and the worker binds the same one
-        return rpcMethod.invoke(statusCallback ? { ...serializedArgs, statusCallback } : serializedArgs);
+        return rpcMethod.invoke({
+            ...serializedArgs,
+            ...(statusCallback ? { statusCallback } : {}),
+            ...(signal ? { signal } : {}),
+        });
     }
 }

package/esm/rpc/RpcClient.d.ts

@@ -27,12 +27,23 @@ export default class RpcClient {
     protected reject(uid: string, error: string | ErrorObject): void;
     protected resolve(uid: string, data: unknown): void;
     /**
-     * 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: string): void;
-    call(method: string, data: unknown): Promise<unknown>;
+    abort(uid: string): void;
+    /**
+     * 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: string, data: unknown, signal?: AbortSignal): Promise<unknown>;
 }
 export {};

package/esm/rpc/RpcClient.js

@@ -1,3 +1,4 @@
+import { makeAbortError } from '../util/aborting.js';
 import { deserializeError } from './serializeError/index.js';
 export default class RpcClient {
     worker;
@@ -125,28 +126,57 @@ 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 (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>>>;
     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.
      *

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.
      *

package/esm/rpc/RpcRegistry.d.ts

@@ -3,7 +3,6 @@ import type { CoreEncodeFeaturesArgs, EncodedFeaturesResult } from '../util/mark
 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, RegionTooLargeResult } from './byteBudget.ts';
@@ -50,6 +49,13 @@ export interface RpcRegistry {
         return: EncodedFeaturesResult | RegionTooLargeResult;
         transferables: EncodedFeaturesResult;
     };
+    CoreGetEncodedFeature: {
+        args: Omit<CoreEncodeFeaturesArgs, 'byteLimit'> & {
+            layer: number;
+            featureIndex: number;
+        };
+        return: SimpleFeatureSerialized | undefined;
+    };
     CoreGetRegionByteEstimate: {
         args: {
             adapterConfig: Record<string, unknown>;
@@ -120,7 +126,7 @@ 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 = {

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 {