@jbrowse/core 4.3.0 → 5.0.0-beta.2

package/esm/util/addTrackFromWidget.d.ts

@@ -0,0 +1,94 @@
+import type { AssemblyNameResolver } from './tracks.ts';
+import type { AbstractSessionModel, SessionWithPublishTrackConf, TrackContainer } from './types/index.ts';
+import type { IStateTreeNode } from '@jbrowse/mobx-state-tree';
+/**
+ * Whether the target track list currently displays any of the track's
+ * assemblies, i.e. the track can be shown there after adding it.
+ *
+ * Both sides resolve through the aliases, because the two names meeting here
+ * come from different places: the container holds whatever the session opened
+ * the view on, and the config holds whatever its author wrote. `===` read a
+ * track configured against `hg38` as undisplayable in a view on `GRCh38`, so
+ * the add landed and nothing appeared, under a snackbar naming the assembly the
+ * user was looking at as one this view does not have open.
+ */
+export declare function containerDisplaysAssembly(container: {
+    assemblyNames?: readonly string[];
+} | undefined, assemblyNames: readonly (string | undefined)[] | undefined, assemblyManager: AssemblyNameResolver): boolean;
+/** the slice of the add-track widget every workflow's submit path writes to */
+export interface AddTrackWidgetSelf extends IStateTreeNode {
+    /**
+     * Where a submitted track opens: the view, or one track list within it when
+     * the widget was opened from a synteny level's track selector. Not the same
+     * as `view` — a workflow reaching past this for `view` adds the track to the
+     * wrong list.
+     */
+    trackContainer: TrackContainer | undefined;
+    clearData: () => void;
+}
+/**
+ * The slice of the add-track widget a whole workflow gets: the submit path
+ * above plus the assembly it writes into. Structural rather than the widget's
+ * own model type, so a plugin contributing a workflow doesn't take a package
+ * dependency on the plugin that owns the widget.
+ */
+export interface AddTrackWorkflowModel extends AddTrackWidgetSelf {
+    assembly: string | undefined;
+    setAssembly: (arg: string) => void;
+}
+/**
+ * Reset the form and dismiss the widget after a successful add.
+ *
+ * Only ever on an add that landed something: finishing throws away what the
+ * user assembled, so doing it when every config was rejected buries the
+ * snackbars explaining why behind an empty form with nothing to retry from.
+ */
+export declare function finishAddTrack(model: AddTrackWidgetSelf, session: AbstractSessionModel): void;
+/**
+ * Add one track config from an add-track workflow, reveal it, and dismiss the
+ * widget — the tail every workflow shares, so all of them decide "show vs.
+ * warn vs. dismiss" the same way.
+ *
+ * Three things a workflow doing this by hand has got wrong:
+ *
+ * - It shows the track in `model.view`, which is the wrong list when the widget
+ *   was opened from a synteny level's track selector. `trackContainer` is the
+ *   target.
+ * - It shows a track whose assembly the container doesn't display, which is
+ *   silently nothing on screen. Say so instead.
+ * - It dismisses the widget even when `publishTrackConf` rejected the config,
+ *   wiping the form behind the error snackbar.
+ *
+ * **A track on an assembly the view synthesized takes neither destination.** The
+ * widget reads its assembly off the containing view and offers no choice of one
+ * outside it (`setAssembly` lists `session.assemblyNames`, which excludes the
+ * temporary ones), so a user opening a file in a read-vs-ref panel arrives here
+ * naming an assembly that goes back when that view closes — and a session list
+ * would keep the config, once per file, in the snapshot they save and share.
+ * That is ADR-084's leak reached through the widget rather than through a
+ * launcher, so it takes ADR-084's answer: the config rides on the track as
+ * `showTrack`'s `inlineConf`, works for the life of the view, and goes out with
+ * it. The container is the one this assembly came from, so it displays it.
+ *
+ * Returns the added config, or undefined when `publishTrackConf` rejected it — it
+ * has already surfaced its own error, and a second, vaguer snackbar on top of
+ * that helps nobody.
+ */
+export declare function addTrackFromWidget({ model, session, conf, }: {
+    model: AddTrackWidgetSelf;
+    session: AbstractSessionModel;
+    conf: Parameters<SessionWithPublishTrackConf['publishTrackConf']>[0] & {
+        trackId: string;
+        name?: string;
+        assemblyNames?: (string | undefined)[];
+    };
+}): (import("@jbrowse/mobx-state-tree").$EmptyObjectBrand & Partial<{
+    [x: string]: any;
+}> & {
+    trackId: string;
+    name?: string;
+    assemblyNames?: (string | undefined)[];
+}) | (import("@jbrowse/mobx-state-tree").ModelInstanceTypeProps<Record<string, any>> & {
+    setSubschema(slotName: string, data: Record<string, unknown>): any;
+    setSlot(slotName: string, value: unknown): void;
+} & IStateTreeNode<import("../configuration/types.ts").AnyConfigurationSchemaType>) | undefined;

package/esm/util/addTrackFromWidget.js

@@ -0,0 +1,90 @@
+import { namesTemporaryAssembly } from './temporaryAssembly.js';
+import { isSameAssemblyName } from './tracks.js';
+import { isSessionModelWithWidgets, isSessionWithPublishTrackConf, } from './types/index.js';
+/**
+ * Whether the target track list currently displays any of the track's
+ * assemblies, i.e. the track can be shown there after adding it.
+ *
+ * Both sides resolve through the aliases, because the two names meeting here
+ * come from different places: the container holds whatever the session opened
+ * the view on, and the config holds whatever its author wrote. `===` read a
+ * track configured against `hg38` as undisplayable in a view on `GRCh38`, so
+ * the add landed and nothing appeared, under a snackbar naming the assembly the
+ * user was looking at as one this view does not have open.
+ */
+export function containerDisplaysAssembly(container, assemblyNames, assemblyManager) {
+    return !!container?.assemblyNames?.some(a => assemblyNames?.some(b => isSameAssemblyName(a, b, assemblyManager)));
+}
+/**
+ * Reset the form and dismiss the widget after a successful add.
+ *
+ * Only ever on an add that landed something: finishing throws away what the
+ * user assembled, so doing it when every config was rejected buries the
+ * snackbars explaining why behind an empty form with nothing to retry from.
+ */
+export function finishAddTrack(model, session) {
+    model.clearData();
+    if (isSessionModelWithWidgets(session)) {
+        session.hideWidget(model);
+    }
+}
+/**
+ * Add one track config from an add-track workflow, reveal it, and dismiss the
+ * widget — the tail every workflow shares, so all of them decide "show vs.
+ * warn vs. dismiss" the same way.
+ *
+ * Three things a workflow doing this by hand has got wrong:
+ *
+ * - It shows the track in `model.view`, which is the wrong list when the widget
+ *   was opened from a synteny level's track selector. `trackContainer` is the
+ *   target.
+ * - It shows a track whose assembly the container doesn't display, which is
+ *   silently nothing on screen. Say so instead.
+ * - It dismisses the widget even when `publishTrackConf` rejected the config,
+ *   wiping the form behind the error snackbar.
+ *
+ * **A track on an assembly the view synthesized takes neither destination.** The
+ * widget reads its assembly off the containing view and offers no choice of one
+ * outside it (`setAssembly` lists `session.assemblyNames`, which excludes the
+ * temporary ones), so a user opening a file in a read-vs-ref panel arrives here
+ * naming an assembly that goes back when that view closes — and a session list
+ * would keep the config, once per file, in the snapshot they save and share.
+ * That is ADR-084's leak reached through the widget rather than through a
+ * launcher, so it takes ADR-084's answer: the config rides on the track as
+ * `showTrack`'s `inlineConf`, works for the life of the view, and goes out with
+ * it. The container is the one this assembly came from, so it displays it.
+ *
+ * Returns the added config, or undefined when `publishTrackConf` rejected it — it
+ * has already surfaced its own error, and a second, vaguer snackbar on top of
+ * that helps nobody.
+ */
+export function addTrackFromWidget({ model, session, conf, }) {
+    if (!isSessionWithPublishTrackConf(session)) {
+        throw new Error("Can't add tracks to this session");
+    }
+    const { trackContainer } = model;
+    if (namesTemporaryAssembly(session, conf)) {
+        if (!trackContainer) {
+            session.notify(`Could not add "${conf.name ?? conf.trackId}": the view it was being added to has closed, and it uses an assembly that only that view had.`, 'warning');
+            return undefined;
+        }
+        void trackContainer.launchTrack(conf.trackId, {}, {}, conf);
+        finishAddTrack(model, session);
+        return conf;
+    }
+    const added = session.publishTrackConf(conf);
+    if (!added) {
+        return undefined;
+    }
+    if (containerDisplaysAssembly(trackContainer, conf.assemblyNames, session.assemblyManager)) {
+        void trackContainer?.launchTrack(conf.trackId);
+    }
+    else {
+        const assemblies = conf.assemblyNames?.filter(a => !!a) ?? [];
+        session.notify(`Added track "${conf.name ?? conf.trackId}" to the session, but it was not displayed because it uses ${assemblies.length
+            ? `assembly "${assemblies.join('", "')}"`
+            : 'an assembly'}, which is not open in this view. Open a view for that assembly and use its track selector to display it.`, 'warning');
+    }
+    finishAddTrack(model, session);
+    return added;
+}

package/esm/util/analytics.d.ts

@@ -1,3 +1,32 @@
-export declare function writeAWSAnalytics(rootModel: any, initialTimeStamp: number, sessionQuery?: string | null): Promise<void>;
-export declare function writeGAAnalytics(rootModel: any, initialTimestamp: number): Promise<void>;
-export declare function doAnalytics(rootModel: any, initialTimestamp: number, initialSessionQuery: string | null | undefined): void;
+import type { AnyConfigurationModel } from '../configuration/index.ts';
+declare global {
+    interface Window {
+        ga?: (...args: unknown[]) => void;
+    }
+}
+type TrackConfig = AnyConfigurationModel & {
+    type: string;
+};
+interface AnalyticsRootModel {
+    jbrowse: {
+        tracks: TrackConfig[];
+        assemblies: unknown[];
+        plugins?: {
+            name?: string;
+        }[];
+    };
+    session?: {
+        sessionTracks: TrackConfig[];
+        views: unknown[];
+    };
+    version: string;
+}
+type AnalyticsRootModelWithConfig = AnalyticsRootModel & {
+    jbrowse: {
+        configuration: AnyConfigurationModel;
+    };
+};
+export declare function writeAWSAnalytics(rootModel: AnalyticsRootModel, initialTimestamp: number, sessionQuery?: string | null): Promise<void>;
+export declare function writeGAAnalytics(rootModel: AnalyticsRootModel, initialTimestamp: number): Promise<void>;
+export declare function doAnalytics(rootModel: AnalyticsRootModelWithConfig | undefined, initialTimestamp: number, initialSessionQuery: string | null | undefined): void;
+export {};

package/esm/util/analytics.js

@@ -1,80 +1,133 @@
-import { readConfObject } from "../configuration/index.js";
-import { isElectron } from "../util/index.js";
-export async function writeAWSAnalytics(rootModel, initialTimeStamp, sessionQuery) {
+import { effectiveRenderer, getGraphicsCapabilities, } from '@jbrowse/render-core/graphicsCapabilities';
+import { readConfObject } from '../configuration/index.js';
+import { isElectron, rIC } from '../util/index.js';
+// Both writers are fire-and-forget from several call sites, so they swallow
+// their own failures rather than rejecting: a floating rejected promise trips
+// the webpack-dev-server overlay (it listens for unhandledrejection), and an
+// analytics ping is never worth interrupting a session for.
+export async function writeAWSAnalytics(rootModel, initialTimestamp, sessionQuery) {
     try {
         const url = 'https://analytics.jbrowse.org/api/v1';
-        const multiAssemblyTracks = rootModel.jbrowse.tracks.filter((track) => (readConfObject(track, 'assemblyNames') || []).length > 1).length;
-        const savedSessionCount = Object.keys(localStorage).filter(name => name.includes('localSaved-')).length;
+        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.
+        const capabilities = await getGraphicsCapabilities();
+        const renderer = effectiveRenderer(capabilities);
+        // The coarse bit only. `glRenderer` names the exact driver and stays local
+        // to the stack-trace dialog, the same line vendor/architecture hold — this
+        // says whether a WebGL2 user is on a rasterizer, which is the population
+        // that pays ~25x Canvas2D on the main thread and the number that decides
+        // whether the ladder should route around it. 'unknown' where nothing probed
+        // or the browser withholds the extension, which must not read as 'false'.
+        const softwareRendering = capabilities.softwareWebgl ?? 'unknown';
         const { jbrowse: config, session, version: ver } = rootModel;
         const { tracks, assemblies, plugins } = config;
+        // stats to be recorded in db
         const stats = {
             ver,
-            'plugins-count': plugins?.length || 0,
-            'plugin-names': plugins?.map((p) => p.name).join(','),
+            'plugins-count': plugins?.length ?? 0,
+            'plugin-names': plugins?.map(p => p.name).join(','),
             'assemblies-count': assemblies.length,
             'tracks-count': tracks.length,
-            'session-tracks-count': session?.sessionTracks.length || 0,
-            'open-views': session?.views.length || 0,
+            'session-tracks-count': session?.sessionTracks.length ?? 0,
+            'open-views': session?.views.length ?? 0,
             'synteny-tracks-count': multiAssemblyTracks,
-            'saved-sessions-count': savedSessionCount,
-            'existing-session-param-type': sessionQuery?.split('-')[0] || 'none',
+            // No `saved-sessions-count`: it counted localStorage keys matching
+            // `localSaved-`, a format nothing has written since autosaved sessions
+            // moved to IndexedDB (`sessionsDB`), so it reported 0 for every user. The
+            // live count is `savedSessionMetadata`, which is web-only and populated by
+            // an async open — reporting it here would race the boot rather than
+            // measure anything, so the field is gone instead of re-sourced.
+            // field if existing session param in query before autogenerated param
+            'existing-session-param-type': sessionQuery?.split('-', 1)[0] || 'none',
+            // screen geometry
             'scn-h': window.screen.height,
             'scn-w': window.screen.width,
+            // window geometry
             'win-h': window.innerHeight,
             'win-w': window.innerWidth,
+            dpr: window.devicePixelRatio,
             electron: isElectron,
-            loadTime: (Date.now() - initialTimeStamp) / 1000,
+            renderer,
+            'software-rendering': softwareRendering,
+            loadTime: (Date.now() - initialTimestamp) / 1000,
             jb2: true,
         };
-        tracks.forEach((track) => {
+        // tallies get processed in the lambda, keyed as e.g. track-types-FeatureTrack
+        const trackTypeCounts = {};
+        for (const track of tracks) {
             const key = `track-types-${track.type}`;
-            stats[key] = stats[key] + 1 || 1;
-        });
-        session?.sessionTracks.forEach((track) => {
+            trackTypeCounts[key] = (trackTypeCounts[key] ?? 0) + 1;
+        }
+        const sessionTrackTypeCounts = {};
+        for (const track of session?.sessionTracks ?? []) {
             const key = `sessionTrack-types-${track.type}`;
-            stats[key] = stats[key] + 1 || 1;
-        });
-        const qs = Object.keys(stats)
-            .map(key => `${key}=${stats[key]}`)
-            .join('&');
+            sessionTrackTypeCounts[key] = (sessionTrackTypeCounts[key] ?? 0) + 1;
+        }
+        Object.assign(stats, trackTypeCounts, sessionTrackTypeCounts);
+        const qs = new URLSearchParams(Object.entries(stats).map(([key, value]) => [key, String(value)])).toString();
         await fetch(`${url}?${qs}`);
     }
     catch (e) {
-        console.error('Failed to write analytics to AWS.', e);
+        console.warn('Failed to write analytics to AWS.', e);
     }
 }
 export async function writeGAAnalytics(rootModel, initialTimestamp) {
-    const jbrowseUser = 'UA-7115575-5';
-    const stats = {
-        'tracks-count': rootModel.jbrowse.tracks.length,
-        ver: rootModel.version,
-        electron: isElectron,
-        loadTime: Date.now() - initialTimestamp,
-        pluginNames: rootModel.jbrowse.plugins?.map((plugin) => plugin.name) || '',
-    };
-    let analyticsScript = "(function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){";
-    analyticsScript +=
-        '(i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),';
-    analyticsScript +=
-        'm=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)';
-    analyticsScript +=
-        "})(window,document,'script','https://www.google-analytics.com/analytics.js','ga');";
-    analyticsScript += `ga('create', '${jbrowseUser}', 'auto', 'jbrowseTracker');`;
-    const gaData = {};
-    const googleDimensions = 'tracks-count ver electron loadTime pluginNames';
-    for (const [index, key] of googleDimensions.split(/\s+/).entries()) {
-        gaData[`dimension${index + 1}`] = stats[key];
+    try {
+        const jbrowseUser = 'UA-7115575-5';
+        const loadTime = Date.now() - initialTimestamp;
+        // custom dimension/metric indices are wired up on the GA property side, so
+        // this order (tracks-count, ver, electron, loadTime, pluginNames) must stay
+        // dimension1..5
+        const gaData = {
+            dimension1: rootModel.jbrowse.tracks.length, // this is all possible tracks
+            dimension2: rootModel.version,
+            dimension3: isElectron,
+            dimension4: loadTime,
+            dimension5: rootModel.jbrowse.plugins?.map(p => p.name).join(',') ?? '',
+            metric1: Math.round(loadTime),
+        };
+        // Plugin names come from the loaded config and are not trusted content (a
+        // config can be loaded from an arbitrary URL). Only this static bootstrap,
+        // with no interpolated data, is ever parsed as script source; gaData is
+        // handed to ga() as a real JS value afterward so untrusted strings can never
+        // break out of the <script> tag the way interpolating them into it would.
+        const analyticsBootstrap = "(function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){" +
+            '(i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),' +
+            'm=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)' +
+            "})(window,document,'script','https://www.google-analytics.com/analytics.js','ga');";
+        const analyticsScriptNode = document.createElement('script');
+        analyticsScriptNode.innerHTML = analyticsBootstrap;
+        document.head.append(analyticsScriptNode);
+        window.ga?.('create', jbrowseUser, 'auto', 'jbrowseTracker');
+        window.ga?.('jbrowseTracker.send', 'pageview', gaData);
+    }
+    catch (e) {
+        console.warn('Failed to write analytics to GA.', e);
     }
-    gaData.metric1 = Math.round(stats.loadTime);
-    analyticsScript += `ga('jbrowseTracker.send', 'pageview',${JSON.stringify(gaData)});`;
-    const analyticsScriptNode = document.createElement('script');
-    analyticsScriptNode.innerHTML = analyticsScript;
-    document.getElementsByTagName('head')[0].append(analyticsScriptNode);
 }
+// One pageview per page load, not per pluginManager. jbrowse-web rebuilds the
+// whole pluginManager (and rootModel) whenever plugins change, and StrictMode
+// builds it twice on mount — without this guard each rebuild re-pings AWS and
+// appends another Google Analytics <script> to <head>, inflating pageviews and
+// growing the document on every plugin install.
+let analyticsSent = false;
 export function doAnalytics(rootModel, initialTimestamp, initialSessionQuery) {
     if (rootModel &&
+        !analyticsSent &&
         !readConfObject(rootModel.jbrowse.configuration, 'disableAnalytics')) {
-        writeAWSAnalytics(rootModel, initialTimestamp, initialSessionQuery);
-        writeGAAnalytics(rootModel, initialTimestamp);
+        analyticsSent = true;
+        // Defer off the critical load path: writeGAAnalytics injects a third-party
+        // Google Analytics script and writeAWSAnalytics probes graphics
+        // capabilities, together ~hundreds of ms of main-thread work at startup.
+        // loadTime is still measured from initialTimestamp, so the reported metric
+        // is unaffected by running these when the browser is idle.
+        rIC(() => {
+            void writeAWSAnalytics(rootModel, initialTimestamp, initialSessionQuery);
+            void writeGAAnalytics(rootModel, initialTimestamp);
+        });
     }
 }

package/esm/util/animationAllowed.d.ts

@@ -0,0 +1,17 @@
+import type { AnimationMode } from './types/index.ts';
+/**
+ * Whether a motion may play at all, before anything about what would move is
+ * consulted: a frame clock has to exist, and the resolved animation mode has to
+ * allow motion — 'enabled' always does, 'disabled' never does, and 'system'
+ * honors the OS prefers-reduced-motion setting, so reduced-motion users get
+ * instant snaps unless they explicitly opt in. The mode comes from the session
+ * preference (`configuration.preferences.animationMode` + user override), which
+ * is `getSession(self).animationMode`.
+ *
+ * In core rather than beside either caller because the two that ask are a
+ * feature-layout morph in the canvas plugin and a viewport flight in the LGV,
+ * and a second copy of this check is a second answer to "does this user want
+ * motion" — the one a reduced-motion reader notices when only half the app
+ * honors it.
+ */
+export declare function animationAllowed(mode: AnimationMode): boolean;

package/esm/util/animationAllowed.js

@@ -0,0 +1,22 @@
+/**
+ * Whether a motion may play at all, before anything about what would move is
+ * consulted: a frame clock has to exist, and the resolved animation mode has to
+ * allow motion — 'enabled' always does, 'disabled' never does, and 'system'
+ * honors the OS prefers-reduced-motion setting, so reduced-motion users get
+ * instant snaps unless they explicitly opt in. The mode comes from the session
+ * preference (`configuration.preferences.animationMode` + user override), which
+ * is `getSession(self).animationMode`.
+ *
+ * In core rather than beside either caller because the two that ask are a
+ * feature-layout morph in the canvas plugin and a viewport flight in the LGV,
+ * and a second copy of this check is a second answer to "does this user want
+ * motion" — the one a reduced-motion reader notices when only half the app
+ * honors it.
+ */
+export function animationAllowed(mode) {
+    const hasFrameClock = typeof requestAnimationFrame === 'function';
+    const prefersReduced = typeof matchMedia === 'function' &&
+        matchMedia('(prefers-reduced-motion: reduce)').matches;
+    return (hasFrameClock &&
+        (mode === 'enabled' || (mode === 'system' && !prefersReduced)));
+}

package/esm/util/applyRowResizeWheel.d.ts

@@ -0,0 +1,10 @@
+interface RowResizeTarget {
+    effectiveRowHeight: number;
+    scrollTop: number;
+    nrow: number;
+    viewportHeight: number;
+    setRowHeight: (n: number) => void;
+    setScrollTop: (n: number) => void;
+}
+export declare function applyRowResizeWheel(e: WheelEvent, el: HTMLElement, model: RowResizeTarget): void;
+export {};

package/esm/util/applyRowResizeWheel.js

@@ -0,0 +1,34 @@
+// shift+wheel resizes the sample rows (a vertical-zoom gesture) rather than
+// scrolling, keeping the row under the cursor pinned in place as the height
+// changes. Shared by every row-stack display — both variant displays and MAF —
+// so the gesture stays identical wherever rows have a resolved height and a
+// scroll offset. setScrollTop clamps to the new scrollableHeight, so the raw
+// target is passed through unclamped.
+import { normalizeWheelDelta } from './wheelZoom.js';
+const MAX_ROW_HEIGHT = 20;
+// px of row-height change per pixel of normalized wheel scroll. A mouse notch
+// (~100px) nudges the height ~0.4px; a trackpad's small continuous deltas
+// accumulate smoothly instead of the old sign-based ±1-per-event, which flew
+// through the whole range on a trackpad's event flood.
+const RESIZE_PX_PER_WHEEL_PX = 1 / 240;
+export function applyRowResizeWheel(e, el, model) {
+    e.preventDefault();
+    // scroll up (deltaY < 0) grows rows; proportional to the normalized delta so
+    // the speed is consistent across mice/trackpads and finer than ±1/event.
+    const delta = -normalizeWheelDelta(e.deltaY, e.deltaMode) * RESIZE_PX_PER_WHEEL_PX;
+    // guard nrow=0 (no samples) so the auto-fit floor stays finite
+    const minRowHeight = model.viewportHeight / Math.max(1, model.nrow);
+    // The cap may stop the gesture going further; it may never move the rows on
+    // its own. So both heights that can already sit above MAX_ROW_HEIGHT raise
+    // it: the auto-fit floor (few samples), and the current height (a pinned
+    // `rowHeight` — the config slot and the "Custom..." dialog are both
+    // unbounded, and MAF's own docs example is 12 while a bases-mode row wants
+    // more). Without the second, a 40px pinned row met `min(20, 40.4)` on the
+    // first notch of a *grow* gesture and halved.
+    const maxRowHeight = Math.max(MAX_ROW_HEIGHT, minRowHeight, model.effectiveRowHeight);
+    const newRowHeight = Math.max(minRowHeight, Math.min(maxRowHeight, model.effectiveRowHeight + delta));
+    const mouseY = e.clientY - el.getBoundingClientRect().top;
+    const rowUnderMouse = (mouseY + model.scrollTop) / model.effectiveRowHeight;
+    model.setRowHeight(newRowHeight);
+    model.setScrollTop(rowUnderMouse * newRowHeight - mouseY);
+}

package/esm/util/assemblyConfigUtils.d.ts

@@ -0,0 +1,144 @@
+import type { FileLocation } from './types/data.ts';
+export declare const adapterTypes: readonly ['IndexedFastaAdapter', 'BgzipFastaAdapter', 'FastaAdapter', 'TwoBitAdapter', 'ChromSizesAdapter'];
+export type AdapterType = (typeof adapterTypes)[number];
+export declare const adapterLabels: Record<AdapterType, string>;
+export declare function adapterHasSequence(adapterSelection: AdapterType): adapterSelection is "BgzipFastaAdapter" | "FastaAdapter" | "IndexedFastaAdapter" | "TwoBitAdapter";
+export interface FormState {
+    adapterSelection: AdapterType;
+    assemblyName: string;
+    assemblyDisplayName: string;
+    fastaLocation: FileLocation;
+    faiLocation: FileLocation;
+    gziLocation: FileLocation;
+    twoBitLocation: FileLocation;
+    chromSizesLocation: FileLocation;
+    refNameAliasesLocation: FileLocation;
+    cytobandsLocation: FileLocation;
+}
+export type LocationField = {
+    [K in keyof FormState]: FormState[K] extends FileLocation ? K : never;
+}[keyof FormState];
+export declare const sidecarRoles: readonly ['fai', 'gzi'];
+export type SidecarRole = (typeof sidecarRoles)[number];
+export declare const sidecars: {
+    readonly fai: {
+        readonly field: 'faiLocation';
+        readonly ext: '.fai';
+        readonly label: 'FASTA index (.fai) file';
+    };
+    readonly gzi: {
+        readonly field: 'gziLocation';
+        readonly ext: '.gzi';
+        readonly label: 'FASTA gzip index (.gzi) file';
+    };
+};
+export declare function makeSetField(setForm: (update: (prev: FormState) => FormState) => void): <K extends keyof FormState>(key: K) => (value: FormState[K]) => void;
+export declare function initialFormState(): FormState;
+export declare function applyPrimaryFile(state: FormState, location: FileLocation): FormState;
+export declare function applyTwoBitFile(state: FormState, location: FileLocation): FormState;
+export declare function clearFormFields(state: FormState): FormState;
+export declare function clearSequenceFiles(state: FormState): FormState;
+export declare function getBaseAssemblyConfig(state: FormState): {
+    name: string;
+    displayName?: string | undefined;
+    refNameAliases?: {
+        adapter: {
+            type: string;
+            location: FileLocation;
+        };
+    } | undefined;
+    cytobands?: {
+        adapter: {
+            type: string;
+            cytobandLocation: FileLocation;
+        };
+    } | undefined;
+};
+export type AssemblyAdapter = {
+    type: 'IndexedFastaAdapter';
+    fastaLocation: FileLocation;
+    faiLocation: FileLocation;
+} | {
+    type: 'BgzipFastaAdapter';
+    fastaLocation: FileLocation;
+    faiLocation: FileLocation;
+    gziLocation: FileLocation;
+} | {
+    type: 'UnindexedFastaAdapter';
+    fastaLocation: FileLocation;
+} | {
+    type: 'TwoBitAdapter';
+    twoBitLocation: FileLocation;
+    chromSizesLocation?: FileLocation;
+} | {
+    type: 'ChromSizesAdapter';
+    chromSizesLocation: FileLocation;
+};
+export type AssemblyConf = ReturnType<typeof getBaseAssemblyConfig> & {
+    sequence: {
+        type: 'ReferenceSequenceTrack';
+        trackId: string;
+        adapter: AssemblyAdapter;
+    };
+};
+export declare function isBlank(location: FileLocation): boolean;
+export declare function formHasSequence(form: FormState): boolean;
+export declare function getAssemblyName(form: FormState): string;
+export declare function getMissingSidecars(form: FormState): ({
+    readonly field: 'faiLocation';
+    readonly ext: '.fai';
+    readonly label: 'FASTA index (.fai) file';
+} | {
+    readonly field: 'gziLocation';
+    readonly ext: '.gzi';
+    readonly label: 'FASTA gzip index (.gzi) file';
+})[];
+export declare function isFormReady(form: FormState): boolean;
+export declare function isFormDirty(form: FormState): boolean;
+export declare function partitionExtraLocations(form: FormState): {
+    used: FileLocation[];
+    unused: FileLocation[];
+};
+export declare function getAssemblyNameFromFilename(filename: string): string;
+export declare function detectAdapterType(filename: string): AdapterType | undefined;
+export type FileRole = 'fasta' | 'fastaGz' | 'fai' | 'gzi' | 'twoBit' | 'chromSizes' | 'cytobands' | 'refNameAliases';
+export declare function classifyFilename(filename: string): FileRole | undefined;
+export declare function classifyAssemblyFiles(locations: FileLocation[]): Partial<FormState>;
+export declare function isSequenceRole(role: FileRole | undefined): boolean;
+export interface ClassifiedLocation {
+    location: FileLocation;
+    role: FileRole | undefined;
+}
+export declare function classifyLocations(locations: FileLocation[]): ClassifiedLocation[];
+/**
+ * Rebuild the file-location fields (plus adapter/name) of `state` from a freshly
+ * classified set of dropped/pasted files.
+ *
+ * The file set is authoritative: a field it says nothing about resets, so
+ * deleting a URL from the box clears the slot it filled. `edited` is the way out
+ * — the fields the user set by hand, which the classifier never gets to answer
+ * for. Without it, typing a .fai into the "this format needs its index" input
+ * and then adding one more URL wiped the .fai and the pane re-asked for it.
+ *
+ * refName aliases and cytobands merge instead of resetting even when untouched:
+ * they are the two slots "More options" also fills, and no file set that omits
+ * them is making a claim about them.
+ */
+export declare function applyClassifiedFiles(state: FormState, locations: FileLocation[], edited: ReadonlySet<keyof FormState>): FormState;
+export declare function buildAssemblyConf(form: FormState, resolveFastaAdapter: (fastaLocation: FileLocation) => Promise<AssemblyAdapter> | AssemblyAdapter): Promise<AssemblyConf>;
+export declare function urlTextToLocations(text: string): FileLocation[];
+export type AdapterConfigResult = {
+    kind: 'ready';
+    adapter: AssemblyAdapter;
+} | {
+    kind: 'needsFastaIndex';
+    fastaLocation: FileLocation;
+};
+export declare function getAdapterConfig({ adapterSelection, fastaLocation, faiLocation, gziLocation, twoBitLocation, chromSizesLocation, }: {
+    adapterSelection: AdapterType;
+    fastaLocation: FileLocation;
+    faiLocation: FileLocation;
+    gziLocation: FileLocation;
+    twoBitLocation: FileLocation;
+    chromSizesLocation: FileLocation;
+}): AdapterConfigResult;