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

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.
@@ -150,7 +149,7 @@ export interface StatusStream {
      * the last label of a fetch that is over.
      *
      * It is not guarded by `isCurrent`: a run that has just finished is no longer
-     * current, and a superseded run must retire its slot too or it votes forever.
+     * current, and its slot must still retire.
      */
     clear: () => void;
 }
@@ -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/quantileExtent.d.ts

@@ -0,0 +1,49 @@
+/** The quantile "Clip outliers" clips at on a scale whose own default is the extremes. */
+export declare const DEFAULT_CLIP_QUANTILE = 0.99;
+/**
+ * #api
+ * The quantile a clip toggle writes: a scale's declared default where that
+ * clips, below 1, else {@link DEFAULT_CLIP_QUANTILE}.
+ */
+export declare function clipQuantileOf(declaredDefault: unknown): number;
+/**
+ * #api
+ * The `k`th smallest of `a[0, n)`, permuting `a` in place. Exact, where a
+ * histogram collapses skewed contact counts into its bottom bucket, and O(n)
+ * where a sort of 4.5M counts measured ~1s. Median-of-three because Hi-C
+ * contacts arrive nearly sorted.
+ */
+export declare function selectNth(a: Float32Array, n: number, k: number): number;
+/**
+ * #api
+ * The least and greatest finite values of `values[0, count)`,
+ * `[Infinity, -Infinity]` where none is finite.
+ */
+export declare function finiteExtremes(values: ArrayLike<number>, count: number): [number, number];
+/**
+ * #api
+ * The nearest-rank `quantile` of `a[0, n)`: the smallest value at least that
+ * share of them sit at or below, so a handful of values clips at their
+ * maximum. Permutes `a`; 0 where `n` is.
+ */
+export declare function quantileOf(a: Float32Array, n: number, quantile: number): number;
+/**
+ * #api
+ * What the open ends of a scale follow over `values[0, count)`: at a
+ * `quantile` of 1 their finite extremes, and below it each end clipped at
+ * that quantile of the values on its side of 0, so one spike takes neither
+ * the axis nor the ramp, and a sparse tail of the other sign keeps its own
+ * end. An axis that starts at 0 adds it itself. Under 0.5 reads as 0.5,
+ * where the ends meet rather than cross. `scales.y.domainQuantile` and a
+ * colour's `domainQuantile` both name it. `[Infinity, -Infinity]` where
+ * nothing is finite.
+ */
+export declare function quantileExtent(values: ArrayLike<number>, count: number, quantile?: number): [number, number];
+/**
+ * #api
+ * {@link quantileExtent} as a scale's open ends read it: over every finite
+ * value on a linear scale, and on a log scale over the positive ones, since a
+ * 0 or a negative met there would floor the domain at 1 and fold a domain
+ * below 1 flat. `[Infinity, -Infinity]` where the scale reads nothing.
+ */
+export declare function scaleExtent(values: ArrayLike<number>, count: number, scale: string, quantile?: number): [number, number];

package/esm/util/quantileExtent.js

@@ -0,0 +1,162 @@
+/** The quantile "Clip outliers" clips at on a scale whose own default is the extremes. */
+export const DEFAULT_CLIP_QUANTILE = 0.99;
+/**
+ * #api
+ * The quantile a clip toggle writes: a scale's declared default where that
+ * clips, below 1, else {@link DEFAULT_CLIP_QUANTILE}.
+ */
+export function clipQuantileOf(declaredDefault) {
+    return typeof declaredDefault === 'number' && declaredDefault < 1
+        ? declaredDefault
+        : DEFAULT_CLIP_QUANTILE;
+}
+function swap(a, i, j) {
+    const t = a[i];
+    a[i] = a[j];
+    a[j] = t;
+}
+/**
+ * #api
+ * The `k`th smallest of `a[0, n)`, permuting `a` in place. Exact, where a
+ * histogram collapses skewed contact counts into its bottom bucket, and O(n)
+ * where a sort of 4.5M counts measured ~1s. Median-of-three because Hi-C
+ * contacts arrive nearly sorted.
+ */
+export function selectNth(a, n, k) {
+    let lo = 0;
+    let hi = n - 1;
+    while (lo < hi) {
+        const mid = (lo + hi) >>> 1;
+        if (a[mid] < a[lo]) {
+            swap(a, mid, lo);
+        }
+        if (a[hi] < a[lo]) {
+            swap(a, hi, lo);
+        }
+        if (a[hi] < a[mid]) {
+            swap(a, hi, mid);
+        }
+        const pivot = a[mid];
+        let i = lo;
+        let j = hi;
+        while (i <= j) {
+            while (a[i] < pivot) {
+                i++;
+            }
+            while (a[j] > pivot) {
+                j--;
+            }
+            if (i <= j) {
+                swap(a, i, j);
+                i++;
+                j--;
+            }
+        }
+        if (k <= j) {
+            hi = j;
+        }
+        else if (k >= i) {
+            lo = i;
+        }
+        else {
+            return a[k];
+        }
+    }
+    return a[k];
+}
+/**
+ * #api
+ * The least and greatest finite values of `values[0, count)`,
+ * `[Infinity, -Infinity]` where none is finite.
+ */
+export function finiteExtremes(values, count) {
+    let min = Infinity;
+    let max = -Infinity;
+    for (let i = 0; i < count; i++) {
+        const v = values[i];
+        if (Number.isFinite(v)) {
+            if (v < min) {
+                min = v;
+            }
+            if (v > max) {
+                max = v;
+            }
+        }
+    }
+    return [min, max];
+}
+/**
+ * #api
+ * The nearest-rank `quantile` of `a[0, n)`: the smallest value at least that
+ * share of them sit at or below, so a handful of values clips at their
+ * maximum. Permutes `a`; 0 where `n` is.
+ */
+export function quantileOf(a, n, quantile) {
+    return n === 0
+        ? 0
+        : selectNth(a, n, Math.min(n - 1, Math.max(0, Math.ceil(quantile * n) - 1)));
+}
+function lowQuantileOf(a, n, quantile) {
+    return n === 0
+        ? 0
+        : selectNth(a, n, Math.max(0, Math.min(n - 1, n - Math.ceil(quantile * n))));
+}
+/**
+ * #api
+ * What the open ends of a scale follow over `values[0, count)`: at a
+ * `quantile` of 1 their finite extremes, and below it each end clipped at
+ * that quantile of the values on its side of 0, so one spike takes neither
+ * the axis nor the ramp, and a sparse tail of the other sign keeps its own
+ * end. An axis that starts at 0 adds it itself. Under 0.5 reads as 0.5,
+ * where the ends meet rather than cross. `scales.y.domainQuantile` and a
+ * colour's `domainQuantile` both name it. `[Infinity, -Infinity]` where
+ * nothing is finite.
+ */
+export function quantileExtent(values, count, quantile = 1) {
+    if (!(quantile < 1)) {
+        return finiteExtremes(values, count);
+    }
+    const q = Math.max(0.5, quantile);
+    const positive = new Float32Array(count);
+    const negative = new Float32Array(count);
+    let np = 0;
+    let nn = 0;
+    for (let i = 0; i < count; i++) {
+        const v = values[i];
+        if (Number.isFinite(v)) {
+            if (v >= 0) {
+                positive[np++] = v;
+            }
+            else {
+                negative[nn++] = v;
+            }
+        }
+    }
+    if (np + nn === 0) {
+        return [Infinity, -Infinity];
+    }
+    const low = nn > 0 ? lowQuantileOf(negative, nn, q) : lowQuantileOf(positive, np, q);
+    const high = np > 0 ? quantileOf(positive, np, q) : quantileOf(negative, nn, q);
+    return [Math.min(low, high), high];
+}
+/**
+ * #api
+ * {@link quantileExtent} as a scale's open ends read it: over every finite
+ * value on a linear scale, and on a log scale over the positive ones, since a
+ * 0 or a negative met there would floor the domain at 1 and fold a domain
+ * below 1 flat. `[Infinity, -Infinity]` where the scale reads nothing.
+ */
+export function scaleExtent(values, count, scale, quantile = 1) {
+    if (scale !== 'log') {
+        return quantileExtent(values, count, quantile);
+    }
+    const positive = new Float32Array(count);
+    let np = 0;
+    for (let i = 0; i < count; i++) {
+        const v = values[i];
+        if (v > 0 && Number.isFinite(v)) {
+            positive[np++] = v;
+        }
+    }
+    return quantileExtent(positive, np, quantile);
+}

package/esm/util/range.d.ts

@@ -20,9 +20,15 @@ export declare function doesIntersect2(left1: number, right1: number, left2: num
 /**
  * Compute the expanded fetch range a tabix adapter must "redispatch" to when
  * features found in a query extend past the requested window. Returns the union
- * of the query with the bounds of every feature whose type is not in
- * `dontRedispatchSet`, or `undefined` when nothing extends past the query (no
- * redispatch needed).
+ * of the query with the bounds of every line `expands` admits, or `undefined`
+ * when nothing extends past the query (no redispatch needed).
+ *
+ * **A predicate, not a set of types**, because the useful question is not what a
+ * record is called. The bound exists to reach a record's *children*, so what
+ * disqualifies a record is having none — and in GFF3 that is answerable exactly,
+ * from whether the record carries an `ID` for a `Parent` to reference. A type
+ * blocklist can only ever approximate it, and it is the caller's format that
+ * knows how: this file reads no column but the coordinates.
  *
  * Feature coordinates arrive interbase, matching the query: @gmod/tabix applies
  * the index's coordinate offset before invoking the line callback, so a GFF/GTF
@@ -30,15 +36,13 @@ export declare function doesIntersect2(left1: number, right1: number, left2: num
  *
  * Seeding the accumulator with the query bounds is what makes the result a
  * union rather than just the feature bounds. A redispatch narrower than the
- * original window would drop a dontRedispatch-typed feature that the first
- * fetch found inside the query but that falls outside the expanded range, since
- * those types are deliberately excluded from the bounds.
+ * original window would drop an excluded line that the first fetch found inside
+ * the query but that falls outside the expanded range.
  */
-export declare function calculateRedispatchRange(features: {
+export declare function calculateRedispatchRange<T extends {
     start: number;
     end: number;
-    type: string;
-}[], dontRedispatchSet: Set<string>, queryStart: number, queryEnd: number): {
+}>(features: T[], expands: (feature: T) => boolean, queryStart: number, queryEnd: number): {
     start: number;
     end: number;
 } | undefined;

package/esm/util/range.js

@@ -45,9 +45,15 @@ export function doesIntersect2(left1, right1, left2, right2) {
 /**
  * Compute the expanded fetch range a tabix adapter must "redispatch" to when
  * features found in a query extend past the requested window. Returns the union
- * of the query with the bounds of every feature whose type is not in
- * `dontRedispatchSet`, or `undefined` when nothing extends past the query (no
- * redispatch needed).
+ * of the query with the bounds of every line `expands` admits, or `undefined`
+ * when nothing extends past the query (no redispatch needed).
+ *
+ * **A predicate, not a set of types**, because the useful question is not what a
+ * record is called. The bound exists to reach a record's *children*, so what
+ * disqualifies a record is having none — and in GFF3 that is answerable exactly,
+ * from whether the record carries an `ID` for a `Parent` to reference. A type
+ * blocklist can only ever approximate it, and it is the caller's format that
+ * knows how: this file reads no column but the coordinates.
  *
  * Feature coordinates arrive interbase, matching the query: @gmod/tabix applies
  * the index's coordinate offset before invoking the line callback, so a GFF/GTF
@@ -55,15 +61,18 @@ export function doesIntersect2(left1, right1, left2, right2) {
  *
  * Seeding the accumulator with the query bounds is what makes the result a
  * union rather than just the feature bounds. A redispatch narrower than the
- * original window would drop a dontRedispatch-typed feature that the first
- * fetch found inside the query but that falls outside the expanded range, since
- * those types are deliberately excluded from the bounds.
+ * original window would drop an excluded line that the first fetch found inside
+ * the query but that falls outside the expanded range.
  */
-export function calculateRedispatchRange(features, dontRedispatchSet, queryStart, queryEnd) {
+export function calculateRedispatchRange(features, expands, queryStart, queryEnd) {
     let minStart = queryStart;
     let maxEnd = queryEnd;
+    // bounds first: only a line reaching past the current bound can widen it, so
+    // the predicate, which may scan the line's text, runs on those few lines and
+    // not on every line in the window
     for (const feature of features) {
-        if (!dontRedispatchSet.has(feature.type)) {
+        if ((feature.start < minStart || feature.end > maxEnd) &&
+            expands(feature)) {
             if (feature.start < minStart) {
                 minStart = feature.start;
             }

package/esm/util/renameRegions.d.ts

@@ -1,21 +1,41 @@
 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';
 export declare function renameRegionIfNeeded(refNameMap: Record<string, string> | undefined, region: Region | Instance<typeof MUIRegion>, getSeqAdapterRefName?: (refName: string) => string): Region & {
     originalRefName?: string;
 };
-export declare function renameRegionsIfNeeded<ARGTYPE extends {
-    assemblyName?: string;
+interface RenameArgs {
     regions?: Region[];
-    stopToken?: StopToken;
+    signal?: AbortSignal;
     adapterConfig: Record<string, unknown>;
     sessionId: string;
     statusCallback?: StatusCallback;
-}>(assemblyManager: AssemblyManager, args: ARGTYPE): Promise<ARGTYPE & {
-    sequenceAdapter: Record<string, unknown> | undefined;
+}
+/**
+ * Rename for a request about one genome, which is every request but a
+ * comparative one. The call's genome is its regions' genome, and renaming
+ * writes it as the call's `assemblyName`, the one field a call names its
+ * genome in: `RpcMethodType.serializeArguments` turns it into the reference a
+ * BAM/CRAM or scan adapter is built with. A region on another assembly is
+ * refused: a request over a synteny adapter renames with
+ * {@link renameComparativeRegions}.
+ */
+export declare function renameRegionsIfNeeded<ARGTYPE extends RenameArgs>(assemblyManager: AssemblyManager, args: ARGTYPE): Promise<ARGTYPE & {
+    assemblyName: string | undefined;
     regions: (Region & {
         originalRefName?: string;
     })[];
 }>;
+/**
+ * Rename for a comparative request (synteny, dotplot, chords), whose regions
+ * sit on two or more assemblies and are each renamed against their own. Such a
+ * request has no genome of its own, so it names none and no reference rides
+ * on it; a synteny adapter reads no reference.
+ */
+export declare function renameComparativeRegions<ARGTYPE extends RenameArgs>(assemblyManager: AssemblyManager, args: ARGTYPE): Promise<ARGTYPE & {
+    regions: (Region & {
+        originalRefName?: string;
+    })[];
+}>;
+export {};