@jbrowse/core 5.0.0-beta.2 → 5.0.0-beta.4

package/esm/ui/legendMenuItem.js

@@ -1,4 +1,3 @@
-import { promotableToggleItem } from './promotableMenuItems.js';
 import { checkboxItem } from './toggleMenuItems.js';
 /**
  * The "Show legend" checkbox, which seven displays build by hand — Hi-C, LD,
@@ -14,31 +13,21 @@ import { checkboxItem } from './toggleMenuItems.js';
  * values legitimately differ (a Hi-C color scale is off by default, a variant
  * genotype key on), and their descriptions describe genuinely different legends.
  * What they now share is being *promotable* — pass `opts.pin` and the row gains
- * the pin that applies the current state to every open track of this display
- * type, offering the display-type default as its snackbar's one action. Every
+ * the pin that toggles the legend on every open track of this display type,
+ * offering the new state as the display-type default in its snackbar. Every
  * display whose legend is backed by a config slot passes one, and gets it from
- * `LegendMixin`'s `showLegendDisplayTypeDefault` rather than calling `makePin`
- * itself: the slot is the per-display half, the accessors over it are not.
+ * `LegendMixin`'s `showLegendDisplayTypeDefault` rather than calling
+ * `makeTogglePin` itself: the slot is the per-display half, the accessors over
+ * it are not.
  *
  * `pin` is optional because two callers have no slot to promote: the Manhattan
  * plot's LD legend and `LinearBasicDisplay`'s color key are a volatile and a
  * per-legend `dismissed` flag respectively, neither of which is config at all.
- * They get the plain row, which is what `checkboxItem` builds either way — the
- * promotable form is that same row plus the pin, per `promotableToggleItem`.
  *
- * Deliberately not used by `synteny-core`'s "Show color legend", which sits
- * inside a "Color by..." submenu where the bare word would not say which legend.
+ * `synteny-core`'s color-by legend has no toggle at all: it comes up with the
+ * modes that have a key and is dismissed from its own close button.
  */
 /** #menuBuilder showLegendCheckboxItem | the shared "Show legend" checkbox */
 export function showLegendCheckboxItem(checked, onToggle, opts) {
-    const { pin, ...rest } = opts ?? {};
-    return pin
-        ? promotableToggleItem({
-            label: 'Show legend',
-            checked,
-            onToggle,
-            pin,
-            ...rest,
-        })
-        : checkboxItem('Show legend', checked, onToggle, rest);
+    return checkboxItem('Show legend', checked, onToggle, opts);
 }

package/esm/ui/menuItemAdornment.d.ts

@@ -6,9 +6,8 @@ import type { MenuItem } from './MenuTypes.ts';
  * the builder already made — the escape hatch, for content nothing else can
  * describe. `pin` is a *description* of the "default for all tracks of
  * this type" pin, and turning it into `PinAdornment` here is the whole
- * point: the builders that set it (`promotableToggleItem`,
- * `promotableRadioItem`) are called from state models and menu modules, which
- * are eager, so a module that constructs the element instead puts MUI's
+ * point: the row builders that set it (`toggleMenuItems.ts`) are called from
+ * state models and menu modules, which are eager, so a module that constructs the element instead puts MUI's
  * `ToggleButton`, `Tooltip` and two icons into every host's first paint.
  *
  * Live in one place rather than at each of the four render sites, because the

package/esm/ui/menuItemAdornment.js

@@ -7,9 +7,8 @@ import { PinAdornment } from './PinAdornment.js';
  * the builder already made — the escape hatch, for content nothing else can
  * describe. `pin` is a *description* of the "default for all tracks of
  * this type" pin, and turning it into `PinAdornment` here is the whole
- * point: the builders that set it (`promotableToggleItem`,
- * `promotableRadioItem`) are called from state models and menu modules, which
- * are eager, so a module that constructs the element instead puts MUI's
+ * point: the row builders that set it (`toggleMenuItems.ts`) are called from
+ * state models and menu modules, which are eager, so a module that constructs the element instead puts MUI's
  * `ToggleButton`, `Tooltip` and two icons into every host's first paint.
  *
  * Live in one place rather than at each of the four render sites, because the

package/esm/ui/menuItems.d.ts

@@ -22,7 +22,6 @@ export { checkboxItem, radioItem, radioItems, toggleItem, withSubHeader, } from
 export { withHint } from './menuLabels.ts';
 export { makeRadioSubMenu } from './radioSubMenu.ts';
 export { showLegendCheckboxItem } from './legendMenuItem.ts';
-export { promotableRadioItem, promotableRadioItems, promotableToggleItem, } from './promotableMenuItems.ts';
-export type { RadioOption, SettingRowOptions } from './toggleMenuItems.ts';
+export type { CheckboxRowOptions, RadioOption, RadioRowOptions, SettingRowOptions, } from './toggleMenuItems.ts';
 export { resolveSubMenu, staysOpenOnClick } from './MenuTypes.ts';
 export type { BaseMenuItem, CheckboxMenuItem, ClickableMenuItem, CustomMenuItem, MenuDivider, MenuItem, MenuItemClickHandler, MenuItemPin, MenuItemsGetter, MenuSubHeader, NormalMenuItem, RadioMenuItem, SubMenuItem, } from './MenuTypes.ts';

package/esm/ui/menuItems.js

@@ -22,5 +22,4 @@ export { checkboxItem, radioItem, radioItems, toggleItem, withSubHeader, } from
 export { withHint } from './menuLabels.js';
 export { makeRadioSubMenu } from './radioSubMenu.js';
 export { showLegendCheckboxItem } from './legendMenuItem.js';
-export { promotableRadioItem, promotableRadioItems, promotableToggleItem, } from './promotableMenuItems.js';
 export { resolveSubMenu, staysOpenOnClick } from './MenuTypes.js';

package/esm/ui/palette.d.ts

@@ -117,33 +117,33 @@ export interface SemanticColors {
 export declare const colorFwdStrand = "#EC8B8B";
 /** #color alignments-strand | Reverse strand | Read maps to the reverse strand */
 export declare const colorRevStrand = "#8F8FD8";
-/** #color alignments-pair-orientation | LR (→ ←, normal proper pair) | Concordant */
+/** #color alignments-pair-orientation | LR (→ ←) | Normal proper pair */
 export declare const colorPairLR = "#d3d3d3";
 export declare const colorPairLRDark = "#8a8a8a";
-/** #color alignments-pair-orientation | RL (← →, mates point away from each other) | Abnormal orientation */
+/** #color alignments-pair-orientation | RL (← →) | Mates point away from each other */
 export declare const colorPairRL = "#0099bb";
-/** #color alignments-pair-orientation | LL (→ →, both mates forward strand) | Abnormal orientation */
+/** #color alignments-pair-orientation | LL (→ →) | Both mates on the forward strand */
 export declare const colorPairLL = "#4d9a4d";
-/** #color alignments-pair-orientation | RR (← ←, both mates reverse strand) | Abnormal orientation */
+/** #color alignments-pair-orientation | RR (← ←) | Both mates on the reverse strand */
 export declare const colorPairRR = "#5555bb";
 export declare const colorNeutralRead = "#c8c8c8";
 /**
- * #color alignments-pair-orientation | Inter-chromosomal | Mate maps to a different chromosome; colored distinctly rather than by orientation
- * #color alignments-insert-size | Mate on a different chromosome | Suggests an inter-chromosomal event
+ * #color alignments-pair-orientation | Inter-chromosomal | Mate on another chromosome
+ * #color alignments-insert-size | Inter-chromosomal | Mate on another chromosome
  */
 export declare const colorInterchrom = "#af4d19";
-/** #color alignments-insert-size | Insert larger than expected | Suggests a deletion spanning the pair */
+/** #color alignments-insert-size | Insert larger than expected | Deletion between the mates */
 export declare const colorLongInsert = "#ff0000";
-/** #color alignments-insert-size | Insert smaller than expected | Suggests an insertion between the pair */
+/** #color alignments-insert-size | Insert smaller than expected | Insertion between the mates */
 export declare const colorShortInsert = "#f582c0";
 /**
- * #color alignments-pair-orientation | Mate unmapped | The other end of the pair aligned nowhere, so orientation and insert size say nothing
- * #color alignments-insert-size | Mate unmapped | The other end of the pair aligned nowhere, so insert size says nothing
+ * #color alignments-pair-orientation | Mate unmapped | Mate aligned nowhere
+ * #color alignments-insert-size | Mate unmapped | Mate aligned nowhere
  */
 export declare const colorUnmappedMate = "#000000";
 export declare const colorUnmappedMateDark = "#4a4a4a";
 export declare const colorLongreadInv = "#7755bb";
-/** #color alignments-pair-orientation | Split paired-end read (inverted) | A paired read's supplementary segment maps opposite-strand to its primary, so the junction is inverted — an inversion or an inverted duplication */
+/** #color alignments-pair-orientation | Split read (inverted) | Supplementary segment on the opposite strand to its primary */
 export declare const colorSplitReadInversion = "#9b30b0";
 export declare const colorSupplementary = "#f0b878";
 export declare const tagColorPalette: string[];

package/esm/ui/palette.js

@@ -231,16 +231,16 @@ const darkNeutrals = {
 export const colorFwdStrand = '#EC8B8B';
 /** #color alignments-strand | Reverse strand | Read maps to the reverse strand */
 export const colorRevStrand = '#8F8FD8';
-/** #color alignments-pair-orientation | LR (→ ←, normal proper pair) | Concordant */
+/** #color alignments-pair-orientation | LR (→ ←) | Normal proper pair */
 export const colorPairLR = '#d3d3d3';
 // Dimmer grey for dark mode: the light #d3d3d3 reads as near-white glaring
 // blocks against a dark track background. Wired into the dark alignmentFill.
 export const colorPairLRDark = '#8a8a8a';
-/** #color alignments-pair-orientation | RL (← →, mates point away from each other) | Abnormal orientation */
+/** #color alignments-pair-orientation | RL (← →) | Mates point away from each other */
 export const colorPairRL = '#0099bb';
-/** #color alignments-pair-orientation | LL (→ →, both mates forward strand) | Abnormal orientation */
+/** #color alignments-pair-orientation | LL (→ →) | Both mates on the forward strand */
 export const colorPairLL = '#4d9a4d';
-/** #color alignments-pair-orientation | RR (← ←, both mates reverse strand) | Abnormal orientation */
+/** #color alignments-pair-orientation | RR (← ←) | Both mates on the reverse strand */
 export const colorPairRR = '#5555bb';
 // Was `colorNostrand`, which named the one thing it essentially never paints. A
 // SAM record's strand is DEFINED from the reverse flag inside the adapter's
@@ -266,8 +266,8 @@ export const colorPairRR = '#5555bb';
 // settle it, and the dark-mode half is `agent-docs/TODO.md`.
 export const colorNeutralRead = '#c8c8c8';
 /**
- * #color alignments-pair-orientation | Inter-chromosomal | Mate maps to a different chromosome; colored distinctly rather than by orientation
- * #color alignments-insert-size | Mate on a different chromosome | Suggests an inter-chromosomal event
+ * #color alignments-pair-orientation | Inter-chromosomal | Mate on another chromosome
+ * #color alignments-insert-size | Inter-chromosomal | Mate on another chromosome
  */
 // THIS SLOT AND `colorUnmappedMate` WERE CHOSEN TOGETHER, and reading either one
 // alone is how the previous pair got stuck. Both are warm, both belong to all
@@ -299,9 +299,9 @@ export const colorNeutralRead = '#c8c8c8';
 // neighbour that must not be confusable: red means "insert too long", and a
 // second red would read as a second statement about insert size.
 export const colorInterchrom = '#af4d19';
-/** #color alignments-insert-size | Insert larger than expected | Suggests a deletion spanning the pair */
+/** #color alignments-insert-size | Insert larger than expected | Deletion between the mates */
 export const colorLongInsert = '#ff0000';
-/** #color alignments-insert-size | Insert smaller than expected | Suggests an insertion between the pair */
+/** #color alignments-insert-size | Insert smaller than expected | Insertion between the mates */
 // This slot has TWO neighbours it must stay clear of, and every past value has
 // solved one by walking into the other. They sit at opposite ends of the
 // lightness axis, which is what makes it a balance rather than a direction:
@@ -349,8 +349,8 @@ export const colorLongInsert = '#ff0000';
 // them.
 export const colorShortInsert = '#f582c0';
 /**
- * #color alignments-pair-orientation | Mate unmapped | The other end of the pair aligned nowhere, so orientation and insert size say nothing
- * #color alignments-insert-size | Mate unmapped | The other end of the pair aligned nowhere, so insert size says nothing
+ * #color alignments-pair-orientation | Mate unmapped | Mate aligned nowhere
+ * #color alignments-insert-size | Mate unmapped | Mate aligned nowhere
  */
 // A NON-COLOUR, at the dark end of the neutral scale on BOTH themes. It takes
 // the first half of the `readOverlap` pattern and not the second, and that split
@@ -421,7 +421,7 @@ export const colorUnmappedMate = '#000000';
 // the least that still reads as a read rather than as a hole.
 export const colorUnmappedMateDark = '#4a4a4a';
 export const colorLongreadInv = '#7755bb';
-/** #color alignments-pair-orientation | Split paired-end read (inverted) | A paired read's supplementary segment maps opposite-strand to its primary, so the junction is inverted — an inversion or an inverted duplication */
+/** #color alignments-pair-orientation | Split read (inverted) | Supplementary segment on the opposite strand to its primary */
 export const colorSplitReadInversion = '#9b30b0';
 export const colorSupplementary = '#f0b878';
 // Qualitative palette for coloring reads by an arbitrary tag value (e.g. the HP

package/esm/ui/promotablePinCoverage.d.ts

@@ -26,10 +26,24 @@ export declare function displayTypesWithPromotableSlots(displayTypes: readonly {
  * Reads `pin.control.slot` and nothing else. A raw `endAdornment` is
  * deliberately not counted: it is an arbitrary element (synteny's colour
  * swatch), so it cannot say which slot it promotes, and a pin built by hand
- * rather than through `promotableToggleItem`/`promotableRadioItem` is a thing to
- * find, not to accept.
+ * rather than through `makePin`/`makeTogglePin` is a thing to find, not to
+ * accept.
  */
 export declare function pinnedSlots(items: MenuItem[]): Set<string>;
+/**
+ * Rows whose pin is the wrong kind for the row, submenus included: a checkbox
+ * row carrying a value pin, or a radio row carrying a toggle pin. Empty is the
+ * healthy answer.
+ *
+ * The row builders type the option so this cannot happen through them; this
+ * is for a `pin` written by hand as a literal, which the type system lets
+ * through as the union. A checkbox row's pin has to be the toggle kind because
+ * that is what a click beside a checkbox is read as — "turn this on for all" —
+ * and a value pin there applies the row's *current* state instead, which
+ * beside an unchecked box is a visible no-op. That shipped once (2026-09-07)
+ * and was caught in a live session, not by a test; this is the test.
+ */
+export declare function misKindedPins(items: MenuItem[]): string[];
 /**
  * A display's promotable slots that its own track menu offers no pin for,
  * sorted. Empty is the healthy answer.

package/esm/ui/promotablePinCoverage.js

@@ -51,8 +51,8 @@ export function displayTypesWithPromotableSlots(displayTypes) {
  * Reads `pin.control.slot` and nothing else. A raw `endAdornment` is
  * deliberately not counted: it is an arbitrary element (synteny's colour
  * swatch), so it cannot say which slot it promotes, and a pin built by hand
- * rather than through `promotableToggleItem`/`promotableRadioItem` is a thing to
- * find, not to accept.
+ * rather than through `makePin`/`makeTogglePin` is a thing to find, not to
+ * accept.
  */
 export function pinnedSlots(items) {
     const found = new Set();
@@ -69,6 +69,42 @@ export function pinnedSlots(items) {
     walk(items);
     return found;
 }
+/**
+ * Rows whose pin is the wrong kind for the row, submenus included: a checkbox
+ * row carrying a value pin, or a radio row carrying a toggle pin. Empty is the
+ * healthy answer.
+ *
+ * The row builders type the option so this cannot happen through them; this
+ * is for a `pin` written by hand as a literal, which the type system lets
+ * through as the union. A checkbox row's pin has to be the toggle kind because
+ * that is what a click beside a checkbox is read as — "turn this on for all" —
+ * and a value pin there applies the row's *current* state instead, which
+ * beside an unchecked box is a visible no-op. That shipped once (2026-09-07)
+ * and was caught in a live session, not by a test; this is the test.
+ */
+export function misKindedPins(items) {
+    const found = [];
+    const walk = (list) => {
+        for (const item of list) {
+            if ('pin' in item && item.pin && 'type' in item) {
+                const { kind } = item.pin.control;
+                const wanted = item.type === 'checkbox'
+                    ? 'toggle'
+                    : item.type === 'radio'
+                        ? 'value'
+                        : undefined;
+                if (wanted && kind !== wanted) {
+                    found.push(`${item.pin.label}: ${kind} pin on a ${item.type} row`);
+                }
+            }
+            if ('subMenu' in item) {
+                walk(resolveSubMenu(item));
+            }
+        }
+    };
+    walk(items);
+    return found;
+}
 /**
  * A display's promotable slots that its own track menu offers no pin for,
  * sorted. Empty is the healthy answer.

package/esm/ui/theme.js

@@ -209,6 +209,11 @@ const baseThemeOptions = {
         MuiFormLabel: {
             styleOverrides: darkModeContrastOverride(['&.Mui-focused']),
         },
+        // the rail, track and thumb are all `currentColor` off the root, so a
+        // midnight root paints the whole control dark-on-dark
+        MuiSlider: {
+            styleOverrides: darkModeContrastOverride(),
+        },
         MuiAccordionSummary: {
             styleOverrides: {
                 root: ({ theme: t }) => ({

package/esm/ui/toggleMenuItems.d.ts

@@ -1,3 +1,4 @@
+import type { TogglePin, ValuePin } from '../configuration/promotablePin.ts';
 import type { CheckboxMenuItem, MenuItem, RadioMenuItem } from './MenuTypes.ts';
 export interface SettingRowOptions {
     helpText?: string;
@@ -5,8 +6,14 @@ export interface SettingRowOptions {
     disabledHelpText?: string;
     keepMenuOpen?: boolean;
 }
-/** #menuBuilder checkboxItem | one checkbox setting row */
-export declare function checkboxItem(label: string, checked: boolean, onToggle: () => void, opts?: SettingRowOptions): CheckboxMenuItem;
+export interface CheckboxRowOptions extends SettingRowOptions {
+    pin?: TogglePin;
+}
+export interface RadioRowOptions extends SettingRowOptions {
+    pin?: ValuePin;
+}
+/** #menuBuilder checkboxItem | one checkbox setting row, with a toggle pin when the setting is promotable */
+export declare function checkboxItem(label: string, checked: boolean, onToggle: () => void, opts?: CheckboxRowOptions): CheckboxMenuItem;
 /**
  * #menuBuilder toggleItem | a checkbox row whose setter takes the new value
  *
@@ -23,15 +30,15 @@ export declare function checkboxItem(label: string, checked: boolean, onToggle:
  * `SettingRowOptions` to a hand-narrowed one-field bag — the exact drift the
  * comment on that interface warns about.
  */
-export declare function toggleItem(label: string, value: boolean, setValue: (value: boolean) => void, opts?: SettingRowOptions): CheckboxMenuItem;
+export declare function toggleItem(label: string, value: boolean, setValue: (value: boolean) => void, opts?: CheckboxRowOptions): CheckboxMenuItem;
 /** #menuBuilder radioItem | one radio setting row; the singular of `radioItems` */
-export declare function radioItem(label: string, checked: boolean, onClick: () => void, opts?: SettingRowOptions): RadioMenuItem;
+export declare function radioItem(label: string, checked: boolean, onClick: () => void, opts?: RadioRowOptions): RadioMenuItem;
 export interface RadioOption<T extends string> extends SettingRowOptions {
     value: T;
     label: string;
 }
-/** #menuBuilder radioItems | a radio group, one row per option */
-export declare function radioItems<T extends string>(options: readonly RadioOption<T>[], current: T | undefined, setMode: (m: T) => void): RadioMenuItem[];
+/** #menuBuilder radioItems | a radio group, one row per option, with a value pin per option when the setting is promotable */
+export declare function radioItems<T extends string>(options: readonly RadioOption<T>[], current: T | undefined, setMode: (m: T) => void, pin?: (value: T) => ValuePin): RadioMenuItem[];
 /**
  * #menuBuilder withSubHeader | a section heading, present only if the section is
  *

package/esm/ui/toggleMenuItems.js

@@ -1,12 +1,16 @@
-/** #menuBuilder checkboxItem | one checkbox setting row */
-export function checkboxItem(label, checked, onToggle, opts) {
-    return {
+function withPin(row, pin) {
+    return pin ? { ...row, pin: { control: pin, label: row.label } } : row;
+}
+/** #menuBuilder checkboxItem | one checkbox setting row, with a toggle pin when the setting is promotable */
+export function checkboxItem(label, checked, onToggle, opts = {}) {
+    const { pin, ...rest } = opts;
+    return withPin({
         label,
         type: 'checkbox',
         checked,
         onClick: onToggle,
-        ...opts,
-    };
+        ...rest,
+    }, pin);
 }
 /**
  * #menuBuilder toggleItem | a checkbox row whose setter takes the new value
@@ -29,24 +33,37 @@ export function toggleItem(label, value, setValue, opts) {
         setValue(!value);
     }, opts);
 }
-// One radio row. The singular of `radioItems`, and what
-// `promotableRadioItem` builds through, so a lone radio row and a member of a
-// group are the same object plus or minus its pin.
+// One radio row. The singular of `radioItems`, for a group the plural form
+// can't express: a row with no single value to promote yet (the colorBy
+// "Tag..." row before a tag is picked), a display whose slot isn't promotable
+// at all (the shared colorBy menu on gwas/variants), or a group gated row by
+// row and mixing in a non-promotable peer (the alignments size presets and
+// their "Custom..." row). **Reach for `radioItems` first**: every option in a
+// group has to get a pin, and hand-naming the rows is what leaves one without.
 /** #menuBuilder radioItem | one radio setting row; the singular of `radioItems` */
-export function radioItem(label, checked, onClick, opts) {
-    return {
+export function radioItem(label, checked, onClick, opts = {}) {
+    const { pin, ...rest } = opts;
+    return withPin({
         label,
         type: 'radio',
         checked,
         onClick,
-        ...opts,
-    };
+        ...rest,
+    }, pin);
 }
-/** #menuBuilder radioItems | a radio group, one row per option */
-export function radioItems(options, current, setMode) {
+// `pin` is a factory rather than a per-option field so a promotable group can't
+// be a row short. **Every option in a group gets a pin, the `promotedBase`
+// value included**: once a non-base value is promoted, taking the base row's
+// offer is the per-value way to undo it, and a radio group with one row silently
+// missing its trailing control reads as a bug. `sashimiArcsMode`'s base looked
+// unpinnable precisely because each row had been named by hand. Pass
+// `value => makePin(self, slot, value)`, or a model member of that shape where
+// the menu module is handed a duck-typed model (alignments).
+/** #menuBuilder radioItems | a radio group, one row per option, with a value pin per option when the setting is promotable */
+export function radioItems(options, current, setMode, pin) {
     return options.map(({ value, label, ...opts }) => radioItem(label, current === value, () => {
         setMode(value);
-    }, opts));
+    }, { ...opts, pin: pin?.(value) }));
 }
 /**
  * #menuBuilder withSubHeader | a section heading, present only if the section is

package/esm/util/Base1DUtils.d.ts

@@ -121,7 +121,7 @@ export declare function bpToPx({ refName, coord, displayedRegionIndex, self, }:
  * Undefined when no displayed region holds the coord, same as `bpToPx`; a
  * caller that means "as far as the region goes" clamps before asking.
  */
-export declare function bpToOffset({ refName, coord, displayedRegions, }: {
+export declare function bpToOffset({ refName, coord, displayedRegions, displayedRegionIndex, }: {
     refName: string;
     coord: number;
     displayedRegions: {
@@ -130,6 +130,7 @@ export declare function bpToOffset({ refName, coord, displayedRegions, }: {
         end: number;
         reversed?: boolean;
     }[];
+    displayedRegionIndex?: number;
 }): BpOffset | undefined;
 /**
  * Where a 0-based genomic coord sits in the LINEARIZED bp space — the
@@ -145,7 +146,7 @@ export declare function bpToOffset({ refName, coord, displayedRegions, }: {
  * `undefined` when no displayed region holds the coord, exactly as `bpToPx`
  * answers: a refName the view is not showing has no place on its screen.
  */
-export declare function bpToLinearBp({ refName, coord, displayedRegions, }: {
+export declare function bpToLinearBp({ refName, coord, displayedRegions, displayedRegionIndex, }: {
     refName: string;
     coord: number;
     displayedRegions: {
@@ -154,6 +155,7 @@ export declare function bpToLinearBp({ refName, coord, displayedRegions, }: {
         end: number;
         reversed?: boolean;
     }[];
+    displayedRegionIndex?: number;
 }): number | undefined;
 /**
  * Screen order of two {@link BpOffset}s: negative when `a` is to the left of

package/esm/util/Base1DUtils.js

@@ -187,9 +187,12 @@ export function bpToPx({ refName, coord, displayedRegionIndex, self, }) {
  * Undefined when no displayed region holds the coord, same as `bpToPx`; a
  * caller that means "as far as the region goes" clamps before asking.
  */
-export function bpToOffset({ refName, coord, displayedRegions, }) {
+export function bpToOffset({ refName, coord, displayedRegions, displayedRegionIndex, }) {
     for (const [index, r] of displayedRegions.entries()) {
-        if (refName === r.refName && coord >= r.start && coord <= r.end) {
+        if (refName === r.refName &&
+            coord >= r.start &&
+            coord <= r.end &&
+            (displayedRegionIndex === undefined || displayedRegionIndex === index)) {
             return { refName, index, offset: bpOffsetInRegion(r, coord) };
         }
     }
@@ -209,8 +212,13 @@ export function bpToOffset({ refName, coord, displayedRegions, }) {
  * `undefined` when no displayed region holds the coord, exactly as `bpToPx`
  * answers: a refName the view is not showing has no place on its screen.
  */
-export function bpToLinearBp({ refName, coord, displayedRegions, }) {
-    const at = bpToOffset({ refName, coord, displayedRegions });
+export function bpToLinearBp({ refName, coord, displayedRegions, displayedRegionIndex, }) {
+    const at = bpToOffset({
+        refName,
+        coord,
+        displayedRegions,
+        displayedRegionIndex,
+    });
     return at ? cumulativeBp(displayedRegions, at.index, at.offset) : undefined;
 }
 /**

package/esm/util/SvgCanvas.js

@@ -479,9 +479,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/adapterConfigKey.d.ts

@@ -0,0 +1,12 @@
+/**
+ * The adapter-config axis of a fetch key: the config a fetch was issued
+ * against, as one string. Every fetch that refetches on an adapter edit folds
+ * this in — the comparative displays, the prerequisite reads, the density
+ * tier, the global family's signature — so the axis is spelled once and cannot
+ * drift between them.
+ *
+ * Not `adapterConfigCacheKey`: that one short-circuits on `adapterId`, which is
+ * right for sharing one adapter instance and wrong for freshness, where an
+ * edit to a config carrying an id still has to read as a different fetch.
+ */
+export declare function adapterConfigKey(adapterConfig: Record<string, unknown>): string;

package/esm/util/adapterConfigKey.js

@@ -0,0 +1,14 @@
+/**
+ * The adapter-config axis of a fetch key: the config a fetch was issued
+ * against, as one string. Every fetch that refetches on an adapter edit folds
+ * this in — the comparative displays, the prerequisite reads, the density
+ * tier, the global family's signature — so the axis is spelled once and cannot
+ * drift between them.
+ *
+ * Not `adapterConfigCacheKey`: that one short-circuits on `adapterId`, which is
+ * right for sharing one adapter instance and wrong for freshness, where an
+ * edit to a config carrying an id still has to read as a different fetch.
+ */
+export function adapterConfigKey(adapterConfig) {
+    return JSON.stringify(adapterConfig);
+}

package/esm/util/adapterMetadata.js

@@ -1,3 +1,4 @@
+import { adapterConfigKey } from './adapterConfigKey.js';
 import { getRpcSessionId } from './parentWalk.js';
 import { getRpcHost } from './sessionServices.js';
 /**
@@ -19,7 +20,7 @@ import { getRpcHost } from './sessionServices.js';
 export function createAdapterMetadataFetch(self) {
     let cached;
     return () => {
-        const key = JSON.stringify(self.adapterConfig);
+        const key = adapterConfigKey(self.adapterConfig);
         if (cached?.key !== key) {
             const promise = getRpcHost(self)
                 // eslint-disable-next-line no-restricted-syntax -- nothing to narrate, nothing a cancel could save

package/esm/util/analytics.js

@@ -9,11 +9,10 @@ export async function writeAWSAnalytics(rootModel, initialTimestamp, sessionQuer
     try {
         const url = 'https://analytics.jbrowse.org/api/v1';
         const multiAssemblyTracks = rootModel.jbrowse.tracks.filter(track => readConfObject(track, 'assemblyNames').length > 1).length;
-        // which rendering backend is actually drawing (WebGPU/WebGL2/Canvas2D) —
-        // capabilities *and* any page-wide pin, so a session that fell back to
-        // Canvas2D is counted as Canvas2D rather than as what the hardware could
-        // have done. Reporting the capability answer here is what made "how many
-        // users end up on Canvas2D" unanswerable.
+        // The rung createGpuHal built where a display has built one by idle time,
+        // else the ladder's prediction with any page-wide pin applied — so a
+        // session that fell back to Canvas2D is counted as Canvas2D rather than as
+        // what the hardware could have done.
         const capabilities = await getGraphicsCapabilities();
         const renderer = effectiveRenderer(capabilities);
         // The coarse bit only. `glRenderer` names the exact driver and stays local

package/esm/util/clampToContig.d.ts

@@ -24,3 +24,20 @@ export declare function clampToContig(assembly: Assembly, region: {
     start: number;
     end: number;
 }): Region | undefined;
+/**
+ * `clampToContig` for a refName that may not be on the assembly at all, which
+ * is the shape a location nobody requested arrives in — a BAM's `nextRef`, an
+ * SA record's contig (REFNAME_NAMESPACES.md). `clampToContig` alone passes an
+ * unknown name through with nothing to clamp against, so it cannot tell "past
+ * the end of a contig we have" from "a contig we do not have", and both callers
+ * need that apart to say which happened.
+ */
+export declare function clampToListedContig(assembly: Assembly, region: {
+    refName: string;
+    start: number;
+    end: number;
+}): {
+    refName: string;
+    onAssembly: boolean;
+    region: Region | undefined;
+};

package/esm/util/clampToContig.js

@@ -26,3 +26,22 @@ export function clampToContig(assembly, region) {
         ? { ...region, assemblyName: assembly.name, refName, start, end }
         : undefined;
 }
+/**
+ * `clampToContig` for a refName that may not be on the assembly at all, which
+ * is the shape a location nobody requested arrives in — a BAM's `nextRef`, an
+ * SA record's contig (REFNAME_NAMESPACES.md). `clampToContig` alone passes an
+ * unknown name through with nothing to clamp against, so it cannot tell "past
+ * the end of a contig we have" from "a contig we do not have", and both callers
+ * need that apart to say which happened.
+ */
+export function clampToListedContig(assembly, region) {
+    const refName = assembly.getCanonicalRefName2(region.refName);
+    const onAssembly = assembly.getRegionForRefName(refName) !== undefined;
+    return {
+        refName,
+        onAssembly,
+        region: onAssembly
+            ? clampToContig(assembly, { ...region, refName })
+            : undefined,
+    };
+}

package/esm/util/colorBits.d.ts

@@ -1,5 +1,7 @@
+import { abgrToCssRgba } from '@jbrowse/render-core/marks/colorFill';
 import type { Color } from './color-bits/index.ts';
 import type { Feature } from './simpleFeature.ts';
+export { abgrToCssRgba };
 export { alpha, blend, darken, formatHEX, formatHEXA, formatRGBA, getAlpha, getBlue, getGreen, getLuminance, getRed, lighten, newColor, parse, toHSLA, toRGBA, } from './color-bits/index.ts';
 export type { Color } from './color-bits/index.ts';
 /**
@@ -35,5 +37,4 @@ export declare function abgrRed(c: number): number;
 export declare function abgrGreen(c: number): number;
 export declare function abgrBlue(c: number): number;
 export declare function abgrAlpha(c: number): number;
-export declare function abgrToCssRgba(c: number): string;
 export declare function cssColorToNormalizedRgba(color: string): [number, number, number, number];