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

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

@@ -30,7 +30,111 @@ function joinLoc(feats, strand, minPos) {
 function featureLine(type, location) {
     return `     ${type.slice(0, TYPE_COLUMN_WIDTH).padEnd(TYPE_COLUMN_WIDTH)} ${location}`;
 }
-function formatTags({ feature, gene }) {
+/**
+ * The feature key column holds one of a closed list, so a SO term JBrowse names
+ * a feature with is not a key by virtue of being a type. A reader that does not
+ * recognize the key falls back to drawing nothing in particular — which is what
+ * a BLAT hit, a CRISPR guide, a restriction site and an hgPcr product all got,
+ * and what `primer` got where SnapGene draws a primer only for `primer_bind`.
+ *
+ * https://www.insdc.org/submitting-standards/feature-table/
+ */
+const INSDC_KEYS = new Set([
+    "3'UTR",
+    "5'UTR",
+    'assembly_gap',
+    'C_region',
+    'CDS',
+    'centromere',
+    'D-loop',
+    'D_segment',
+    'exon',
+    'gap',
+    'gene',
+    'iDNA',
+    'intron',
+    'J_segment',
+    'mat_peptide',
+    'misc_binding',
+    'misc_difference',
+    'misc_feature',
+    'misc_recomb',
+    'misc_RNA',
+    'misc_structure',
+    'mobile_element',
+    'modified_base',
+    'mRNA',
+    'N_region',
+    'ncRNA',
+    'old_sequence',
+    'operon',
+    'oriT',
+    'polyA_site',
+    'precursor_RNA',
+    'prim_transcript',
+    'primer_bind',
+    'propeptide',
+    'protein_bind',
+    'regulatory',
+    'rep_origin',
+    'repeat_region',
+    'rRNA',
+    'S_region',
+    'sig_peptide',
+    'source',
+    'stem_loop',
+    'STS',
+    'telomere',
+    'tmRNA',
+    'transit_peptide',
+    'tRNA',
+    'unsure',
+    'V_region',
+    'V_segment',
+    'variation',
+]);
+// SO terms this tree emits that the feature table spells differently. Anything
+// absent from both this and INSDC_KEYS is a real feature with no key of its own
+// — a guide, a PAM, a restriction site, a BLAT hit, an hgPcr product — and
+// becomes misc_feature, which is what the key exists for.
+const SO_TO_INSDC = {
+    five_prime_UTR: "5'UTR",
+    three_prime_UTR: "3'UTR",
+    primer: 'primer_bind',
+    primer_binding_site: 'primer_bind',
+    transcript: 'mRNA',
+    pseudogene: 'gene',
+    promoter: 'regulatory',
+    enhancer: 'regulatory',
+    terminator: 'regulatory',
+    polyA_site: 'polyA_site',
+    origin_of_replication: 'rep_origin',
+    repeat_unit: 'repeat_region',
+    SNV: 'variation',
+    SNP: 'variation',
+};
+// The keys whose group shares one /gene symbol. A feature with children is not
+// a gene by having them: threading the symbol off any parent labelled an hgPcr
+// product `/gene="100 bp"` and a BLAT hit `/gene="YourSeq 99.1%"`, which reads
+// downstream as a gene of that name.
+const GENE_GROUP_KEYS = new Set([
+    'gene',
+    'mRNA',
+    'ncRNA',
+    'rRNA',
+    'tRNA',
+    'tmRNA',
+    'misc_RNA',
+    'precursor_RNA',
+    'prim_transcript',
+    'CDS',
+    'exon',
+]);
+export function insdcFeatureKey(type) {
+    const mapped = SO_TO_INSDC[type] ?? type;
+    return INSDC_KEYS.has(mapped) ? mapped : 'misc_feature';
+}
+function formatTags({ feature, gene, key, }) {
     const tags = [];
     // /gene ties gene/mRNA/CDS together; /label is what SnapGene/Geneious/ApE
     // display as the feature name on the map
@@ -41,6 +145,12 @@ function formatTags({ feature, gene }) {
     if (label) {
         tags.push(qualifier('label', label));
     }
+    // a feature that had to become misc_feature still knows what it is, so the
+    // term it came in as rides along rather than being dropped at the key column
+    const type = `${feature.get('type')}`;
+    if (key === 'misc_feature' && type && type !== 'misc_feature') {
+        tags.push(qualifier('note', type));
+    }
     for (const key of Object.keys(feature.toJSON())) {
         if (!coreFields.has(key)) {
             const value = formatAttributeValue(feature.get(key));
@@ -64,19 +174,22 @@ function formatCDS({ feats, gene, strand, minPos, }) {
 export function formatFeatWithSubfeatures({ feature, minPos, geneName, }) {
     const subfeatures = feature.get('subfeatures') ?? [];
     const strand = feature.get('strand') ?? 0;
-    const type = `${feature.get('type')}`;
+    const key = insdcFeatureKey(`${feature.get('type')}`);
     const exons = subfeatures.filter(f => f.get('type') === 'exon');
-    // A top-level feature with children establishes the gene-group name, which is
-    // threaded down so every part of the gene shares one /gene qualifier.
+    // A gene-group feature with children establishes the symbol, which is threaded
+    // down so every part of the gene shares one /gene qualifier.
     const ownName = feature.get('name') ?? feature.get('id');
-    const gene = geneName ?? (subfeatures.length > 0 && ownName ? ownName : undefined);
+    const gene = geneName ??
+        (GENE_GROUP_KEYS.has(key) && subfeatures.length > 0 && ownName
+            ? ownName
+            : undefined);
     // A spliced transcript is rendered as join() of its exons rather than a
     // single span, so external tools see the correct intron/exon structure.
     const segments = exons.length > 0 ? exons : [feature];
     const location = joinLoc(segments, strand, minPos);
     const primary = [
-        featureLine(type, location),
-        ...formatTags({ feature, gene }),
+        featureLine(key, location),
+        ...formatTags({ feature, gene, key }),
     ];
     const cds = subfeatures.filter(f => f.get('type') === 'CDS');
     const sansCDS = subfeatures.filter(f => f.get('type') !== 'CDS' && f.get('type') !== 'exon');
@@ -98,15 +211,24 @@ function formatOrigin(sequence) {
     lines.push('//');
     return lines;
 }
-// LOCUS line column layout per the GenBank flat-file spec: name at col 13,
-// length right-justified ending at col 40, molecule/topology/division/date in
-// their fixed slots.
+// LOCUS line column layout per the GenBank flat-file spec. A positional parser
+// reads each field out of a fixed slot, so the widths below ARE the format:
+//
+//   1-5 LOCUS · 6-12 spaces · 13-28 name · 29 space · 30-40 length ·
+//   41-44 " bp " · 45-47 strandedness · 48-54 molecule · 55 space ·
+//   56-63 topology · 64 space · 65-67 division · 68 space · 69-79 date
+//
+// Molecule runs to 54 and topology starts at 56, which is one column right of
+// where it reads: every real NCBI record spells `DNA` then five spaces then
+// `circular`. Writing topology from 55 put a letter in the space at 55 and
+// Biopython refused all nine snapshot records, while the snapshot tests stayed
+// green because they pin the bytes rather than the format. `locusColumns` in
+// the test file is the check that names which slot moved.
 //
 // The name is the 16-column locus field, so it is the refName rather than the
 // region: `chr17:7,668,402..7,687,550` sanitizes to 22 characters and pushed
-// every field after it 6 columns right, which is a length a positional parser
-// then reads out of the wrong slot. The coordinates are on DEFINITION, where
-// the line is free text.
+// every field after it 6 columns right. The coordinates are on DEFINITION,
+// where the line is free text.
 const LOCUS_NAME_WIDTH = 16;
 function formatLocus(refName, length) {
     const name = refName.replaceAll(/[^\w.]/g, '_').slice(0, LOCUS_NAME_WIDTH);
@@ -117,9 +239,9 @@ function formatLocus(refName, length) {
         String(length).padStart(11),
         ' bp ',
         '   ',
-        'DNA'.padEnd(6),
+        'DNA'.padEnd(7),
         ' ',
-        'linear'.padEnd(9),
+        'linear'.padEnd(8),
         ' ',
         'UNK'.padEnd(3),
         ' ',
@@ -148,7 +270,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 +281,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 +304,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/pluginDefinitions.d.ts

@@ -38,10 +38,6 @@ export interface ESMUrlPluginDefinition {
     name?: string;
 }
 export type ESMPluginDefinition = ESMLocPluginDefinition | ESMUrlPluginDefinition;
-export interface CJSPluginDefinition {
-    cjsUrl: string;
-    name?: string;
-}
 /**
  * A plugin named by its plugin-store entry rather than by a url — the query
  * ("MsaView, for this JBrowse") instead of a precomputed answer ("these exact
@@ -81,15 +77,14 @@ export interface StorePluginDefinition {
  * `loadUMDPlugin` looks up on `globalThis`, and `storePlugin` is the assertion
  * that the manifest is where this came from.
  */
-export type PluginDefinition = (UMDUrlPluginDefinition | UMDLocPluginDefinition | LegacyUMDPluginDefinition | ESMLocPluginDefinition | ESMUrlPluginDefinition | CJSPluginDefinition | StorePluginDefinition) & {
+export type PluginDefinition = (UMDUrlPluginDefinition | UMDLocPluginDefinition | LegacyUMDPluginDefinition | ESMLocPluginDefinition | ESMUrlPluginDefinition | StorePluginDefinition) & {
     storePlugin?: string;
 };
 export declare function isUMDPluginDefinition(def: PluginDefinition): def is UMDPluginDefinition | LegacyUMDPluginDefinition;
 export declare function isESMPluginDefinition(def: PluginDefinition): def is ESMPluginDefinition;
-export declare function isCJSPluginDefinition(def: PluginDefinition): def is CJSPluginDefinition;
 /**
  * Whether a definition names a store entry to resolve. Deliberately not part of
- * the CJS/ESM/UMD trio `assertSingleKind` counts: those are loaders, and a ref
+ * the ESM/UMD pair `assertSingleKind` counts: those are loaders, and a ref
  * is not one. A ref names *which plugin*, and pairing it with a url is the
  * supported migration shape rather than the two-loaders ambiguity that guard
  * exists to refuse.
@@ -184,6 +179,38 @@ export declare function pluginLabel(definition: PluginDefinition): string;
  * drift apart and disagree about what is a duplicate.
  */
 export declare function samePlugin(a: PluginDefinition, b: PluginDefinition): boolean;
+/**
+ * Whether a list entry is one the loaded copy could have come from — its url,
+ * or the store entry both name.
+ *
+ * `samePlugin` without the name clause, which would also match a session entry
+ * naming the same plugin at another url: that is the copy the dedupe *dropped*,
+ * not the list the loaded one lives in.
+ *
+ * The ref half is what a url comparison cannot do in either direction. An entry
+ * the permanent list keeps as a ref resolves to whatever build the store
+ * publishes for this JBrowse, so its pinned url and the loaded one drift apart
+ * on the first upgrade while the ref stays the same string.
+ */
+export declare function holdsPlugin(entry: PluginDefinition, loaded: PluginDefinition): boolean;
+/**
+ * Whether a list entry names the exact build that loaded — the question a
+ * remove asks, where {@link holdsPlugin} asks which list to look in.
+ *
+ * A config's `plugins[]` is the one list that can legitimately hold two entries
+ * for a single plugin: the update flow writes a second entry at a newer url and
+ * then removes the first. So an entry carrying a url is judged on that url
+ * alone. Both entries may carry the store ref they were minted under, and
+ * matching on it would remove the version just installed.
+ *
+ * An entry with no url of its own — a bare `{ "storePlugin": "MsaView" }`,
+ * which is the form a config at a permanent url is meant to use — pins no
+ * build, so the ref is the only thing identifying it. Judged on the url it does
+ * not have, such an entry matched nothing: uninstall filtered the list and
+ * removed no row, while still asking for the whole-app reload an uninstall
+ * triggers, so the plugin came back.
+ */
+export declare function holdsPluginVersion(entry: PluginDefinition, loaded: PluginDefinition): boolean;
 /**
  * The candidates no definition in `existing` already describes — `dedupePlugins`
  * across two lists whose first one is already settled, for a source loaded after

package/esm/pluginDefinitions.js

@@ -13,12 +13,9 @@ export function isUMDPluginDefinition(def) {
 export function isESMPluginDefinition(def) {
     return 'esmUrl' in def || 'esmLoc' in def;
 }
-export function isCJSPluginDefinition(def) {
-    return 'cjsUrl' in def;
-}
 /**
  * Whether a definition names a store entry to resolve. Deliberately not part of
- * the CJS/ESM/UMD trio `assertSingleKind` counts: those are loaders, and a ref
+ * the ESM/UMD pair `assertSingleKind` counts: those are loaders, and a ref
  * is not one. A ref names *which plugin*, and pairing it with a url is the
  * supported migration shape rather than the two-loaders ambiguity that guard
  * exists to refuse.
@@ -76,19 +73,16 @@ export function dropVendoredPlugins(defs, alsoVendored = []) {
     return defs.filter(d => !(isUMDPluginDefinition(d) && vendored.has(d.name)));
 }
 // The two functions below describe a definition by picking the one url it will
-// be loaded from, so both dispatch in loadPlugin's order — CJS, then ESM, then
-// UMD. Keep them in step with it: they are what the plugin trust gate
-// (checkPlugins) reads and what the untrusted-plugin prompt shows, so an order
-// that disagrees with the loader's vets one url and executes another. They once
-// did disagree, and a definition carrying both `umdUrl` and `cjsUrl` was
-// approved on its jbrowse.org umd url while loadPlugin require()d its cjs one.
-// assertSingleKind now rejects such a definition outright; this order is the
-// second half of that guarantee, since the gate runs before the loader does.
+// be loaded from, so both dispatch in loadPlugin's order — ESM, then UMD. Keep
+// them in step with it: they are what the plugin trust gate (checkPlugins)
+// reads and what the untrusted-plugin prompt shows, so an order that disagrees
+// with the loader's vets one url and executes another. They once did disagree,
+// and a definition naming two loaders was approved on its jbrowse.org url while
+// loadPlugin ran the other. assertSingleKind now rejects such a definition
+// outright; this order is the second half of that guarantee, since the gate
+// runs before the loader does.
 export function pluginDescriptionString(d) {
-    if (isCJSPluginDefinition(d)) {
-        return `CJS plugin ${d.cjsUrl}`;
-    }
-    else if (isESMPluginDefinition(d)) {
+    if (isESMPluginDefinition(d)) {
         return `ESM plugin ${'esmUrl' in d ? d.esmUrl : d.esmLoc.uri}`;
     }
     else if (isUMDPluginDefinition(d)) {
@@ -110,10 +104,7 @@ export function pluginDescriptionString(d) {
  * the same plugin just because neither has a url.
  */
 export function maybePluginUrl(d) {
-    if (isCJSPluginDefinition(d)) {
-        return d.cjsUrl;
-    }
-    else if (isESMPluginDefinition(d)) {
+    if (isESMPluginDefinition(d)) {
         return 'esmUrl' in d ? d.esmUrl : d.esmLoc.uri;
     }
     else if (isUMDPluginDefinition(d)) {
@@ -196,6 +187,49 @@ export function samePlugin(a, b) {
         (nameA !== undefined && nameA === nameB) ||
         (urlA !== undefined && urlA === urlB));
 }
+function sameStoreRef(entry, loaded) {
+    const ref = storePluginName(entry);
+    return ref !== undefined && ref === storePluginName(loaded);
+}
+/**
+ * Whether a list entry is one the loaded copy could have come from — its url,
+ * or the store entry both name.
+ *
+ * `samePlugin` without the name clause, which would also match a session entry
+ * naming the same plugin at another url: that is the copy the dedupe *dropped*,
+ * not the list the loaded one lives in.
+ *
+ * The ref half is what a url comparison cannot do in either direction. An entry
+ * the permanent list keeps as a ref resolves to whatever build the store
+ * publishes for this JBrowse, so its pinned url and the loaded one drift apart
+ * on the first upgrade while the ref stays the same string.
+ */
+export function holdsPlugin(entry, loaded) {
+    return (isPluginUrl(entry, maybePluginUrl(loaded)) || sameStoreRef(entry, loaded));
+}
+/**
+ * Whether a list entry names the exact build that loaded — the question a
+ * remove asks, where {@link holdsPlugin} asks which list to look in.
+ *
+ * A config's `plugins[]` is the one list that can legitimately hold two entries
+ * for a single plugin: the update flow writes a second entry at a newer url and
+ * then removes the first. So an entry carrying a url is judged on that url
+ * alone. Both entries may carry the store ref they were minted under, and
+ * matching on it would remove the version just installed.
+ *
+ * An entry with no url of its own — a bare `{ "storePlugin": "MsaView" }`,
+ * which is the form a config at a permanent url is meant to use — pins no
+ * build, so the ref is the only thing identifying it. Judged on the url it does
+ * not have, such an entry matched nothing: uninstall filtered the list and
+ * removed no row, while still asking for the whole-app reload an uninstall
+ * triggers, so the plugin came back.
+ */
+export function holdsPluginVersion(entry, loaded) {
+    const url = maybePluginUrl(entry);
+    return url === undefined
+        ? sameStoreRef(entry, loaded)
+        : url === maybePluginUrl(loaded);
+}
 /**
  * The candidates no definition in `existing` already describes — `dedupePlugins`
  * across two lists whose first one is already settled, for a source loaded after

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
@@ -27,6 +26,7 @@ export default abstract class BaseRpcDriver {
      */
     freeSession(sessionId: string): Promise<void>;
     destroy(): void;
+    warmUp(): 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.
@@ -34,6 +34,8 @@ export default class BaseRpcDriver {
             .invoke({ sessionId });
     }
     destroy() { }
+    // start whatever a first call would otherwise wait for; nothing, here
+    warmUp() { }
     async call(sessionId, functionName, args) {
         if (!sessionId) {
             throw new TypeError('sessionId is required');
@@ -44,40 +46,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

@@ -14,6 +14,7 @@ interface PendingCall {
 export default class RpcClient {
     worker: Worker;
     pending: Map<string, PendingCall>;
+    private destroyed;
     private events;
     private counter;
     constructor(worker: Worker);
@@ -27,12 +28,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 {};