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

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

@@ -1,34 +1,71 @@
 import type PluginManager from '../../PluginManager.ts';
+import type { LegacyDisplaySnapshot } from './migrateTrackConfig.ts';
 import type { Instance } from '@jbrowse/mobx-state-tree';
+interface TrackConfigSnapshot {
+    trackId: string;
+    name: string;
+    type: string;
+    assemblyNames?: unknown;
+    textSearching?: {
+        textSearchAdapter?: unknown;
+    };
+    adapter?: {
+        type?: unknown;
+    };
+    displays?: LegacyDisplaySnapshot[];
+}
+/**
+ * Whether a track's adapter serves what a display type draws from: every
+ * `adapterCapabilities` entry the display asks for, among those the adapter
+ * type declares.
+ */
+export declare function adapterFeeds(pluginManager: PluginManager, adapter: TrackConfigSnapshot['adapter']): (display: {
+    adapterCapabilities: readonly string[];
+}) => boolean;
+/**
+ * The display types of `trackType` a track on `adapter` can draw as, in the
+ * track type's order.
+ */
+export declare function displayTypesFedBy(pluginManager: PluginManager, trackType: string, adapter: TrackConfigSnapshot['adapter']): string[];
+/**
+ * The display types a view may open a track as, best first: those its adapter
+ * feeds, the ones its config declares leading in declared order. A declared
+ * display the adapter cannot feed stays in the config as settings and is never
+ * a candidate.
+ */
+export declare function displayCandidates(pluginManager: PluginManager, track: {
+    type: string;
+    adapter?: TrackConfigSnapshot['adapter'];
+    displays?: readonly {
+        type: string;
+    }[];
+}): string[];
 /**
  * Snapshot normalization shared by every track config schema (including
- * ReferenceSequenceTrack). Runs the `Core-preProcessTrackConfig` extension
- * point, expands the `displayDefaults` shorthand, auto-fills a stub display for
- * each of the track type's registered displays, normalizes legacy display-type
- * aliases to their canonical name, dedupes by type (first wins), and lifts
- * legacy renderer configs.
+ * ReferenceSequenceTrack). Loads retired display types as the displays they
+ * retired into, runs the `Core-preProcessTrackConfig` extension point,
+ * auto-fills a stub display for each of the track type's registered displays
+ * whose adapter capabilities the track's adapter declares, folds the
+ * `displayDefaults` shorthand into those entries, dedupes by type (first wins),
+ * and lifts legacy renderer configs.
  */
 export declare function preprocessTrackConfigSnapshot(pluginManager: PluginManager, snapshot: Record<string, unknown>): {
     trackId: string;
     name: string;
     type: string;
+    assemblyNames?: unknown;
+    textSearching?: {
+        textSearchAdapter?: unknown;
+    };
+    adapter?: {
+        type?: unknown;
+    };
     displays: {
         type: string;
         featureHeight?: {} | null | undefined;
         displayId: string;
     }[];
 };
-/**
- * The `addDisplayConf` action shared by every track config schema — appends a
- * display config unless one with the same displayId already exists.
- */
-interface DisplayConf {
-    type: string;
-    displayId: string;
-}
-export declare function trackConfigActions(self: unknown): {
-    addDisplayConf(conf: DisplayConf): DisplayConf | undefined;
-};
 /**
  * #config BaseTrack
  * Configuration shared by all track types. Concrete tracks (FeatureTrack,
@@ -36,168 +73,92 @@ export declare function trackConfigActions(self: unknown): {
  * fields in addition to its own.
  */
 export declare function createBaseTrackConfig(pluginManager: PluginManager): import("../../configuration/configurationSchema.ts").ConfigurationSchemaType<{
-    /**
-     * #slot
-     */
     readonly name: {
-        readonly description: "descriptive name of the track, falls back to the trackId when unset";
-        readonly type: "string";
-        readonly defaultValue: "";
+        type: "string";
+    } & {
+        defaultValue: string;
     };
-    /**
-     * #slot
-     */
     readonly assemblyNames: {
-        readonly description: "name of the assembly (or assemblies) track belongs to";
-        readonly type: "stringArray";
-        readonly defaultValue: readonly ["assemblyName"];
+        type: "stringArray";
+    } & {
+        defaultValue: unknown;
     };
-    /**
-     * #slot
-     */
     readonly description: {
-        readonly description: "a description of the track";
-        readonly type: "string";
-        readonly defaultValue: "";
+        type: "string";
+    } & {
+        defaultValue: string;
     };
-    /**
-     * #slot
-     */
     readonly category: {
-        readonly description: "the category and sub-categories of a track";
-        readonly type: "stringArray";
-        readonly defaultValue: readonly [];
+        type: "stringArray";
+    } & {
+        defaultValue: unknown;
     };
-    /**
-     * #slot
-     */
     readonly metadata: {
-        readonly type: "frozen";
-        readonly description: "anything to add about this track";
-        readonly defaultValue: {};
+        type: "frozen";
+    } & {
+        defaultValue: unknown;
     };
-    /**
-     * #slot
-     * where this track's data comes from. Its `type` names the adapter for
-     * the file format (`BamAdapter`, `Gff3TabixAdapter`, ...) and the rest of
-     * the object is that adapter's own slots — see the adapter pages for
-     * each. Most adapters also accept a `uri` shorthand in place of writing
-     * their location slots out.
-     */
-    readonly adapter: import("@jbrowse/mobx-state-tree").IAnyType;
+    readonly adapter: import("@jbrowse/core/PluginManager").PluggableConfigSchemaType;
     readonly textSearching: import("../../configuration/configurationSchema.ts").ConfigurationSchemaType<{
-        /**
-         * #slot textSearching.indexingAttributes
-         */
         readonly indexingAttributes: {
-            readonly type: "stringArray";
-            readonly description: "list of which feature attributes to index for text searching";
-            readonly defaultValue: readonly ["Name", "ID", "symbol"];
+            type: "stringArray";
+        } & {
+            defaultValue: unknown;
         };
-        /**
-         * #slot textSearching.indexingFeatureTypesToExclude
-         */
         readonly indexingFeatureTypesToExclude: {
-            readonly type: "stringArray";
-            readonly description: "list of feature types to exclude in text search index";
-            readonly defaultValue: readonly ["CDS", "exon"];
+            type: "stringArray";
+        } & {
+            defaultValue: unknown;
         };
-        /**
-         * #slot textSearching.indexingFeatureTypesToInclude
-         * The only feature types to index, dropping every other type the file
-         * carries. Empty (the default) means no allow list, i.e. index
-         * everything `indexingFeatureTypesToExclude` does not name.
-         *
-         * Use this instead of the exclude list when the file draws from a
-         * vocabulary you do not control. An NCBI RefSeq GFF3 uses 115 feature
-         * types, 80 of them leaf records with nothing to search for — a `match`
-         * is labelled with a bare UUID, a `cDNA_match` with an MD5, every
-         * `biological_region` with the literal string "biological region" — so
-         * a deny list leaks whichever type is added next, while the allow list
-         * (gene, pseudogene, and the transcript types) does not grow. Both may
-         * be set: this one admits, the exclude list then narrows.
-         *
-         * GFF3 only; the GTF and VCF indexers do not filter by type.
-         */
         readonly indexingFeatureTypesToInclude: {
-            readonly type: "stringArray";
-            readonly description: "the only feature types to index; empty means index every type not excluded";
-            readonly defaultValue: readonly [];
+            type: "stringArray";
+        } & {
+            defaultValue: unknown;
         };
-        /**
-         * #slot textSearching.textSearchAdapter
-         * a per-track name search index, normally a `TrixTextSearchAdapter`
-         * over what `jbrowse text-index --tracks` built. Without one, this
-         * track's features are only findable through an assembly-wide search
-         * adapter.
-         */
-        readonly textSearchAdapter: import("@jbrowse/mobx-state-tree").IAnyType;
-    }, import("../../configuration/configurationSchema.ts").ConfigurationSchemaOptions<undefined, undefined>>;
-    /**
-     * #slot
-     * An **array** of full display configs, e.g.
-     * `displays: [{ type: 'LinearBasicDisplay', color: 'green' }]`. Each entry
-     * names a display `type`; use this when you need exact control — your own
-     * `displayId`, different settings for two displays, or choosing which
-     * display is the default.
-     *
-     * For the common case, prefer the `displayDefaults` shorthand instead — an
-     * object of appearance settings (e.g. `displayDefaults: { color: 'green' }`)
-     * that JBrowse routes to whichever display uses each setting, so you don't
-     * have to name the display or write the array.
-     *
-     * See the [track config guide](/docs/config_guides/tracks/#configuring-displays).
-     */
-    readonly displays: import("@jbrowse/mobx-state-tree").IArrayType<import("@jbrowse/mobx-state-tree").IAnyType>;
-    /**
-     * #slot
-     * jexl callbacks that add, rewrite or hide fields in this track's
-     * feature-details panel. Four slots, listed at
-     * [FormatDetails](/docs/config/formatdetails), and the same schema exists
-     * session-wide as `configuration.formatDetails`.
-     */
+        readonly textSearchAdapter: import("@jbrowse/mobx-state-tree").ITypeUnion<any, any, import("../../configuration/types.ts").PluggableConfigNode | undefined>;
+    }, import("../../configuration/configurationSchema.ts").ConfigurationSchemaOptions<undefined, undefined, undefined, import("../../configuration/requirements.ts").ConfigurationSchemaRequirement<Partial<Record<string, string[]>>, string>, any>>;
+    readonly displays: import("@jbrowse/mobx-state-tree").IArrayType<import("@jbrowse/core/PluginManager").PluggableConfigSchemaType>;
     readonly formatDetails: import("../../configuration/configurationSchema.ts").ConfigurationSchemaType<{
         readonly feature: {
-            readonly type: "frozen";
-            readonly description: "adds extra fields to the feature details";
-            readonly defaultValue: {};
-            readonly contextVariable: ["feature"];
+            type: "frozen";
+        } & {
+            defaultValue: unknown;
         };
         readonly subfeatures: {
-            readonly type: "frozen";
-            readonly description: "adds extra fields to the subfeatures of a feature";
-            readonly defaultValue: {};
-            readonly contextVariable: ["feature"];
+            type: "frozen";
+        } & {
+            defaultValue: unknown;
         };
         readonly depth: {
-            readonly type: "maybeNumber";
-            readonly description: "levels of subfeature the formatDetails.subfeatures callback runs on, default 2";
+            type: "maybeNumber";
         };
         readonly maxDepth: {
-            readonly type: "maybeNumber";
-            readonly description: "hide subfeatures nested deeper than this, default no limit";
+            type: "maybeNumber";
         };
-    }, import("../../configuration/configurationSchema.ts").ConfigurationSchemaOptions<undefined, undefined>>;
-    /**
-     * #slot
-     * jexl callbacks that add, rewrite or hide fields in this track's About
-     * dialog. Two slots, listed at
-     * [FormatAbout](/docs/config/formatabout), and the same schema exists
-     * session-wide as `configuration.formatAbout`.
-     */
+    }, import("../../configuration/configurationSchema.ts").ConfigurationSchemaOptions<undefined, undefined, undefined, import("../../configuration/requirements.ts").ConfigurationSchemaRequirement<Partial<Record<string, string[]>>, string>, any>>;
     readonly formatAbout: import("../../configuration/configurationSchema.ts").ConfigurationSchemaType<{
         readonly config: {
-            readonly type: "frozen";
-            readonly description: "formats configuration object in about dialog";
-            readonly defaultValue: {};
-            readonly contextVariable: ["config"];
+            type: "frozen";
+        } & {
+            defaultValue: unknown;
         };
         readonly hideUris: {
-            readonly type: "boolean";
-            readonly defaultValue: false;
+            type: "boolean";
+        } & {
+            defaultValue: boolean;
         };
-    }, import("../../configuration/configurationSchema.ts").ConfigurationSchemaOptions<undefined, undefined>>;
-}, import("../../configuration/configurationSchema.ts").ConfigurationSchemaOptions<undefined, "trackId">>;
+    }, import("../../configuration/configurationSchema.ts").ConfigurationSchemaOptions<undefined, undefined, undefined, import("../../configuration/requirements.ts").ConfigurationSchemaRequirement<Partial<Record<string, string[]>>, string>, any>>;
+    type: {
+        type: "string";
+    } & {
+        defaultValue: string;
+    };
+    trackId: {
+        type: "string";
+    } & {
+        defaultValue: string;
+    };
+}, import("../../configuration/configurationSchema.ts").ConfigurationSchemaOptions<undefined, "trackId", true, import("../../configuration/requirements.ts").ConfigurationSchemaRequirement<Partial<Record<string, string[]>>, string>, any>>;
 export type BaseTrackConfigSchema = ReturnType<typeof createBaseTrackConfig>;
 export type BaseTrackConfig = Instance<BaseTrackConfigSchema>;
 export {};

package/esm/pluggableElementTypes/models/baseTrackConfig.js

@@ -1,67 +1,101 @@
 import { types } from '@jbrowse/mobx-state-tree';
 import { ConfigurationSchema, FormatAboutConfigSchemaFactory, FormatDetailsConfigSchemaFactory, } from '../../configuration/index.js';
+import { expandLooseSearchIndex } from '../../util/expandLooseSearchIndex.js';
 import { expandTrackConfigShorthand } from './expandTrackConfigShorthand.js';
-import { liftLegacyRendererConfig } from './migrateTrackConfig.js';
+import { liftLegacyRendererConfig, migrateRetiredDisplays, } from './migrateTrackConfig.js';
+/**
+ * Whether a track's adapter serves what a display type draws from: every
+ * `adapterCapabilities` entry the display asks for, among those the adapter
+ * type declares.
+ */
+export function adapterFeeds(pluginManager, adapter) {
+    const type = adapter?.type;
+    const capabilities = new Set(typeof type === 'string' && pluginManager.hasAdapterType(type)
+        ? pluginManager.getAdapterType(type).adapterCapabilities
+        : []);
+    return (display) => display.adapterCapabilities.every(c => capabilities.has(c));
+}
+/**
+ * The display types of `trackType` a track on `adapter` can draw as, in the
+ * track type's order.
+ */
+export function displayTypesFedBy(pluginManager, trackType, adapter) {
+    return pluginManager
+        .getTrackType(trackType)
+        .displayTypes.filter(adapterFeeds(pluginManager, adapter))
+        .map(d => d.name);
+}
+/**
+ * The display types a view may open a track as, best first: those its adapter
+ * feeds, the ones its config declares leading in declared order. A declared
+ * display the adapter cannot feed stays in the config as settings and is never
+ * a candidate.
+ */
+export function displayCandidates(pluginManager, track) {
+    const declared = (track.displays ?? []).map(d => pluginManager.resolveDisplayTypeRecord(d.type)?.name ?? d.type);
+    const rank = (name) => {
+        const i = declared.indexOf(name);
+        return i === -1 ? declared.length : i;
+    };
+    return displayTypesFedBy(pluginManager, track.type, track.adapter).sort((a, b) => rank(a) - rank(b));
+}
 /**
  * Snapshot normalization shared by every track config schema (including
- * ReferenceSequenceTrack). Runs the `Core-preProcessTrackConfig` extension
- * point, expands the `displayDefaults` shorthand, auto-fills a stub display for
- * each of the track type's registered displays, normalizes legacy display-type
- * aliases to their canonical name, dedupes by type (first wins), and lifts
- * legacy renderer configs.
+ * ReferenceSequenceTrack). Loads retired display types as the displays they
+ * retired into, runs the `Core-preProcessTrackConfig` extension point,
+ * auto-fills a stub display for each of the track type's registered displays
+ * whose adapter capabilities the track's adapter declares, folds the
+ * `displayDefaults` shorthand into those entries, dedupes by type (first wins),
+ * and lifts legacy renderer configs.
  */
 export function preprocessTrackConfigSnapshot(pluginManager, snapshot) {
-    const snap = expandTrackConfigShorthand(pluginManager.evaluateExtensionPoint(
+    const pre = pluginManager.evaluateExtensionPoint(
     /** #extensionPoint Core-preProcessTrackConfig | sync | Rewrite a track config snapshot before it is instantiated */
-    'Core-preProcessTrackConfig', structuredClone(snapshot)), pluginManager);
-    // expandTrackConfigShorthand folds any `displayDefaults` shorthand into
-    // `displays`, but its early-return branches can leave a malformed `displays`
-    // untouched; guard so MST union-type probing never crashes on a non-array
-    // `displays`.
-    const displays = Array.isArray(snap.displays) ? snap.displays : [];
-    if (snap.trackId !== 'placeholderId') {
-        // Add any of the track type's possible displays not already on the snapshot
+    'Core-preProcessTrackConfig', migrateRetiredDisplays(pluginManager, structuredClone(snapshot)));
+    // a non-array `displays` would crash MST union-type probing
+    const declared = Array.isArray(pre.displays) ? pre.displays : [];
+    let displays = declared;
+    if (pre.trackId !== 'placeholderId') {
+        // The displays the config declared lead, in its order; every other one
+        // the adapter feeds follows in the track type's own order.
         try {
-            const configDisplayTypes = new Set(displays.map(d => d.type));
-            for (const d of pluginManager.getTrackType(snap.type).displayTypes) {
-                if (!configDisplayTypes.has(d.name)) {
-                    displays.push({
-                        displayId: `${snap.trackId}-${d.name}`,
-                        type: d.name,
-                    });
-                }
-            }
+            const declaredTypes = new Set(declared.map(d => d.type));
+            const feeds = adapterFeeds(pluginManager, pre.adapter);
+            displays = [
+                ...declared,
+                ...pluginManager
+                    .getTrackType(pre.type ?? '')
+                    .displayTypes.filter(d => !declaredTypes.has(d.name) && feeds(d))
+                    .map(d => ({ displayId: `${pre.trackId}-${d.name}`, type: d.name })),
+            ];
         }
         catch (e) {
-            throw new Error(`Unknown track type "${snap.type}" in ${JSON.stringify(snap)}`, { cause: e });
+            throw new Error(`Unknown track type "${pre.type}" in ${JSON.stringify(pre)}`, { cause: e });
         }
     }
-    const displayElements = pluginManager.getDisplayElements();
-    const knownDisplayTypes = new Set(displayElements.map(d => d.name));
-    // Map of legacy display type → canonical name, built from each DisplayType's
-    // `aliases` declaration. Lets each display "own" its renames without a central
-    // migration file.
-    const displayAliasMap = new Map();
-    for (const d of displayElements) {
-        if (d.aliases) {
-            for (const alias of d.aliases) {
-                displayAliasMap.set(alias, d.name);
-            }
-        }
-    }
-    // After alias normalization, dedupe by type so the track config holds one
-    // display per type (old sessions can carry several display configs whose types
-    // are all aliases of one canonical type). First occurrence wins to preserve
-    // the default (displays[0]).
+    const snap = expandTrackConfigShorthand({ ...pre, displays }, pluginManager);
+    const knownDisplayTypes = new Set(pluginManager.getDisplayElements().map(d => d.name));
+    // one display per type; the first keeps its place as the default
     const seenTypes = new Set();
+    const { textSearching } = snap;
     return {
         ...snap,
-        displays: displays
-            .map(d => {
-            const canonical = displayAliasMap.get(d.type);
-            return canonical ? { ...d, type: canonical } : d;
+        ...(textSearching?.textSearchAdapter
+            ? {
+                textSearching: {
+                    ...textSearching,
+                    textSearchAdapter: expandLooseSearchIndex(textSearching.textSearchAdapter, snap.assemblyNames),
+                },
+            }
+            : {}),
+        displays: snap.displays
+            .filter(d => {
+            const known = knownDisplayTypes.has(d.type);
+            if (!known) {
+                console.warn(`Dropping display of unknown type "${d.type}" from track "${snap.trackId}": no registered display type has that name`);
+            }
+            return known;
         })
-            .filter(d => knownDisplayTypes.has(d.type))
             .filter(d => {
             const dup = seenTypes.has(d.type);
             seenTypes.add(d.type);
@@ -70,23 +104,6 @@ export function preprocessTrackConfigSnapshot(pluginManager, snapshot) {
             .map(d => liftLegacyRendererConfig(d, snap.trackId)),
     };
 }
-export function trackConfigActions(self) {
-    const { displays } = self;
-    return {
-        addDisplayConf(conf) {
-            const { type } = conf;
-            if (!type) {
-                throw new Error('display type not specified');
-            }
-            const display = displays.find(d => d.displayId === conf.displayId);
-            if (display) {
-                return display;
-            }
-            const length = displays.push(conf);
-            return displays[length - 1];
-        },
-    };
-}
 /**
  * #config BaseTrack
  * Configuration shared by all track types. Concrete tracks (FeatureTrack,
@@ -94,6 +111,14 @@ export function trackConfigActions(self) {
  * fields in addition to its own.
  */
 export function createBaseTrackConfig(pluginManager) {
+    const none = types.optional(types.undefined, undefined);
+    const adapter = pluginManager.pluggableConfigSchemaType('text search adapter');
+    // A dispatcher rather than `types.maybe` or member order. Every adapter here
+    // is all-default, so an omitted key has to resolve to nothing rather than the
+    // first registered adapter (textSearchAdapterSlotOmission.test.ts). And
+    // clearing a set slot, as undo does, must not hand `undefined` to the current
+    // adapter's preProcessSnapshot, which MST's own matching does to test it.
+    const optionalTextSearchAdapter = types.union({ dispatcher: snapshot => (snapshot === undefined ? none : adapter) }, none, adapter);
     return ConfigurationSchema('BaseTrack', {
         /**
          * #slot
@@ -186,11 +211,12 @@ export function createBaseTrackConfig(pluginManager) {
             /**
              * #slot textSearching.textSearchAdapter
              * a per-track name search index, normally a `TrixTextSearchAdapter`
-             * over what `jbrowse text-index --tracks` built. Without one, this
+             * over what `jbrowse text-index --tracks` built; `'genes.ix'` is
+             * enough, searching this track's assemblies. Without one, this
              * track's features are only findable through an assembly-wide search
              * adapter.
              */
-            textSearchAdapter: pluginManager.pluggableConfigSchemaType('text search adapter'),
+            textSearchAdapter: optionalTextSearchAdapter,
         }),
         /**
          * #slot
@@ -211,17 +237,15 @@ export function createBaseTrackConfig(pluginManager) {
         /**
          * #slot
          * jexl callbacks that add, rewrite or hide fields in this track's
-         * feature-details panel. Four slots, listed at
-         * [FormatDetails](/docs/config/formatdetails), and the same schema exists
-         * session-wide as `configuration.formatDetails`.
+         * feature-details panel. The same schema exists session-wide as
+         * `configuration.formatDetails`.
          */
         formatDetails: FormatDetailsConfigSchemaFactory(),
         /**
          * #slot
          * jexl callbacks that add, rewrite or hide fields in this track's About
-         * dialog. Two slots, listed at
-         * [FormatAbout](/docs/config/formatabout), and the same schema exists
-         * session-wide as `configuration.formatAbout`.
+         * dialog. The same schema exists session-wide as
+         * `configuration.formatAbout`.
          */
         formatAbout: FormatAboutConfigSchemaFactory(),
     }, {
@@ -231,6 +255,5 @@ export function createBaseTrackConfig(pluginManager) {
          */
         explicitIdentifier: 'trackId',
         explicitlyTyped: true,
-        actions: trackConfigActions,
     });
 }

package/esm/pluggableElementTypes/models/components/SaveTrackData.js

@@ -39,17 +39,15 @@ function useTrackDataExport({ model, regions, regionStr, type, options, }) {
             getConf(model, 'trackId'),
             regionStr,
             type,
-            // a string, not the boolean: useFetch reads a `false` anywhere in an
-            // array key as "don't fetch", so the gated state would fetch nothing
-            force ? 'forced' : 'gated',
+            force,
         ]
-        : null, async (_name, _trackId, _regions, fileType, mode, stopToken, statusCallback) => fetchTrackData({
+        : null, async (_name, _trackId, _regions, fileType, forced, signal, statusCallback) => fetchTrackData({
         model,
         regions,
         type: fileType,
         options,
-        force: mode === 'forced',
-        stopToken,
+        force: forced,
+        signal,
         statusCallback,
     }));
     return { result: data, error, loading: isLoading, status, setForce };

package/esm/pluggableElementTypes/models/components/fetchTrackData.d.ts

@@ -1,7 +1,6 @@
 import type { AnyConfigurationModel } from '../../../configuration/index.ts';
 import type { Region } from '../../../util/index.ts';
 import type { StatusCallback } from '../../../util/progress.ts';
-import type { StopToken } from '../../../util/stopToken.ts';
 import type { FileTypeExporter } from '../saveTrackFileTypes/types.ts';
 import type { IStateTreeNode } from '@jbrowse/mobx-state-tree';
 /**
@@ -41,15 +40,15 @@ export interface TrackDataResult {
  *
  * This reads every feature in the visible region, which on a deep track is the
  * same work the display itself does — worth cancelling when the dialog closes,
- * and worth naming while it runs, hence the stop token and status callback.
+ * and worth naming while it runs, hence the signal and status callback.
  */
-export declare function fetchTrackData({ model, regions, type, options, force, stopToken, statusCallback, }: {
+export declare function fetchTrackData({ model, regions, type, options, force, signal, statusCallback, }: {
     model: ExportableTrack;
     regions: Region[];
     type: string;
     options: Record<string, FileTypeExporter>;
     /** skip the size pre-flight — the user has seen the estimate and said yes */
     force?: boolean;
-    stopToken?: StopToken;
+    signal?: AbortSignal;
     statusCallback?: StatusCallback;
 }): Promise<TrackDataResult>;

package/esm/pluggableElementTypes/models/components/fetchTrackData.js

@@ -30,13 +30,13 @@ function endWithNewline(str) {
  *
  * This reads every feature in the visible region, which on a deep track is the
  * same work the display itself does — worth cancelling when the dialog closes,
- * and worth naming while it runs, hence the stop token and status callback.
+ * and worth naming while it runs, hence the signal and status callback.
  */
-export async function fetchTrackData({ model, regions, type, options, force, stopToken, statusCallback, }) {
+export async function fetchTrackData({ model, regions, type, options, force, signal, statusCallback, }) {
     const session = getSession(model);
     const sessionId = getRpcSessionId(model);
     const adapterConfig = getConf(model, ['adapter']);
-    const opts = { stopToken, statusCallback };
+    const opts = { signal, statusCallback };
     const { exportsDataViaAdapter } = model;
     // The same index lookup the display's gate takes before it fetches, for the
     // same reason: this menu item pulls the region the display just refused to