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

package/esm/util/SvgCanvas.js

@@ -1,4 +1,5 @@
 import { measureText as measureTextWidth } from './measureText.js';
+import { splitPaintAlpha } from './svgColorProps.js';
 const XML_ESCAPES = {
     '&': '&',
     '<': '&lt;',
@@ -29,14 +30,16 @@ function parseFont(font) {
 // SVG-compatible attributes. The default sans-serif family is left off so
 // feature labels match the raw-JSX <text> elements (ruler, scalebar, etc.),
 // which set no family either; an explicitly-set family is still emitted.
-function fontAttrs(font) {
+function fontAttrs(font, scale) {
     const { prefix, size, family } = parseFont(font);
     const tokens = prefix.split(/\s+/).filter(Boolean);
     const weight = tokens.find(t => fontWeightTokens.has(t) || /^\d{1,4}$/.test(t));
     const style = tokens.find(t => fontStyleTokens.has(t));
     return [
-        ` font-size="${size}"`,
-        family === '' || family === 'sans-serif' ? '' : ` font-family="${family}"`,
+        ` font-size="${Number(size) * scale}"`,
+        family === '' || family === 'sans-serif'
+            ? ''
+            : ` font-family="${escapeXml(family)}"`,
         weight ? ` font-weight="${weight}"` : '',
         style ? ` font-style="${style}"` : '',
     ].join('');
@@ -47,25 +50,34 @@ function fontAttrs(font) {
 // mint `svgcanvas-clip-0`, whereupon `url(#svgcanvas-clip-0)` resolves to the
 // first and every later layer is clipped to some other layer's rect.
 //
-// Document-global, not process-global: `resetSvgClipIds` below.
+// Document-global, not process-global: `withFreshSvgClipIds` below.
 let clipIdCounter = 0;
 /**
- * Restart clip-id numbering for a new export document.
+ * Run `render` as one document's clip-id numbering run, starting at 0, then put
+ * the counter back.
  *
- * Without it the counter runs for the lifetime of the process, so an export is
- * numbered from wherever the previous one stopped and the same view exported
- * twice differs in every clip id. That is the churn `svgNodeId` was written to
- * get rid of, arriving by a second route: diffing two saved SVGs shows changes
- * that aren't real, and `jest -t` on any export test but the first fails its
- * checked-in snapshot with a diff that is nothing but renumbering.
+ * Starting at 0 is what makes the same view export to the same bytes: a counter
+ * left running numbers each export from wherever the previous one stopped, so
+ * diffing two saved SVGs shows changes that aren't real and `jest -t` on any
+ * export test but the first fails its snapshot on renumbering alone.
  *
- * Called by `wrapSvgExport`, and safe there and only there: the
- * `renderToStaticMarkup` it wraps is synchronous, so every `PaintLayer` in the
- * document draws before any other export can begin. Anything that resets on a
- * boundary an `await` can cross would let two exports share a numbering run.
+ * Putting it back is what keeps a file export from renumbering the page: live
+ * figures (`useViewSvgFigure`) mint from the same counter into one DOM, where
+ * ids must not repeat, so a reset that stuck would let the next figure reuse an
+ * id another figure still points at.
+ *
+ * `render` must be synchronous — an `await` inside it would let two documents
+ * share a numbering run.
  */
-export function resetSvgClipIds() {
+export function withFreshSvgClipIds(render) {
+    const saved = clipIdCounter;
     clipIdCounter = 0;
+    try {
+        return render();
+    }
+    finally {
+        clipIdCounter = saved;
+    }
 }
 export class SvgCanvas {
     parts = [];
@@ -115,6 +127,13 @@ export class SvgCanvas {
     get axisAligned() {
         return this.b === 0 && this.c === 0;
     }
+    // How much the CTM scales a length, for what SVG draws at a size of its own
+    // rather than through transformed coordinates: stroke widths, dashes and
+    // font sizes. Exact for a uniform scale; the geometric mean otherwise, where
+    // a Canvas2D pen would draw an ellipse no stroke-width can state.
+    get lengthScale() {
+        return Math.sqrt(Math.abs(this.a * this.d - this.b * this.c));
+    }
     transformPoint(x, y) {
         return [this.a * x + this.c * y + this.e, this.b * x + this.d * y + this.f];
     }
@@ -170,23 +189,20 @@ export class SvgCanvas {
                 ? 'end'
                 : 'start';
     }
-    // Split rgba(r,g,b,a) into separate color + opacity SVG attributes for
-    // compatibility with SVG 1.1 consumers like Inkscape that don't honor the
-    // alpha component of CSS3 rgba() fill/stroke values. Whitespace-tolerant so
-    // spaced forms (MUI alpha(), colord toRgbString → "rgba(255, 177, 29, 0.12)")
-    // are separated too, not just the compact "rgba(255,177,29,0.12)".
     paintAttr(name, style) {
         const s = `${style}`;
-        const m = /^rgba\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*,\s*([\d.]+)\s*\)$/.exec(s);
-        if (m) {
-            const a = Number.parseFloat(m[4]);
-            const base = `${name}="rgb(${m[1]},${m[2]},${m[3]})"`;
-            return a < 1 ? `${base} ${name}-opacity="${a}"` : base;
+        const split = splitPaintAlpha(s);
+        if (!split) {
+            return `${name}="${s}"`;
         }
-        return `${name}="${s}"`;
+        const base = `${name}="${split.color}"`;
+        return split.opacity < 1
+            ? `${base} ${name}-opacity="${split.opacity}"`
+            : base;
     }
     strokeAttrs() {
-        let attrs = ` ${this.paintAttr('stroke', this.strokeStyle)} stroke-width="${this.lineWidth}"`;
+        const scale = this.lengthScale;
+        let attrs = ` ${this.paintAttr('stroke', this.strokeStyle)} stroke-width="${this.lineWidth * scale}"`;
         if (this.lineCap !== 'butt') {
             attrs += ` stroke-linecap="${this.lineCap}"`;
         }
@@ -194,7 +210,7 @@ export class SvgCanvas {
             attrs += ` stroke-linejoin="${this.lineJoin}"`;
         }
         if (this.lineDash.length > 0) {
-            attrs += ` stroke-dasharray="${this.lineDash.join(',')}"`;
+            attrs += ` stroke-dasharray="${this.lineDash.map(d => d * scale).join(',')}"`;
         }
         return attrs;
     }
@@ -358,34 +374,40 @@ export class SvgCanvas {
         this.ellipse(x, y, radius, radius, 0, startAngle, endAngle, counterclockwise);
     }
     ellipse(x, y, radiusX, radiusY, rotation, startAngle, endAngle, counterclockwise = false) {
-        const [cx, cy] = this.transformPoint(x, y);
         const [rx, ry] = this.transformSize(radiusX, radiusY);
-        const sweep = counterclockwise ? 0 : 1;
-        const diff = endAngle - startAngle;
-        const deg = (rotation * 180) / Math.PI;
+        // A mirrored CTM turns a clockwise sweep counterclockwise on the page, and
+        // its rotation the other way.
+        const mirrored = this.a * this.d < 0;
+        const sweep = counterclockwise === mirrored ? 1 : 0;
+        const deg = ((mirrored ? -rotation : rotation) * 180) / Math.PI;
         // Canvas measures the angle on the UNROTATED ellipse and then spins the
         // whole thing, so the endpoint is the parametric point rotated — not the
-        // point at (angle + rotation).
+        // point at (angle + rotation) — and then placed by the CTM.
         const at = (angle) => {
-            const px = rx * Math.cos(angle);
-            const py = ry * Math.sin(angle);
-            return [
-                cx + px * Math.cos(rotation) - py * Math.sin(rotation),
-                cy + px * Math.sin(rotation) + py * Math.cos(rotation),
-            ];
+            const px = radiusX * Math.cos(angle);
+            const py = radiusY * Math.sin(angle);
+            return this.transformPoint(x + px * Math.cos(rotation) - py * Math.sin(rotation), y + px * Math.sin(rotation) + py * Math.cos(rotation));
         };
-        if (Math.abs(diff) >= 2 * Math.PI) {
+        // The angle actually swept, as Canvas2D resolves it: in the stated
+        // direction, a whole turn once it reaches 2π, and otherwise wrapped into
+        // [0, 2π) — so a clockwise sweep from 0.5π back to 0 goes the long way.
+        const TAU = 2 * Math.PI;
+        const signed = counterclockwise
+            ? startAngle - endAngle
+            : endAngle - startAngle;
+        const swept = signed >= TAU ? TAU : ((signed % TAU) + TAU) % TAU;
+        const [sx, sy] = at(startAngle);
+        if (swept === TAU) {
             // A closed ellipse has coincident endpoints, which an SVG arc command
-            // degenerates on — so go round in two halves.
-            const [mx, my] = at(startAngle);
-            const [halfX, halfY] = at(startAngle + Math.PI);
-            this.pathData += `M${mx},${my}A${rx},${ry} ${deg} 1 ${sweep} ${halfX},${halfY}A${rx},${ry} ${deg} 1 ${sweep} ${mx},${my}`;
+            // degenerates on — so go round in two halves, as a subpath of its own.
+            const half = counterclockwise ? -Math.PI : Math.PI;
+            const [hx, hy] = at(startAngle + half);
+            this.pathData += `M${sx},${sy}A${rx},${ry} ${deg} 1 ${sweep} ${hx},${hy}A${rx},${ry} ${deg} 1 ${sweep} ${sx},${sy}`;
             return;
         }
-        const [sx, sy2] = at(startAngle);
         const [ex, ey] = at(endAngle);
-        const largeArc = Math.abs(diff) > Math.PI ? 1 : 0;
-        this.pathData += !this.pathData ? `M${sx},${sy2}` : `L${sx},${sy2}`;
+        const largeArc = swept > Math.PI ? 1 : 0;
+        this.pathData += !this.pathData ? `M${sx},${sy}` : `L${sx},${sy}`;
         this.pathData += `A${rx},${ry} ${deg} ${largeArc} ${sweep} ${ex},${ey}`;
     }
     bezierCurveTo(cp1x, cp1y, cp2x, cp2y, x, y) {
@@ -441,19 +463,16 @@ export class SvgCanvas {
     fillText(text, x, y) {
         const [tx, ty] = this.transformPoint(x, y);
         const escaped = escapeXml(text);
-        this.emit(`<text x="${tx}" y="${ty}" ${this.paintAttr('fill', this.fillStyle)}${fontAttrs(this.font)} text-anchor="${this.textAnchor()}" dominant-baseline="${this.dominantBaseline()}">${escaped}</text>`);
+        this.emit(`<text x="${tx}" y="${ty}" ${this.paintAttr('fill', this.fillStyle)}${fontAttrs(this.font, this.lengthScale)} text-anchor="${this.textAnchor()}" dominant-baseline="${this.dominantBaseline()}">${escaped}</text>`);
     }
     strokeText(text, x, y) {
         const [tx, ty] = this.transformPoint(x, y);
         const escaped = escapeXml(text);
-        this.emit(`<text x="${tx}" y="${ty}" fill="none"${this.strokeAttrs()}${fontAttrs(this.font)} text-anchor="${this.textAnchor()}" dominant-baseline="${this.dominantBaseline()}">${escaped}</text>`);
+        this.emit(`<text x="${tx}" y="${ty}" fill="none"${this.strokeAttrs()}${fontAttrs(this.font, this.lengthScale)} text-anchor="${this.textAnchor()}" dominant-baseline="${this.dominantBaseline()}">${escaped}</text>`);
     }
     drawImage(..._args) {
         // no-op: raster images can't be meaningfully serialized to SVG paths
     }
-    putImageData(..._args) {
-        // no-op
-    }
     clip(..._args) {
         // Use the current path as a clipPath, then open a `<g clip-path>`
         // group that subsequent draws will land inside. The group is closed by
@@ -479,9 +498,10 @@ export class SvgCanvas {
     // The family goes through, not just the size: `measureText` switches to the
     // fixed monospace advance on seeing one, so dropping it measured a monospace
     // string against the proportional table — the same string, laid out one way on
-    // a real canvas and another in the export, with nothing to show which. No draw
-    // function calls ctx.measureText today; this is here so the first one to do it
-    // doesn't inherit a silent discrepancy.
+    // a real canvas and another in the export, with nothing to show which. An
+    // estimate all the same: a draw whose layout turns on a width (synteny's
+    // off-screen mate labels) measures through a real canvas and passes the
+    // result in, so the figure names what the screen named.
     measureText(text) {
         const { size, family } = parseFont(this.font);
         return { width: measureTextWidth(text, Number(size), family) };

package/esm/util/TimeTraveller.d.ts

@@ -9,10 +9,13 @@ declare const TimeTraveller: import("@jbrowse/mobx-state-tree").IModelType<{
 }, {
     history: unknown[];
     notTrackingUndo: boolean;
+    hasPendingRecord: boolean;
 } & {
     readonly canUndo: boolean;
     readonly canRedo: boolean;
 } & {
+    setHasPendingRecord(value: boolean): void;
+    flushPendingRecord(): void;
     stopTrackingUndo(): void;
     resumeTrackingUndo(): void;
     addUndoState(snapshot: unknown): void;

package/esm/util/TimeTraveller.js

@@ -14,13 +14,16 @@ const TimeTraveller = types
     .volatile(() => ({
     history: [],
     notTrackingUndo: false,
+    hasPendingRecord: false,
 }))
     .views(self => ({
     get canUndo() {
-        return self.undoIdx > 0 && !self.notTrackingUndo;
+        return ((self.undoIdx > 0 || self.hasPendingRecord) && !self.notTrackingUndo);
     },
     get canRedo() {
-        return self.undoIdx < self.history.length - 1 && !self.notTrackingUndo;
+        return (self.undoIdx < self.history.length - 1 &&
+            !self.hasPendingRecord &&
+            !self.notTrackingUndo);
     },
 }))
     .actions(self => {
@@ -93,7 +96,21 @@ const TimeTraveller = types
             skipNextUndoState = false;
         }
     }
+    let recordPending;
     return {
+        setHasPendingRecord(value) {
+            self.hasPendingRecord = value;
+        },
+        flushPendingRecord() {
+            if (debounceTimer) {
+                clearTimeout(debounceTimer);
+                debounceTimer = undefined;
+            }
+            if (self.hasPendingRecord) {
+                self.hasPendingRecord = false;
+                recordPending?.();
+            }
+        },
         stopTrackingUndo() {
             self.notTrackingUndo = true;
         },
@@ -141,14 +158,17 @@ const TimeTraveller = types
             skipNextUndoState = false;
             self.history = [];
             self.undoIdx = -1;
+            self.hasPendingRecord = false;
             // read the target's current state rather than a snapshot captured per
             // change: any change inside the debounce window re-times it, so when it
             // does fire the two agree
             const record = () => {
+                this.setHasPendingRecord(false);
                 if (targetStore) {
                     this.addUndoState(getSnapshot(targetStore));
                 }
             };
+            recordPending = record;
             // onPatch, not onSnapshot: this only needs to know *that* the target
             // changed, and the snapshot is taken once per debounce window below.
             // onSnapshot would serialize the whole target on every single change to
@@ -178,17 +198,29 @@ const TimeTraveller = types
                         clearTimeout(debounceTimer);
                         debounceTimer = undefined;
                     }
+                    this.setHasPendingRecord(false);
                     return;
                 }
+                if (!self.hasPendingRecord) {
+                    this.setHasPendingRecord(true);
+                }
                 armRecording(record);
             });
             this.addUndoState(getSnapshot(targetStore));
         },
         undo() {
+            this.flushPendingRecord();
+            if (self.undoIdx <= 0) {
+                return;
+            }
             self.undoIdx--;
             applyHistoryState(self.undoIdx);
         },
         redo() {
+            this.flushPendingRecord();
+            if (self.undoIdx >= self.history.length - 1) {
+                return;
+            }
             self.undoIdx++;
             applyHistoryState(self.undoIdx);
         },

package/esm/util/aborting.d.ts

@@ -20,4 +20,43 @@ export declare function handleFetchError(exception: unknown, isCurrent: () => bo
  * @param exception -
  */
 export declare function isAbortException(exception: unknown): boolean;
+/**
+ * Throw an AbortError if `signal` has aborted. A `signal.aborted` read, so it
+ * is cheap enough for the body of a loop; place it after any await and in any
+ * per-item callback a reader hands you.
+ */
+export declare function checkAbortSignal(signal?: AbortSignal): void;
+/**
+ * Run an awaited stage under `signal`: checked before it starts, and again
+ * once it settles. The check after is the one that gets left out when the two
+ * are placed by hand — a stop landing during a long await otherwise goes
+ * unseen until the next stage.
+ */
+export declare function withAbortCheck<T>(signal: AbortSignal | undefined, fn: () => T | Promise<T>): Promise<T>;
+export interface AbortBreakpoint {
+    /** True once every ~50 ms of wall time, otherwise a counter bump. */
+    due(): boolean;
+    /** Yield a task so a posted abort can land, then throw if it did. */
+    yield(): Promise<void>;
+}
+/**
+ * Cancellation for a loop that can run for seconds without awaiting — a
+ * whole-genome projection, a matrix fill. A `signal.aborted` read inside such a
+ * loop never changes, because the abort is a posted message; the loop has to
+ * give the event loop a turn now and then. A loop bounded by the byte gate or
+ * one region's features finishes before this would matter and only checks.
+ *
+ *     const breakpoint = createAbortBreakpoint(signal)
+ *     for (const row of rows) {
+ *       if (breakpoint.due()) {
+ *         await breakpoint.yield()
+ *       }
+ *       …
+ *     }
+ *
+ * Two calls rather than one because an `await` on a non-promise still costs a
+ * microtask, about 60 ns against 2 ns for the `due()` read, and a loop over
+ * every read in a pileup notices the difference.
+ */
+export declare function createAbortBreakpoint(signal?: AbortSignal): AbortBreakpoint;
 export {};

package/esm/util/aborting.js

@@ -1,3 +1,5 @@
+import { isElectron, isNode } from './environment.js';
+import { createTimeGate } from './timeGate.js';
 class AbortError extends Error {
     code;
 }
@@ -33,15 +35,95 @@ export function handleFetchError(exception, isCurrent, setError) {
  */
 export function isAbortException(exception) {
     return (
-    // DOMException
-    // message contains aborted for bubbling through RPC
-    // things we have seen that we want to catch here
-    // Error: aborted
-    // AbortError: aborted
-    // AbortError: The user aborted a request.
+    // The message test is for an abort whose name did not survive a boundary
+    // (Electron IPC, RpcServer's message-only fallback). A timeout is a failure
+    // even though Node words it "The operation was aborted due to timeout".
     exception instanceof Error &&
+        exception.name !== 'TimeoutError' &&
         (exception.name === 'AbortError' ||
             // standard-ish non-DOM abort exception
             (exception instanceof AbortError && exception.code === 'ERR_ABORTED') ||
             /\b(aborted|aborterror)\b/i.test(exception.message)));
 }
+/**
+ * Throw an AbortError if `signal` has aborted. A `signal.aborted` read, so it
+ * is cheap enough for the body of a loop; place it after any await and in any
+ * per-item callback a reader hands you.
+ */
+export function checkAbortSignal(signal) {
+    if (signal?.aborted) {
+        throw makeAbortError();
+    }
+}
+/**
+ * Run an awaited stage under `signal`: checked before it starts, and again
+ * once it settles. The check after is the one that gets left out when the two
+ * are placed by hand — a stop landing during a long await otherwise goes
+ * unseen until the next stage.
+ */
+export async function withAbortCheck(signal, fn) {
+    checkAbortSignal(signal);
+    const result = await fn();
+    checkAbortSignal(signal);
+    return result;
+}
+const YIELD_INTERVAL_MS = 50;
+/**
+ * Give the event loop one turn. A worker learns of an abort through a posted
+ * message, and a message is a task: an `await` on an already-settled promise
+ * drains only microtasks and delivers nothing. A browser realm, Electron's
+ * included, gets a MessageChannel task, which unlike `setTimeout` is not
+ * clamped. Not `scheduler.yield`: Chromium runs its continuation ahead of a
+ * posted message, so a worker loop yielding that way never sees the abort.
+ * Plain Node and jsdom get the timer: a MessagePort turn there runs no due
+ * timer, and under jest the abort is one.
+ */
+const yieldToEventLoop = (() => {
+    if ((isElectron || !isNode) && typeof MessageChannel !== 'undefined') {
+        const channel = new MessageChannel();
+        let resolvers = [];
+        channel.port1.onmessage = () => {
+            const pending = resolvers;
+            resolvers = [];
+            for (const resolve of pending) {
+                resolve();
+            }
+        };
+        return () => new Promise(resolve => {
+            resolvers.push(resolve);
+            channel.port2.postMessage(0);
+        });
+    }
+    return () => new Promise(resolve => {
+        setTimeout(resolve, 0);
+    });
+})();
+/**
+ * Cancellation for a loop that can run for seconds without awaiting — a
+ * whole-genome projection, a matrix fill. A `signal.aborted` read inside such a
+ * loop never changes, because the abort is a posted message; the loop has to
+ * give the event loop a turn now and then. A loop bounded by the byte gate or
+ * one region's features finishes before this would matter and only checks.
+ *
+ *     const breakpoint = createAbortBreakpoint(signal)
+ *     for (const row of rows) {
+ *       if (breakpoint.due()) {
+ *         await breakpoint.yield()
+ *       }
+ *       …
+ *     }
+ *
+ * Two calls rather than one because an `await` on a non-promise still costs a
+ * microtask, about 60 ns against 2 ns for the `due()` read, and a loop over
+ * every read in a pileup notices the difference.
+ */
+export function createAbortBreakpoint(signal) {
+    const gate = createTimeGate();
+    return {
+        due: () => gate(YIELD_INTERVAL_MS),
+        async yield() {
+            await yieldToEventLoop();
+            checkAbortSignal(signal);
+        },
+    };
+}

package/esm/util/adapterMetadata.d.ts

@@ -11,7 +11,7 @@ import type { IStateTreeNode } from '@jbrowse/mobx-state-tree';
  *
  * Keyed on the adapter config rather than memoized for the display's life, so
  * a track re-pointed in the config editor stops serving the old header's
- * descriptions. Cleared on failure so a later click retries. No stop token and
+ * descriptions. Cleared on failure so a later click retries. No signal and
  * no status: nothing to narrate, and nothing a cancel could save — the widget
  * opens on the result.
  */

package/esm/util/adapterMetadata.js

@@ -1,3 +1,4 @@
+import { isDataCurrent } from './isDataCurrent.js';
 import { getRpcSessionId } from './parentWalk.js';
 import { getRpcHost } from './sessionServices.js';
 /**
@@ -12,19 +13,19 @@ import { getRpcHost } from './sessionServices.js';
  *
  * Keyed on the adapter config rather than memoized for the display's life, so
  * a track re-pointed in the config editor stops serving the old header's
- * descriptions. Cleared on failure so a later click retries. No stop token and
+ * descriptions. Cleared on failure so a later click retries. No signal and
  * no status: nothing to narrate, and nothing a cancel could save — the widget
  * opens on the result.
  */
 export function createAdapterMetadataFetch(self) {
     let cached;
     return () => {
-        const key = JSON.stringify(self.adapterConfig);
-        if (cached?.key !== key) {
+        const { adapterConfig } = self;
+        if (!cached || !isDataCurrent(cached.adapterConfig, adapterConfig)) {
             const promise = getRpcHost(self)
                 // eslint-disable-next-line no-restricted-syntax -- nothing to narrate, nothing a cancel could save
                 .rpcManager.call(getRpcSessionId(self), 'CoreGetMetadata', {
-                adapterConfig: self.adapterConfig,
+                adapterConfig,
             })
                 .catch((e) => {
                 if (cached?.promise === promise) {
@@ -32,7 +33,7 @@ export function createAdapterMetadataFetch(self) {
                 }
                 throw e;
             });
-            cached = { key, promise };
+            cached = { adapterConfig, promise };
         }
         return cached.promise;
     };

package/esm/util/addAndShowTrack.d.ts

@@ -15,8 +15,5 @@ import type { SessionWithAddSessionTrack } from './types/index.ts';
 export declare function addAndShowTrack(session: SessionWithAddSessionTrack, conf: Parameters<SessionWithAddSessionTrack['addSessionTrackConf']>[0] & {
     trackId: string;
 }, view?: {
-    showTrack: (trackId: string) => void;
-}): (import("@jbrowse/mobx-state-tree").ModelInstanceTypeProps<Record<string, any>> & {
-    setSubschema(slotName: string, data: Record<string, unknown>): any;
-    setSlot(slotName: string, value: unknown): void;
-} & import("@jbrowse/mobx-state-tree").IStateTreeNode<import("../configuration/types.ts").AnyConfigurationSchemaType>) | undefined;
+    launchTrack: (trackId: string) => Promise<unknown>;
+}): import("../configuration/types.ts").AnyConfigurationModel | undefined;

package/esm/util/addAndShowTrack.js

@@ -16,8 +16,12 @@ export function addAndShowTrack(session, conf, view) {
     // addSessionTrackConf already notified on an invalid conf; showing a trackId
     // that was never added would only add a second "Could not resolve identifier"
     // snackbar
+    //
+    // `launchTrack`, voided: the display's state model may still be a dynamic
+    // import away, and every caller here is a menu item or a dialog button whose
+    // return value is the added config rather than the opened track
     if (added) {
-        view?.showTrack(conf.trackId);
+        void view?.launchTrack(conf.trackId);
     }
     return added;
 }

package/esm/util/addRelativeUris.d.ts

@@ -1,14 +1,26 @@
 /**
- * Stamp `baseUri` next to every `uri` in a config so relative URIs resolve
- * against the location the config itself was loaded from. jbrowse-web runs this
- * when it fetches a config.json from a URL; anything that injects a fetched
- * config as an object (a hub, a track hub connection, a headless render) has to
- * run it too, or the config's relative data URIs resolve against the page.
+ * Stamp `baseUri` next to every `uri` in a config, and beside a MultiWiggle
+ * `bigWigs` array of bare URI strings, so relative URIs resolve against the
+ * location the config itself was loaded from. A file written as a bare string
+ * where a location object can go (a search index, `refNameAliases`,
+ * `cytobands`, a `bedLocations` entry) has no object to stamp, so it becomes
+ * `{ uri, baseUri }`.
+ * jbrowse-web runs this when it fetches a config.json from a URL; anything that
+ * injects a fetched config as an object (a hub, a track hub connection, a
+ * headless render) has to run it too, or the config's relative data URIs
+ * resolve against the page.
  *
  * Lives in core because core is what consumes the result — the assembly config
  * schema and expandAssemblyConfigShorthand read `baseUri` back out.
  */
 export declare function addRelativeUris(config: Record<string, unknown> | null, base: URL): void;
+/**
+ * A copy of `config` with every relative URI stamped against the page, which
+ * is what the page itself would resolve it against. An RPC worker started from
+ * a `blob:` URL has no such base, so a location it receives without one fails
+ * to parse there.
+ */
+export declare function withPageBaseUri<T>(config: T): T;
 /**
  * Inverse of {@link addRelativeUris}: recursively delete every synthetic
  * `baseUri` key (mutates in place), e.g. before serializing a config snapshot