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

package/esm/util/cellsStep.js

@@ -0,0 +1,439 @@
+// The `cells` step: each row's runs against the reference it was fanned out
+// of, and the texts its walk reads, which the fused identity kernel in
+// cellMatches.ts walks too. Imported by relative path only.
+import { DASH, SPACE, firstDrawn, isGapByte, isUnknownBase, lastDrawn, sameBase, } from './alignedBytes.js';
+import { DerivedTable, numberReaderOf, readerOf, valueAt, } from './featureTable.js';
+import { FannedTable, boundsThrough } from './stepTables.js';
+export const DEFAULT_CELLS_FIELD = 'seq';
+const CELL_STATES = ['match', 'mismatch', 'gap', 'insertion'];
+export const MATCH = 0;
+export const MISMATCH = 1;
+const GAP = 2;
+const INSERTION = 3;
+export const NO_STATE = 255;
+// A reference base's cell: no state outside the drawn columns, else the row's
+// gap, or its base matched or not regardless of case.
+export function cellState(refByte, rowByte, drawn) {
+    return !drawn
+        ? NO_STATE
+        : isGapByte(rowByte)
+            ? GAP
+            : sameBase(refByte, rowByte)
+                ? MATCH
+                : MISMATCH;
+}
+// Whether a cell counts toward identity: matched or not against a known
+// reference base.
+export function comparesBase(state, refByte) {
+    return state <= MISMATCH && !isUnknownBase(refByte);
+}
+// What the cells of one run share besides their state: whether they are
+// compared, so a run's `match` is one value.
+export function runKey(state, refByte) {
+    return state <= MISMATCH && isUnknownBase(refByte) ? 1 : 0;
+}
+// A mismatch always starts a run of its own, so each differing base is one
+// instance and a text over `base` letters every one.
+export function opensRun(state, key, runState, openKey) {
+    return state !== runState || key !== openKey || state === MISMATCH;
+}
+// The row a cell step reads against: past any table that only reordered or
+// annotated the rows, the one they were fanned out of.
+function containerOf(table) {
+    let at = table;
+    let toBase;
+    while (at instanceof DerivedTable && !at.madeFrom) {
+        toBase = at.parentRow ? compose(toBase, at.parentRow) : toBase;
+        at = at.parent;
+    }
+    if (!(at instanceof DerivedTable)) {
+        return undefined;
+    }
+    return {
+        made: at,
+        toMade: toBase,
+        table: at.parent,
+        row: at.parentRow ? compose(toBase, at.parentRow) : toBase,
+    };
+}
+function compose(outer, inner) {
+    if (!outer) {
+        return inner;
+    }
+    const out = new Uint32Array(outer.length);
+    for (let i = 0; i < outer.length; i++) {
+        out[i] = inner[outer[i]];
+    }
+    return out;
+}
+// Below this length a character loop copies a string faster than
+// `encodeInto`, as the MAF packer measured.
+const ASCII_COPY_MAX_LENGTH = 64;
+const encoder = new TextEncoder();
+// A column's text as bytes, one per character: an adapter's own, or the
+// strings a feature holds copied into one buffer.
+function textOf(column, n) {
+    if (column.kind === 'text') {
+        return column;
+    }
+    const read = readerOf(column);
+    const texts = new Array(n);
+    let total = 0;
+    for (let i = 0; i < n; i++) {
+        const v = read(i);
+        if (typeof v === 'string') {
+            texts[i] = v;
+            total += v.length;
+        }
+    }
+    const bytes = new Uint8Array(total);
+    const offset = new Uint32Array(n);
+    const length = new Uint32Array(n);
+    let pos = 0;
+    for (let i = 0; i < n; i++) {
+        const text = texts[i];
+        if (text === undefined) {
+            continue;
+        }
+        offset[i] = pos;
+        if (text.length <= ASCII_COPY_MAX_LENGTH) {
+            for (let c = 0; c < text.length; c++) {
+                bytes[pos + c] = text.charCodeAt(c);
+            }
+            length[i] = text.length;
+        }
+        else {
+            length[i] = encoder.encodeInto(text, bytes.subarray(pos, pos + text.length)).written;
+        }
+        pos += text.length;
+    }
+    return { kind: 'text', bytes, offset, length, at: undefined };
+}
+/**
+ * The texts a `cells` walk reads, by the row of the table it walked: each
+ * row's own, and the reference it is read against, which a row fanned out of
+ * a container reads off the container.
+ */
+class WalkedTexts {
+    row;
+    reference;
+    refRow;
+    constructor(row, ref, refRow) {
+        this.row = row;
+        this.reference = ref;
+        this.refRow = refRow;
+    }
+    rowOf(r) {
+        const { at } = this.row;
+        return at ? at[r] : r;
+    }
+    refOf(r) {
+        const p = this.refRow ? this.refRow[r] : r;
+        const { at } = this.reference;
+        return at ? at[p] : p;
+    }
+}
+export function walkedTexts(table, field) {
+    const row = textOf(table.column(field), table.length);
+    const container = containerOf(table);
+    const made = container?.made;
+    if (container && !(made instanceof FannedTable && made.hasKept)) {
+        const { table: base } = container;
+        return new WalkedTexts(row, textOf(base.column(field), base.length), container.row);
+    }
+    // A container a flatten kept with nothing to fan out is the row itself, so
+    // its reference is its own container's, as its `parent()` says.
+    const byParent = (r) => table.row(r).parent?.()?.get(field);
+    const readContainer = container
+        ? readerOf(container.table.column(field))
+        : undefined;
+    const read = readContainer && made instanceof FannedTable
+        ? (r) => {
+            const { toMade, row: refRow } = container;
+            return made.isKept(toMade ? toMade[r] : r)
+                ? byParent(r)
+                : readContainer(refRow ? refRow[r] : r);
+        }
+        : byParent;
+    return new WalkedTexts(row, textOf({ kind: 'value', read }, table.length));
+}
+/**
+ * The runs a `cells` step answers, one per stretch of one state against the
+ * reference, typed: each run's span, its state and the text column it starts
+ * at, with `base`, `match` and `length` read back out of the texts when asked
+ * for.
+ */
+class CellTable extends DerivedTable {
+    start;
+    end;
+    state;
+    textAt;
+    texts;
+    firstOfRow;
+    derived = new Map();
+    constructor(parent, parentRow, lanes, texts) {
+        super(parent, parentRow);
+        this.start = lanes.start;
+        this.end = lanes.end;
+        this.state = lanes.state;
+        this.textAt = lanes.textAt;
+        this.texts = texts;
+    }
+    get madeFrom() {
+        return true;
+    }
+    laneOf(name, build) {
+        let column = this.derived.get(name);
+        if (!column) {
+            column = build();
+            this.derived.set(name, column);
+        }
+        return column;
+    }
+    own(name) {
+        switch (name) {
+            case 'start': {
+                return { kind: 'number', values: this.start, at: undefined };
+            }
+            case 'end': {
+                return { kind: 'number', values: this.end, at: undefined };
+            }
+            case 'state': {
+                return {
+                    kind: 'category',
+                    codes: this.state,
+                    labels: CELL_STATES,
+                    at: undefined,
+                };
+            }
+            case 'match': {
+                return this.laneOf(name, () => {
+                    const values = new Float32Array(this.length);
+                    for (let i = 0; i < this.length; i++) {
+                        const s = this.state[i];
+                        values[i] = comparesBase(s, this.refByte(i))
+                            ? s === MATCH
+                                ? 1
+                                : 0
+                            : Number.NaN;
+                    }
+                    return { kind: 'number', values, at: undefined, nanIsAbsent: true };
+                });
+            }
+            case 'length': {
+                return this.laneOf(name, () => {
+                    const values = new Float32Array(this.length).fill(Number.NaN);
+                    for (let i = 0; i < this.length; i++) {
+                        if (this.state[i] === INSERTION) {
+                            values[i] = this.inserted(i).length;
+                        }
+                    }
+                    return { kind: 'number', values, at: undefined, nanIsAbsent: true };
+                });
+            }
+            case 'base': {
+                return this.laneOf(name, () => {
+                    const values = new Array(this.length);
+                    for (let i = 0; i < this.length; i++) {
+                        const s = this.state[i];
+                        values[i] =
+                            s === MISMATCH
+                                ? this.mismatched(i)
+                                : s === INSERTION
+                                    ? this.inserted(i)
+                                    : undefined;
+                    }
+                    return { kind: 'value', read: i => values[i] };
+                });
+            }
+            default: {
+                return undefined;
+            }
+        }
+    }
+    refByte(i) {
+        const { reference: ref } = this.texts;
+        const f = this.texts.refOf(this.parentOf(i));
+        return ref.bytes[ref.offset[f] + this.textAt[i]];
+    }
+    mismatched(i) {
+        const { bytes, offset } = this.texts.row;
+        const k = this.texts.rowOf(this.parentOf(i));
+        return String.fromCharCode(bytes[offset[k] + this.textAt[i]]);
+    }
+    // The bases a row holds where the reference has none, from the column the
+    // insertion starts at to the reference's next base.
+    inserted(i) {
+        const { row, reference: ref } = this.texts;
+        const r = this.parentOf(i);
+        const k = this.texts.rowOf(r);
+        const f = this.texts.refOf(r);
+        const rowAt = row.offset[k];
+        const refAt = ref.offset[f];
+        const end = Math.min(row.length[k], ref.length[f]);
+        let out = '';
+        for (let col = this.textAt[i]; col < end && ref.bytes[refAt + col] === DASH; col++) {
+            const b = row.bytes[rowAt + col];
+            if (!isGapByte(b)) {
+                out += String.fromCharCode(b);
+            }
+        }
+        return out;
+    }
+    id(i) {
+        const p = this.parentOf(i);
+        this.firstOfRow ??= firstRowIndex(this.parentRow, this.parent.length);
+        return `${this.parent.row(p).id()}#${i - this.firstOfRow[p]}`;
+    }
+    json(i) {
+        const out = {
+            ...this.parent.row(this.parentOf(i)).toJSON(),
+            start: this.start[i],
+            end: this.end[i],
+            state: CELL_STATES[this.state[i]],
+        };
+        for (const name of ['base', 'match', 'length']) {
+            const v = valueAt(this.column(name), i);
+            if (v !== undefined) {
+                out[name] = v;
+            }
+        }
+        return out;
+    }
+}
+// The lanes a `cells` walk writes, doubled as a row would overrun them.
+class RunLanes {
+    start;
+    end;
+    state;
+    textAt;
+    parentRow;
+    length = 0;
+    constructor(capacity) {
+        this.start = new Uint32Array(capacity);
+        this.end = new Uint32Array(capacity);
+        this.state = new Uint8Array(capacity);
+        this.textAt = new Uint32Array(capacity);
+        this.parentRow = new Uint32Array(capacity);
+    }
+    reserve(more) {
+        const need = this.length + more;
+        if (need <= this.start.length) {
+            return;
+        }
+        const size = Math.max(this.start.length * 2, need);
+        const widen = (a) => {
+            const next = new a.constructor(size);
+            next.set(a);
+            return next;
+        };
+        this.start = widen(this.start);
+        this.end = widen(this.end);
+        this.state = widen(this.state);
+        this.textAt = widen(this.textAt);
+        this.parentRow = widen(this.parentRow);
+    }
+    // One row's runs against its reference: a run per column is the most it
+    // can answer, so the lanes grow once and the walk writes through locals.
+    walk(r, startPos, rowBytes, rowAt, rowLen, refBytes, refAt, refLen) {
+        this.reserve(refLen + 1);
+        const { start, end, state, textAt, parentRow } = this;
+        let n = this.length;
+        let pos = startPos;
+        const first = firstDrawn(rowBytes, rowAt, rowLen);
+        const last = lastDrawn(rowBytes, rowAt, rowLen, first);
+        let runStart = -1;
+        let runState = NO_STATE;
+        let openKey = -1;
+        let runCol = 0;
+        let insertAt = -1;
+        for (let col = 0; col < refLen; col++) {
+            const refByte = refBytes[refAt + col];
+            const rowByte = col < rowLen ? rowBytes[rowAt + col] : SPACE;
+            if (refByte === DASH) {
+                if (insertAt < 0 && col < rowLen && !isGapByte(rowByte)) {
+                    insertAt = col;
+                }
+                continue;
+            }
+            if (insertAt >= 0) {
+                start[n] = pos;
+                end[n] = pos;
+                state[n] = INSERTION;
+                textAt[n] = insertAt;
+                parentRow[n] = r;
+                n++;
+                insertAt = -1;
+            }
+            const st = cellState(refByte, rowByte, col >= first && col <= last && col < rowLen);
+            const key = runKey(st, refByte);
+            if (opensRun(st, key, runState, openKey)) {
+                if (runStart >= 0) {
+                    start[n] = runStart;
+                    end[n] = pos;
+                    state[n] = runState;
+                    textAt[n] = runCol;
+                    parentRow[n] = r;
+                    n++;
+                }
+                runStart = st === NO_STATE ? -1 : pos;
+                runState = st;
+                openKey = key;
+                runCol = col;
+            }
+            pos++;
+        }
+        if (runStart >= 0) {
+            start[n] = runStart;
+            end[n] = pos;
+            state[n] = runState;
+            textAt[n] = runCol;
+            parentRow[n] = r;
+            n++;
+        }
+        this.length = n;
+    }
+}
+// Where each parent row's children start, for children written parent by
+// parent in order.
+function firstRowIndex(parentRow, parents) {
+    const first = new Uint32Array(parents);
+    for (let i = parentRow.length - 1; i >= 0; i--) {
+        first[parentRow[i]] = i;
+    }
+    return first;
+}
+export function cells({ table, bounds }, step) {
+    const { field = DEFAULT_CELLS_FIELD } = step;
+    const texts = walkedTexts(table, field);
+    const readStart = numberReaderOf(table.column('start'));
+    const { bytes: rowBytes, offset: rowOffset, length: rowLength } = texts.row;
+    const { bytes: refBytes, offset: refOffset, length: refLength, } = texts.reference;
+    // A run per reference base is the most a row can answer and far past what
+    // one does, so the lanes start at an eighth of it.
+    let bound = 0;
+    for (let r = 0; r < table.length; r++) {
+        bound += refLength[texts.refOf(r)] + 1;
+    }
+    const lanes = new RunLanes(Math.max(1024, bound >>> 3));
+    for (let r = 0; r < table.length; r++) {
+        const f = texts.refOf(r);
+        const refLen = refLength[f];
+        const pos = readStart(r);
+        if (refLen > 0 && pos >= 0) {
+            const k = texts.rowOf(r);
+            lanes.walk(r, pos, rowBytes, rowOffset[k], rowLength[k], refBytes, refOffset[f], refLen);
+        }
+    }
+    const n = lanes.length;
+    const rows = lanes.parentRow.subarray(0, n);
+    return {
+        table: new CellTable(table, rows, {
+            start: lanes.start.subarray(0, n),
+            end: lanes.end.subarray(0, n),
+            state: lanes.state.subarray(0, n),
+            textAt: lanes.textAt.subarray(0, n),
+        }, texts),
+        bounds: boundsThrough(bounds, rows),
+    };
+}

package/esm/util/color-bits/parse.js

@@ -239,16 +239,27 @@ export function parseColor(color) {
     }
     throw new Error(`Color.parse(): invalid CSS color: "${color}"`);
 }
+/** A channel's leading number, throwing where it has none, as `rgb(a,b,1)`. */
+function parseNumber(value) {
+    const n = Number.parseFloat(value);
+    if (Number.isNaN(n)) {
+        throw new TypeError(`Color.parse(): invalid CSS color channel: "${value}"`);
+    }
+    return n;
+}
 /**
- * Accepts: "50%", "128"
+ * Accepts: "50%", "128", "none"
  * https://developer.mozilla.org/en-US/docs/Web/CSS/color_value/rgb#values
  * @returns a value in the 0 to 255 range
  */
 function parseColorChannel(channel) {
+    if (channel === 'none') {
+        return 0;
+    }
     if (channel.charCodeAt(channel.length - 1) === PERCENT) {
-        return Math.round((Number.parseFloat(channel) / 100) * 255);
+        return Math.round((parseNumber(channel) / 100) * 255);
     }
-    return Math.round(Number.parseFloat(channel));
+    return Math.round(parseNumber(channel));
 }
 /**
  * Accepts: "50%", ".5", "0.5"
@@ -268,9 +279,9 @@ function parseAlphaValue(channel) {
         return 0;
     }
     if (channel.charCodeAt(channel.length - 1) === PERCENT) {
-        return Number.parseFloat(channel) / 100;
+        return parseNumber(channel) / 100;
     }
-    return Number.parseFloat(channel);
+    return parseNumber(channel);
 }
 /**
  * Accepts: "360", "360deg", "400grad", "6.28rad", "1turn", "none"
@@ -302,7 +313,7 @@ function parseAngle(angle) {
             factor = 360;
         }
     }
-    const turns = Number.parseFloat(angle) / factor;
+    const turns = parseNumber(angle) / factor;
     // Hue is periodic, and every caller of this is a hue. `hueToRGB` corrects its
     // argument by at most one turn, so it reads `hsl(-720deg)` as a hue two turns
     // below the wheel rather than as red — folding here is what makes the three
@@ -317,7 +328,7 @@ function parsePercentage(value) {
     if (value.charCodeAt(0) === N) {
         return 0;
     }
-    return Number.parseFloat(value) / 100;
+    return parseNumber(value) / 100;
 }
 /**
  * Accepts: "1.0", "100%", "none"
@@ -328,9 +339,9 @@ function parsePercentageOrValue(value) {
         return 0;
     }
     if (value.charCodeAt(value.length - 1) === PERCENT) {
-        return Number.parseFloat(value) / 100;
+        return parseNumber(value) / 100;
     }
-    return Number.parseFloat(value);
+    return parseNumber(value);
 }
 /**
  * Accepts: "100", "100%", "none"
@@ -341,9 +352,9 @@ function parsePercentageFor(value, range) {
         return 0;
     }
     if (value.charCodeAt(value.length - 1) === PERCENT) {
-        return (Number.parseFloat(value) / 100) * range;
+        return (parseNumber(value) / 100) * range;
     }
-    return Number.parseFloat(value);
+    return parseNumber(value);
 }
 // HSL functions
 function hueToRGB(p, q, t) {

package/esm/util/colorRamp.js

@@ -90,6 +90,11 @@ const PURPLEORANGE_STOPS = [
     [179, 88, 6, 255],
     [127, 59, 8, 255],
 ];
+const REDGREYBLUE_STOPS = [
+    [199, 67, 56, 255],
+    [140, 140, 140, 255],
+    [47, 102, 176, 255],
+];
 const SCHEME_STOPS = {
     viridis: VIRIDIS_STOPS,
     juicebox: JUICEBOX_STOPS,
@@ -101,6 +106,7 @@ const SCHEME_STOPS = {
     cividis: stopsFromHex(CIVIDIS_HEX_SPEC),
     redblue: REDBLUE_STOPS,
     purpleorange: PURPLEORANGE_STOPS,
+    redgreyblue: REDGREYBLUE_STOPS,
 };
 function luminanceOverWhite([r, g, b, a]) {
     const over = (c) => 255 + (c - 255) * (a / 255);

package/esm/util/colorScale.d.ts

@@ -36,8 +36,8 @@ export interface FieldPreset<S extends string = ColorScaleName> {
 export type FieldPresets<S extends string = ColorScaleName> = Readonly<Record<string, FieldPreset<S>>>;
 /**
  * The fields whose values have names, an order and colours of their own on
- * every display, beneath each display's own presets. Red forward and blue
- * reverse is what the synteny ribbons paint too. The SV classes are
+ * every display, beneath each display's own presets. The synteny ribbons
+ * paint strand from this range too. The SV classes are
  * `svClassOf`'s, deletion red and duplication blue as dbVar and gnomAD-SV
  * paint them, insertion the pileup's purple, and the rest kept apart under
  * deuteranopia and protanopia. A record with no class files under `''`, so
@@ -143,6 +143,13 @@ export interface ColorSlots {
     domainQuantile?: number;
     labels?: readonly unknown[];
 }
+/** A quantitative scale's ends among the members `member` reads, each a number or unset. */
+export declare function scaleEndsOf(member: (name: string) => unknown): ScaleEnds;
+/**
+ * The members `colorProblems` reads among the ones `member` reads, each of the
+ * type it reads or unset, so a config snapshot and a config node answer alike.
+ */
+export declare function colorSlotsOf(member: (name: string) => unknown): ColorSlots;
 /**
  * What a colour object's slots say together that no single slot can refuse,
  * since the config editor writes one slot at a time (ADR-133), read with its

package/esm/util/colorScale.js

@@ -20,8 +20,8 @@ export const IDENTITY_SCALE = 'identity';
 const CATEGORICAL_PRESET = { scale: 'categorical' };
 /**
  * The fields whose values have names, an order and colours of their own on
- * every display, beneath each display's own presets. Red forward and blue
- * reverse is what the synteny ribbons paint too. The SV classes are
+ * every display, beneath each display's own presets. The synteny ribbons
+ * paint strand from this range too. The SV classes are
  * `svClassOf`'s, deletion red and duplication blue as dbVar and gnomAD-SV
  * paint them, insertion the pileup's purple, and the rest kept apart under
  * deuteranopia and protanopia. A record with no class files under `''`, so
@@ -165,6 +165,37 @@ export function scaleEndProblems({ domainMin, domainMax, domainQuantile }, { rev
 export function noticeLines(setting, problems) {
     return problems.map(({ slot, message }) => `${setting}.${slot}: ${message}`);
 }
+function numberOf(value) {
+    return typeof value === 'number' ? value : undefined;
+}
+function stringOf(value) {
+    return typeof value === 'string' ? value : undefined;
+}
+function listOf(value) {
+    return Array.isArray(value) ? value : undefined;
+}
+/** A quantitative scale's ends among the members `member` reads, each a number or unset. */
+export function scaleEndsOf(member) {
+    return {
+        domainMin: numberOf(member('domainMin')),
+        domainMax: numberOf(member('domainMax')),
+        domainQuantile: numberOf(member('domainQuantile')),
+    };
+}
+/**
+ * The members `colorProblems` reads among the ones `member` reads, each of the
+ * type it reads or unset, so a config snapshot and a config node answer alike.
+ */
+export function colorSlotsOf(member) {
+    return {
+        ...scaleEndsOf(member),
+        field: stringOf(member('field')) ?? '',
+        scale: stringOf(member('scale')),
+        domain: listOf(member('domain')),
+        range: listOf(member('range')),
+        labels: listOf(member('labels')),
+    };
+}
 function pinned(entry) {
     return entry !== '' && Number.isFinite(Number(entry));
 }

package/esm/util/colorSchemes.d.ts

@@ -7,9 +7,11 @@
  * transparent to red, as Juicebox paints contacts; `fall` runs white through
  * yellow and red to black, as HiGlass does; `reds` and `blues` are
  * ColorBrewer's, from white; `redblue` and `purpleorange` diverge through
- * white, ColorBrewer's RdBu and PuOr.
+ * white, ColorBrewer's RdBu and PuOr; `redgreyblue` diverges through a grey
+ * middle, which stays visible on a white page where a white middle would not,
+ * as the MAF display's identity ramp paints it.
  */
-export declare const COLOR_SCHEMES: readonly ['viridis', 'magma', 'inferno', 'cividis', 'juicebox', 'fall', 'reds', 'blues', 'redblue', 'purpleorange'];
+export declare const COLOR_SCHEMES: readonly ['viridis', 'magma', 'inferno', 'cividis', 'juicebox', 'fall', 'reds', 'blues', 'redblue', 'purpleorange', 'redgreyblue'];
 /** #api */
 export type ColorSchemeName = (typeof COLOR_SCHEMES)[number];
 /**

package/esm/util/colorSchemes.js

@@ -7,7 +7,9 @@
  * transparent to red, as Juicebox paints contacts; `fall` runs white through
  * yellow and red to black, as HiGlass does; `reds` and `blues` are
  * ColorBrewer's, from white; `redblue` and `purpleorange` diverge through
- * white, ColorBrewer's RdBu and PuOr.
+ * white, ColorBrewer's RdBu and PuOr; `redgreyblue` diverges through a grey
+ * middle, which stays visible on a white page where a white middle would not,
+ * as the MAF display's identity ramp paints it.
  */
 export const COLOR_SCHEMES = [
     'viridis',
@@ -20,6 +22,7 @@ export const COLOR_SCHEMES = [
     'blues',
     'redblue',
     'purpleorange',
+    'redgreyblue',
 ];
 /**
  * #api

package/esm/util/copyToClipboard.js

@@ -7,7 +7,14 @@ export default async function copyToClipboard(text, options = {}) {
     // navigator.clipboard is only present in secure contexts; isSecureContext is
     // the real gate, so insecure http:// falls through to execCommand below
     if (format === 'text/plain' && window.isSecureContext) {
-        await navigator.clipboard.writeText(text);
+        try {
+            await navigator.clipboard.writeText(text);
+        }
+        catch (e) {
+            if (!execCommandCopy(text, format)) {
+                throw e;
+            }
+        }
     }
     else if (!execCommandCopy(text, format)) {
         throw new Error('the browser rejected the clipboard write');

package/esm/util/createAbortRotation.js

@@ -81,9 +81,9 @@ export function createAbortRotation(self, report) {
             // Opened before the superseded slot retires, so the window is never idle
             // across the handover and the label on screen survives it (ADR-080).
             // Retired here rather than left to the superseded run's `finally`, which
-            // comes only when its work settles — and a CRAM record read or a shared
-            // parse the signal is withheld from runs on past the abort, its last
-            // reading summed into this fetch's bar the whole time.
+            // comes only when its work settles — and a CRAM record read, or a shared
+            // `cachedSetup` parse the replacement rejoins, runs on past the abort,
+            // its last reading summed into this fetch's bar the whole time.
             const stream = statusWindow.open({ isCurrent });
             openStream?.clear();
             openStream = stream;