@jbrowse/core 4.3.0 → 5.0.0-beta.2

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 {};

package/esm/util/bpUtils.js

@@ -0,0 +1,103 @@
+import { reducePrecision, sum, toLocale, toPrecision } from './numericUtils.js';
+function roundToNearestPointOne(num) {
+    return Math.round(num * 10) / 10;
+}
+export function bpToPx(bp, { reversed, end = 0, start = 0, }, bpPerPx) {
+    return roundToNearestPointOne((reversed ? end - bp : bp - start) / bpPerPx);
+}
+export function bpSpanPx(leftBp, rightBp, region, bpPerPx) {
+    const start = bpToPx(leftBp, region, bpPerPx);
+    const end = bpToPx(rightBp, region, bpPerPx);
+    return region.reversed ? [end, start] : [start, end];
+}
+export function featureSpanPx(feature, region, bpPerPx) {
+    return bpSpanPx(feature.get('start'), feature.get('end'), region, bpPerPx);
+}
+export function getBpDisplayStr(total) {
+    // the unit comes from the rounded value, not the raw one: 3-significant-digit
+    // rounding of 999,500bp reaches 1000, which reads as "1Mbp" not "1,000Kbp"
+    const mb = toPrecision(total / 1_000_000);
+    return mb >= 1
+        ? `${toLocale(mb)}Mbp`
+        : total >= 1000
+            ? `${reducePrecision(total / 1_000)}Kbp`
+            : `${Math.floor(total)}bp`;
+}
+const BP_UNITS = {
+    k: 1_000,
+    m: 1_000_000,
+    g: 1_000_000_000,
+};
+/**
+ * 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 const BP_QUANTITY_SOURCE = String.raw `(?:-?\d+(?:\.\d+)?[kmg](?:bp?)?|-?\d+(?:bp)?)`;
+const BP_QUANTITY_REGEX = new RegExp(String.raw `^(?:(-?\d+(?:\.\d+)?)([kmg])(?:bp?)?|(-?\d+)(?:bp)?)$`, 'i');
+/**
+ * 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 function parseBpString(str) {
+    const match = BP_QUANTITY_REGEX.exec(str.replaceAll(',', ''));
+    if (!match) {
+        return undefined;
+    }
+    const [, scaled, unit, plain] = match;
+    return plain === undefined
+        ? // rounded because the scaled value can land off an integer ("1.0000001M"),
+            // and a coordinate is a whole number of bases
+            Math.round(+scaled * BP_UNITS[unit.toLowerCase()])
+        : +plain;
+}
+export function getTickDisplayStr(totalBp, bpPerPx) {
+    return Math.floor(bpPerPx / 1_000) > 0
+        ? `${toLocale(Number.parseFloat((totalBp / 1_000_000).toFixed(2)))}M`
+        : toLocale(Math.floor(totalBp));
+}
+/**
+ * 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 async function bytesForRegions(regions, index) {
+    const blockResults = await Promise.all(regions.map(r => index.blocksForRange(r.refName, r.start, r.end)));
+    const seen = new Map();
+    for (const block of blockResults.flat()) {
+        const { minv, maxv } = block;
+        seen.set(`${minv.blockPosition}:${minv.dataPosition ?? 0}-${maxv.blockPosition}:${maxv.dataPosition ?? 0}`, block);
+    }
+    return sum([...seen.values()].map(block => block.fetchedSize
+        ? block.fetchedSize()
+        : block.maxv.blockPosition + 65535 - block.minv.blockPosition));
+}

package/esm/util/cacheBudgets.d.ts

@@ -0,0 +1,55 @@
+import { SharedBudget } from '@gmod/shared-read-cache';
+/**
+ * The ceiling on what the indexed-format libraries retain, shared by every
+ * adapter in this JS context — so one per RPC worker, plus one on the main
+ * thread, which is the scope that actually runs out of memory.
+ *
+ * ## Why this is not per file
+ *
+ * `@gmod/bam`, `@gmod/tabix` and `@gmod/cram` each take a per-file budget,
+ * sized so that a single track panning never falls off the cliff where a cache
+ * smaller than one query's working set stops caching entirely (`@gmod/bam` ADR
+ * 0014). But `dataAdapterCache` holds one adapter — and so one `BamFile`, one
+ * `TabixIndexedFile`, one `IndexedCramFile` — per open track for the life of
+ * that track, so a per-file ceiling is multiplied by the track count and
+ * nothing bounds the sum.
+ *
+ * Measured in `@gmod/bam` ADR 0018: three moderately deep alignments tracks
+ * browsing eight windows retained 1109 MB at 1665 MB RSS, still climbing, with
+ * **every cache well under its own 1 GB ceiling** — so the ceiling was not what
+ * held the line, and nothing else was either. Six tracks reached 1442 MB. The
+ * idle timeouts cannot help here by construction: they reclaim what has gone
+ * quiet, and nothing is quiet while the reader is browsing.
+ *
+ * Dividing each library's ceiling by the track count is the obvious fix and it
+ * is worse than doing nothing: at 128 MB per file — eight tracks under a
+ * gigabyte — the same workload cost 101 refills on the revisit against 98 for
+ * the cold pass. A shared budget has no such failure, because a member yields
+ * only what is globally least-recently-used: tracks the reader is not looking
+ * at hand their space to the one being panned, so the active track keeps a
+ * whole working set however many are open.
+ *
+ * ## The number is not new
+ *
+ * 1 GB is the libraries' own per-file default (`DEFAULT_MAX_CACHE_BYTES` in
+ * both `@gmod/bam` and `@gmod/cram`), moved from per-file to per-context. That
+ * makes this a strict tightening — retention can only fall — and avoids
+ * inventing a number that would need its own justification. With one file open
+ * the two ceilings coincide; from the second file on, this one is the one that
+ * binds. The budget still has to clear one query's working set or the cliff
+ * returns, and on that workload 512 MB shared across three tracks already cost
+ * 43 refills where 1 GB cost 4.
+ *
+ * ## One budget, because every member weighs bytes
+ *
+ * `SharedBudget.total` is a sum over its members, so they must all weigh in the
+ * same unit, and `sizeOf` is opaque, so nothing could catch a mismatch at
+ * runtime. `@gmod/bam` and `@gmod/tabix` weigh decompressed bytes, and since 14
+ * `@gmod/cram` weighs a decoded slice by `DecodedSlice.byteLength` — its typed
+ * columns exactly and its strings by estimate, within 1–8% of the measured heap
+ * (its ADR 0013). Before that a CRAM slice weighed its record count, which is
+ * why this used to be two budgets named for their units: a million records
+ * could not be added to bytes, and never bound long-read data either, where a
+ * 6 MB slice counted as 37.
+ */
+export declare const decompressedBytesBudget: SharedBudget;

package/esm/util/cacheBudgets.js

@@ -0,0 +1,55 @@
+import { SharedBudget } from '@gmod/shared-read-cache';
+/**
+ * The ceiling on what the indexed-format libraries retain, shared by every
+ * adapter in this JS context — so one per RPC worker, plus one on the main
+ * thread, which is the scope that actually runs out of memory.
+ *
+ * ## Why this is not per file
+ *
+ * `@gmod/bam`, `@gmod/tabix` and `@gmod/cram` each take a per-file budget,
+ * sized so that a single track panning never falls off the cliff where a cache
+ * smaller than one query's working set stops caching entirely (`@gmod/bam` ADR
+ * 0014). But `dataAdapterCache` holds one adapter — and so one `BamFile`, one
+ * `TabixIndexedFile`, one `IndexedCramFile` — per open track for the life of
+ * that track, so a per-file ceiling is multiplied by the track count and
+ * nothing bounds the sum.
+ *
+ * Measured in `@gmod/bam` ADR 0018: three moderately deep alignments tracks
+ * browsing eight windows retained 1109 MB at 1665 MB RSS, still climbing, with
+ * **every cache well under its own 1 GB ceiling** — so the ceiling was not what
+ * held the line, and nothing else was either. Six tracks reached 1442 MB. The
+ * idle timeouts cannot help here by construction: they reclaim what has gone
+ * quiet, and nothing is quiet while the reader is browsing.
+ *
+ * Dividing each library's ceiling by the track count is the obvious fix and it
+ * is worse than doing nothing: at 128 MB per file — eight tracks under a
+ * gigabyte — the same workload cost 101 refills on the revisit against 98 for
+ * the cold pass. A shared budget has no such failure, because a member yields
+ * only what is globally least-recently-used: tracks the reader is not looking
+ * at hand their space to the one being panned, so the active track keeps a
+ * whole working set however many are open.
+ *
+ * ## The number is not new
+ *
+ * 1 GB is the libraries' own per-file default (`DEFAULT_MAX_CACHE_BYTES` in
+ * both `@gmod/bam` and `@gmod/cram`), moved from per-file to per-context. That
+ * makes this a strict tightening — retention can only fall — and avoids
+ * inventing a number that would need its own justification. With one file open
+ * the two ceilings coincide; from the second file on, this one is the one that
+ * binds. The budget still has to clear one query's working set or the cliff
+ * returns, and on that workload 512 MB shared across three tracks already cost
+ * 43 refills where 1 GB cost 4.
+ *
+ * ## One budget, because every member weighs bytes
+ *
+ * `SharedBudget.total` is a sum over its members, so they must all weigh in the
+ * same unit, and `sizeOf` is opaque, so nothing could catch a mismatch at
+ * runtime. `@gmod/bam` and `@gmod/tabix` weigh decompressed bytes, and since 14
+ * `@gmod/cram` weighs a decoded slice by `DecodedSlice.byteLength` — its typed
+ * columns exactly and its strings by estimate, within 1–8% of the measured heap
+ * (its ADR 0013). Before that a CRAM slice weighed its record count, which is
+ * why this used to be two budgets named for their units: a million records
+ * could not be added to bytes, and never bound long-read data either, where a
+ * 6 MB slice counted as 37.
+ */
+export const decompressedBytesBudget = new SharedBudget(1024 * 2 ** 20);

package/esm/util/cachedSetup.d.ts

@@ -0,0 +1,51 @@
+import type { BaseOptions } from '../data_adapters/BaseAdapter/types.ts';
+/** byte-granularity progress reporter to hand an index reader's `onProgress` */
+type OnProgress = (current: number, total?: number) => void;
+/**
+ * Memoize an adapter's one-time setup (open the file, read the header, build a
+ * parser, download and parse a whole file) into a loader every method can
+ * await.
+ *
+ * Four behaviors, each of which a hand-rolled `p ??= f().catch(...)` gets wrong
+ * in a way that is invisible until it isn't:
+ *
+ * - **A rejected setup clears the memo**, so the next call retries instead of
+ *   replaying the same rejection for the life of the adapter.
+ * - **Progress fans out to every live waiter.** The setup body reports to
+ *   whoever is *currently* awaiting it, not to whoever happened to start it. A
+ *   memo that captured the first caller's `statusCallback` went silent the
+ *   moment that fetch was superseded — the display's latest-wins guard gates the
+ *   old callback off — so the fetch replacing it awaited a multi-GB parse behind
+ *   a blank loading overlay.
+ * - **`stopToken` is withheld from the shared work.** Honoring one caller's
+ *   cancel would abort a parse the caller replacing it is already waiting on,
+ *   and reject them both. A superseded fetch just stops listening. Cancellation
+ *   stays with the per-call work (indexed range queries), which no one else is
+ *   waiting on.
+ * - **`label` is shown only while the *first* attempt is in flight.** Re-entry
+ *   on pan/zoom (every getFeatures and byte estimate awaits the loader) would
+ *   otherwise re-flash "Downloading index" over an index that is already
+ *   resident.
+ *
+ * Pass `label` when the setup is an index read that narrates nothing itself, so
+ * the label is the whole story. Omit it when the setup reports from the inside —
+ * a whole-file fetch driving its own download bar — since two labels for one
+ * download is worse than one, and phases nest (see `openPhase` in progress.ts).
+ * `onProgress` is for handing to an index reader that can upgrade the label to a
+ * determinate bar.
+ */
+export declare function cachedSetup<T>({ setup, label, }: {
+    setup: (opts: BaseOptions, onProgress?: OnProgress) => Promise<T>;
+    label?: string;
+}): (opts?: BaseOptions) => Promise<T>;
+/**
+ * {@link cachedSetup} taking a bare function instead of an options object.
+ *
+ * Kept because it is a published `@jbrowse/core/util` export and so pinned ABI
+ * (see reference/PLUGIN_ABI_STABILITY.md); nothing in this repo calls it. It
+ * used to be a second implementation, which is the thing worth not having: two
+ * memos with the same shape and different answers about whose `statusCallback`
+ * the shared work reports to, and no one place saying which to reach for.
+ */
+export declare function createSharedSetup<T>(run: (opts: BaseOptions) => Promise<T>): (opts?: BaseOptions) => Promise<T>;
+export {};

package/esm/util/cachedSetup.js

@@ -0,0 +1,87 @@
+import { downloadStatus } from './progress.js';
+/**
+ * Memoize an adapter's one-time setup (open the file, read the header, build a
+ * parser, download and parse a whole file) into a loader every method can
+ * await.
+ *
+ * Four behaviors, each of which a hand-rolled `p ??= f().catch(...)` gets wrong
+ * in a way that is invisible until it isn't:
+ *
+ * - **A rejected setup clears the memo**, so the next call retries instead of
+ *   replaying the same rejection for the life of the adapter.
+ * - **Progress fans out to every live waiter.** The setup body reports to
+ *   whoever is *currently* awaiting it, not to whoever happened to start it. A
+ *   memo that captured the first caller's `statusCallback` went silent the
+ *   moment that fetch was superseded — the display's latest-wins guard gates the
+ *   old callback off — so the fetch replacing it awaited a multi-GB parse behind
+ *   a blank loading overlay.
+ * - **`stopToken` is withheld from the shared work.** Honoring one caller's
+ *   cancel would abort a parse the caller replacing it is already waiting on,
+ *   and reject them both. A superseded fetch just stops listening. Cancellation
+ *   stays with the per-call work (indexed range queries), which no one else is
+ *   waiting on.
+ * - **`label` is shown only while the *first* attempt is in flight.** Re-entry
+ *   on pan/zoom (every getFeatures and byte estimate awaits the loader) would
+ *   otherwise re-flash "Downloading index" over an index that is already
+ *   resident.
+ *
+ * Pass `label` when the setup is an index read that narrates nothing itself, so
+ * the label is the whole story. Omit it when the setup reports from the inside —
+ * a whole-file fetch driving its own download bar — since two labels for one
+ * download is worse than one, and phases nest (see `openPhase` in progress.ts).
+ * `onProgress` is for handing to an index reader that can upgrade the label to a
+ * determinate bar.
+ */
+export function cachedSetup({ setup, label, }) {
+    const waiting = new Set();
+    let cached;
+    let ready = false;
+    const run = (opts, onProgress) => {
+        cached ??= setup({
+            ...opts,
+            stopToken: undefined,
+            statusCallback: status => {
+                for (const cb of waiting) {
+                    cb(status);
+                }
+            },
+        }, onProgress)
+            .then(result => {
+            ready = true;
+            return result;
+        })
+            .catch((e) => {
+            cached = undefined;
+            throw e;
+        });
+        return cached;
+    };
+    return async (opts = {}) => {
+        const { statusCallback } = opts;
+        if (statusCallback) {
+            waiting.add(statusCallback);
+        }
+        try {
+            return await (label === undefined || ready
+                ? run(opts)
+                : downloadStatus(label, statusCallback, onProgress => run(opts, onProgress)));
+        }
+        finally {
+            if (statusCallback) {
+                waiting.delete(statusCallback);
+            }
+        }
+    };
+}
+/**
+ * {@link cachedSetup} taking a bare function instead of an options object.
+ *
+ * Kept because it is a published `@jbrowse/core/util` export and so pinned ABI
+ * (see reference/PLUGIN_ABI_STABILITY.md); nothing in this repo calls it. It
+ * used to be a second implementation, which is the thing worth not having: two
+ * memos with the same shape and different answers about whose `statusCallback`
+ * the shared work reports to, and no one place saying which to reach for.
+ */
+export function createSharedSetup(run) {
+    return cachedSetup({ setup: run });
+}

package/esm/util/calculateDynamicBlocks.d.ts

@@ -1,3 +1,8 @@
 import { BlockSet } from './blockTypes.ts';
 import type { Base1DViewModel } from './calculateStaticBlocks.ts';
+/**
+ * Returns a BlockSet covering only the regions currently visible in the view.
+ * Used by tracks where static blocks are not feasible. start/end/offsetPx may
+ * be fractional.
+ */
 export default function calculateDynamicBlocks(model: Base1DViewModel, padding?: boolean, elision?: boolean): BlockSet;

package/esm/util/calculateDynamicBlocks.js

@@ -1,104 +1,107 @@
-import { getSnapshot, isStateTreeNode } from '@jbrowse/mobx-state-tree';
-import { BlockSet, ContentBlock, ElidedBlock, InterRegionPaddingBlock, } from "./blockTypes.js";
-import { assembleLocStringFast } from "./index.js";
-import { intersection2 } from "./range.js";
+import { BlockSet } from './blockTypes.js';
+import { intersection2 } from './range.js';
+/**
+ * Returns a BlockSet covering only the regions currently visible in the view.
+ * Used by tracks where static blocks are not feasible. start/end/offsetPx may
+ * be fractional.
+ */
 export default function calculateDynamicBlocks(model, padding = true, elision = true) {
-    const { offsetPx, displayedRegions, bpPerPx, width, minimumBlockWidth, interRegionPaddingWidth, } = model;
-    if (!width) {
-        throw new Error('view has no width, cannot calculate displayed blocks');
-    }
+    const { offsetPx, displayedRegions, bpPerPx, width, minimumBlockWidth } = model;
+    // A zero-width view yields an empty BlockSet: intersection2 rejects the
+    // degenerate window, so the loop pushes nothing. Mirrors calculateStaticBlocks
+    // rather than throwing inside what callers read as a MobX computed.
     const invBpPerPx = 1 / bpPerPx;
     const blocks = new BlockSet();
     let displayedRegionLeftPx = 0;
     const windowLeftPx = offsetPx;
     const windowRightPx = windowLeftPx + width;
-    for (let regionNumber = 0; regionNumber < displayedRegions.length; regionNumber++) {
-        const region = displayedRegions[regionNumber];
-        const { assemblyName, refName, start: regionStart, end: regionEnd, reversed, } = region;
-        const displayedRegionRightPx = displayedRegionLeftPx + (regionEnd - regionStart) * invBpPerPx;
+    const lastRegionIndex = displayedRegions.length - 1;
+    for (let displayedRegionIndex = 0; displayedRegionIndex < displayedRegions.length; displayedRegionIndex++) {
+        // see calculateStaticBlocks: regions are laid out left to right, so nothing
+        // past the window's right edge can intersect it
+        if (displayedRegionLeftPx > windowRightPx) {
+            break;
+        }
+        const region = displayedRegions[displayedRegionIndex];
+        const { start: regionStart, end: regionEnd, reversed } = region;
         const regionWidthPx = (regionEnd - regionStart) * invBpPerPx;
-        const parentRegion = isStateTreeNode(region) ? getSnapshot(region) : region;
+        const displayedRegionRightPx = displayedRegionLeftPx + regionWidthPx;
         const [leftPx, rightPx] = intersection2(windowLeftPx, windowRightPx, displayedRegionLeftPx, displayedRegionRightPx);
         if (leftPx !== undefined && rightPx !== undefined) {
-            let start;
-            let end;
-            let isLeftEndOfDisplayedRegion;
-            let isRightEndOfDisplayedRegion;
-            let blockOffsetPx;
-            if (reversed) {
-                start = Math.max(regionStart, regionEnd - (rightPx - displayedRegionLeftPx) * bpPerPx);
-                end = regionEnd - (leftPx - displayedRegionLeftPx) * bpPerPx;
-                isLeftEndOfDisplayedRegion = end === regionEnd;
-                isRightEndOfDisplayedRegion = start === regionStart;
-                blockOffsetPx = displayedRegionLeftPx + (regionEnd - end) * invBpPerPx;
-            }
-            else {
-                start = (leftPx - displayedRegionLeftPx) * bpPerPx + regionStart;
-                end = Math.min(regionEnd, (rightPx - displayedRegionLeftPx) * bpPerPx + regionStart);
-                isLeftEndOfDisplayedRegion = start === regionStart;
-                isRightEndOfDisplayedRegion = end === regionEnd;
-                blockOffsetPx =
-                    displayedRegionLeftPx + (start - regionStart) * invBpPerPx;
-            }
+            // bp spanned between the region's left edge and the clipped block edges
+            const leftBp = (leftPx - displayedRegionLeftPx) * bpPerPx;
+            const rightBp = (rightPx - displayedRegionLeftPx) * bpPerPx;
+            const start = reversed
+                ? Math.max(regionStart, regionEnd - rightBp)
+                : regionStart + leftBp;
+            const end = reversed
+                ? regionEnd - leftBp
+                : Math.min(regionEnd, regionStart + rightBp);
+            // both reversed/forward offset formulae reduce algebraically to leftPx
+            const blockOffsetPx = leftPx;
             const widthPx = (end - start) * invBpPerPx;
-            const blockData = {
-                assemblyName,
-                refName,
-                start,
-                end,
-                reversed,
-                offsetPx: blockOffsetPx,
-                parentRegion,
-                regionNumber,
-                widthPx,
-                isLeftEndOfDisplayedRegion,
-                isRightEndOfDisplayedRegion,
-                key: `${assembleLocStringFast({
+            // Under minimumBlockWidth this region is elided, and BlockSet merges an
+            // elided block into a preceding elided run keeping only its widthPx — so
+            // building the key and the block object is work thrown away, which at
+            // whole-genome zoom on a fragmented assembly is nearly every region and
+            // most of the frame. Two edges keep the skip output-identical: the first
+            // region can never take it, because nothing has been pushed for the run
+            // to merge into, so its leading padding block still gets built; the last
+            // region is held out, because it may still owe a trailing padding block
+            // keyed off its own key.
+            const merged = elision &&
+                regionWidthPx < minimumBlockWidth &&
+                displayedRegionIndex !== lastRegionIndex &&
+                blocks.growElidedRun(widthPx);
+            if (!merged) {
+                const { assemblyName, refName } = region;
+                // Pixel comparisons avoid the bpPerPx round-trip float drift that can
+                // make end !== regionEnd even when the full region is in view.
+                const isLeftEndOfDisplayedRegion = leftPx <= displayedRegionLeftPx;
+                const isRightEndOfDisplayedRegion = rightPx >= displayedRegionRightPx;
+                const key = `${assemblyName}:${refName}:${start}:${end}:${displayedRegionIndex}${reversed ? ':rev' : ''}`;
+                if (padding &&
+                    displayedRegionIndex === 0 &&
+                    isLeftEndOfDisplayedRegion) {
+                    blocks.push({
+                        type: 'InterRegionPaddingBlock',
+                        key: `${key}-beforeFirstRegion`,
+                        widthPx: -offsetPx,
+                        offsetPx: blockOffsetPx + offsetPx,
+                        variant: 'boundary',
+                    });
+                }
+                const data = {
                     assemblyName,
                     refName,
                     start,
                     end,
                     reversed,
-                })}-${regionNumber}${reversed ? '-reversed' : ''}`,
-            };
-            if (padding && blocks.length === 0 && isLeftEndOfDisplayedRegion) {
-                blocks.push(new InterRegionPaddingBlock({
-                    key: `${blockData.key}-beforeFirstRegion`,
-                    widthPx: -offsetPx,
-                    offsetPx: blockData.offsetPx + offsetPx,
-                    variant: 'boundary',
-                }));
-            }
-            if (elision && regionWidthPx < minimumBlockWidth) {
-                blocks.push(new ElidedBlock(blockData));
-            }
-            else {
-                blocks.push(new ContentBlock(blockData));
-            }
-            if (padding) {
-                if (regionWidthPx >= minimumBlockWidth &&
-                    blockData.isRightEndOfDisplayedRegion &&
-                    regionNumber < displayedRegions.length - 1) {
-                    blocks.push(new InterRegionPaddingBlock({
-                        key: `${blockData.key}-rightpad`,
-                        widthPx: interRegionPaddingWidth,
-                        offsetPx: blockData.offsetPx + blockData.widthPx,
-                    }));
-                    displayedRegionLeftPx += interRegionPaddingWidth;
-                }
-                if (regionNumber === displayedRegions.length - 1 &&
-                    blockData.isRightEndOfDisplayedRegion) {
-                    blockOffsetPx = blockData.offsetPx + blockData.widthPx;
-                    blocks.push(new InterRegionPaddingBlock({
-                        key: `${blockData.key}-afterLastRegion`,
-                        widthPx: width - blockOffsetPx + offsetPx,
-                        offsetPx: blockOffsetPx,
+                    offsetPx: blockOffsetPx,
+                    displayedRegionIndex,
+                    widthPx,
+                    isLeftEndOfDisplayedRegion,
+                    isRightEndOfDisplayedRegion,
+                    key,
+                };
+                blocks.push(elision && regionWidthPx < minimumBlockWidth
+                    ? { ...data, type: 'ElidedBlock' }
+                    : { ...data, type: 'ContentBlock' });
+                if (padding &&
+                    displayedRegionIndex === lastRegionIndex &&
+                    isRightEndOfDisplayedRegion) {
+                    const afterOffsetPx = blockOffsetPx + widthPx;
+                    blocks.push({
+                        type: 'InterRegionPaddingBlock',
+                        key: `${key}-afterLastRegion`,
+                        widthPx: width - afterOffsetPx + offsetPx,
+                        offsetPx: afterOffsetPx,
                         variant: 'boundary',
-                    }));
+                    });
                 }
             }
         }
-        displayedRegionLeftPx += (regionEnd - regionStart) * invBpPerPx;
+        displayedRegionLeftPx += regionWidthPx;
     }
     return blocks;
 }

package/esm/util/calculateStaticBlocks.d.ts

@@ -1,5 +1,5 @@
 import { BlockSet } from './blockTypes.ts';
-import type { Region } from './types/index.ts';
+import type { Region } from './types/data.ts';
 import type { Region as RegionModel } from './types/mst.ts';
 import type { Instance } from '@jbrowse/mobx-state-tree';
 export interface Base1DViewModel {
@@ -8,6 +8,5 @@ export interface Base1DViewModel {
     displayedRegions: (Region | Instance<typeof RegionModel>)[];
     bpPerPx: number;
     minimumBlockWidth: number;
-    interRegionPaddingWidth: number;
 }
-export default function calculateStaticBlocks(model: Base1DViewModel, padding?: boolean, elision?: boolean, extra?: number, width?: number): BlockSet;
+export default function calculateStaticBlocks(model: Base1DViewModel, padding?: boolean, elision?: boolean): BlockSet;