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

package/esm/util/progress.d.ts

@@ -1,9 +1,8 @@
-import type { StopToken, StopTokenChecker } from './stopToken.ts';
 /**
  * Indeterminate phase: set `label` on the status channel, run `fn`, then restore
- * whatever phase encloses it — `''` when there is none. Pass `stopToken` and the
+ * whatever phase encloses it — `''` when there is none. Pass `signal` and the
  * phase becomes a cancellation boundary too: this is the labelled form of
- * {@link withStopTokenCheck}, so `fn` is checked on both sides of its await and
+ * {@link withAbortCheck}, so `fn` is checked on both sides of its await and
  * neither check has to be remembered at the call site. The determinate
  * counterpart is {@link withProgress}.
  *
@@ -15,7 +14,7 @@ import type { StopToken, StopTokenChecker } from './stopToken.ts';
  * fetching — `downloadPhase(label, location)` builds one — and a plain string
  * everywhere else. It nests and retires identically either way.
  */
-export declare function updateStatus<U>(msg: string | StatusPhase, cb: StatusCallback | undefined, fn: () => U | Promise<U>, stopToken?: StopToken): Promise<U>;
+export declare function updateStatus<U>(msg: string | StatusPhase, cb: StatusCallback | undefined, fn: () => U | Promise<U>, signal?: AbortSignal): Promise<U>;
 /**
  * A determinate reading on the status channel: a phase label plus how far
  * through it the operation is. The loading UI renders the message and a bar.
@@ -238,7 +237,7 @@ export declare function throttleStatusEmits(emit: StatusCallback): (status: RpcS
  * of a burst, not each one in turn.
  *
  * Both fetch families own one: `FetchMixin` for the LGV displays, and
- * `createStopTokenRotation` for the bare-autorun fetches (dotplot, synteny)
+ * `createAbortRotation` for the bare-autorun fetches (dotplot, synteny)
  * that compose no fetch mixin — and a display that has both lends the mixin's
  * to the rotation rather than opening a second on one field. A plain function
  * rather than shared model state because the two families declare their status
@@ -298,13 +297,13 @@ declare function downloadStatusReporter(statusCallback: StatusCallback | undefin
  * which: bytes for the index readers, blocks and expected-value chunks for
  * `@gmod/hic`. All of them report `(current, total?)`.
  *
- * `stopToken` makes the phase a cancellation boundary, exactly as it does on
+ * `signal` makes the phase a cancellation boundary, exactly as it does on
  * {@link updateStatus} — `fn` is checked on both sides of its await.
  *
  * A {@link StatusPhase} `label` carries its source onto the readings too, so a
  * download that stalls part-way through still names the file it was reading.
  */
-export declare function downloadStatus<T>(label: string | StatusPhase, statusCallback: StatusCallback | undefined, fn: (onProgress: ReturnType<typeof downloadStatusReporter>) => T | Promise<T>, stopToken?: StopToken): Promise<T>;
+export declare function downloadStatus<T>(label: string | StatusPhase, statusCallback: StatusCallback | undefined, fn: (onProgress: ReturnType<typeof downloadStatusReporter>) => T | Promise<T>, signal?: AbortSignal): Promise<T>;
 /**
  * One concurrent operation's contribution to a fan-out's shared status: what it
  * is reporting right now, plus how much of each phase it has already finished
@@ -415,20 +414,22 @@ export declare function createStatusFanOut(statusCallback: StatusCallback | unde
  */
 export type ProgressReporter = (current?: number) => void;
 /**
- * The single per-iteration callback for long synchronous worker loops. The
- * returned `report(current)` is called once per outer-loop iteration and does
- * two throttled jobs on each call:
+ * The single per-iteration callback for long worker loops. The returned
+ * `report(current)` is called once per outer-loop iteration and does two jobs
+ * on each call:
  *
- * - checks the stop token via the existing throttled {@link checkStopTokenThrottled}
- *   machinery, so cancellation interrupts the loop within milliseconds instead
- *   of only at phase boundaries, and
+ * - checks `signal`, which sees only an abort that landed at the loop's last
+ *   await, and
  * - emits a {@link StatusWithProgress} through `statusCallback` at most once per
  *   `throttleMs`, so the main thread gets a live percentage without flooding
  *   the postMessage channel.
  *
+ * `report()` never yields, so it does not make a loop interruptible. A loop
+ * that can run for seconds takes `createAbortBreakpoint` beside it.
+ *
  * Both jobs are optional: with no `statusCallback`/`total` this is purely a
- * throttled cancellation tick, so a loop has exactly one inner callback whether
- * or not it drives the progress UI.
+ * cancellation tick, so a loop has exactly one inner callback whether or not
+ * it drives the progress UI.
  *
  * Emission is gated on wall-clock time (`throttleMs`) through {@link
  * createTimeGate}, which thins the `Date.now()` reads as well as the emits —
@@ -436,24 +437,23 @@ export type ProgressReporter = (current?: number) => void;
  * plain `for` and call `report()` once per item (it owns the counter), or
  * `report(n)` for an explicit position.
  */
-export declare function createProgressReporter({ label, total, statusCallback, stopToken, stopTokenCheck, throttleMs, }: {
+export declare function createProgressReporter({ label, total, statusCallback, signal, throttleMs, }: {
     label?: string;
     total?: number;
     statusCallback?: (status: RpcStatus) => void;
-    stopToken?: StopToken;
-    stopTokenCheck?: StopTokenChecker;
+    signal?: AbortSignal;
     throttleMs?: number;
 }): ProgressReporter;
 /**
  * Run a measurable phase: shows `label` at 0%, hands `fn` a {@link
- * ProgressReporter} to drive during the work, then checks the stop token once
+ * ProgressReporter} to drive during the work, then checks the signal once
  * more and restores the enclosing phase. The determinate counterpart to
  * `updateStatus`, and it nests the same way — see {@link openPhase}.
  */
-export declare function withProgress<T>({ label, total, statusCallback, stopToken, }: {
+export declare function withProgress<T>({ label, total, statusCallback, signal, }: {
     label: string;
     total: number;
     statusCallback?: (status: RpcStatus) => void;
-    stopToken?: StopToken;
+    signal?: AbortSignal;
 }, fn: (report: ProgressReporter) => T | Promise<T>): Promise<T>;
 export {};

package/esm/util/progress.js

@@ -1,4 +1,4 @@
-import { checkStopTokenThrottled, createStopTokenChecker, withStopTokenCheck, } from './stopToken.js';
+import { checkAbortSignal, withAbortCheck } from './aborting.js';
 import { createTimeGate } from './timeGate.js';
 const openPhases = new WeakMap();
 /**
@@ -41,9 +41,9 @@ function openPhase(cb, label) {
 }
 /**
  * Indeterminate phase: set `label` on the status channel, run `fn`, then restore
- * whatever phase encloses it — `''` when there is none. Pass `stopToken` and the
+ * whatever phase encloses it — `''` when there is none. Pass `signal` and the
  * phase becomes a cancellation boundary too: this is the labelled form of
- * {@link withStopTokenCheck}, so `fn` is checked on both sides of its await and
+ * {@link withAbortCheck}, so `fn` is checked on both sides of its await and
  * neither check has to be remembered at the call site. The determinate
  * counterpart is {@link withProgress}.
  *
@@ -55,7 +55,7 @@ function openPhase(cb, label) {
  * fetching — `downloadPhase(label, location)` builds one — and a plain string
  * everywhere else. It nests and retires identically either way.
  */
-export async function updateStatus(msg, cb, fn, stopToken) {
+export async function updateStatus(msg, cb, fn, signal) {
     const endPhase = openPhase(cb, msg);
     // pessimistic, so anything leaving this scope other than a value — a throw, a
     // cancel — retires the phase as unfinished
@@ -65,7 +65,7 @@ export async function updateStatus(msg, cb, fn, stopToken) {
     // forever — the error surfaces under a stale "Downloading file"
     try {
         cb?.(msg);
-        const result = await withStopTokenCheck(stopToken, fn);
+        const result = await withAbortCheck(signal, fn);
         outcome = 'completed';
         return result;
     }
@@ -341,7 +341,7 @@ export function throttleStatusEmits(emit) {
  * of a burst, not each one in turn.
  *
  * Both fetch families own one: `FetchMixin` for the LGV displays, and
- * `createStopTokenRotation` for the bare-autorun fetches (dotplot, synteny)
+ * `createAbortRotation` for the bare-autorun fetches (dotplot, synteny)
  * that compose no fetch mixin — and a display that has both lends the mixin's
  * to the rotation rather than opening a second on one field. A plain function
  * rather than shared model state because the two families declare their status
@@ -531,14 +531,14 @@ function downloadStatusReporter(statusCallback, label) {
  * which: bytes for the index readers, blocks and expected-value chunks for
  * `@gmod/hic`. All of them report `(current, total?)`.
  *
- * `stopToken` makes the phase a cancellation boundary, exactly as it does on
+ * `signal` makes the phase a cancellation boundary, exactly as it does on
  * {@link updateStatus} — `fn` is checked on both sides of its await.
  *
  * A {@link StatusPhase} `label` carries its source onto the readings too, so a
  * download that stalls part-way through still names the file it was reading.
  */
-export async function downloadStatus(label, statusCallback, fn, stopToken) {
-    return updateStatus(label, statusCallback, () => fn(downloadStatusReporter(statusCallback, label)), stopToken);
+export async function downloadStatus(label, statusCallback, fn, signal) {
+    return updateStatus(label, statusCallback, () => fn(downloadStatusReporter(statusCallback, label)), signal);
 }
 /** How much of `message` this slot has already finished. */
 function finished(slot, message) {
@@ -751,20 +751,22 @@ function continuesPhase(previous, status) {
         reading.current >= previous.current);
 }
 /**
- * The single per-iteration callback for long synchronous worker loops. The
- * returned `report(current)` is called once per outer-loop iteration and does
- * two throttled jobs on each call:
+ * The single per-iteration callback for long worker loops. The returned
+ * `report(current)` is called once per outer-loop iteration and does two jobs
+ * on each call:
  *
- * - checks the stop token via the existing throttled {@link checkStopTokenThrottled}
- *   machinery, so cancellation interrupts the loop within milliseconds instead
- *   of only at phase boundaries, and
+ * - checks `signal`, which sees only an abort that landed at the loop's last
+ *   await, and
  * - emits a {@link StatusWithProgress} through `statusCallback` at most once per
  *   `throttleMs`, so the main thread gets a live percentage without flooding
  *   the postMessage channel.
  *
+ * `report()` never yields, so it does not make a loop interruptible. A loop
+ * that can run for seconds takes `createAbortBreakpoint` beside it.
+ *
  * Both jobs are optional: with no `statusCallback`/`total` this is purely a
- * throttled cancellation tick, so a loop has exactly one inner callback whether
- * or not it drives the progress UI.
+ * cancellation tick, so a loop has exactly one inner callback whether or not
+ * it drives the progress UI.
  *
  * Emission is gated on wall-clock time (`throttleMs`) through {@link
  * createTimeGate}, which thins the `Date.now()` reads as well as the emits —
@@ -772,13 +774,12 @@ function continuesPhase(previous, status) {
  * plain `for` and call `report()` once per item (it owns the counter), or
  * `report(n)` for an explicit position.
  */
-export function createProgressReporter({ label = '', total, statusCallback, stopToken, stopTokenCheck, throttleMs = 100, }) {
-    const checker = stopTokenCheck ?? createStopTokenChecker(stopToken);
+export function createProgressReporter({ label = '', total, statusCallback, signal, throttleMs = 100, }) {
     const emitDue = createTimeGate();
     let count = 0;
     return (current = count) => {
         count = current + 1;
-        checkStopTokenThrottled(checker);
+        checkAbortSignal(signal);
         if (statusCallback !== undefined &&
             total !== undefined &&
             emitDue(throttleMs)) {
@@ -788,29 +789,29 @@ export function createProgressReporter({ label = '', total, statusCallback, stop
 }
 /**
  * Run a measurable phase: shows `label` at 0%, hands `fn` a {@link
- * ProgressReporter} to drive during the work, then checks the stop token once
+ * ProgressReporter} to drive during the work, then checks the signal once
  * more and restores the enclosing phase. The determinate counterpart to
  * `updateStatus`, and it nests the same way — see {@link openPhase}.
  */
-export async function withProgress({ label, total, statusCallback, stopToken, }, fn) {
+export async function withProgress({ label, total, statusCallback, signal, }, fn) {
     const report = createProgressReporter({
         label,
         total,
         statusCallback,
-        stopToken,
+        signal,
     });
     const endPhase = openPhase(statusCallback, label);
     // pessimistic for the same reason as `updateStatus`: a phase that leaves this
     // scope any way other than returning did not finish its work
     let outcome = 'failed';
     try {
-        // inside the try, because `report` checks the stop token before it emits and
-        // so throws here on a token already stopped. Outside, that threw past the
+        // inside the try, because `report` checks the signal before it emits and
+        // so throws here on one already aborted. Outside, that threw past the
         // close and left the phase open on the channel — a slot whose last word is a
         // label is one `aggregateStatus` counts as in flight for the rest of the
         // batch.
         report(0);
-        const result = await withStopTokenCheck(stopToken, () => fn(report));
+        const result = await withAbortCheck(signal, () => fn(report));
         outcome = 'completed';
         return result;
     }

package/esm/util/renameRegions.d.ts

@@ -1,5 +1,4 @@
 import type { StatusCallback } from './progress.ts';
-import type { StopToken } from './stopToken.ts';
 import type { AssemblyManager, Region } from './types/index.ts';
 import type { Region as MUIRegion } from './types/mst.ts';
 import type { Instance } from '@jbrowse/mobx-state-tree';
@@ -9,7 +8,7 @@ export declare function renameRegionIfNeeded(refNameMap: Record<string, string>
 export declare function renameRegionsIfNeeded<ARGTYPE extends {
     assemblyName?: string;
     regions?: Region[];
-    stopToken?: StopToken;
+    signal?: AbortSignal;
     adapterConfig: Record<string, unknown>;
     sessionId: string;
     statusCallback?: StatusCallback;

package/esm/util/renderToStaticMarkup.js

@@ -14,8 +14,10 @@ import { createRoot } from 'react-dom/client';
 // (packages/lib/src/renderToStaticMarkup.ts there) -- because a rendering
 // library asking its host for a renderer was the coupling worth removing, and
 // because react-dom is a host external for a plugin anyway, so it costs them a
-// few hundred bytes rather than a duplicate react. sharedModules.purity.test.ts
-// is what keeps this file off the worker's graph now.
+// few hundred bytes rather than a duplicate react. Re-exporting it from the
+// barrel would also stub `@jbrowse/core/util` in the worker, since the
+// generator stubs a module whose graph reaches react-dom; workerModules.test.ts
+// fails on that.
 //
 // https://react.dev/reference/react-dom/server/renderToString#removing-rendertostring-from-the-client-code
 export function renderToStaticMarkup(node) {
@@ -25,13 +27,23 @@ export function renderToStaticMarkup(node) {
     // jbrowse-img) loads @emotion/react before `document` exists, so its default
     // cache context is null — provide one explicitly here.
     const cache = createCache({ key: 'css' });
-    const root = createRoot(div);
+    // a client root reports a render error and unmounts, so without this the
+    // export is an empty string its caller writes as a file
+    const uncaught = [];
+    const root = createRoot(div, {
+        onUncaughtError: error => {
+            uncaught.push(error);
+        },
+    });
     let html;
     try {
         // eslint-disable-next-line @eslint-react/dom-no-flush-sync
         flushSync(() => {
             root.render(React.createElement(CacheProvider, { value: cache }, node));
         });
+        if (uncaught.length > 0) {
+            throw uncaught[0];
+        }
         html = div.innerHTML;
     }
     finally {
@@ -44,17 +56,5 @@ export function renderToStaticMarkup(node) {
         // once the markup is a string, which no longer depends on the DOM.
         root.unmount();
     }
-    // SVG 1.1 presentation attributes (`fill`, `stroke`) take a <color>, which
-    // does not include rgba() — alpha belongs in a separate fill-opacity /
-    // stroke-opacity. Illustrator and older Inkscape drop an element whose fill
-    // they cannot parse, so the alpha is stripped rather than left to break the
-    // whole shape. It is *dropped*, not converted, so a translucent color exports
-    // fully opaque: components that need transparency to survive set a separate
-    // opacity attribute instead (`CrossHatches`, `RowSeparatorLines`).
-    //
-    // Rewriting `fill="rgba(r,g,b,a)"` into `fill="rgb(r,g,b)" fill-opacity="a"`
-    // would preserve the appearance and let those two drop their workarounds, but
-    // it changes the pixels of every export carrying an rgba color, so it needs a
-    // visual pass before the snapshots are regenerated.
-    return html.replaceAll(/\brgba\((.+?),[^,]+?\)/g, 'rgb($1)');
+    return html;
 }

package/esm/util/rxjs.d.ts

@@ -1,20 +1,19 @@
 import { Observable } from 'rxjs';
-import type { StopToken } from './stopToken.ts';
 import type { Observer } from 'rxjs';
 /**
  * Wrapper for rxjs Observable.create with improved error handling and aborting
  * support.
  *
- * A `stopToken` errors the subscriber with an abort error the moment the token
- * is stopped, rather than waiting for `func` to finish work whose result is
- * already discarded. The fetch paths filter abort errors out (`isAbortException`)
- * so a cancel does not surface as a track error. It cannot interrupt `func`
- * itself — a body doing long synchronous work still needs its own
- * `checkStopToken` ticks — but it does stop delivery downstream.
+ * A `signal` errors the subscriber with an abort error the moment it aborts,
+ * rather than waiting for `func` to finish work whose result is already
+ * discarded. The fetch paths filter abort errors out (`isAbortException`) so a
+ * cancel does not surface as a track error. It cannot interrupt `func` itself
+ * — a body doing long synchronous work still needs its own `checkAbortSignal`
+ * ticks — but it does stop delivery downstream.
  *
  * @param func - observer function, could be async
  */
-export declare function ObservableCreate<T>(func: (arg: Observer<T>) => void | Promise<void>, stopToken?: StopToken): Observable<T>;
+export declare function ObservableCreate<T>(func: (arg: Observer<T>) => void | Promise<void>, signal?: AbortSignal): Observable<T>;
 /**
  * Subscribe to an observable and resolve when it completes, running `onNext` per
  * item as it arrives — the streaming shape for parsing items out of a feature

package/esm/util/rxjs.js

@@ -1,30 +1,28 @@
 import { Observable } from 'rxjs';
-import { stopTokenSignal } from './stopToken.js';
 /**
  * Wrapper for rxjs Observable.create with improved error handling and aborting
  * support.
  *
- * A `stopToken` errors the subscriber with an abort error the moment the token
- * is stopped, rather than waiting for `func` to finish work whose result is
- * already discarded. The fetch paths filter abort errors out (`isAbortException`)
- * so a cancel does not surface as a track error. It cannot interrupt `func`
- * itself — a body doing long synchronous work still needs its own
- * `checkStopToken` ticks — but it does stop delivery downstream.
+ * A `signal` errors the subscriber with an abort error the moment it aborts,
+ * rather than waiting for `func` to finish work whose result is already
+ * discarded. The fetch paths filter abort errors out (`isAbortException`) so a
+ * cancel does not surface as a track error. It cannot interrupt `func` itself
+ * — a body doing long synchronous work still needs its own `checkAbortSignal`
+ * ticks — but it does stop delivery downstream.
  *
  * @param func - observer function, could be async
  */
-export function ObservableCreate(func, stopToken) {
+export function ObservableCreate(func, signal) {
     return new Observable((observer) => {
-        const { signal, dispose } = stopTokenSignal(stopToken);
         const stop = () => {
-            observer.error(signal.reason);
+            observer.error(signal?.reason);
         };
-        if (signal.aborted) {
-            // stopped before subscribe: no 'abort' event is coming
+        if (signal?.aborted) {
+            // aborted before subscribe: no 'abort' event is coming
             stop();
         }
         else {
-            signal.addEventListener('abort', stop);
+            signal?.addEventListener('abort', stop);
             try {
                 const ret = func(observer);
                 if (ret?.catch) {
@@ -38,8 +36,7 @@ export function ObservableCreate(func, stopToken) {
             }
         }
         return () => {
-            signal.removeEventListener('abort', stop);
-            dispose();
+            signal?.removeEventListener('abort', stop);
         };
     });
 }

package/esm/util/simpleFeature.d.ts

@@ -90,7 +90,6 @@ export interface SimpleFeatureSerializedNoId {
     name?: string;
     id?: string | number;
     uniqueId?: string;
-    __jbrowsefmt?: Record<string, unknown>;
     mate?: {
         refName: string;
         start: number;

package/esm/util/svgColorProps.d.ts

@@ -5,3 +5,14 @@ export declare function getStrokeProps(str: string): {
 export declare function getFillProps(str: string): {
     [x: string]: string | number;
 };
+/**
+ * A paint value split into the `rgb()` an SVG 1.1 `<color>` can carry and the
+ * alpha it cannot, for a separate `*-opacity`. Illustrator and older Inkscape
+ * drop an element whose fill they cannot parse, so `rgba()`, `hsl()`, `#rgba`
+ * and `transparent` have to be split before they reach a file. Undefined for a
+ * value that is already an SVG color, `none` or a `url()`.
+ */
+export declare function splitPaintAlpha(value: string): {
+    color: string;
+    opacity: number;
+} | undefined;

package/esm/util/svgColorProps.js

@@ -1,4 +1,4 @@
-import { formatHEX, getAlpha, newColor, parseCssColorOr } from './colorBits.js';
+import { formatHEX, getAlpha, getBlue, getGreen, getRed, newColor, parseCssColorOr, } from './colorBits.js';
 // Matches colord()'s fallback for unparsable input.
 const FALLBACK = newColor(0, 0, 0, 255);
 // Works on the packed Color directly rather than via colord(): these run per
@@ -26,3 +26,30 @@ export function getStrokeProps(str) {
 export function getFillProps(str) {
     return svgColorProps(str, 'fill', 'fillOpacity');
 }
+// four channels, comma- or slash-separated, so a three-channel `rgb(4,5,6)`
+// never reads its blue as an alpha
+const FUNCTIONAL_ALPHA = /^(?:rgb|hsl)a?\((?:[^,/)]+,){3}\s*([\d.]+)(%?)\s*\)$|^(?:rgb|hsl)a?\([^,/)]+\/\s*([\d.]+)(%?)\s*\)$/i;
+const HEX_ALPHA = /^#(?:[\da-f]{4}|[\da-f]{8})$/i;
+const NOT_SVG_COLOR = /^(?:rgba|hsla?)\(|^transparent$/i;
+/**
+ * A paint value split into the `rgb()` an SVG 1.1 `<color>` can carry and the
+ * alpha it cannot, for a separate `*-opacity`. Illustrator and older Inkscape
+ * drop an element whose fill they cannot parse, so `rgba()`, `hsl()`, `#rgba`
+ * and `transparent` have to be split before they reach a file. Undefined for a
+ * value that is already an SVG color, `none` or a `url()`.
+ */
+export function splitPaintAlpha(value) {
+    const m = FUNCTIONAL_ALPHA.exec(value);
+    if (!m && !HEX_ALPHA.test(value) && !NOT_SVG_COLOR.test(value)) {
+        return undefined;
+    }
+    const c = parseCssColorOr(value, FALLBACK);
+    const digits = m?.[1] ?? m?.[3];
+    const percent = (m?.[2] ?? m?.[4]) === '%';
+    return {
+        color: `rgb(${getRed(c)},${getGreen(c)},${getBlue(c)})`,
+        opacity: digits === undefined
+            ? getAlpha(c) / 255
+            : Math.min(1, Number(digits) / (percent ? 100 : 1)),
+    };
+}

package/esm/util/tabix.d.ts

@@ -1,5 +1,4 @@
 import type { StatusCallback } from './progress.ts';
-import type { StopToken } from './stopToken.ts';
 /**
  * A raw tabix line paired with the metadata the GFF3/GTF adapters need before
  * parsing: `offset` (the tabix byte offset) mints a stable per-feature id that
@@ -34,13 +33,13 @@ interface TabixLineSource {
  * label, capturing each line's byte offset, indexed start/end, and feature type
  * into a {@link TabixLine}. Shared by the GFF3 and GTF tabix adapters.
  *
- * The stop token becomes the read's `AbortSignal`, so a cancelled fetch drops
+ * The signal becomes the read's `AbortSignal`, so a cancelled fetch drops
  * its block reads at the socket instead of downloading them and discarding the
  * lines. @gmod/tabix aborts a block shared between callers only once every
  * joined caller has aborted (`AggregateAbortController`), so this can't cancel a
  * chunk another region still needs.
  */
-export declare function readTabixLines(gff: TabixLineSource, refName: string, start: number, end: number, statusCallback?: StatusCallback, stopToken?: StopToken): Promise<TabixLine[]>;
+export declare function readTabixLines(gff: TabixLineSource, refName: string, start: number, end: number, statusCallback?: StatusCallback, signal?: AbortSignal): Promise<TabixLine[]>;
 /**
  * Read a region's tabix lines, then — if any feature found there extends past
  * the query — read the overhang on either side, so a parent line's children (a
@@ -84,7 +83,7 @@ export declare function readTabixLinesRedispatched(file: TabixLineSource, query:
     end: number;
 }, expands: (line: TabixLine) => boolean, opts?: {
     statusCallback?: StatusCallback;
-    stopToken?: StopToken;
+    signal?: AbortSignal;
 }): Promise<TabixLine[]>;
 /**
  * Minimal structural view of the `@gmod/tabix` call a header read needs, kept

package/esm/util/tabix.js

@@ -1,6 +1,5 @@
 import { createStatusFanOut, downloadStatus } from './progress.js';
 import { calculateRedispatchRange } from './range.js';
-import { withStopTokenSignal } from './stopToken.js';
 /**
  * Read the feature type (column 3) from a raw GFF3/GTF line without a full
  * split. Used only to classify a line for redispatch.
@@ -18,15 +17,15 @@ function extractType(line) {
  * label, capturing each line's byte offset, indexed start/end, and feature type
  * into a {@link TabixLine}. Shared by the GFF3 and GTF tabix adapters.
  *
- * The stop token becomes the read's `AbortSignal`, so a cancelled fetch drops
+ * The signal becomes the read's `AbortSignal`, so a cancelled fetch drops
  * its block reads at the socket instead of downloading them and discarding the
  * lines. @gmod/tabix aborts a block shared between callers only once every
  * joined caller has aborted (`AggregateAbortController`), so this can't cancel a
  * chunk another region still needs.
  */
-export function readTabixLines(gff, refName, start, end, statusCallback, stopToken) {
+export function readTabixLines(gff, refName, start, end, statusCallback, signal) {
     const lines = [];
-    return withStopTokenSignal(stopToken, signal => downloadStatus('Downloading features', statusCallback, onProgress => gff.getLines(refName, start, end, {
+    return downloadStatus('Downloading features', statusCallback, onProgress => gff.getLines(refName, start, end, {
         lineCallback: (line, offset, s, e) => {
             lines.push({
                 line,
@@ -38,7 +37,7 @@ export function readTabixLines(gff, refName, start, end, statusCallback, stopTok
         },
         onProgress,
         signal,
-    }))).then(() => lines);
+    })).then(() => lines);
 }
 /**
  * Read a region's tabix lines, then — if any feature found there extends past
@@ -81,10 +80,10 @@ export async function readTabixLinesRedispatched(file,
 // the region's locus only — kept structural, like TabixLineSource above, so
 // this module stays free of the `types` barrel and its MST models
 query, expands, opts = {}) {
-    const { statusCallback, stopToken } = opts;
+    const { statusCallback, signal } = opts;
     // `cb` is not optional: each read decides where it reports, and the flanks
     // report somewhere the first read does not
-    const read = (start, end, cb) => readTabixLines(file, query.refName, start, end, cb, stopToken);
+    const read = (start, end, cb) => readTabixLines(file, query.refName, start, end, cb, signal);
     const lines = await read(query.start, query.end, statusCallback);
     const redispatch = calculateRedispatchRange(lines, expands, query.start, query.end);
     if (redispatch) {

package/esm/util/thresholdScale.d.ts

@@ -0,0 +1,54 @@
+import type { CategoricalField } from './categoricalField.ts';
+/**
+ * #api
+ * A domain written as strings — the shared `domain` slot is a `stringArray` —
+ * read back as the numbers it names. A member that is not a number reads NaN,
+ * which every comparison against it declines.
+ */
+export declare function numericDomain(domain: readonly (string | number)[]): number[];
+/**
+ * #api
+ * A threshold scale's cut points as {@link thresholdIndex} walks them: the
+ * numbers the domain names, ascending. Cuts written high to low, as p-value
+ * thresholds often are, left the middle interval unreachable, the walk stopping
+ * at the first cut a value is under.
+ */
+export declare function thresholdCuts(domain: readonly (string | number)[]): number[];
+/**
+ * #api
+ * The bin a value falls in: how many of the ascending cut points it is at or
+ * past, so a palette with one more entry than the domain paints it as
+ * `palette[thresholdIndex(value, domain)]`. A value that is not a finite
+ * number is in no bin and answers -1.
+ */
+export declare function thresholdIndex(value: unknown, domain: readonly number[]): number;
+/**
+ * #api
+ * The colour of each interval, in order: the declared palette, and the
+ * default categorical palette where it runs out.
+ */
+export declare function thresholdPalette(bins: number, palette?: readonly string[]): string[];
+/**
+ * #api
+ * What a threshold scale's bins are called in a key, one label per palette
+ * entry: `< a` below the first cut, `a – b` between two, `≥ b` past the last.
+ */
+export declare function thresholdLabels(domain: readonly number[]): string[];
+/**
+ * #api
+ * The key a value holding text that is no number files under on a threshold
+ * scale, painted the misconfiguration grey rather than passing for a missing
+ * value.
+ */
+export declare const NOT_A_NUMBER_LABEL = "(not a number)";
+/**
+ * #api
+ * A threshold scale read the way every categorical channel reads its field: a
+ * value files under the label of the bin it falls in, a feature with no value
+ * under `''`, and text that is no number under {@link NOT_A_NUMBER_LABEL}.
+ * The bins are the whole domain, so a key lists each one.
+ */
+export declare function thresholdField(field: string, { domain, range, }?: {
+    domain?: readonly string[];
+    range?: readonly string[];
+}): CategoricalField;