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

package/esm/util/diagonalizeRegions.d.ts

@@ -1,5 +1,4 @@
 import type { StatusCallback } from './progress.ts';
-import type { StopToken } from './stopToken.ts';
 import type { Region } from './types/data.ts';
 export interface AlignmentData {
     refRefName: string;
@@ -17,7 +16,7 @@ export interface DiagonalizationResult {
         regionsReversed: number;
     };
 }
-export declare function diagonalizeRegions(alignments: AlignmentData[], referenceRegions: Region[], currentRegions: Region[], { stopToken, statusCallback, }?: {
-    stopToken?: StopToken;
+export declare function diagonalizeRegions(alignments: AlignmentData[], referenceRegions: Region[], currentRegions: Region[], { signal, statusCallback, }?: {
+    signal?: AbortSignal;
     statusCallback?: StatusCallback;
 }): Promise<DiagonalizationResult>;

package/esm/util/diagonalizeRegions.js

@@ -1,6 +1,6 @@
+import { checkAbortSignal } from './aborting.js';
 import { cmpStr } from './cmpStr.js';
 import { createProgressReporter } from './progress.js';
-import { checkStopToken } from './stopToken.js';
 // A strand vote at least this lopsided (80% of aligned bases agreeing) decides
 // the reversal by itself. Below that the vote is unreliable: a chromosome
 // carrying many inversions splits it near 50/50, and MCScan `strand` is the
@@ -61,19 +61,14 @@ function anchorStats({ alignments, bases, strandWeightedSum }) {
 //
 // - refRefName:   horizontal-axis (reference) chromosome
 // - queryRefName: vertical-axis (query) chromosome
-export async function diagonalizeRegions(alignments, referenceRegions, currentRegions, { stopToken, statusCallback, } = {}) {
-    // Both passes below are long enough to notice on a whole-genome alignment —
-    // the grouping walks every alignment, and the ordering pass sorts each query
-    // chromosome's group. They used to share a single cancel check between them,
-    // so the whole grouping pass ran after a cancel and the bar sat on the
-    // fetch's last message throughout. Two reporters because the phases count
-    // different things (alignments, then chromosomes), so one auto-incrementing
-    // counter across both would report a meaningless fraction.
+export async function diagonalizeRegions(alignments, referenceRegions, currentRegions, { signal, statusCallback, } = {}) {
+    // Two reporters because the phases count different things (alignments, then
+    // chromosomes). No breakpoint: each pass measured ~50ms over 500k alignments.
     const reportGrouping = createProgressReporter({
         label: 'Grouping alignments',
         total: alignments.length,
         statusCallback,
-        stopToken,
+        signal,
     });
     // first appearance wins: a refName can appear in more than one reference
     // region, and the ordering key is where that chromosome starts on the axis
@@ -118,7 +113,7 @@ export async function diagonalizeRegions(alignments, referenceRegions, currentRe
         label: 'Ordering chromosomes',
         total: queryGroups.size,
         statusCallback,
-        stopToken,
+        signal,
     });
     for (const [verticalChrom, group] of queryGroups) {
         reportOrdering();
@@ -142,7 +137,7 @@ export async function diagonalizeRegions(alignments, referenceRegions, currentRe
             });
         }
     }
-    checkStopToken(stopToken);
+    checkAbortSignal(signal);
     queryOrdering.sort((a, b) => a.bestRefIndex - b.bestRefIndex ||
         a.bestRefPos - b.bestRefPos ||
         cmpStr(a.refName, b.refName));

package/esm/util/expandLooseSearchIndex.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Fill in what a search index written short leaves out: `type` from a `uri`
+ * naming a `.ix`, which is what `jbrowse text-index` writes, and
+ * `assemblyNames` from the caller — the track's own for a per-track index, or a
+ * config's only assembly. A key already written is kept.
+ */
+export declare function expandLooseSearchIndex<T>(snap: T, assemblyNames?: unknown): T;

package/esm/util/expandLooseSearchIndex.js

@@ -0,0 +1,25 @@
+/**
+ * Fill in what a search index written short leaves out: `type` from a `uri`
+ * naming a `.ix`, which is what `jbrowse text-index` writes, and
+ * `assemblyNames` from the caller — the track's own for a per-track index, or a
+ * config's only assembly. A key already written is kept.
+ */
+export function expandLooseSearchIndex(snap, assemblyNames) {
+    if (typeof snap !== 'object' || snap === null || Array.isArray(snap)) {
+        return snap;
+    }
+    const index = snap;
+    const guessType = index.type === undefined &&
+        typeof index.uri === 'string' &&
+        /\.ix$/i.test(index.uri.split(/[?#]/)[0]);
+    const fillNames = index.assemblyNames === undefined &&
+        Array.isArray(assemblyNames) &&
+        assemblyNames.length > 0;
+    return guessType || fillNames
+        ? {
+            ...index,
+            ...(guessType ? { type: 'TrixTextSearchAdapter' } : {}),
+            ...(fillNames ? { assemblyNames } : {}),
+        }
+        : snap;
+}

package/esm/util/featureTransforms.d.ts

@@ -1,11 +1,38 @@
 import type { JexlInstance } from './jexlStrings.ts';
-import type { AggregateOp, TransformStep } from './markEncodingTypes.ts';
+import type { AggregateOp, FacetSection, FieldRef, TransformStep } from './markEncodingTypes.ts';
 import type { Feature } from './simpleFeature.ts';
+export declare const DEFAULT_BIN_FIELD = "start";
 export declare const DEFAULT_BIN_AS: [string, string];
+export declare const DEFAULT_FLATTEN_FIELD = "subfeatures";
 export declare const DEFAULT_COVERAGE_AS = "coverage";
-export declare const DEFAULT_STACK_AS = "row";
-export declare const DEFAULT_STACK_FIELDS: [string, string];
+export declare const DEFAULT_PILEUP_AS = "row";
+export declare const DEFAULT_PILEUP_FIELDS: [string, string];
 export declare function aggregateFieldName({ op, field, as }: AggregateOp): string;
+/**
+ * #api
+ * One layer of a faceted request: its features in section order, and the
+ * stacked row of each, index for index.
+ */
+export interface FacetedLayer {
+    features: readonly Feature[];
+    rows: readonly number[];
+}
+/**
+ * #api
+ * A faceted request's layers: the features split on `field`'s key, each
+ * layer's own steps run over each section alone, and the sections stacked —
+ * a section's rows start where the one above it ends, and it is as tall as
+ * the tallest layer packed it. Every layer's features come back in section
+ * order beside their stacked rows, so a faceted display is the unfaceted one
+ * drawn once per section, and a feature is handed on as its steps left it.
+ */
+export declare function facetLayers(features: readonly Feature[], field: FieldRef, layers: readonly {
+    transform?: readonly TransformStep[];
+    row?: FieldRef;
+}[], jexl?: JexlInstance): {
+    layers: FacetedLayer[];
+    sections: FacetSection[];
+};
 /**
  * #api
  * Run the transform steps over a feature list, in order, in the worker. The

package/esm/util/featureTransforms.js

@@ -1,9 +1,14 @@
-import { stringToJexlExpression } from './jexlStrings.js';
+import { categoricalField } from './categoricalField.js';
+import { fieldReader, isPlainFieldRef } from './fieldReader.js';
+import { isJexl, stringToJexlExpression } from './jexlStrings.js';
+import { numericValue } from './numericValue.js';
 import SimpleFeature, { buildJexlContext } from './simpleFeature.js';
+export const DEFAULT_BIN_FIELD = 'start';
 export const DEFAULT_BIN_AS = ['start', 'end'];
+export const DEFAULT_FLATTEN_FIELD = 'subfeatures';
 export const DEFAULT_COVERAGE_AS = 'coverage';
-export const DEFAULT_STACK_AS = 'row';
-export const DEFAULT_STACK_FIELDS = ['start', 'end'];
+export const DEFAULT_PILEUP_AS = 'row';
+export const DEFAULT_PILEUP_FIELDS = ['start', 'end'];
 /**
  * A feature with fields written over another's: what `formula` and `bin`
  * produce, without copying the base feature's data per step.
@@ -58,6 +63,26 @@ function expression(expr, jexl) {
     }
     return stringToJexlExpression(expr, jexl);
 }
+// A step reads a name or a dotted path. A plain name keeps the direct
+// `f.get` its loop has always made; this is the reader a path takes instead,
+// chosen once per step. A computed field is a `formula` step's to make.
+function pathReader(ref, step) {
+    if (isJexl(ref)) {
+        throw new Error(`${step} field is a name or a dotted path, and a formula step in front computes one (${ref})`);
+    }
+    return fieldReader(ref, undefined);
+}
+// A list holding one value is that value, as a VCF's ALT and INFO fields
+// arrive, and a longer one is its text: a Map keys a list by identity, which
+// made every feature a group of its own. A missing value is one group, whether
+// the field is absent or holds a VCF's `.`.
+function groupKey(value) {
+    return Array.isArray(value)
+        ? value.length === 1
+            ? (value[0] ?? undefined)
+            : value.join(',')
+        : (value ?? undefined);
+}
 function filter(features, expr, jexl) {
     const compiled = expression(expr, jexl);
     return features.filter(f => compiled.eval(buildJexlContext({ feature: f })));
@@ -97,10 +122,13 @@ class FlattenedFeature {
     }
 }
 function flatten(features, step) {
-    const { field = 'subfeatures', index, keepEmpty } = step;
+    const { field = DEFAULT_FLATTEN_FIELD, index, keepEmpty } = step;
     const out = [];
+    const read = isPlainFieldRef(field)
+        ? undefined
+        : pathReader(field, 'a flatten');
     for (const f of features) {
-        const items = f.get(field);
+        const items = read ? read(f) : f.get(field);
         if (!Array.isArray(items) || items.length === 0) {
             if (keepEmpty) {
                 out.push(f);
@@ -121,13 +149,21 @@ function flatten(features, step) {
     return out;
 }
 function bin(features, step) {
-    const { field = 'start', step: size } = step;
+    const { field = DEFAULT_BIN_FIELD, step: size } = step;
     if (!(size > 0)) {
         throw new Error(`a bin step needs a positive size (${size})`);
     }
     const [asStart, asEnd] = step.as ?? DEFAULT_BIN_AS;
+    if (isPlainFieldRef(field)) {
+        return features.map(f => {
+            const v = numericValue(f.get(field));
+            const start = Math.floor(v / size) * size;
+            return new DerivedFeature(f, { [asStart]: start, [asEnd]: start + size });
+        });
+    }
+    const read = pathReader(field, 'a bin');
     return features.map(f => {
-        const v = Number(f.get(field));
+        const v = numericValue(read(f));
         const start = Math.floor(v / size) * size;
         return new DerivedFeature(f, { [asStart]: start, [asEnd]: start + size });
     });
@@ -145,7 +181,8 @@ function groupMembers(features, groupby) {
     for (const f of features) {
         let node = root;
         for (let i = 0; i < last; i++) {
-            const v = f.get(groupby[i]);
+            const raw = f.get(groupby[i]);
+            const v = typeof raw === 'object' ? groupKey(raw) : raw;
             let next = node.get(v);
             if (!next) {
                 next = new Map();
@@ -153,7 +190,8 @@ function groupMembers(features, groupby) {
             }
             node = next;
         }
-        const v = f.get(groupby[last]);
+        const raw = f.get(groupby[last]);
+        const v = typeof raw === 'object' ? groupKey(raw) : raw;
         let members = node.get(v);
         if (!members) {
             members = [];
@@ -164,11 +202,49 @@ function groupMembers(features, groupby) {
     }
     return groups;
 }
+// `groupMembers` over readers, for a groupby naming a dotted path.
+function groupMembersBy(features, reads) {
+    const last = reads.length - 1;
+    const root = new Map();
+    const groups = [];
+    for (const f of features) {
+        let node = root;
+        for (let i = 0; i < last; i++) {
+            const v = groupKey(reads[i](f));
+            let next = node.get(v);
+            if (!next) {
+                next = new Map();
+                node.set(v, next);
+            }
+            node = next;
+        }
+        const v = groupKey(reads[last](f));
+        let members = node.get(v);
+        if (!members) {
+            members = [];
+            node.set(v, members);
+            groups.push(members);
+        }
+        members.push(f);
+    }
+    return groups;
+}
+function keyedGroupby(groupby) {
+    return groupby.some(field => !isPlainFieldRef(field));
+}
 function aggregate(features, step) {
     const { groupby = [], ops } = step;
     const out = [];
     let serial = 0;
-    for (const members of groupMembers(features, groupby)) {
+    const reads = keyedGroupby(groupby)
+        ? groupby.map(field => pathReader(field, 'an aggregate'))
+        : undefined;
+    const opReads = ops.map(({ op, field }) => op === 'count' || field === undefined || isPlainFieldRef(field)
+        ? undefined
+        : pathReader(field, 'an aggregate'));
+    for (const members of reads
+        ? groupMembersBy(features, reads)
+        : groupMembers(features, groupby)) {
         const first = members[0];
         const refName = first.get('refName');
         let start = Infinity;
@@ -178,11 +254,14 @@ function aggregate(features, step) {
             end = Math.max(end, m.get('end'));
         }
         const data = {};
-        for (const field of groupby) {
-            data[field] = first.get(field);
+        for (const [i, field] of groupby.entries()) {
+            data[field] = groupKey(reads ? reads[i](first) : first.get(field));
         }
-        for (const agg of ops) {
-            data[aggregateFieldName(agg)] = aggregateValue(members, agg);
+        for (const [k, agg] of ops.entries()) {
+            const read = opReads[k];
+            data[aggregateFieldName(agg)] = read
+                ? aggregateValueBy(members, agg.op, read)
+                : aggregateValue(members, agg);
         }
         out.push(new MadeFeature({ ...data, refName, start, end }, `#${serial++}`));
     }
@@ -200,7 +279,7 @@ function aggregateValue(members, { op, field }) {
     let min = Infinity;
     let max = -Infinity;
     for (const m of members) {
-        const v = Number(m.get(field));
+        const v = numericValue(m.get(field));
         if (!Number.isFinite(v)) {
             continue;
         }
@@ -224,31 +303,92 @@ function aggregateValue(members, { op, field }) {
         }
     }
 }
+// `aggregateValue` over a reader, for an op naming a dotted path. A function
+// of its own, and the fold written out again, so the loop above stays the size
+// it was: both variants in one body measured 1.04-1.20x on a plain field.
+function aggregateValueBy(members, op, read) {
+    let sum = 0;
+    let n = 0;
+    let min = Infinity;
+    let max = -Infinity;
+    for (const m of members) {
+        const v = numericValue(read(m));
+        if (!Number.isFinite(v)) {
+            continue;
+        }
+        sum += v;
+        n++;
+        min = Math.min(min, v);
+        max = Math.max(max, v);
+    }
+    return op === 'sum'
+        ? sum
+        : n === 0
+            ? undefined
+            : op === 'mean'
+                ? sum / n
+                : op === 'min'
+                    ? min
+                    : max;
+}
 /**
- * The lowest row each feature fits on, greedy first fit in start order: the
- * layout a pileup is, as a step in front of the encoder rather than a packer
- * behind it. `rowEnds[r]` is where row `r` is free again, so the scan is over
- * rows rather than over features.
+ * The lowest row each feature fits on, greedy first fit in start order, as a
+ * step in front of the encoder rather than a packer behind it. `rowEnds[r]` is
+ * where row `r` is free again, so the scan is over rows rather than over
+ * features.
  */
-function stack(features, step) {
-    const as = step.as ?? DEFAULT_STACK_AS;
-    const [startField, endField] = step.fields ?? DEFAULT_STACK_FIELDS;
+function pileup(features, step) {
+    const as = step.as ?? DEFAULT_PILEUP_AS;
+    const [startField, endField] = step.fields ?? DEFAULT_PILEUP_FIELDS;
     const padding = step.padding ?? 0;
-    const out = [];
-    for (const members of groupMembers(features, step.groupby ?? [])) {
-        members.sort((a, b) => Number(a.get(startField)) - Number(b.get(startField)));
-        const rowEnds = [];
-        for (const f of members) {
-            const start = Number(f.get(startField));
-            const end = Number(f.get(endField));
-            let row = 0;
-            while (row < rowEnds.length && rowEnds[row] > start) {
-                row++;
+    const n = features.length;
+    const starts = new Float64Array(n);
+    const ends = new Float64Array(n);
+    let inOrder = true;
+    if (isPlainFieldRef(startField) && isPlainFieldRef(endField)) {
+        for (let i = 0; i < n; i++) {
+            const f = features[i];
+            starts[i] = numericValue(f.get(startField));
+            ends[i] = numericValue(f.get(endField));
+            inOrder &&= i === 0 || starts[i] >= starts[i - 1];
+        }
+    }
+    else {
+        const readStart = pathReader(startField, 'a pileup');
+        const readEnd = pathReader(endField, 'a pileup');
+        for (let i = 0; i < n; i++) {
+            const f = features[i];
+            starts[i] = numericValue(readStart(f));
+            ends[i] = numericValue(readEnd(f));
+            inOrder &&= i === 0 || starts[i] >= starts[i - 1];
+        }
+    }
+    // Any unreadable start leaves the list out of order. Read as Infinity, it
+    // sorts last and packs where it claims no row a readable one could want,
+    // where NaN left the sort without an order and a row's end unreadable.
+    if (!inOrder) {
+        for (let i = 0; i < n; i++) {
+            if (Number.isNaN(starts[i])) {
+                starts[i] = Infinity;
             }
-            rowEnds[row] = (end > start ? end : start) + padding;
-            out.push(new DerivedFeature(f, { [as]: row }));
         }
     }
+    const order = inOrder
+        ? undefined
+        : Uint32Array.from(starts, (_, i) => i).sort((a, b) => starts[a] - starts[b] || a - b);
+    const rowEnds = [];
+    const out = [];
+    for (let k = 0; k < n; k++) {
+        const i = order ? order[k] : k;
+        const start = starts[i];
+        const end = ends[i];
+        let row = 0;
+        while (row < rowEnds.length && rowEnds[row] > start) {
+            row++;
+        }
+        rowEnds[row] = (end > start ? end : start) + padding;
+        out.push(new DerivedFeature(features[i], { [as]: row }));
+    }
     return out;
 }
 /**
@@ -298,6 +438,63 @@ function coverage(features, step) {
     }
     return out;
 }
+function rowOf(value) {
+    const row = Number(value);
+    return row > 0 ? Math.floor(row) : 0;
+}
+/**
+ * #api
+ * A faceted request's layers: the features split on `field`'s key, each
+ * layer's own steps run over each section alone, and the sections stacked —
+ * a section's rows start where the one above it ends, and it is as tall as
+ * the tallest layer packed it. Every layer's features come back in section
+ * order beside their stacked rows, so a faceted display is the unfaceted one
+ * drawn once per section, and a feature is handed on as its steps left it.
+ */
+export function facetLayers(features, field, layers, jexl) {
+    const categories = categoricalField(field);
+    const read = fieldReader(field, jexl);
+    const byKey = new Map();
+    for (const f of features) {
+        const key = categories.key(read(f));
+        const members = byKey.get(key);
+        if (members) {
+            members.push(f);
+        }
+        else {
+            byKey.set(key, [f]);
+        }
+    }
+    const readRows = layers.map(l => fieldReader(l.row ?? DEFAULT_PILEUP_AS, jexl));
+    const out = layers.map(() => ({
+        features: [],
+        rows: [],
+    }));
+    const sections = [];
+    let next = 0;
+    for (const key of [...byKey.keys()].sort(categories.compare)) {
+        const members = byKey.get(key);
+        let rowCount = 1;
+        for (const [l, { transform }] of layers.entries()) {
+            const placed = transform?.length
+                ? runTransforms(members, transform, jexl)
+                : members;
+            const readRow = readRows[l];
+            const layer = out[l];
+            for (const f of placed) {
+                const row = rowOf(readRow(f));
+                if (row + 1 > rowCount) {
+                    rowCount = row + 1;
+                }
+                layer.features.push(f);
+                layer.rows.push(next + row);
+            }
+        }
+        sections.push({ key, firstRow: next, rowCount });
+        next += rowCount;
+    }
+    return { layers: out, sections };
+}
 /**
  * #api
  * Run the transform steps over a feature list, in order, in the worker. The
@@ -332,8 +529,8 @@ export function runTransforms(features, steps, jexl) {
                 current = coverage(current, step);
                 break;
             }
-            case 'stack': {
-                current = stack(current, step);
+            case 'pileup': {
+                current = pileup(current, step);
                 break;
             }
         }

package/esm/util/fetchAndMaybeUnzip.js

@@ -1,6 +1,5 @@
 import { redactSource } from './getLocationUri.js';
 import { downloadStatus, phaseOf, updateStatus } from './progress.js';
-import { withStopTokenSignal } from './stopToken.js';
 export function isGzip(buf) {
     return buf[0] === 31 && buf[1] === 139 && buf[2] === 8;
 }
@@ -36,10 +35,10 @@ label = 'Downloading file') {
     const phase = loc.source === undefined
         ? label
         : { message: phaseOf(label), source: redactSource(loc.source) };
-    const { statusCallback, stopToken } = opts;
-    // the stop token becomes the read's signal, so a cancelled whole-file load
-    // drops at the socket rather than downloading a multi-GB body to completion
-    const buf = await withStopTokenSignal(stopToken, signal => downloadStatus(phase, statusCallback, onProgress => loc.readFile({ ...opts, onProgress, signal })));
+    const { statusCallback, signal } = opts;
+    // the signal reaches the read, so a cancelled whole-file load drops at the
+    // socket rather than downloading a multi-GB body to completion
+    const buf = await downloadStatus(phase, statusCallback, onProgress => loc.readFile({ ...opts, onProgress, signal }));
     // the inflater is imported dynamically because this module is reachable from
     // the core/util barrel, so a static import put bgzf-filehandle + pako
     // (~180KB) on the startup path of every page load; only an actually-gzipped
@@ -51,7 +50,7 @@ label = 'Downloading file') {
         }, 
         // a cancel landing here is otherwise discovered only by whatever parses
         // the result, after a whole-file inflate has run to completion
-        stopToken)
+        signal)
         : buf;
 }
 export async function fetchAndMaybeUnzipText(loc, opts, label) {

package/esm/util/fetchContext.d.ts

@@ -1,9 +1,8 @@
 import type { RpcCallArgs, RpcCallReturn } from '../rpc/RpcRegistry.ts';
 import type { StatusCallback } from './progress.ts';
-import type { StopToken } from './stopToken.ts';
 import type { IStateTreeNode } from '@jbrowse/mobx-state-tree';
 export interface FetchContext {
-    stopToken: StopToken;
+    signal: AbortSignal;
     isStale: () => boolean;
     /**
      * The RPC `statusCallback` for the work this context describes: guarded to
@@ -24,18 +23,18 @@ export interface FetchContext {
     /**
      * The one way a fetch calls an RPC: the registry-typed
      * `rpcManager.call(rpcSessionId, method, args)` with this context's
-     * `stopToken` and `statusCallback` injected. Both used to be hand-threaded
+     * `signal` and `statusCallback` injected. Both used to be hand-threaded
      * at every fetch site, and forgetting either was silent — no cancellation
      * for that display, or no progress — which is exactly the failure class the
      * envelope makes inexpressible: a fetch cannot issue an RPC the cancel and
      * the status bar don't know about.
      *
      * Declared with a `this` parameter so it reads the *holding* context's
-     * token and callback — the fan-out copies rebind it to their own status
+     * signal and callback — the fan-out copies rebind it to their own status
      * slot by construction — and so destructuring it off the context is a type
      * error rather than a stale binding.
      */
-    callRpc: <M extends string>(this: FetchContext, method: M, args: Omit<RpcCallArgs<M>, 'stopToken' | 'statusCallback'>) => Promise<RpcCallReturn<M>>;
+    callRpc: <M extends string>(this: FetchContext, method: M, args: Omit<RpcCallArgs<M>, 'signal' | 'statusCallback'>) => Promise<RpcCallReturn<M>>;
 }
 /**
  * Build a {@link FetchContext} over a live fetch's primitives. One
@@ -52,7 +51,7 @@ export interface FetchContext {
  * track, which is what the breakpoint split view's overlay fetch does.
  */
 export declare function makeFetchContext(self: IStateTreeNode, base: {
-    stopToken: StopToken;
+    signal: AbortSignal;
     isStale: () => boolean;
     statusCallback: StatusCallback;
 }): FetchContext;

package/esm/util/fetchContext.js

@@ -21,7 +21,7 @@ export function makeFetchContext(self, base) {
         callRpc(method, args) {
             return getRpcHost(self).rpcManager.call(getRpcSessionId(self), method, {
                 ...args,
-                stopToken: this.stopToken,
+                signal: this.signal,
                 statusCallback: this.statusCallback,
             });
         },

package/esm/util/fetchHub.d.ts

@@ -12,4 +12,6 @@ export declare function hubUrl(hub: string): string;
  * the name straight to `createLinearGenomeView({ assembly: 'hg38' })` for the
  * common case; call this directly only to cherry-pick tracks from the catalog.
  */
-export declare function fetchHub(hub: string): Promise<HubConfig>;
+export declare function fetchHub(hub: string, { signal }?: {
+    signal?: AbortSignal;
+}): Promise<HubConfig>;

package/esm/util/fetchHub.js

@@ -15,9 +15,9 @@ export function hubUrl(hub) {
  * the name straight to `createLinearGenomeView({ assembly: 'hg38' })` for the
  * common case; call this directly only to cherry-pick tracks from the catalog.
  */
-export async function fetchHub(hub) {
+export async function fetchHub(hub, { signal } = {}) {
     const url = hubUrl(hub);
-    const response = await fetch(url);
+    const response = await fetch(url, { signal });
     if (response.ok) {
         const config = (await response.json());
         // hosted configs reference their data relative to the config's own location

package/esm/util/fetchSeq.d.ts

@@ -1,12 +1,11 @@
 import type { StatusCallback } from './progress.ts';
-import type { StopToken } from './stopToken.ts';
 import type { AbstractSessionModel } from './types/index.ts';
-export declare function fetchSeq({ start, end, refName, assemblyName, session, stopToken, statusCallback, }: {
+export declare function fetchSeq({ start, end, refName, assemblyName, session, signal, statusCallback, }: {
     start: number;
     end: number;
     refName: string;
     assemblyName: string;
     session: AbstractSessionModel;
-    stopToken?: StopToken;
+    signal?: AbortSignal;
     statusCallback?: StatusCallback;
 }): Promise<string>;

package/esm/util/fetchSeq.js

@@ -1,5 +1,5 @@
 import { getSequenceAdapterConfig } from '../assemblyManager/getSequenceAdapterConfig.js';
-export async function fetchSeq({ start, end, refName, assemblyName, session, stopToken, statusCallback, }) {
+export async function fetchSeq({ start, end, refName, assemblyName, session, signal, statusCallback, }) {
     const { rpcManager, assemblyManager } = session;
     const assembly = await assemblyManager.waitForAssembly(assemblyName);
     if (!assembly) {
@@ -28,7 +28,7 @@ export async function fetchSeq({ start, end, refName, assemblyName, session, sto
             refName: seqAdapterRefName,
             assemblyName,
         },
-        stopToken,
+        signal,
         statusCallback,
     });
     return seq ?? '';

package/esm/util/fieldReader.d.ts

@@ -0,0 +1,17 @@
+import type { JexlInstance } from './jexlStrings.ts';
+import type { Feature } from './simpleFeature.ts';
+/**
+ * #api
+ * What a channel reads off a feature: a field by name, a dotted path into a
+ * structured field where no field carries the whole name (`INFO.SVTYPE` on a
+ * VCF record), or a `jexl:` expression over `feature`. A jexl expression that
+ * does not compile throws here, once, rather than on every feature.
+ */
+export declare function fieldReader(ref: string, jexl: JexlInstance | undefined): (feature: Feature) => unknown;
+/**
+ * #api
+ * Whether a field ref is a bare name: what `feature.get` answers on its own,
+ * with no path to walk and no expression to evaluate. A loop over a plain name
+ * keeps the direct call, and only a config that writes a path pays for one.
+ */
+export declare function isPlainFieldRef(ref: string): ref is never;