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

package/esm/pluggableElementTypes/models/BaseTrackModel.js

@@ -324,10 +324,8 @@ export function createBaseTrackModel(pm, trackType, baseTrackConfig) {
              * completely untouched ones — `reaction` only fires on an actual change.
              *
              * `equals: compareStructural` is load-bearing, not an optimization:
-             * `self.configuration` is a re-resolving reference, and persisting a save
-             * can swap the resolved node identity (the delta path reconciles in place
-             * but still churns once, and a session without deltas replaces the frozen
-             * `jbrowse.tracks` entry, rehydrating a brand-new MST node every write).
+             * `self.configuration` is a re-resolving reference, and an undo or a
+             * session restore swaps the resolved node for a new working copy.
              * Referential comparison would treat every such swap as a fresh change
              * and re-fire the save, an unbounded debounced loop. Structural
              * comparison settles once the content stops changing.

package/esm/pluggableElementTypes/models/baseTrackConfig.js

@@ -177,6 +177,7 @@ export function createBaseTrackConfig(pluginManager) {
                 type: 'stringArray',
                 description: 'list of which feature attributes to index for text searching',
                 defaultValue: ['Name', 'ID', 'symbol'],
+                advanced: true,
             },
             /**
              * #slot textSearching.indexingFeatureTypesToExclude
@@ -185,6 +186,7 @@ export function createBaseTrackConfig(pluginManager) {
                 type: 'stringArray',
                 description: 'list of feature types to exclude in text search index',
                 defaultValue: ['CDS', 'exon'],
+                advanced: true,
             },
             /**
              * #slot textSearching.indexingFeatureTypesToInclude
@@ -207,6 +209,7 @@ export function createBaseTrackConfig(pluginManager) {
                 type: 'stringArray',
                 description: 'the only feature types to index; empty means index every type not excluded',
                 defaultValue: [],
+                advanced: true,
             },
             /**
              * #slot textSearching.textSearchAdapter

package/esm/rpc/RpcRegistry.d.ts

@@ -100,9 +100,10 @@ export interface RpcRegistry {
         args: Record<string, unknown>;
         return: void;
     };
-    CoreLoadAdapterCode: {
+    CoreLoadTrackCode: {
         args: {
             adapterTypes: string[];
+            rpcMethods: string[];
         };
         return: void;
     };

package/esm/rpc/byteBudget.d.ts

@@ -33,6 +33,13 @@ export interface RegionTooLargeResult {
     partial?: boolean;
 }
 export declare function isRegionRefused(result: unknown): result is RegionTooLargeResult;
+/**
+ * The thrown form of the same refusal, for an adapter whose limit only a fetch
+ * can find, such as a graph's node count. Marked by an own `regionTooLarge`
+ * property, which crosses the worker boundary, so an adapter's own error class
+ * opts in without importing anything.
+ */
+export declare function isRegionTooLargeError(error: unknown): error is Error;
 /** Undefined, never 0, when no region could be measured. */
 export declare function largestRegionBytes(perRegion: (number | undefined)[]): number | undefined;
 /** A non-positive declared limit means "no opinion" (htsget reports 0). */

package/esm/rpc/byteBudget.js

@@ -3,6 +3,16 @@ import { updateStatus } from '../util/progress.js';
 export function isRegionRefused(result) {
     return (typeof result === 'object' && result !== null && 'regionTooLarge' in result);
 }
+/**
+ * The thrown form of the same refusal, for an adapter whose limit only a fetch
+ * can find, such as a graph's node count. Marked by an own `regionTooLarge`
+ * property, which crosses the worker boundary, so an adapter's own error class
+ * opts in without importing anything.
+ */
+export function isRegionTooLargeError(error) {
+    return (error instanceof Error &&
+        error.regionTooLarge === true);
+}
 /** Undefined, never 0, when no region could be measured. */
 export function largestRegionBytes(perRegion) {
     let largest;

package/esm/rpc/coreRpcMethods.d.ts

@@ -6,7 +6,7 @@ export { default as CoreGetEncodedLayers } from './methods/CoreGetEncodedLayers.
 export { default as CoreGetEncodedFeature } from './methods/CoreGetEncodedFeature.ts';
 export { default as CoreGetSequence } from './methods/CoreGetSequence.ts';
 export { default as CoreFreeResources } from './methods/CoreFreeResources.ts';
-export { default as CoreLoadAdapterCode } from './methods/CoreLoadAdapterCode.ts';
+export { default as CoreLoadTrackCode } from './methods/CoreLoadTrackCode.ts';
 export { default as CoreGetRegionByteEstimate } from './methods/CoreGetRegionByteEstimate.ts';
 export { default as CoreGetFeatureDensity } from './methods/CoreGetFeatureDensity.ts';
 export { default as CoreGetRegions } from './methods/CoreGetRegions.ts';

package/esm/rpc/coreRpcMethods.js

@@ -6,7 +6,7 @@ export { default as CoreGetEncodedLayers } from './methods/CoreGetEncodedLayers.
 export { default as CoreGetEncodedFeature } from './methods/CoreGetEncodedFeature.js';
 export { default as CoreGetSequence } from './methods/CoreGetSequence.js';
 export { default as CoreFreeResources } from './methods/CoreFreeResources.js';
-export { default as CoreLoadAdapterCode } from './methods/CoreLoadAdapterCode.js';
+export { default as CoreLoadTrackCode } from './methods/CoreLoadTrackCode.js';
 export { default as CoreGetRegionByteEstimate } from './methods/CoreGetRegionByteEstimate.js';
 export { default as CoreGetFeatureDensity } from './methods/CoreGetFeatureDensity.js';
 export { default as CoreGetRegions } from './methods/CoreGetRegions.js';

package/esm/rpc/explainTransferError.js

@@ -14,9 +14,9 @@
 // sentence this appends to.
 //
 // Only runs on the error path.
-// The deepest RPC result in the tree is the regular multi-sample variant one:
-// `perRegionCellData.0.featureGenotypeMap.<featureId>.genotypeCodes` — four
-// containers down. The alignments result is three (`groups.3.data.mismatchStarts`),
+// The deepest RPC result in the tree is the multi-sample variant one:
+// `perRegionCellData.0.featureInfo.<index>.genotypeCodes` — four containers
+// down. The alignments result is three (`groups.3.data.mismatchStarts`),
 // synteny two (`instanceData.bp1`, `attributes.identity`) and most are one. The
 // walk is capped rather than unbounded because a payload also carries plain data
 // — a featureIds array of half a million strings — and there is no reason to

package/esm/rpc/methods/CoreLoadTrackCode.d.ts

@@ -0,0 +1,17 @@
+import RpcMethodType from '../../pluggableElementTypes/RpcMethodType.ts';
+import type { RpcExecuteArgs } from '../RpcRegistry.ts';
+/**
+ * Load the code a track's first request runs in the worker it is about to use:
+ * its adapter classes and the RPC methods its display names. Each arrives by
+ * dynamic import on that request otherwise, after the view lays out, the
+ * assembly loads and the request's refNames resolve.
+ *
+ * At launch rather than at worker boot: until `parallelizeChunkLoading` is
+ * installed a classic worker loads chunks by serial `importScripts`, and an
+ * import there delayed the first data request 360ms at 80ms RTT.
+ */
+export default class CoreLoadTrackCode extends RpcMethodType<'CoreLoadTrackCode'> {
+    name: 'CoreLoadTrackCode';
+    execute({ adapterTypes, rpcMethods, }: RpcExecuteArgs<'CoreLoadTrackCode'>): Promise<void>;
+    serializeArguments(args: Record<string, unknown>): Promise<Record<string, unknown>>;
+}

package/esm/rpc/methods/CoreLoadTrackCode.js

@@ -0,0 +1,24 @@
+import RpcMethodType from '../../pluggableElementTypes/RpcMethodType.js';
+/**
+ * Load the code a track's first request runs in the worker it is about to use:
+ * its adapter classes and the RPC methods its display names. Each arrives by
+ * dynamic import on that request otherwise, after the view lays out, the
+ * assembly loads and the request's refNames resolve.
+ *
+ * At launch rather than at worker boot: until `parallelizeChunkLoading` is
+ * installed a classic worker loads chunks by serial `importScripts`, and an
+ * import there delayed the first data request 360ms at 80ms RTT.
+ */
+export default class CoreLoadTrackCode extends RpcMethodType {
+    name = 'CoreLoadTrackCode';
+    async execute({ adapterTypes, rpcMethods, }) {
+        const { pluginManager } = this;
+        await Promise.all([
+            ...adapterTypes.map(type => pluginManager.getAdapterType(type).getAdapterClass()),
+            ...rpcMethods.map(name => pluginManager.getRpcMethodType(name).preload()),
+        ]);
+    }
+    async serializeArguments(args) {
+        return args;
+    }
+}

package/esm/ui/AppLogo.js

@@ -1,10 +1,50 @@
 import { jsx as _jsx } from "react/jsx-runtime";
+import { useEffect, useState } from 'react';
 import { observer } from 'mobx-react';
 import { readConfObject } from '../configuration/index.js';
+import { isUriLocation } from '../util/types/data.js';
 import { LogoFull } from './Logo.js';
+function resolvedUri(location) {
+    return location.baseUri
+        ? new URL(location.uri, location.baseUri).href
+        : location.uri;
+}
+// A URI goes straight to the <img>, which needs no CORS; a local path, a
+// blob or a file handle is read into an object URL.
+function useLogoSrc(location) {
+    const [objectUrl, setObjectUrl] = useState();
+    useEffect(() => {
+        if (!location || isUriLocation(location)) {
+            return;
+        }
+        let url;
+        let cancelled = false;
+        import('../util/io/index.js')
+            .then(({ openLocation }) => openLocation(location).readFile())
+            .then(bytes => {
+            if (!cancelled) {
+                url = URL.createObjectURL(new Blob([bytes]));
+                setObjectUrl(url);
+            }
+        })
+            .catch((e) => {
+            console.error(e);
+        });
+        return () => {
+            cancelled = true;
+            if (url) {
+                URL.revokeObjectURL(url);
+            }
+        };
+    }, [location]);
+    return location && isUriLocation(location)
+        ? resolvedUri(location)
+        : location
+            ? objectUrl
+            : undefined;
+}
 const Logo = observer(function Logo({ session, }) {
-    const { configuration } = session;
-    const logoPath = readConfObject(configuration, 'logoPath');
-    return logoPath?.uri ? (_jsx("img", { src: logoPath.uri, alt: "Custom logo" })) : (_jsx(LogoFull, { variant: "white" }));
+    const src = useLogoSrc(readConfObject(session.configuration, 'logoPath'));
+    return src ? (_jsx("img", { src: src, alt: "Custom logo" })) : (_jsx(LogoFull, { variant: "white" }));
 });
 export default Logo;

package/esm/ui/buildExtraTrackMenuItems.d.ts

@@ -1,10 +1,10 @@
 import type PluginManager from '../PluginManager.ts';
-import type { AnyConfigurationModel } from '../configuration/index.ts';
+import type { AnyTrackConfig } from '../configuration/index.ts';
 import type { AbstractSessionModel, TrackActionView } from '../util/types/index.ts';
 import type { MenuItem } from './MenuTypes.ts';
 export interface ExtraTrackMenuItemsProps {
     session: AbstractSessionModel;
-    config: AnyConfigurationModel;
+    config: AnyTrackConfig;
     view?: TrackActionView;
 }
 /** Return the items to add, or nothing when the track isn't yours. */

package/esm/ui/colors.d.ts

@@ -15,11 +15,9 @@ export declare const paletteColors: {
  * The wide qualitative palette: every scheme above, in order, deduped and with
  * the neutrals dropped. ~40 entries.
  *
- * One list, because "give each row a distinct color" is one question this repo
- * answers in two places — the multi-row painter handing colors out by row
- * index, and the arrangement dialog's palette-by-attribute — and two lists
- * would mean a track's automatic colors and the colors it takes when a user
- * palettes it by hand were different palettes for no reason a reader could see.
+ * A feature's categorical colour deals from it; a row's deals from
+ * `rowPaletteColorAt`, which re-lights tableau10 rather than reaching for
+ * another scheme's hues.
  *
  * `tableau10` leads because its hues are the most evenly separated, so a track
  * with a handful of rows spends only that. The tail is what makes the 26
@@ -31,21 +29,16 @@ export declare const paletteColors: {
  * re-palettes), while a by-position painter has no value to hash and wraps.
  *
  * **It holds 14 pairs `similarColors` calls the same** — five schemes' blues,
- * oranges, greens, reds and pinks — and deduping it at construction is the
- * wrong reading of that, measured on the 38 GENCODE gene biotypes. Hashed,
- * which is what a track with no `colorDomain` does, 30 of them land on 22
- * colors and 38 on 26; the loss is the birthday collision on 40 slots, not the
- * near-twins, and only 3 of the pairs they land on read alike. Pruning to the
- * 30 distinct entries makes that 23 and 24, so it costs ten colors and buys
- * nothing.
+ * oranges, greens, reds and pinks. A dealt scale (`categoricalScale`'s `held`)
+ * steps over a twin of a color already dealt, so they cost a track only once
+ * it has more values than the 30 distinct entries.
  *
- * The near-twins bite the PINNED case instead, where a `domain` spends the
- * list in order: 30 listed values take 30 colors today and 7 of those pairs
- * read alike. Ordering the distinct 30 first and the twins behind them fixes
- * that outright (0 pairs at 30 listed values, 11 at 38 where the twins are
- * reached anyway) and costs no colors — but it moves every hashed color in
- * marks, GWAS, canvas, multi-row and the arrangement dialog, so it is a pass
- * with a figure refresh in it.
+ * The near-twins bite a `domain` instead, which spends the list in order: 30
+ * listed values take 30 colors and 7 of those pairs read alike. Ordering the
+ * distinct 30 first and the twins behind them fixes that outright (0 pairs at
+ * 30 listed values, 11 at 38 where the twins are reached anyway) and costs no
+ * colors — but it moves every hashed color in marks, GWAS, canvas, multi-row
+ * and the arrangement dialog, so it is a pass with a figure refresh in it.
  */
 export declare const categoricalPalette: string[];
 /**
@@ -60,18 +53,30 @@ export declare const categoricalPalette: string[];
 export declare function categoricalValueColor(value: string): string;
 export declare function categoricalValueColor<T>(value: string, palette: readonly T[]): T;
 /**
- * The categorical rule every scaled channel resolves through. With no
- * `domain` a value takes `categoricalValueColor`'s slot in `range`. With one,
- * the listed values take `range` in order, continuing into the `fallback`
- * entries `range` lacks past its end, and any other value takes a slot of the
- * whole list derived from itself that no listed value holds, nor one
- * `isNear` calls the same. A value's entry depends only on the value and the
- * declaration, so every region agrees on it, and adding a listed value moves
- * only the unlisted values on the slots it takes.
+ * The slots a categorical scale has dealt the values it met that its `domain`
+ * does not list, each recorded on first sight and never dealt again. The
+ * caller owns it and hands the same one to every scale that should agree.
  */
-export declare function categoricalScale<T>(domain: readonly (string | number)[] | undefined, range: readonly T[], { fallback, isNear, }?: {
+export type HeldSlots = Map<string, number>;
+/**
+ * The categorical rule every scaled channel resolves through. The values
+ * `domain` lists take `range` in order, continuing into the `fallback`
+ * entries `range` lacks past its end. Any other value takes the slot derived
+ * from itself (`categoricalValueColor`'s, with no `domain`) unless a listed
+ * value holds it or one `isNear` calls the same, and then another slot derived
+ * from itself.
+ *
+ * With `held`, a value is dealt once, on first sight: its slot avoids every
+ * slot `held` already records and their near twins as well, so values met
+ * together never share an entry while the list has room, and the slot is
+ * recorded so the value keeps it as others arrive. A value nothing else
+ * collides with keeps the entry it takes without `held`. With no `domain`, the
+ * deal spends `range` before spilling into the `fallback` entries it lacks.
+ */
+export declare function categoricalScale<T>(domain: readonly (string | number)[] | undefined, range: readonly T[], { fallback, isNear, held, }?: {
     fallback?: readonly T[];
     isNear?: (a: T, b: T) => boolean;
+    held?: HeldSlots;
 }): (value: string) => T;
 /**
  * Whether two CSS colors read as one: under 0.05 apart in OKLab, where the
@@ -81,9 +86,10 @@ export declare function similarColors(a: string, b: string): boolean;
 /**
  * `categoricalScale` for a color channel: `palette` (the wide palette when
  * empty) spent in `domain` order and continued into the wide palette, and an
- * unlisted value never on a listed value's color or one that reads the same.
+ * unlisted value never on a listed value's color or one that reads the same,
+ * nor, with `held`, on the color of a value met before it.
  */
-export declare function categoricalColorScale(domain: readonly (string | number)[] | undefined, palette?: readonly string[]): (value: string) => string;
+export declare function categoricalColorScale(domain: readonly (string | number)[] | undefined, palette?: readonly string[], held?: HeldSlots): (value: string) => string;
 /**
  * The color one value of a categorical color channel paints, by
  * `categoricalColorScale`. A value-less feature is neutral grey, and an array
@@ -104,6 +110,11 @@ export declare function hashString(str: string): number;
 export declare function getQueryColor(queryName: string): string;
 /** The palette color for a chromosome at `position` in its assembly. */
 export declare function refNamePaletteColorAt(position: number): string;
+/**
+ * The colour the row palette deals the row or value at `position`: tableau10
+ * less its grey, then re-lit laps of it, as a karyotype's are.
+ */
+export declare function rowPaletteColorAt(position: number): string;
 /**
  * The color a refName paints, BY POSITION IN THE ASSEMBLY where the caller
  * knows its chromosome order.

package/esm/ui/colors.js

@@ -98,11 +98,9 @@ export const paletteColors = {
  * The wide qualitative palette: every scheme above, in order, deduped and with
  * the neutrals dropped. ~40 entries.
  *
- * One list, because "give each row a distinct color" is one question this repo
- * answers in two places — the multi-row painter handing colors out by row
- * index, and the arrangement dialog's palette-by-attribute — and two lists
- * would mean a track's automatic colors and the colors it takes when a user
- * palettes it by hand were different palettes for no reason a reader could see.
+ * A feature's categorical colour deals from it; a row's deals from
+ * `rowPaletteColorAt`, which re-lights tableau10 rather than reaching for
+ * another scheme's hues.
  *
  * `tableau10` leads because its hues are the most evenly separated, so a track
  * with a handful of rows spends only that. The tail is what makes the 26
@@ -114,21 +112,16 @@ export const paletteColors = {
  * re-palettes), while a by-position painter has no value to hash and wraps.
  *
  * **It holds 14 pairs `similarColors` calls the same** — five schemes' blues,
- * oranges, greens, reds and pinks — and deduping it at construction is the
- * wrong reading of that, measured on the 38 GENCODE gene biotypes. Hashed,
- * which is what a track with no `colorDomain` does, 30 of them land on 22
- * colors and 38 on 26; the loss is the birthday collision on 40 slots, not the
- * near-twins, and only 3 of the pairs they land on read alike. Pruning to the
- * 30 distinct entries makes that 23 and 24, so it costs ten colors and buys
- * nothing.
+ * oranges, greens, reds and pinks. A dealt scale (`categoricalScale`'s `held`)
+ * steps over a twin of a color already dealt, so they cost a track only once
+ * it has more values than the 30 distinct entries.
  *
- * The near-twins bite the PINNED case instead, where a `domain` spends the
- * list in order: 30 listed values take 30 colors today and 7 of those pairs
- * read alike. Ordering the distinct 30 first and the twins behind them fixes
- * that outright (0 pairs at 30 listed values, 11 at 38 where the twins are
- * reached anyway) and costs no colors — but it moves every hashed color in
- * marks, GWAS, canvas, multi-row and the arrangement dialog, so it is a pass
- * with a figure refresh in it.
+ * The near-twins bite a `domain` instead, which spends the list in order: 30
+ * listed values take 30 colors and 7 of those pairs read alike. Ordering the
+ * distinct 30 first and the twins behind them fixes that outright (0 pairs at
+ * 30 listed values, 11 at 38 where the twins are reached anyway) and costs no
+ * colors — but it moves every hashed color in marks, GWAS, canvas, multi-row
+ * and the arrangement dialog, so it is a pass with a figure refresh in it.
  */
 export const categoricalPalette = [
     ...new Set([...tableau10, ...set1, ...dark2, ...set2, ...category10].filter(hex => !NEUTRALS.has(hex.toLowerCase()))),
@@ -159,19 +152,24 @@ function freeSlot(value, size, taken) {
     return slot;
 }
 /**
- * The categorical rule every scaled channel resolves through. With no
- * `domain` a value takes `categoricalValueColor`'s slot in `range`. With one,
- * the listed values take `range` in order, continuing into the `fallback`
- * entries `range` lacks past its end, and any other value takes a slot of the
- * whole list derived from itself that no listed value holds, nor one
- * `isNear` calls the same. A value's entry depends only on the value and the
- * declaration, so every region agrees on it, and adding a listed value moves
- * only the unlisted values on the slots it takes.
+ * The categorical rule every scaled channel resolves through. The values
+ * `domain` lists take `range` in order, continuing into the `fallback`
+ * entries `range` lacks past its end. Any other value takes the slot derived
+ * from itself (`categoricalValueColor`'s, with no `domain`) unless a listed
+ * value holds it or one `isNear` calls the same, and then another slot derived
+ * from itself.
+ *
+ * With `held`, a value is dealt once, on first sight: its slot avoids every
+ * slot `held` already records and their near twins as well, so values met
+ * together never share an entry while the list has room, and the slot is
+ * recorded so the value keeps it as others arrive. A value nothing else
+ * collides with keeps the entry it takes without `held`. With no `domain`, the
+ * deal spends `range` before spilling into the `fallback` entries it lacks.
  */
-export function categoricalScale(domain, range, { fallback = [], isNear, } = {}) {
+export function categoricalScale(domain, range, { fallback = [], isNear, held, } = {}) {
     const base = range.length ? range : fallback;
     const listed = [...new Set((domain ?? []).map(String))].filter(v => v !== '');
-    if (listed.length === 0) {
+    if (listed.length === 0 && !held) {
         return value => base[valueSlot(value, base.length)];
     }
     const seen = new Set(base.map(entryKey));
@@ -183,19 +181,44 @@ export function categoricalScale(domain, range, { fallback = [], isNear, } = {})
         }),
     ];
     const size = entries.length;
+    const twins = [];
+    const twinsOf = (slot) => (twins[slot] ??= entries.flatMap((entry, i) => i === slot || isNear?.(entries[slot], entry) ? [i] : []));
     const rank = new Map(listed.map((value, i) => [value, i]));
-    const listedSlots = new Set(listed.map((_, i) => i % size));
-    const taken = new Set(entries.flatMap((entry, i) => listedSlots.has(i) ||
-        (isNear && [...listedSlots].some(j => isNear(entries[j], entry)))
-        ? [i]
-        : []));
+    const listedTaken = new Set(listed.flatMap((_, i) => twinsOf(i % size)));
+    const tiers = listed.length > 0
+        ? [[0, size]]
+        : [[0, base.length], [base.length, size]];
+    const deal = (value, taken) => {
+        for (const [from, to] of tiers) {
+            const inTier = from === 0 && to === size
+                ? taken
+                : new Set([...taken].filter(s => s >= from && s < to).map(s => s - from));
+            if (inTier.size < to - from) {
+                return from + freeSlot(value, to - from, inTier);
+            }
+        }
+        return valueSlot(value, tiers[0][1]);
+    };
     return value => {
         const i = rank.get(value);
-        return entries[i !== undefined
-            ? i % size
-            : taken.size < size
-                ? freeSlot(value, size, taken)
-                : valueSlot(value, size)];
+        if (i !== undefined) {
+            return entries[i % size];
+        }
+        if (!held) {
+            return entries[deal(value, listedTaken)];
+        }
+        let slot = held.get(value);
+        if (slot === undefined) {
+            const taken = new Set(listedTaken);
+            for (const s of held.values()) {
+                for (const twin of twinsOf(s)) {
+                    taken.add(twin);
+                }
+            }
+            slot = deal(value, taken);
+            held.set(value, slot);
+        }
+        return entries[slot];
     };
 }
 const oklabByColor = new Map();
@@ -219,12 +242,14 @@ export function similarColors(a, b) {
 /**
  * `categoricalScale` for a color channel: `palette` (the wide palette when
  * empty) spent in `domain` order and continued into the wide palette, and an
- * unlisted value never on a listed value's color or one that reads the same.
+ * unlisted value never on a listed value's color or one that reads the same,
+ * nor, with `held`, on the color of a value met before it.
  */
-export function categoricalColorScale(domain, palette = []) {
+export function categoricalColorScale(domain, palette = [], held) {
     return categoricalScale(domain, palette, {
         fallback: categoricalPalette,
         isNear: similarColors,
+        held,
     });
 }
 const MAX_CACHED_SCALES = 16;
@@ -316,11 +341,23 @@ const PALETTE_LAP_TONES = [
     // and pinks all pin against the top of the sRGB gamut and converge there.
     { lightnessShift: 0.18, chromaScale: 0.8 },
 ];
+// The colour at `position` in `hexes`, each lap past the end re-lit.
+function lapColorAt(hexes, position) {
+    const hex = hexes[position % hexes.length];
+    const lap = PALETTE_LAP_TONES[Math.floor(position / hexes.length) % PALETTE_LAP_TONES.length];
+    return lap ? relight(hex, lap.lightnessShift, lap.chromaScale) : hex;
+}
 /** The palette color for a chromosome at `position` in its assembly. */
 export function refNamePaletteColorAt(position) {
-    const hex = refNameColorHexes[position % refNameColorHexes.length];
-    const lap = PALETTE_LAP_TONES[Math.floor(position / refNameColorHexes.length) % PALETTE_LAP_TONES.length];
-    return lap ? relight(hex, lap.lightnessShift, lap.chromaScale) : hex;
+    return lapColorAt(refNameColorHexes, position);
+}
+const rowColorHexes = tableau10.filter(hex => !NEUTRALS.has(hex));
+/**
+ * The colour the row palette deals the row or value at `position`: tableau10
+ * less its grey, then re-lit laps of it, as a karyotype's are.
+ */
+export function rowPaletteColorAt(position) {
+    return lapColorAt(rowColorHexes, position);
 }
 /**
  * The color a refName paints, BY POSITION IN THE ASSEMBLY where the caller

package/esm/ui/multiTrackMenuItems.d.ts

@@ -1,10 +1,10 @@
 import type PluginManager from '../PluginManager.ts';
-import type { AnyConfigurationModel } from '../configuration/index.ts';
+import type { AnyTrackConfig } from '../configuration/index.ts';
 import type { AbstractSessionModel } from '../util/types/index.ts';
 import type { MenuItem } from './MenuTypes.ts';
 import type { IStateTreeNode } from '@jbrowse/mobx-state-tree';
 export interface MultiTrackSelection extends IStateTreeNode {
-    selection: AnyConfigurationModel[];
+    selection: AnyTrackConfig[];
 }
 export interface MultiTrackMenuItemsProps {
     session: AbstractSessionModel;

package/esm/util/alignedBytes.d.ts

@@ -0,0 +1,19 @@
+export declare const DASH = 45;
+export declare const SPACE = 32;
+export declare const LOWER_BIT = 32;
+export declare const N_UPPER = 78;
+/** No base at this column of a row: a gap, or the padding of a short row. */
+export declare function isGapByte(b: number): b is 32 | 45;
+export declare function sameBase(a: number, b: number): boolean;
+/**
+ * An `N` reference base, which a row neither matches nor mismatches, so
+ * identity leaves it uncounted.
+ */
+export declare function isUnknownBase(b: number): boolean;
+/**
+ * The first column carrying the row's own sequence. A gap run reaching either
+ * end of a row measures where the block was cut, not the alignment.
+ */
+export declare function firstDrawn(bytes: Uint8Array, at: number, len: number): number;
+/** The last column carrying the row's own sequence, from `firstDrawn`'s answer. */
+export declare function lastDrawn(bytes: Uint8Array, at: number, len: number, first: number): number;

package/esm/util/alignedBytes.js

@@ -0,0 +1,37 @@
+export const DASH = 45;
+export const SPACE = 32;
+export const LOWER_BIT = 0x20;
+export const N_UPPER = 78;
+/** No base at this column of a row: a gap, or the padding of a short row. */
+export function isGapByte(b) {
+    return b === DASH || b === SPACE;
+}
+export function sameBase(a, b) {
+    return (a | LOWER_BIT) === (b | LOWER_BIT);
+}
+/**
+ * An `N` reference base, which a row neither matches nor mismatches, so
+ * identity leaves it uncounted.
+ */
+export function isUnknownBase(b) {
+    return (b & ~LOWER_BIT) === N_UPPER;
+}
+/**
+ * The first column carrying the row's own sequence. A gap run reaching either
+ * end of a row measures where the block was cut, not the alignment.
+ */
+export function firstDrawn(bytes, at, len) {
+    let first = 0;
+    while (first < len && isGapByte(bytes[at + first])) {
+        first++;
+    }
+    return first;
+}
+/** The last column carrying the row's own sequence, from `firstDrawn`'s answer. */
+export function lastDrawn(bytes, at, len, first) {
+    let last = len - 1;
+    while (last > first && isGapByte(bytes[at + last])) {
+        last--;
+    }
+    return last;
+}

package/esm/util/analytics.d.ts

@@ -1,22 +1,21 @@
-import type { AnyConfigurationModel } from '../configuration/index.ts';
+import type { AnyConfigurationModel, TrackConfigEntry } from '../configuration/index.ts';
 declare global {
     interface Window {
         ga?: (...args: unknown[]) => void;
     }
 }
-type TrackConfig = AnyConfigurationModel & {
-    type: string;
-};
 interface AnalyticsRootModel {
     jbrowse: {
-        tracks: TrackConfig[];
+        tracks: TrackConfigEntry[];
         assemblies: unknown[];
         plugins?: {
             name?: string;
         }[];
     };
     session?: {
-        sessionTracks: TrackConfig[];
+        sessionTracks: {
+            type: string;
+        }[];
         views: unknown[];
     };
     version: string;