@jbrowse/core 4.3.0 → 5.0.0-beta.10

package/esm/util/binnedAggregate.js

@@ -0,0 +1,275 @@
+// The interval `bin` and the `aggregate` behind it as one kernel, which
+// `runSteps` in featureTransforms.ts reaches by relative path only.
+import { readerOf } from './featureTable.js';
+import { isPlainFieldRef } from './fieldReader.js';
+import { isJexl } from './jexlStrings.js';
+import { BIN_OVERLAP_FIELD, DEFAULT_BIN_AS, OpSums, binSize, groupKey, intervalsOf, isWeighted, madeGroups, stepNumberReader, } from './stepTables.js';
+/**
+ * The bin's edges and `overlap` a piece carries, where an `aggregate` reads a
+ * field off a piece: the row's own field where the bin wrote none. A later
+ * entry of the bin's written fields shadows an earlier one of the same name,
+ * as the piece table's columns do.
+ */
+const FROM_ROW = 0;
+const FROM_BIN_START = 1;
+const FROM_BIN_END = 2;
+const FROM_OVERLAP = 3;
+function pieceSource(field, [asStart, asEnd]) {
+    return field === BIN_OVERLAP_FIELD
+        ? FROM_OVERLAP
+        : field === asEnd
+            ? FROM_BIN_END
+            : field === asStart
+                ? FROM_BIN_START
+                : FROM_ROW;
+}
+function pick(source, row, lo, hi, overlap) {
+    return source === FROM_ROW
+        ? row
+        : source === FROM_BIN_START
+            ? lo
+            : source === FROM_BIN_END
+                ? hi
+                : overlap;
+}
+/**
+ * Whether an interval `bin` and the `aggregate` behind it run as one kernel:
+ * the aggregate groups by the bin's two edges, and every field it reads is a
+ * plain name, so a piece's value is its row's or one the bin wrote.
+ */
+export function fusesBinAggregate(bin, agg) {
+    const as = bin.as ?? DEFAULT_BIN_AS;
+    const groupby = agg.groupby ?? [];
+    const plain = (field) => field === undefined || (isPlainFieldRef(field) && !isJexl(field));
+    return (bin.fields !== undefined &&
+        as[0] !== as[1] &&
+        groupby.length === 2 &&
+        as.every(edge => groupby.includes(edge)) &&
+        as.every(plain) &&
+        agg.ops.every(op => plain(op.field) && plain(op.weight)));
+}
+// Beyond this many bins over the pieces a dense bin index costs more than the
+// pieces would, and the two steps run as written.
+const SPARSE_BINS_PER_PIECE = 2;
+const SPARSE_BINS_SLACK = 65536;
+/**
+ * An interval `bin` and the `aggregate` grouped by its edges as one walk: each
+ * row's bins accumulate straight into their group's sums, with no piece table,
+ * the way `binRawRegion` bins a BigWig's raw section. The groups come out in
+ * the order the pieces would have met them and each sum adds its pieces in
+ * the pieces' order, so the answer is the two steps' to the bit. Undefined
+ * where the bins spread too thinly over the region for a dense index.
+ */
+export function binnedAggregate({ table, bounds }, bin, agg) {
+    const size = binSize(bin);
+    const as = bin.as ?? DEFAULT_BIN_AS;
+    const iv = intervalsOf(table, bin.fields, size, bounds);
+    const { lowBin, highBin } = iv;
+    const sections = bounds.length - 1;
+    // Each section's bins from its lowest, at `offset[s]` in one index.
+    const offset = new Float64Array(sections + 1);
+    for (let s = 0; s < sections; s++) {
+        const span = highBin[s] - lowBin[s] + 1;
+        offset[s + 1] = offset[s] + (span > 0 ? span : 0);
+    }
+    const spans = offset[sections];
+    if (spans > SPARSE_BINS_PER_PIECE * iv.pieces + SPARSE_BINS_SLACK) {
+        return undefined;
+    }
+    const capacity = Math.min(spans, iv.pieces);
+    const groupOfBin = new Int32Array(spans).fill(-1);
+    const groupRow = new Uint32Array(capacity);
+    const groupBin = new Float64Array(capacity);
+    const groupSection = new Uint32Array(capacity);
+    const start = new Float64Array(capacity);
+    const end = new Float64Array(capacity);
+    const startSource = pieceSource('start', as);
+    const endSource = pieceSource('end', as);
+    // A group's extent is its bin's where the pieces' start and end are the
+    // bin's edges, the least and greatest of its pieces' otherwise.
+    const binExtent = startSource === FROM_BIN_START && endSource === FROM_BIN_END;
+    const readRowStart = readerOf(table.column('start'));
+    const readRowEnd = readerOf(table.column('end'));
+    const groups = numberGroups({ iv, bounds, size, lowBin, offset, groupOfBin }, { groupRow, groupBin, groupSection, start, end }, binExtent
+        ? undefined
+        : { startSource, endSource, readRowStart, readRowEnd });
+    const walk = { iv, bounds, size, lowBin, offset, groupOfBin };
+    const ops = agg.ops.map(op => {
+        const sums = new OpSums(op, groups);
+        const valueSource = op.op === 'count' || op.field === undefined
+            ? undefined
+            : pieceSource(op.field, as);
+        const weightSource = op.weight !== undefined && isWeighted(op)
+            ? pieceSource(op.weight, as)
+            : undefined;
+        const rowNumbers = (field, source) => field !== undefined && source === FROM_ROW
+            ? stepNumberReader(table, field, 'an aggregate')
+            : undefined;
+        const readValue = rowNumbers(op.field, valueSource);
+        const readWeight = rowNumbers(op.weight, weightSource);
+        if ((valueSource === undefined || readValue) &&
+            (weightSource === undefined ||
+                readWeight ||
+                weightSource === FROM_OVERLAP)) {
+            addByRow(walk, sums, readValue, readWeight, weightSource === FROM_OVERLAP);
+        }
+        else {
+            addByPiece(walk, sums, valueSource, weightSource, readValue, readWeight);
+        }
+        return sums.column(groups);
+    });
+    // A field's value on each group's first piece.
+    const each = (field) => {
+        const source = pieceSource(field, as);
+        const read = readerOf(table.column(field));
+        const out = new Array(groups);
+        for (let g = 0; g < groups; g++) {
+            const i = groupRow[g];
+            const lo = groupBin[g] * size;
+            const hi = lo + size;
+            out[g] =
+                source === FROM_ROW
+                    ? read(i)
+                    : pick(source, 0, lo, hi, Math.min(iv.end[i], hi) - Math.max(iv.start[i], lo));
+        }
+        return out;
+    };
+    return madeGroups({
+        groups,
+        keys: (agg.groupby ?? []).map((field) => [
+            field,
+            each(field).map(groupKey),
+        ]),
+        ops,
+        step: agg,
+        refNames: each('refName'),
+        start: start.slice(0, groups),
+        end: end.slice(0, groups),
+        sectionOf: groupSection,
+        sections: bounds.length,
+    });
+}
+/**
+ * Each bin's group, numbered in the order the pieces meet them, with the
+ * first piece's row, the bin and the section, and each group's extent: its
+ * bin's, or the least start and greatest end its pieces read where `extent`
+ * says where they read them. Answers how many groups there are.
+ */
+function numberGroups({ iv, bounds, size, lowBin, offset, groupOfBin }, out, extent) {
+    const { groupRow, groupBin, groupSection, start, end } = out;
+    let groups = 0;
+    for (let s = 0; s + 1 < bounds.length; s++) {
+        const base = offset[s] - lowBin[s];
+        for (let i = bounds[s]; i < bounds[s + 1]; i++) {
+            const first = iv.first[i];
+            if (Number.isNaN(first)) {
+                continue;
+            }
+            const last = iv.last[i];
+            for (let b = first; b <= last; b++) {
+                let g = groupOfBin[base + b];
+                if (g < 0) {
+                    g = groups++;
+                    groupOfBin[base + b] = g;
+                    groupRow[g] = i;
+                    groupBin[g] = b;
+                    groupSection[g] = s;
+                    start[g] = b * size;
+                    end[g] = b * size + size;
+                }
+            }
+        }
+    }
+    if (extent) {
+        start.fill(Infinity);
+        end.fill(-Infinity);
+        const { startSource, endSource, readRowStart, readRowEnd } = extent;
+        for (let s = 0; s + 1 < bounds.length; s++) {
+            const base = offset[s] - lowBin[s];
+            for (let i = bounds[s]; i < bounds[s + 1]; i++) {
+                const first = iv.first[i];
+                if (Number.isNaN(first)) {
+                    continue;
+                }
+                const ownStart = readRowStart(i);
+                const ownEnd = readRowEnd(i);
+                for (let b = first; b <= iv.last[i]; b++) {
+                    const g = groupOfBin[base + b];
+                    const lo = b * size;
+                    const hi = lo + size;
+                    const overlap = Math.min(iv.end[i], hi) - Math.max(iv.start[i], lo);
+                    start[g] = Math.min(start[g], pick(startSource, ownStart, lo, hi, overlap));
+                    end[g] = Math.max(end[g], pick(endSource, ownEnd, lo, hi, overlap));
+                }
+            }
+        }
+    }
+    return groups;
+}
+/**
+ * One op's sums where its value is its row's and its weight its row's, its
+ * piece's overlap or none: a row whose value or weight is not a number adds
+ * nothing to any bin, so it is skipped whole. A piece's overlap is always a
+ * number, since the row's ends are.
+ */
+function addByRow({ iv, bounds, size, lowBin, offset, groupOfBin }, { sum, weight, min, max, op }, readValue, readWeight, byOverlap) {
+    const readsValue = op !== 'count';
+    for (let s = 0; s + 1 < bounds.length; s++) {
+        const base = offset[s] - lowBin[s];
+        for (let i = bounds[s]; i < bounds[s + 1]; i++) {
+            const first = iv.first[i];
+            const v = readValue ? readValue(i) : Number.NaN;
+            const rowWeight = readWeight ? readWeight(i) : 1;
+            if (Number.isNaN(first) ||
+                (readsValue && !Number.isFinite(v)) ||
+                !Number.isFinite(rowWeight)) {
+                continue;
+            }
+            const rowS = iv.start[i];
+            const rowE = iv.end[i];
+            const last = iv.last[i];
+            for (let b = first; b <= last; b++) {
+                const g = groupOfBin[base + b];
+                const lo = b * size;
+                const w = byOverlap
+                    ? Math.min(rowE, lo + size) - Math.max(rowS, lo)
+                    : rowWeight;
+                weight[g] += w;
+                if (readsValue) {
+                    sum[g] += v * w;
+                    if (v < min[g]) {
+                        min[g] = v;
+                    }
+                    if (v > max[g]) {
+                        max[g] = v;
+                    }
+                }
+            }
+        }
+    }
+}
+/** One op's sums where its value or weight is a field the bin wrote. */
+function addByPiece({ iv, bounds, size, lowBin, offset, groupOfBin }, sums, valueSource, weightSource, readValue, readWeight) {
+    for (let s = 0; s + 1 < bounds.length; s++) {
+        const base = offset[s] - lowBin[s];
+        for (let i = bounds[s]; i < bounds[s + 1]; i++) {
+            const first = iv.first[i];
+            if (Number.isNaN(first)) {
+                continue;
+            }
+            const rowV = readValue ? readValue(i) : Number.NaN;
+            const rowW = readWeight ? readWeight(i) : 1;
+            const last = iv.last[i];
+            for (let b = first; b <= last; b++) {
+                const lo = b * size;
+                const hi = lo + size;
+                const overlap = Math.min(iv.end[i], hi) - Math.max(iv.start[i], lo);
+                sums.add(groupOfBin[base + b], valueSource === undefined
+                    ? Number.NaN
+                    : pick(valueSource, rowV, lo, hi, overlap), weightSource === undefined
+                    ? 1
+                    : pick(weightSource, rowW, lo, hi, overlap));
+            }
+        }
+    }
+}

package/esm/util/blockTypes.d.ts

@@ -1,59 +1,78 @@
+interface BlockData {
+    key: string;
+    offsetPx: number;
+    widthPx: number;
+    assemblyName?: string;
+    refName?: string;
+    start?: number;
+    end?: number;
+    reversed?: boolean;
+    displayedRegionIndex?: number;
+    isLeftEndOfDisplayedRegion?: boolean;
+    isRightEndOfDisplayedRegion?: boolean;
+    variant?: 'boundary';
+}
+export interface ContentBlock extends BlockData {
+    type: 'ContentBlock';
+    assemblyName: string;
+    refName: string;
+    start: number;
+    end: number;
+}
+export interface ElidedBlock extends BlockData {
+    type: 'ElidedBlock';
+}
+export interface InterRegionPaddingBlock extends BlockData {
+    type: 'InterRegionPaddingBlock';
+}
+export type BaseBlock = ContentBlock | ElidedBlock | InterRegionPaddingBlock;
+/**
+ * A content block as a region that addresses whole bases.
+ *
+ * `calculateDynamicBlocks` says in its own docstring that start/end may be
+ * FRACTIONAL — a block is a span of screen, and the view is only at a whole
+ * base when the pan and the zoom both happen to land there. Anything naming
+ * bases rather than pixels needs this: a sequence fetch, a bookmark, and above
+ * all a locString, since `BP_QUANTITY_SOURCE` rejects a bare fractional
+ * coordinate on purpose ("a bare '1.5' as a coordinate is a mistake").
+ *
+ * `reversed` is dropped with the pixels. It orients a projection, and a region
+ * that has left the screen is not being projected; carrying it only reached
+ * `assembleLocString`, which spells it `[rev]` in a field the user is about to
+ * read.
+ */
+export declare function wholeBaseRegion(block: ContentBlock): {
+    assemblyName: string;
+    refName: string;
+    start: number;
+    end: number;
+};
+export declare function wholeBaseRegions(blocks: ContentBlock[]): {
+    assemblyName: string;
+    refName: string;
+    start: number;
+    end: number;
+}[];
 type Func<T> = (value: BaseBlock, index: number, array: BaseBlock[]) => T;
 export declare class BlockSet {
     blocks: BaseBlock[];
     constructor(blocks?: BaseBlock[]);
-    [Symbol.iterator](): Generator<BaseBlock, void, unknown>;
     push(block: BaseBlock): void;
-    getBlocks(): BaseBlock[];
-    getRegions(): {
-        refName: string;
-        start: number;
-        end: number;
-        assemblyName: string;
-        reversed: boolean | undefined;
-    }[];
+    /**
+     * Widen a trailing elided run by widthPx, reporting whether there was one to
+     * widen. `push` keeps nothing but the width off an ElidedBlock it merges, so
+     * a caller holding the width can skip building the block that would have
+     * carried it — which at whole-genome zoom is nearly every region, see
+     * calculateDynamicBlocks.
+     */
+    growElidedRun(widthPx: number): boolean;
     map<T, U = this>(func: Func<T>, thisarg?: U): T[];
     forEach<T, U = this>(func: Func<T>, thisarg?: U): void;
     get length(): number;
     get totalWidthPx(): number;
     get totalWidthPxWithoutBorders(): number;
     get offsetPx(): number;
-    get contentBlocks(): BaseBlock[];
+    get contentBlocks(): ContentBlock[];
     get totalBp(): number;
 }
-export declare class BaseBlock {
-    type: string;
-    regionNumber?: number;
-    reversed?: boolean;
-    refName: string;
-    start: number;
-    end: number;
-    assemblyName: string;
-    key: string;
-    offsetPx: number;
-    widthPx: number;
-    variant?: string;
-    isLeftEndOfDisplayedRegion?: boolean;
-    constructor(data: Record<string, any>);
-    toRegion(): {
-        refName: string;
-        start: number;
-        end: number;
-        assemblyName: string;
-        reversed: boolean | undefined;
-    };
-}
-export declare class ContentBlock extends BaseBlock {
-    type: string;
-}
-export declare class ElidedBlock extends BaseBlock {
-    type: string;
-    widthPx: number;
-    elidedBlockCount: number;
-    constructor(data: Record<string, any>);
-    push(otherBlock: ElidedBlock): void;
-}
-export declare class InterRegionPaddingBlock extends BaseBlock {
-    type: string;
-}
 export {};

package/esm/util/blockTypes.js

@@ -1,32 +1,77 @@
+/**
+ * A content block as a region that addresses whole bases.
+ *
+ * `calculateDynamicBlocks` says in its own docstring that start/end may be
+ * FRACTIONAL — a block is a span of screen, and the view is only at a whole
+ * base when the pan and the zoom both happen to land there. Anything naming
+ * bases rather than pixels needs this: a sequence fetch, a bookmark, and above
+ * all a locString, since `BP_QUANTITY_SOURCE` rejects a bare fractional
+ * coordinate on purpose ("a bare '1.5' as a coordinate is a mistake").
+ *
+ * `reversed` is dropped with the pixels. It orients a projection, and a region
+ * that has left the screen is not being projected; carrying it only reached
+ * `assembleLocString`, which spells it `[rev]` in a field the user is about to
+ * read.
+ */
+export function wholeBaseRegion(block) {
+    return {
+        assemblyName: block.assemblyName,
+        refName: block.refName,
+        start: Math.floor(block.start),
+        end: Math.ceil(block.end),
+    };
+}
+export function wholeBaseRegions(blocks) {
+    return blocks.map(wholeBaseRegion);
+}
+// A merged elided run can span several displayed regions, so its per-region
+// identity is meaningless: refName/start/end are cleared and only widthPx stays
+// valid. The leftover key, assemblyName, displayedRegionIndex,
+// isRightEndOfDisplayedRegion belong to the FIRST sub-block — don't key off them
+// for an ElidedBlock.
+function mergeElided(run, widthPx) {
+    run.refName = '';
+    run.start = 0;
+    run.end = 0;
+    run.widthPx += widthPx;
+}
 export class BlockSet {
     blocks;
     constructor(blocks = []) {
         this.blocks = blocks;
     }
-    *[Symbol.iterator]() {
-        yield* this.blocks;
-    }
     push(block) {
-        if (block.type === 'ElidedBlock' && this.blocks.length > 0) {
-            const lastBlock = this.blocks.at(-1);
-            if (lastBlock?.type === 'ElidedBlock') {
-                ;
-                lastBlock.push(block);
-                return;
-            }
+        const last = this.blocks.at(-1);
+        if (block.type === 'ElidedBlock' && last?.type === 'ElidedBlock') {
+            mergeElided(last, block.widthPx);
+        }
+        else {
+            this.blocks.push(block);
         }
-        this.blocks.push(block);
-    }
-    getBlocks() {
-        return this.blocks;
     }
-    getRegions() {
-        return this.blocks.map(block => block.toRegion());
+    /**
+     * Widen a trailing elided run by widthPx, reporting whether there was one to
+     * widen. `push` keeps nothing but the width off an ElidedBlock it merges, so
+     * a caller holding the width can skip building the block that would have
+     * carried it — which at whole-genome zoom is nearly every region, see
+     * calculateDynamicBlocks.
+     */
+    growElidedRun(widthPx) {
+        const last = this.blocks.at(-1);
+        if (last?.type !== 'ElidedBlock') {
+            return false;
+        }
+        mergeElided(last, widthPx);
+        return true;
     }
     map(func, thisarg) {
+        // deliberately mirrors Array#map's (callback, thisArg) signature
+        // eslint-disable-next-line unicorn/no-array-method-this-argument
         return this.blocks.map(func, thisarg);
     }
     forEach(func, thisarg) {
+        // deliberately mirrors Array#forEach's (callback, thisArg) signature
+        // eslint-disable-next-line unicorn/no-array-method-this-argument
         this.blocks.forEach(func, thisarg);
     }
     get length() {
@@ -52,68 +97,16 @@ export class BlockSet {
         return this.blocks.length > 0 ? this.blocks[0].offsetPx : 0;
     }
     get contentBlocks() {
-        return this.blocks.filter(block => block.type === 'ContentBlock');
+        return this.blocks.filter((block) => block.type === 'ContentBlock');
     }
     get totalBp() {
         let total = 0;
-        for (let i = 0, l = this.contentBlocks.length; i < l; i++) {
-            const b = this.contentBlocks[i];
-            total += b.end - b.start;
+        for (let i = 0, l = this.blocks.length; i < l; i++) {
+            const b = this.blocks[i];
+            if (b.type === 'ContentBlock') {
+                total += b.end - b.start;
+            }
         }
         return total;
     }
 }
-export class BaseBlock {
-    type = 'BaseBlock';
-    regionNumber;
-    reversed;
-    refName;
-    start;
-    end;
-    assemblyName;
-    key;
-    offsetPx;
-    widthPx = 0;
-    variant;
-    isLeftEndOfDisplayedRegion;
-    constructor(data) {
-        Object.assign(this, data);
-        this.assemblyName = data.assemblyName;
-        this.refName = data.refName;
-        this.start = data.start;
-        this.end = data.end;
-        this.key = data.key;
-        this.offsetPx = data.offsetPx;
-    }
-    toRegion() {
-        return {
-            refName: this.refName,
-            start: this.start,
-            end: this.end,
-            assemblyName: this.assemblyName,
-            reversed: this.reversed,
-        };
-    }
-}
-export class ContentBlock extends BaseBlock {
-    type = 'ContentBlock';
-}
-export class ElidedBlock extends BaseBlock {
-    type = 'ElidedBlock';
-    widthPx;
-    elidedBlockCount = 0;
-    constructor(data) {
-        super(data);
-        this.widthPx = data.widthPx;
-    }
-    push(otherBlock) {
-        this.elidedBlockCount += 1;
-        this.refName = '';
-        this.start = 0;
-        this.end = 0;
-        this.widthPx += otherBlock.widthPx;
-    }
-}
-export class InterRegionPaddingBlock extends BaseBlock {
-    type = 'InterRegionPaddingBlock';
-}

package/esm/util/bpUtils.d.ts

@@ -0,0 +1,81 @@
+import type { Region } from './types/data.ts';
+export interface MinimalRegion {
+    start: number;
+    end: number;
+    reversed?: boolean;
+}
+export declare function bpToPx(bp: number, { reversed, end, start, }: {
+    start?: number;
+    end?: number;
+    reversed?: boolean;
+}, bpPerPx: number): number;
+export declare function bpSpanPx(leftBp: number, rightBp: number, region: MinimalRegion, bpPerPx: number): readonly [number, number];
+export declare function featureSpanPx(feature: {
+    get: (key: string) => number;
+}, region: MinimalRegion, bpPerPx: number): readonly [number, number];
+export declare function getBpDisplayStr(total: number): string;
+/**
+ * The grammar of a single base-pair quantity, as a regex source fragment so
+ * that callers matching it in a larger pattern (a locString coordinate range,
+ * say) stay in step with {@link parseBpString}. Match case-insensitively.
+ *
+ * A decimal point is allowed only on the unit-suffixed alternative. That is
+ * deliberate: "1.5Mb" is a number a user means, whereas a bare "1.5" as a
+ * coordinate is a mistake, and it should stay an error rather than silently
+ * yielding a fractional coordinate.
+ */
+export declare const BP_QUANTITY_SOURCE: string;
+/**
+ * Parse a base-pair count written the way people type one: plain digits, with
+ * optional thousand separators, and with an optional metric unit suffix. So
+ * "150", "1,500", "1.5kb", "1.5k", "34Mb" and "2G" are all accepted.
+ *
+ * The unit's tail is loose because both "kb" and "k" are in common use, and
+ * because everything {@link getBpDisplayStr} prints has to come back in. The
+ * app shows a window size as "1.5Mbp" in the zoom slider tooltip and over a
+ * rubberband selection, so a user who reads one off the screen and types it
+ * into a bp field has typed a string this must accept.
+ *
+ * Returns undefined, rather than NaN or a throw, when the string is not a bp
+ * quantity, so that callers validating a text field can test it directly.
+ */
+export declare function parseBpString(str: string): number | undefined;
+export declare function getTickDisplayStr(totalBp: number, bpPerPx: number): string;
+interface VirtualOffset {
+    blockPosition: number;
+    dataPosition?: number;
+}
+interface Block {
+    minv: VirtualOffset;
+    maxv: VirtualOffset;
+    /**
+     * Bytes this block's fetch actually reads. @gmod/tabix and @gmod/bam compute
+     * it from an `endPosition` that `clampChunkEnds` has tightened down to the
+     * next known BGZF block boundary, so it is materially smaller than the
+     * full-block padding the fallback below has to assume.
+     */
+    fetchedSize?: () => number;
+}
+/**
+ * Index-only estimate of the bytes a fetch of these regions would download.
+ *
+ * Prefers each block's own `fetchedSize()`. The fallback —
+ * `maxv + 65535 - minv` — has to pad by a whole maximum-size BGZF block,
+ * because the compressed length of the block at `maxv` is not recorded in the
+ * index; it is what this did for every block before the parsers exposed a
+ * tightened figure, and it over-estimates.
+ *
+ * Blocks are also de-duplicated across regions. Two adjacent regions routinely
+ * resolve to the same chunk, and it is downloaded once, so counting it twice
+ * inflated the estimate for exactly the multi-region queries this gates.
+ *
+ * Note @gmod/tabix's own `TabixIndexedFile.bytesForRegions` is strictly better
+ * still — it runs the chunk merger over the combined set, so it also collapses
+ * *overlapping* blocks rather than only identical ones — and every tabix
+ * adapter in this repo calls that instead. This remains for other index shapes
+ * and for plugins outside the repo, which reach it through `@jbrowse/core/util`.
+ */
+export declare function bytesForRegions(regions: Region[], index: {
+    blocksForRange: (ref: string, start: number, end: number) => Promise<Block[]>;
+}): Promise<number>;
+export {};