@jbrowse/core 4.3.0 → 5.0.0-beta.10

package/esm/util/installInitAutorun.js

@@ -0,0 +1,107 @@
+import { addDisposer, isAlive } from '@jbrowse/mobx-state-tree';
+import { autorun } from 'mobx';
+import { getNotificationSink } from './sessionServices.js';
+// Clear only when the pending blob is still the exact object we applied. A
+// setLaunch that lands while `apply` is awaiting (React StrictMode remounts, a
+// programmatic re-launch) swaps in a new object; clearing unconditionally would
+// silently drop it. Leaving it lets the drain loop apply it next.
+function clearIfUnchanged(self, init) {
+    if (isAlive(self) && self.pendingLaunch === init) {
+        self.setLaunch(undefined);
+    }
+}
+async function applyInitOnce(self, init, { apply, materialized }) {
+    try {
+        await apply(init, {
+            superseded: () => !isAlive(self) || self.pendingLaunch !== init,
+        });
+        clearIfUnchanged(self, init);
+    }
+    catch (e) {
+        // the autorun body is async, so anything escaping here becomes an
+        // unhandled rejection: no report at all, and the drain stops with the view
+        // half-initialized
+        console.error(e);
+        if (isAlive(self)) {
+            if (materialized()) {
+                clearIfUnchanged(self, init);
+                getNotificationSink(self).notifyError(`${e}`, e);
+            }
+            else {
+                self.setError(e);
+            }
+        }
+    }
+}
+function currentInit(self, { ready }) {
+    return isAlive(self) && ready() ? self.pendingLaunch : undefined;
+}
+// Apply pending inits one at a time until none remain. Serializing (rather
+// than letting the autorun run `apply` concurrently) is what keeps re-entrant
+// width churn safe: overlapping applies duplicate whatever the init appends
+// (LGV's highlights did exactly this) and, where `apply` rebuilds sub-views,
+// the second run detaches the models the first is still awaiting. Looping also
+// guarantees an init set mid-apply is eventually applied instead of stranded.
+async function drainInit(self, opts) {
+    let pending = currentInit(self, opts);
+    while (pending !== undefined) {
+        await applyInitOnce(self, pending, opts);
+        const next = currentInit(self, opts);
+        // a fatal failure keeps `launch` for a reload retry; the same object still
+        // sitting there means it was not consumed, so stop rather than spin on it
+        pending = next === pending ? undefined : next;
+    }
+}
+/**
+ * The launch state machine shared by the views that take a declarative launch
+ * blob (LinearGenomeView, DotplotView, LinearSyntenyView): the re-entry guard,
+ * the readiness gate, the serialized drain, the identity-checked clear, the
+ * isAlive guards, and one failure policy.
+ *
+ * The failure policy keys off `materialized`, the same line `withLaunchInput`
+ * draws for persistence:
+ *
+ * - Not materialized — nothing is on screen and `launch` is still persisted, so
+ *   keep it for a reload retry and `setError`. That flips the view onto its
+ *   import form, which renders the error in its own banner; a snackbar would
+ *   state the same failure twice and the banner is the one that persists.
+ * - Materialized — the view works, so a later failure is one sub-step's
+ *   problem and must not take the view down with it. `setError` would, since
+ *   showImportForm keys off `error` alone and would discard rows that loaded
+ *   fine, so report it as a snackbar instead. Clearing `launch` is also what
+ *   disarms the re-fire: `ready` usually folds in the measured width, so
+ *   leaving it set lets any resize re-run `apply` over a half-applied blob.
+ *
+ * `apply` therefore never clears `launch` and never catches for reporting — it
+ * catches only the failures it wants to keep going through (a bad locstring in
+ * one row), and everything it lets escape is fatal-as-of-that-point.
+ */
+export function installInitAutorun(self, opts) {
+    // `draining` is a plain closure flag, intentionally NOT observable so it
+    // stays out of the dependency graph. The autorun observes init + whatever
+    // `ready` reads, so it re-fires when either changes, but a re-entrant pass
+    // while a drain is in flight is a no-op — drainInit already consumes
+    // whatever init is current. The flag is load-bearing, not incidental:
+    // `ready` flips true→false→true when the measured width resets (StrictMode
+    // remount, a workspace tab being shown again), which re-fires this whether it
+    // is an autorun or a reaction.
+    let draining = false;
+    addDisposer(self, autorun(async function initAutorun() {
+        // read both unconditionally: they are the dependency set, and a run
+        // that bails still has to be woken by the thing it bailed on. Teardown
+        // mutates observables `ready` reads before the disposers run, and
+        // reading a detached node throws — here into an unawaited promise.
+        const alive = isAlive(self);
+        const isReady = alive && opts.ready();
+        const init = alive ? self.pendingLaunch : undefined;
+        if (isReady && init !== undefined && !draining) {
+            draining = true;
+            try {
+                await drainInit(self, opts);
+            }
+            finally {
+                draining = false;
+            }
+        }
+    }, { name: opts.name }));
+}

package/esm/util/installPrerequisiteFetch.d.ts

@@ -0,0 +1,115 @@
+import type { StatusReporter } from './createAbortRotation.ts';
+import type { FetchContext } from './fetchContext.ts';
+import type { FetchSkeletonHost } from './installFetch.ts';
+/**
+ * What a prerequisite read needs of the display it runs on, beside the
+ * skeleton's own three. Duck-typed rather than a foundation's `Instance` type,
+ * because the hosts compose different foundations — one per fetch family, and
+ * the comparative displays compose none of them — and this is the only thing
+ * they have in common.
+ */
+export interface PrerequisiteFetchHost extends FetchSkeletonHost {
+    /**
+     * Read in `prepare`, so it is **tracked**: an adapter edited in the config
+     * editor has to re-read, and `run`'s own reads are untracked by contract.
+     */
+    adapterConfig: Record<string, unknown>;
+    isMinimized: boolean;
+}
+/**
+ * A prerequisite read's answer, stamped with the adapter config it answers.
+ * A display holds the latest one and reads it through `readFor`, so an answer
+ * never outlives its adapter config and no failure path has to clear it.
+ */
+export interface AdapterRead<T> {
+    adapterConfig: Record<string, unknown>;
+    value: T;
+}
+/**
+ * `read`'s value while it answers the adapter config `host` holds; undefined
+ * until a read of that config commits, which a failed read never does.
+ *
+ * Equal by value, as the fetch key is: an undo rebuilds the track's config,
+ * handing back an equal adapter config the fetch declines to read again.
+ */
+export declare function readFor<T>(host: {
+    adapterConfig: Record<string, unknown>;
+}, read: AdapterRead<T> | undefined): T | undefined;
+/**
+ * A **prerequisite read**: one RPC about the adapter itself, beside the
+ * display's primary fetch. Four in the tree — HiC's `CoreGetInfo` header read,
+ * whose `resolutions` every contacts fetch waits on; the multi-sample sample
+ * list, which `fetchNeeded` declines until; the tiered alignment file's
+ * `CoreGetInfo` header, which decides the LOD tier a synteny fetch asks for;
+ * and the mark display's source list, which gives each listed source a row —
+ * and they sit on three different fetch foundations, which is why this sits in
+ * core beside the skeleton and not beside any of them.
+ *
+ * They had the shape below hand-copied, comment for comment, and each term is a
+ * rule rather than a preference:
+ *
+ * - **the adapter config is the whole trigger and the whole key.** Tracked in
+ *   `prepare` so a config-editor edit re-reads; keyed on the same value so an
+ *   un-minimize over the same file re-reads nothing. Getting one without the
+ *   other gives either a stale header or a walk of a `.hic` norm-vector index on
+ *   every expand.
+ * - **the answer carries the same key** (`AdapterRead`), and a display reads
+ *   it through `readFor`, so an answer to a previous adapter config is never
+ *   read as the current one, and a failed read leaves nothing to clear.
+ * - **an answer to a config the display no longer holds is dropped**, and so is
+ *   its error. An undo that brings back the config already answered makes the
+ *   skeleton decline a re-read, while the read of the abandoned config runs
+ *   on, still current; landing, it would stamp its key, force a second read of
+ *   the held one and hand the display a list for another file, on which the
+ *   variant display resets its arrangement.
+ * - **minimized is the gate**, and a display with a second condition of its own
+ *   passes `gate` — the sample-list read waits for the LGV to be measured as
+ *   well, so a full-file scan does not start ahead of the display's own first
+ *   fetch, and the tier read waits on the track declaring a tier threshold at
+ *   all.
+ * - **no `contract`.** This is the second fetch on a display whose foundation
+ *   installed both checks already: `assertDisplayContract` would report the
+ *   double-attach it exists to catch, and a second retry check would consume the
+ *   same `reloadCounter` bumps as the first.
+ * - **where the status goes is the caller's** (`report`). The two LGV reads
+ *   lend the display's own status window, so the read takes a slot beside the
+ *   primary fetch rather than opening a second writer over the one status field
+ *   (ADR-081) — and it matters more here than for most fetches: a prerequisite
+ *   runs inside the pre-first-paint window, where the scrim is up because
+ *   nothing is drawn rather than because `isLoading` is, so `statusMessage` is
+ *   the only thing that can say what is happening. The tier read narrates
+ *   nothing; a header is not a load.
+ *
+ * `createAdapterMetadataFetch` keys on the same adapter config and is
+ * deliberately NOT one of these: no trigger, no signal and no status,
+ * because it is fetched lazily when a details widget opens and the widget opens
+ * on the result. A prerequisite read is the one a display's own fetch waits on.
+ *
+ * **A declaration, not the skeleton this name used to be.** There was an
+ * `installPrerequisiteFetch` until 2026-08-23, and `3c5aa7fce2` deleted it for
+ * a good reason: it carried a `runOne` of its own — a fifth copy of begin →
+ * clear → run → commit-if-current → `handleFetchError` → end — and once
+ * `installFetch` owned that sequence, a second one was pure drift surface. This
+ * one adds no sequence, no rotation and no error rule; it is terms handed to
+ * `installFetch`, the same shape `installGlobalFetchAutorun` and
+ * `installComparativeFetchAutorun` are. Add nothing here that a family could
+ * not state as an option to the skeleton.
+ *
+ * Everything the skeleton gives it is the point of going through the skeleton:
+ * the latest-wins rotation (so a superseding read aborts the one it replaced,
+ * and only a superseding read does — a user cancel of the primary fetch cannot
+ * strand the display the way sharing its signal would), the clear at the start,
+ * the currency-guarded error rule, the unconditional `reloadCounter` read that
+ * makes the chrome's Retry re-run this, and the retired status slot that keeps a
+ * failed read from leaving a progress chip up for good.
+ */
+export declare function installPrerequisiteFetch<TResult>(self: PrerequisiteFetchHost, { name, delay, report, gate, run, commit, setError, }: {
+    name: string;
+    delay: number;
+    report: StatusReporter;
+    /** an extra term of the display's own, ANDed under `!isMinimized` */
+    gate?: () => boolean;
+    run: (adapterConfig: Record<string, unknown>, ctx: FetchContext) => Promise<TResult | undefined>;
+    commit: (read: AdapterRead<TResult>) => void;
+    setError: (error?: unknown) => void;
+}): void;

package/esm/util/installPrerequisiteFetch.js

@@ -0,0 +1,111 @@
+import { isAlive } from '@jbrowse/mobx-state-tree';
+import { installFetch } from './installFetch.js';
+import { isDataCurrent } from './isDataCurrent.js';
+/**
+ * `read`'s value while it answers the adapter config `host` holds; undefined
+ * until a read of that config commits, which a failed read never does.
+ *
+ * Equal by value, as the fetch key is: an undo rebuilds the track's config,
+ * handing back an equal adapter config the fetch declines to read again.
+ */
+export function readFor(host, read) {
+    return read !== undefined &&
+        isDataCurrent(read.adapterConfig, host.adapterConfig)
+        ? read.value
+        : undefined;
+}
+/**
+ * A **prerequisite read**: one RPC about the adapter itself, beside the
+ * display's primary fetch. Four in the tree — HiC's `CoreGetInfo` header read,
+ * whose `resolutions` every contacts fetch waits on; the multi-sample sample
+ * list, which `fetchNeeded` declines until; the tiered alignment file's
+ * `CoreGetInfo` header, which decides the LOD tier a synteny fetch asks for;
+ * and the mark display's source list, which gives each listed source a row —
+ * and they sit on three different fetch foundations, which is why this sits in
+ * core beside the skeleton and not beside any of them.
+ *
+ * They had the shape below hand-copied, comment for comment, and each term is a
+ * rule rather than a preference:
+ *
+ * - **the adapter config is the whole trigger and the whole key.** Tracked in
+ *   `prepare` so a config-editor edit re-reads; keyed on the same value so an
+ *   un-minimize over the same file re-reads nothing. Getting one without the
+ *   other gives either a stale header or a walk of a `.hic` norm-vector index on
+ *   every expand.
+ * - **the answer carries the same key** (`AdapterRead`), and a display reads
+ *   it through `readFor`, so an answer to a previous adapter config is never
+ *   read as the current one, and a failed read leaves nothing to clear.
+ * - **an answer to a config the display no longer holds is dropped**, and so is
+ *   its error. An undo that brings back the config already answered makes the
+ *   skeleton decline a re-read, while the read of the abandoned config runs
+ *   on, still current; landing, it would stamp its key, force a second read of
+ *   the held one and hand the display a list for another file, on which the
+ *   variant display resets its arrangement.
+ * - **minimized is the gate**, and a display with a second condition of its own
+ *   passes `gate` — the sample-list read waits for the LGV to be measured as
+ *   well, so a full-file scan does not start ahead of the display's own first
+ *   fetch, and the tier read waits on the track declaring a tier threshold at
+ *   all.
+ * - **no `contract`.** This is the second fetch on a display whose foundation
+ *   installed both checks already: `assertDisplayContract` would report the
+ *   double-attach it exists to catch, and a second retry check would consume the
+ *   same `reloadCounter` bumps as the first.
+ * - **where the status goes is the caller's** (`report`). The two LGV reads
+ *   lend the display's own status window, so the read takes a slot beside the
+ *   primary fetch rather than opening a second writer over the one status field
+ *   (ADR-081) — and it matters more here than for most fetches: a prerequisite
+ *   runs inside the pre-first-paint window, where the scrim is up because
+ *   nothing is drawn rather than because `isLoading` is, so `statusMessage` is
+ *   the only thing that can say what is happening. The tier read narrates
+ *   nothing; a header is not a load.
+ *
+ * `createAdapterMetadataFetch` keys on the same adapter config and is
+ * deliberately NOT one of these: no trigger, no signal and no status,
+ * because it is fetched lazily when a details widget opens and the widget opens
+ * on the result. A prerequisite read is the one a display's own fetch waits on.
+ *
+ * **A declaration, not the skeleton this name used to be.** There was an
+ * `installPrerequisiteFetch` until 2026-08-23, and `3c5aa7fce2` deleted it for
+ * a good reason: it carried a `runOne` of its own — a fifth copy of begin →
+ * clear → run → commit-if-current → `handleFetchError` → end — and once
+ * `installFetch` owned that sequence, a second one was pure drift surface. This
+ * one adds no sequence, no rotation and no error rule; it is terms handed to
+ * `installFetch`, the same shape `installGlobalFetchAutorun` and
+ * `installComparativeFetchAutorun` are. Add nothing here that a family could
+ * not state as an option to the skeleton.
+ *
+ * Everything the skeleton gives it is the point of going through the skeleton:
+ * the latest-wins rotation (so a superseding read aborts the one it replaced,
+ * and only a superseding read does — a user cancel of the primary fetch cannot
+ * strand the display the way sharing its signal would), the clear at the start,
+ * the currency-guarded error rule, the unconditional `reloadCounter` read that
+ * makes the chrome's Retry re-run this, and the retired status slot that keeps a
+ * failed read from leaving a progress chip up for good.
+ */
+export function installPrerequisiteFetch(self, { name, delay, report, gate = () => true, run, commit, setError, }) {
+    installFetch(self, {
+        name,
+        delay,
+        report,
+        gate: () => !self.isMinimized && gate(),
+        prepare: () => ({ adapterConfig: self.adapterConfig }),
+        fetchKey: ({ adapterConfig }) => adapterConfig,
+        run: async ({ adapterConfig }, ctx) => {
+            const held = () => isAlive(self) && isDataCurrent(adapterConfig, self.adapterConfig);
+            try {
+                const value = await run(adapterConfig, ctx);
+                return held() ? value : undefined;
+            }
+            catch (e) {
+                if (held()) {
+                    throw e;
+                }
+                return undefined;
+            }
+        },
+        commit: (value, { adapterConfig }) => {
+            commit({ adapterConfig, value });
+        },
+        setError,
+    });
+}

package/esm/util/intervals.d.ts

@@ -0,0 +1,20 @@
+export interface BasicFeature {
+    end: number;
+    start: number;
+    refName: string;
+}
+/**
+ * Merge intervals that overlap once each is grown by `padding` on both sides.
+ * `padding` is per side, so the merge window between two intervals is `2 *
+ * padding` — the default merges anything within 10kb of its neighbour, not 5kb.
+ * Callers that have already baked their padding into start/end pass 0.
+ */
+export declare function mergeIntervals<T extends {
+    start: number;
+    end: number;
+}>(intervals: T[], padding?: number): T[];
+/**
+ * {@link mergeIntervals} per refName: returns a new array of non-overlapping
+ * features. `padding` carries the same per-side meaning.
+ */
+export declare function gatherOverlaps<T extends BasicFeature>(regions: T[], padding?: number): T[];

package/esm/util/intervals.js

@@ -0,0 +1,37 @@
+/**
+ * Merge intervals that overlap once each is grown by `padding` on both sides.
+ * `padding` is per side, so the merge window between two intervals is `2 *
+ * padding` — the default merges anything within 10kb of its neighbour, not 5kb.
+ * Callers that have already baked their padding into start/end pass 0.
+ */
+export function mergeIntervals(intervals, padding = 5000) {
+    if (intervals.length <= 1) {
+        return intervals;
+    }
+    // clone so neither the input array order nor its elements are mutated
+    const sorted = [...intervals].sort((a, b) => a.start - b.start);
+    const stack = [{ ...sorted[0] }];
+    for (let i = 1; i < sorted.length; i++) {
+        const top = stack.at(-1);
+        const next = sorted[i];
+        if (top.end + padding < next.start - padding) {
+            stack.push({ ...next });
+        }
+        else if (top.end < next.end) {
+            top.end = next.end;
+        }
+    }
+    return stack;
+}
+/**
+ * {@link mergeIntervals} per refName: returns a new array of non-overlapping
+ * features. `padding` carries the same per-side meaning.
+ */
+export function gatherOverlaps(regions, padding = 5000) {
+    const memo = {};
+    for (const x of regions) {
+        memo[x.refName] ??= [];
+        memo[x.refName].push(x);
+    }
+    return Object.values(memo).flatMap(group => mergeIntervals(group, padding));
+}

package/esm/util/io/RemoteFileWithRangeCache.d.ts

@@ -1,11 +1,10 @@
-import { RemoteFile } from 'generic-filehandle2';
-export declare function clearCache(): void;
-export declare class RemoteFileWithRangeCache extends RemoteFile {
-    private cachedStat?;
-    stat(): Promise<{
-        size: number;
-    }>;
-    private fetchRange;
-    private getCachedRange;
-    fetch(url: string | RequestInfo, init?: RequestInit): Promise<Response>;
-}
+/**
+ * The chunk cache now lives in `@gmod/range-cache-filehandle`, extracted from
+ * this file so the @gmod parsers can use it without depending on
+ * `@jbrowse/core`, react and mobx-state-tree.
+ *
+ * Kept as a re-export rather than deleted: `products/jbrowse-web/src/tests`
+ * imports `clearCache` from this path directly, and `@jbrowse/core/util/io`
+ * re-exports the two classes from here.
+ */
+export { CachedFilehandle, RemoteFileWithRangeCache, clearCache, sweepIdleCache, } from '@gmod/range-cache-filehandle';

package/esm/util/io/RemoteFileWithRangeCache.js

@@ -1,148 +1,10 @@
-import { RemoteFile } from 'generic-filehandle2';
-const MAX_CACHE_ENTRIES = 2000;
-const CHUNK_SIZE = 256 * 1024;
-const MAX_CONCURRENT = 20;
-let cache = new Map();
-let activeCount = 0;
-const queue = [];
-function getCached(key) {
-    return cache.get(key);
-}
-function putCached(key, buffer) {
-    if (cache.size >= MAX_CACHE_ENTRIES) {
-        const firstKey = cache.keys().next().value;
-        if (firstKey !== undefined) {
-            cache.delete(firstKey);
-        }
-    }
-    cache.set(key, buffer);
-}
-export function clearCache() {
-    cache = new Map();
-}
-function runNext() {
-    if (queue.length > 0 && activeCount < MAX_CONCURRENT) {
-        activeCount++;
-        const next = queue.shift();
-        next();
-    }
-}
-function limitConcurrency(fn) {
-    return new Promise((resolve, reject) => {
-        function run() {
-            fn().then(val => {
-                activeCount--;
-                resolve(val);
-                runNext();
-            }, (err) => {
-                activeCount--;
-                reject(err instanceof Error ? err : new Error(String(err)));
-                runNext();
-            });
-        }
-        if (activeCount < MAX_CONCURRENT) {
-            activeCount++;
-            run();
-        }
-        else {
-            queue.push(run);
-        }
-    });
-}
-function cacheKey(url, chunkIndex) {
-    return `${url}:${chunkIndex}`;
-}
-export class RemoteFileWithRangeCache extends RemoteFile {
-    cachedStat;
-    async stat() {
-        if (!this.cachedStat) {
-            await this.getCachedRange(this.url, 0, 1);
-        }
-        return this.cachedStat ?? { size: 0 };
-    }
-    async fetchRange(url, start, end, signal) {
-        const res = await super.fetch(url, {
-            signal: signal ?? undefined,
-            headers: { range: `bytes=${start}-${end}` },
-        });
-        if (res.status === 416) {
-            return new Uint8Array(0);
-        }
-        if (!res.ok) {
-            const hint = ' (should be 206 for range requests)';
-            const msg = `HTTP ${res.status} fetching ${url} bytes ${start}-${end}${res.status === 200 ? hint : ''}`;
-            throw Object.assign(new Error(msg), { status: res.status });
-        }
-        if (!this.cachedStat) {
-            const contentRange = res.headers.get('content-range');
-            const match = contentRange ? /\/(\d+)$/.exec(contentRange) : null;
-            if (match) {
-                this.cachedStat = { size: parseInt(match[1], 10) };
-            }
-        }
-        return new Uint8Array(await res.arrayBuffer());
-    }
-    async getCachedRange(url, start, length, signal) {
-        const startChunk = Math.floor(start / CHUNK_SIZE);
-        const endChunk = Math.floor((start + length - 1) / CHUNK_SIZE);
-        let effectiveEndChunk = endChunk;
-        for (let i = startChunk; i < endChunk; i++) {
-            const c = getCached(cacheKey(url, i));
-            if (c !== undefined && c.length < CHUNK_SIZE) {
-                effectiveEndChunk = i;
-                break;
-            }
-        }
-        const chunkCount = effectiveEndChunk - startChunk + 1;
-        const runs = [];
-        for (let i = 0; i < chunkCount; i++) {
-            if (!getCached(cacheKey(url, startChunk + i))) {
-                const lastRun = runs[runs.length - 1];
-                if (lastRun?.end === i - 1) {
-                    lastRun.end = i;
-                }
-                else {
-                    runs.push({ start: i, end: i });
-                }
-            }
-        }
-        await Promise.all(runs.map(run => limitConcurrency(async () => {
-            const runStartChunk = startChunk + run.start;
-            const runEndChunk = startChunk + run.end;
-            const rangeStart = runStartChunk * CHUNK_SIZE;
-            const rangeEnd = (runEndChunk + 1) * CHUNK_SIZE - 1;
-            const data = await this.fetchRange(url, rangeStart, rangeEnd, signal);
-            for (let i = run.start; i <= run.end; i++) {
-                const offset = (i - run.start) * CHUNK_SIZE;
-                putCached(cacheKey(url, startChunk + i), data.subarray(offset, offset + CHUNK_SIZE));
-            }
-        })));
-        const offsetInFirstChunk = start - startChunk * CHUNK_SIZE;
-        const result = new Uint8Array(length);
-        let written = 0;
-        for (let i = 0; i < chunkCount; i++) {
-            const chunk = getCached(cacheKey(url, startChunk + i));
-            const sourceStart = i === 0 ? offsetInFirstChunk : 0;
-            const available = chunk.length - sourceStart;
-            const needed = length - written;
-            const copyLen = Math.min(available, needed);
-            result.set(chunk.subarray(sourceStart, sourceStart + copyLen), written);
-            written += copyLen;
-        }
-        return result.subarray(0, written);
-    }
-    async fetch(url, init) {
-        const range = new Headers(init?.headers).get('range');
-        if (range) {
-            const rangeParse = /bytes=(\d+)-(\d+)/.exec(range);
-            if (rangeParse) {
-                const [, startStr, endStr] = rangeParse;
-                const s = Number.parseInt(startStr, 10);
-                const e = Number.parseInt(endStr, 10);
-                const buffer = await this.getCachedRange(String(url), s, e - s + 1, init?.signal);
-                return new Response(buffer, { status: 206 });
-            }
-        }
-        return super.fetch(url, init);
-    }
-}
+/**
+ * The chunk cache now lives in `@gmod/range-cache-filehandle`, extracted from
+ * this file so the @gmod parsers can use it without depending on
+ * `@jbrowse/core`, react and mobx-state-tree.
+ *
+ * Kept as a re-export rather than deleted: `products/jbrowse-web/src/tests`
+ * imports `clearCache` from this path directly, and `@jbrowse/core/util/io`
+ * re-exports the two classes from here.
+ */
+export { CachedFilehandle, RemoteFileWithRangeCache, clearCache, sweepIdleCache, } from '@gmod/range-cache-filehandle';

package/esm/util/io/index.d.ts

@@ -1,7 +1,44 @@
 import type PluginManager from '../../PluginManager.ts';
-import type { FileLocation, UriLocation } from '../types/index.ts';
+import type { FileLocation, UriLocation } from '../types/data.ts';
 import type { Fetcher, GenericFilehandle } from 'generic-filehandle2';
+/** if a UriLocation has a baseUri, resolves its uri with respect to that base */
 export declare function resolveUriLocation(location: UriLocation): UriLocation;
 export declare function openLocation(location: FileLocation, pluginManager?: PluginManager): GenericFilehandle;
+/**
+ * Open a tabix-style index (TBI or CSI) and return it under the correct
+ * filehandle key for `new TabixIndexedFile(...)`. Centralizes the CSI-vs-TBI
+ * branch so callers can't mismatch the two — e.g. writing `=== 'CSI'` on both
+ * the csi and tbi lines, which silently yields no index at all.
+ */
+export declare function openTabixIndexFilehandle(location: FileLocation, indexType: string | undefined, pluginManager?: PluginManager): {
+    csiFilehandle: GenericFilehandle;
+    tbiFilehandle?: undefined;
+} | {
+    csiFilehandle?: undefined;
+    tbiFilehandle: GenericFilehandle;
+};
+/**
+ * A fetch that presents `location`'s credentials — and only for urls that
+ * credential covers.
+ *
+ * An account's own fetcher signs whatever url it is handed: the location it was
+ * built from decides which token to mint, not where the token may go. That is
+ * fine for a caller holding one url, which is what `openLocation` is, and wrong
+ * for one that fetches urls a *server* names. Htsget is the second kind — a
+ * ticket request answers with data-block urls that can point anywhere — and it
+ * had no way to ask whether a given url was still in scope.
+ *
+ * So ask here. Every url other than the one the fetcher was requested for goes
+ * back through the account's `handlesLocation`, which is the same
+ * `uriMatchesDomains` test that chose the account in the first place. Both
+ * directions matter: `domains` entries scope to a path as well as a host
+ * (`data.mylab.org/private`, and the origin-plus-directory form every ephemeral
+ * HTTP Basic account is minted with), and one account routinely spans several
+ * hosts (Dropbox lists seven). An origin comparison is wrong for both.
+ *
+ * Anything out of scope gets a plain fetch rather than `checkAuthNeededFetch`:
+ * a 401 from a url the config never named should not raise a credential prompt
+ * for a host the server picked.
+ */
 export declare function getFetcher(location: FileLocation, pluginManager?: PluginManager): Fetcher;
-export { RemoteFileWithRangeCache } from './RemoteFileWithRangeCache.ts';
+export { CachedFilehandle, RemoteFileWithRangeCache, } from './RemoteFileWithRangeCache.ts';