loom-browser 0.0.9 → 0.0.10

package/dist/types/browser/index.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Browser module barrel exports.
+ *
+ * Re-exports from headless/ (Layer 3, no DOM) and dom/ (Layer 4, DOM shell).
+ */
+export { HeadlessGenomeBrowser, BrowserEvent } from './headless/headlessGenomeBrowser';
+export type { HeadlessGenomeBrowserOptions, ManagedTrack, AddRulerOptions, AddWigTrackOptions, AddGtxTrackOptions, AddBedTrackOptions, AddAnnotationTrackOptions, AddInteractionTrackOptions, AddSequenceTrackOptions, AddWigTrackWithFeaturesOptions, AddBedTrackWithFeaturesOptions, } from './headless/headlessGenomeBrowser';
+export { ROIManager } from './headless/roiManager';
+export type { ROIEventCallbacks } from './headless/roiManager';
+export { TrackDataManager } from './headless/trackDataManager';
+export type { DataEventCallbacks } from './headless/trackDataManager';
+export { isAbortError, normalizeError } from './headless/errors';
+export { SESSION_VERSION, createTrackFromSession, fromIgvSession, toIgvSession, } from './headless/session';
+export type { CreateTrackFromSessionOptions } from './headless/session';
+export { GenomeBrowser } from './dom/genomeBrowser';
+export type { GenomeBrowserOptions, BrowserEvents } from './dom/genomeBrowser';
+export { PointerEventManager } from './dom/pointerEventManager';
+export type { PointerBrowserAccess } from './dom/pointerEventManager';
+export { ROIOverlayManager } from './dom/roiOverlayManager';
+export type { ROIOverlayCallbacks } from './dom/roiOverlayManager';
+export { ContextMenuManager } from './dom/contextMenuManager';
+export type { ContextMenuManagerCallbacks } from './dom/contextMenuManager';
+export { createDefaultContextMenuProvider, createDefaultPopupProvider } from './dom/defaultProviders';
+export { renderDOMBrowserSVG, svgToPNG, triggerDownload } from './dom/browserExport';

package/dist/types/browserExport.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Browser export utilities — SVG and PNG export for the DOM GenomeBrowser.
+ *
+ * Pure functions that render the multi-track browser state to SVG/PNG,
+ * including axis columns and ROI overlays.
+ *
+ * Extracted from GenomeBrowser to isolate export logic.
+ *
+ * Layer 4 (DOM): requires DOM APIs (for PNG rendering via Image/Canvas).
+ */
+import type { Locus, ROI } from './types';
+import type { ManagedTrack } from './headlessGenomeBrowser';
+import type { RenderTheme } from './themes/renderTheme';
+/**
+ * Render the DOM browser view as an SVG string, including axis columns.
+ *
+ * Pure function — takes all needed state as parameters.
+ * Matches igv.js Browser.toSVG() which calls renderSVGAxis() for each TrackView.
+ */
+export declare function renderDOMBrowserSVG(managedTracks: readonly ManagedTrack[], locus: Locus, theme: RenderTheme, visibleROIs: ROI[], axisColumnWidth: number, options?: {
+    width?: number;
+    containerWidth?: number;
+    backdropColor?: string;
+}): string;
+/**
+ * Convert an SVG string to a PNG data URL.
+ *
+ * Pipeline: SVG string → Blob → object URL → Image → Canvas (DPR-scaled) → toDataURL.
+ */
+export declare function svgToPNG(svgString: string, width: number, height: number, dpr: number): Promise<string>;
+/** Trigger a file download via a temporary anchor element. */
+export declare function triggerDownload(filename: string, url: string): void;

package/dist/types/commandDispatcher.d.ts

@@ -7,7 +7,7 @@
  *
  * Follows the discriminated-union + result-map pattern from workerProvider.ts.
  */
-import type { HeadlessGenomeBrowser } from './headlessGenomeBrowser';
+import type { HeadlessGenomeBrowser } from './browser/headless/headlessGenomeBrowser';
 import type { ROI, ROISetConfig, TrackSessionConfig, SessionConfig } from './types';
 import type { TrackSelector } from './trackSelector';
 import type { ProjectedState, TrackSummary } from './stateProjection';

package/dist/types/contextMenuManager.d.ts

@@ -0,0 +1,49 @@
+/**
+ * ContextMenuManager — handles right-click context menus for tracks and ROIs.
+ *
+ * Manages the contextmenu event listener, lazy input dialog creation,
+ * track-specific and common menu item assembly, and ROI context menus.
+ *
+ * Extracted from GenomeBrowser to isolate context menu lifecycle.
+ *
+ * Layer 4 (DOM): requires DOM APIs.
+ */
+import type { Track, TrackContextMenuEvent, ROI, Locus } from './types';
+import type { ContextMenuProvider } from './contextMenuProvider';
+import type { PopupProvider } from './popupProvider';
+/** Callback interface for context menu actions that require browser-level coordination. */
+export interface ContextMenuManagerCallbacks {
+    findTrackForTarget(target: EventTarget | null): Track | null;
+    getLocus(): Locus;
+    getViewportWidth(): number;
+    removeTrack(track: Track): void;
+    onAxisUpdate(track: Track): void;
+    updateROI(roiId: string, changes: Partial<Omit<ROI, 'id'>>): ROI | undefined;
+    removeROI(roiId: string): boolean;
+    setLocus(locus: Locus): void;
+    emitTrackContextMenu(event: TrackContextMenuEvent): void;
+    emitROIContextMenu(event: {
+        roi: ROI;
+        genomicLocation: number;
+        x: number;
+        y: number;
+    }): void;
+}
+export declare class ContextMenuManager {
+    private container;
+    private axisColumnWidth;
+    private contextMenuProvider;
+    private popupProvider;
+    private callbacks;
+    private handleContextMenu;
+    private inputDialog;
+    constructor(container: HTMLElement, axisColumnWidth: number, contextMenuProvider: ContextMenuProvider | undefined, popupProvider: PopupProvider | undefined, callbacks: ContextMenuManagerCallbacks);
+    /** Attach the contextmenu event listener to the container. */
+    setup(): void;
+    /** Show context menu for an ROI region. */
+    showROIContextMenu(roi: ROI, e: MouseEvent): void;
+    /** Remove context menu listener and dispose of input dialog. */
+    dispose(): void;
+    /** Lazy-create the input dialog element. Consolidates duplicated creation logic. */
+    private ensureInputDialog;
+}

package/dist/types/data/searchService.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Gene/feature name lookup via the igv.org locus web service.
+ *
+ * Ports js/searchFeatures.ts: searchWebService() + parseSearchResults().
+ * Layer 1 — no DOM dependencies.
+ */
+/** Result from a gene/feature name search. */
+export interface SearchResult {
+    chr: string;
+    start: number;
+    end: number;
+    name: string;
+}
+/**
+ * Look up a gene/feature name via the igv.org locus web service.
+ * Returns the first matching result, or undefined if not found.
+ */
+export declare function searchWebService(featureName: string, genomeId: string, signal?: AbortSignal): Promise<SearchResult | undefined>;
+/**
+ * Parse tab-delimited search results from igv.org locus.php.
+ * Format per line: GENENAME\tchr:start-end\tdescription
+ * Returns the first valid result, or undefined.
+ */
+export declare function parseSearchResults(data: string): SearchResult | undefined;

package/dist/types/dataSourceWorkerProvider.d.ts

@@ -9,7 +9,7 @@
  *
  * Layer 1 (Data + Layout): no DOM.
  */
-import type { DataSourceConfig, Locus } from './types';
+import type { DataSourceConfig, DataSourceConfigMethod, Locus } from './types';
 /** Main thread → Worker messages. */
 export type DataSourceWorkerRequest = {
     type: 'create';
@@ -24,7 +24,7 @@ export type DataSourceWorkerRequest = {
 } | {
     type: 'configure';
     instanceId: string;
-    method: string;
+    method: DataSourceConfigMethod;
     args: unknown[];
 } | {
     type: 'cancel';
@@ -67,7 +67,7 @@ export interface DataSourceWorkerProvider {
      * Send a configuration update to a worker-resident DataSource.
      * Used for serializable setter calls like setCumulativeOffsets, setWindowFunction.
      */
-    configure(instanceId: string, method: string, ...args: unknown[]): void;
+    configure(instanceId: string, method: DataSourceConfigMethod, ...args: unknown[]): void;
     /**
      * Destroy a worker-resident DataSource instance.
      */

package/dist/types/dataSources/bigWigDataSource.d.ts

@@ -1,6 +1,6 @@
-import type { DataSource, Locus, WigFeature, WindowFunction } from '../types';
+import type { DataSource, ConfigurableDataSource, Locus, WigFeature, WindowFunction } from '../types';
 import type { CumulativeOffsets } from '../genome/chromSizes';
-export declare class BigWigDataSource implements DataSource<WigFeature> {
+export declare class BigWigDataSource implements DataSource<WigFeature>, ConfigurableDataSource {
     private url;
     private _windowFunction;
     private _cumulativeOffsets?;

package/dist/types/dataSources/config.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Data source configuration types.
+ *
+ * Discriminated union for serializable data source reconstruction.
+ * Used by session serialization, track factories, and worker infrastructure.
+ *
+ * Layer 1 (Data): no DOM, no canvas.
+ */
+import type { WindowFunction, TextFileFormat } from '../types';
+/** Discriminated union for data source reconstruction. */
+export type DataSourceConfig = BigWigDataSourceConfig | GtxDataSourceConfig | UCSCDataSourceConfig | TextDataSourceConfig | MemoryDataSourceConfig;
+export interface BigWigDataSourceConfig {
+    type: 'bigwig';
+    url: string;
+    windowFunction?: WindowFunction;
+}
+export interface GtxDataSourceConfig {
+    type: 'gtx';
+    url: string;
+    experimentId: string;
+    windowFunction?: WindowFunction;
+}
+export interface UCSCDataSourceConfig {
+    type: 'ucsc';
+    genome?: string;
+    track?: string;
+}
+export interface TextDataSourceConfig {
+    type: 'text';
+    url: string;
+    /** Explicit format override. When absent, inferred from URL. */
+    format?: TextFileFormat;
+    /** Index URL override. Defaults to url + '.tbi'. */
+    indexURL?: string;
+    /** Whether the file is indexed (tabix). When absent, auto-detected from indexURL presence. */
+    indexed?: boolean;
+}
+export interface MemoryDataSourceConfig {
+    type: 'memory';
+}

package/dist/types/dataSources/configureDataSource.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Type-safe method dispatch for DataSource configuration.
+ *
+ * Centralizes setter calls by name (e.g., setCumulativeOffsets, setWindowFunction)
+ * on DataSource instances that may or may not implement ConfigurableDataSource.
+ *
+ * Previously used unsafe `Record<string, unknown>` casts — now constrained to
+ * known method names via `DataSourceConfigMethod`.
+ *
+ * Layer 1 (Data): no DOM, no canvas.
+ */
+import type { DataSource, ConfigurableDataSource, DataSourceConfigMethod } from '../types';
+/**
+ * Call a named configuration setter on a DataSource if it exists.
+ * The method name is constrained to known ConfigurableDataSource methods.
+ */
+export declare function configureDataSource(ds: DataSource & Partial<ConfigurableDataSource>, method: DataSourceConfigMethod, ...args: unknown[]): void;

package/dist/types/dataSources/createDataSource.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Factory: create a DataSource from a serializable DataSourceConfig.
+ *
+ * Shared by MainThreadProvider and DataSourceRegistry (worker-side) to
+ * avoid duplicating the config → DataSource mapping logic.
+ *
+ * Does NOT handle 'memory' or 'sequence' configs — those require
+ * non-serializable inputs (in-memory features, SequenceProvider function)
+ * and must stay on the main thread.
+ *
+ * Layer 1 (Data): no DOM, no canvas.
+ */
+import type { DataSource, DataSourceConfig } from '../types';
+export declare function createDataSource(config: DataSourceConfig): DataSource;

package/dist/types/dataSources/geneDataSource.d.ts

@@ -1,10 +1,11 @@
-import type { DataSource, Locus, AnnotationFeature } from '../types';
+import type { DataSource, ConfigurableDataSource, Locus, AnnotationFeature } from '../types';
 import type { CumulativeOffsets } from '../genome/chromSizes';
 import type { FetchGenesOptions } from '../data/ucscApi';
-export declare class GeneDataSource implements DataSource<AnnotationFeature> {
+export declare class GeneDataSource implements DataSource<AnnotationFeature>, ConfigurableDataSource {
     private options;
     private _cumulativeOffsets?;
-    constructor(options?: FetchGenesOptions);
+    private maxWgFeatures;
+    constructor(options?: FetchGenesOptions, maxWgFeatures?: number);
     /** Set cumulative offsets for whole genome view coordinate transformation. */
     setCumulativeOffsets(offsets: CumulativeOffsets): void;
     fetch(locus: Locus, _bpPerPixel: number, signal: AbortSignal): Promise<AnnotationFeature[]>;

package/dist/types/dataSources/gtxDataSource.d.ts

@@ -15,9 +15,9 @@
  *
  * Layer 1 (Data + Layout): no DOM, no canvas.
  */
-import type { DataSource, Locus, WigFeature, WindowFunction } from '../types';
+import type { DataSource, ConfigurableDataSource, Locus, WigFeature, WindowFunction } from '../types';
 import type { CumulativeOffsets } from '../genome/chromSizes';
-export declare class GtxDataSource implements DataSource<WigFeature> {
+export declare class GtxDataSource implements DataSource<WigFeature>, ConfigurableDataSource {
     private url;
     private experimentId;
     private _windowFunction;

package/dist/types/dataSources/memoryDataSource.d.ts

@@ -7,7 +7,7 @@
  *
  * Layer 1 (Data + Layout): no DOM, no canvas.
  */
-import type { DataSource, Locus } from '../types';
+import type { DataSource, ConfigurableDataSource, Locus } from '../types';
 import type { CacheableFeature } from '../featureCache';
 import type { CumulativeOffsets } from '../genome/chromSizes';
 /**
@@ -16,7 +16,7 @@ import type { CumulativeOffsets } from '../genome/chromSizes';
  * Features are indexed in a FeatureCache on construction for efficient
  * spatial queries. Calling `setFeatures()` replaces the cache entirely.
  */
-export declare class MemoryDataSource<F extends CacheableFeature = CacheableFeature> implements DataSource<F> {
+export declare class MemoryDataSource<F extends CacheableFeature = CacheableFeature> implements DataSource<F>, ConfigurableDataSource {
     private cache;
     private _resolveChromName?;
     private _cumulativeOffsets?;

package/dist/types/dataSources/sequenceDataSource.d.ts

@@ -1,5 +1,7 @@
 import type { DataSource, Locus, SequenceProvider } from '../types';
 import type { SequenceFeature } from '../tracks/sequence/sequenceRenderer';
+/** Default bpPerPixel threshold above which sequence data is not loaded. Matches igv.js bppSequenceThreshold = 10. */
+export declare const DEFAULT_BPP_SEQUENCE_THRESHOLD = 10;
 /**
  * DataSource for sequence tracks — wraps a SequenceProvider to conform
  * to the standard DataSource<SequenceFeature> interface.
@@ -10,6 +12,7 @@ import type { SequenceFeature } from '../tracks/sequence/sequenceRenderer';
  */
 export declare class SequenceDataSource implements DataSource<SequenceFeature> {
     private sequenceProvider;
-    constructor(sequenceProvider: SequenceProvider);
+    private bppThreshold;
+    constructor(sequenceProvider: SequenceProvider, bppThreshold?: number);
     fetch(locus: Locus, bpPerPixel: number, signal: AbortSignal): Promise<SequenceFeature[]>;
 }

package/dist/types/dataSources/textFeatureSource.d.ts

@@ -10,7 +10,7 @@
  * Port of js/feature/textFeatureSource.ts and js/feature/featureFileReader.ts.
  * Layer 1 (Data + Layout): no DOM.
  */
-import type { DataSource, Locus, TextFileFormat } from '../types';
+import type { DataSource, ConfigurableDataSource, Locus, TextFileFormat } from '../types';
 import type { CacheableFeature } from '../featureCache';
 import type { CumulativeOffsets } from '../genome/chromSizes';
 export interface TextFeatureSourceConfig {
@@ -31,7 +31,7 @@ export interface TextFeatureSourceConfig {
  * For indexed files: uses TabixReader to query by region, parses lines on each fetch.
  * For non-indexed files: loads entire file on first fetch, caches in FeatureCache.
  */
-export declare class TextFeatureSource<F extends CacheableFeature = CacheableFeature> implements DataSource<F> {
+export declare class TextFeatureSource<F extends CacheableFeature = CacheableFeature> implements DataSource<F>, ConfigurableDataSource {
     private readonly url;
     private readonly format;
     private readonly assembleGFF;
@@ -56,4 +56,6 @@ export declare class TextFeatureSource<F extends CacheableFeature = CacheableFea
     private fetchNonIndexed;
     private loadAllFeatures;
     private fetchWG;
+    /** Release resources (TabixReader, feature cache). */
+    dispose(): void;
 }

package/dist/types/dataSources/wholeGenomeUtils.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Whole-genome coordinate transform utilities.
+ *
+ * Shared logic for converting per-chromosome features to genome-wide
+ * coordinates using CumulativeOffsets. Used by all DataSource implementations
+ * that support whole-genome view.
+ *
+ * Layer 1 (Data): no DOM, no canvas.
+ */
+import type { CumulativeOffsets } from '../genome/chromSizes';
+/** Minimal feature shape required for whole-genome coordinate transform. */
+interface GenomicFeature {
+    chr?: string;
+    start: number;
+    end: number;
+}
+/**
+ * Transform per-chromosome features to genome-wide coordinates.
+ *
+ * For each feature, replaces `chr` with `'all'` and shifts `start`/`end`
+ * by the chromosome's cumulative offset. Features on unknown chromosomes
+ * are silently dropped. Results are sorted by start position.
+ */
+/**
+ * Fetch features for all chromosomes in parallel, tolerating individual failures.
+ *
+ * Uses `Promise.allSettled` so a single chromosome failure doesn't abort the
+ * entire whole-genome view. If ALL chromosomes fail, the first error is re-thrown.
+ *
+ * @param chrNames - Chromosome names to fetch
+ * @param fetchChrom - Per-chromosome fetch function
+ * @param signal - AbortSignal for cancellation
+ * @returns Flattened array of features from all successful chromosome fetches
+ */
+export declare function fetchAllChromosomes<F>(chrNames: string[], fetchChrom: (chr: string) => Promise<F[]>, signal?: AbortSignal): Promise<F[]>;
+export declare function transformToWholeGenome<F extends GenomicFeature>(features: F[], offsets: CumulativeOffsets): F[];
+export {};

package/dist/types/defaultProviders.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Default provider factories for GenomeBrowser.
+ *
+ * Creates lazy-loaded Web Component-based providers for popups and context menus.
+ * Separated to keep GenomeBrowser focused on browser orchestration.
+ *
+ * Layer 4 (DOM): requires DOM APIs.
+ */
+import type { ContextMenuProvider } from './contextMenuProvider';
+import type { PopupProvider } from './popupProvider';
+/**
+ * Create a default ContextMenuProvider using <loom-context-menu>.
+ * This avoids statically importing the Web Component class (which extends
+ * HTMLElement and breaks SSR). The custom element self-registers on first
+ * import of ui/components/LoomContextMenu, but GenomeBrowser is always
+ * DOM-attached so we can safely trigger registration here.
+ */
+export declare function createDefaultContextMenuProvider(): ContextMenuProvider;
+/**
+ * Create a default PopupProvider using <loom-popup>.
+ * Same lazy/SSR-safe pattern as createDefaultContextMenuProvider.
+ */
+export declare function createDefaultPopupProvider(): PopupProvider;

package/dist/types/errors.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Shared error utilities for the Loom genome browser.
+ *
+ * Consolidates error classification and normalization patterns
+ * previously scattered across multiple modules.
+ */
+/** Check if an error is an AbortError (from fetch abort, signal abort, or worker abort). */
+export declare function isAbortError(err: unknown): boolean;
+/** Normalize an unknown thrown value into an Error instance. */
+export declare function normalizeError(err: unknown): Error;

package/dist/types/formats/featureParser.d.ts

@@ -40,7 +40,7 @@ interface DecoderInfo {
     /** Whether parsed features need GFF transcript assembly. */
     requiresAssembly: boolean;
     /** Optional post-processing of all decoded features (e.g., BEDPE fixup). */
-    postProcess?: (features: any[]) => void;
+    postProcess?: (features: unknown[]) => void;
 }
 /**
  * Get the appropriate decoder function and delimiter for a format string.

package/dist/types/genomeBrowser.d.ts

@@ -9,6 +9,12 @@
  * Ruler tracks get special treatment: dragging on a ruler creates a selection
  * overlay (sweep-to-zoom) instead of panning.
  *
+ * Delegates to focused single-responsibility modules:
+ * - PointerEventManager: drag/pan/sweep/click/hover/wheel/reorder
+ * - ROIOverlayManager: DOM-based ROI region rendering
+ * - ContextMenuManager: right-click context menus for tracks and ROIs
+ * - browserExport: SVG/PNG export utilities
+ *
  * Usage:
  *   const browser = new GenomeBrowser(container, {
  *       locus: { chr: 'chr17', start: 7668000, end: 7688000 },
@@ -78,42 +84,17 @@ export interface GenomeBrowserOptions extends HeadlessGenomeBrowserOptions {
 export declare class GenomeBrowser extends HeadlessGenomeBrowser {
     private container;
     private interactive;
-    private isDragging;
-    private lastPointerX;
-    private isSweeping;
-    private sweepStartX;
-    private sweepOverlay;
-    private sweepRulerCanvas;
-    private pointerDownX;
-    private pointerDownY;
-    private pointerDownTarget;
-    private lastClickTime;
-    private lastClickX;
-    private lastClickY;
-    private singleClickTimer;
-    private hoverThrottleId;
-    private _rafId;
     private resizeObserver;
     private trackRows;
-    private handleContextMenu;
-    private inputDialog;
     private remoteConnection;
-    private reorderDragTrack;
-    private reorderDragRow;
-    private reorderHandlers;
-    private handlePointerDown;
-    private handlePointerMove;
-    private handlePointerUp;
-    private handleMouseMove;
-    private handleMouseLeave;
-    private handleDocMouseDown;
-    private handleWheel;
-    private wheelRafId;
-    private roiOverlayContainer;
-    private roiElements;
     private featureOverlays;
     /** Worker provider auto-created by `workers` option. Disposed on cleanup. */
     private ownedWorkerProvider;
+    private handleKeyDown;
+    private handleDocMouseDown;
+    private pointerManager;
+    private roiOverlayManager;
+    private contextMenuManager;
     constructor(container: HTMLElement, options: GenomeBrowserOptions);
     /** Build a DOM row for a track (axis column + viewport wrapper). */
     private _buildTrackRow;
@@ -133,7 +114,6 @@ export declare class GenomeBrowser extends HeadlessGenomeBrowser {
     loadSession(session: SessionConfig, options?: CreateTrackFromSessionOptions): void;
     /** Re-render all tracks, reading width from the DOM container. */
     render(): void;
-    /** Clean up event listeners, remove canvases, and dispose headless core. */
     /**
      * Attach a remote WebSocket connection.
      * Incoming command messages are automatically dispatched.
@@ -151,70 +131,29 @@ export declare class GenomeBrowser extends HeadlessGenomeBrowser {
     private updateAxisContent;
     /**
      * Prepare an axis canvas at the correct size with DPR scaling,
-     * then delegate to the given stateless render function.
+     * then delegate to the stateless render function.
      */
     private paintAxisCanvas;
     /** Check if a pointer event target is a ruler track canvas. */
     private isRulerCanvas;
-    private createSweepOverlay;
-    private removeSweepOverlay;
-    private setupDragHandlers;
     /** Check if an event originated inside an overlay UI component (Shadow DOM) or ROI element. */
     private isOverlayTarget;
     /** Find the track whose canvas contains the given event target. */
     private findTrackForTarget;
-    /** Canvas-relative coordinates from a mouse/pointer event. */
-    private canvasCoords;
-    private handleClick;
-    private setupHoverHandlers;
-    private teardownHoverHandlers;
-    private setupContextMenuHandler;
-    private teardownContextMenuHandler;
     /** Sync DOM after any sort (addTrack, addGeneTrack, etc.). */
     protected onTracksSorted(): void;
     /** Reorder DOM rows to match managedTracks order. */
     private syncDOMOrder;
-    /** Set up drag-to-reorder pointer handlers on an axis div. */
-    private setupReorderHandlers;
-    /** Remove reorder handlers for a track. */
-    private teardownReorderHandlers;
-    private teardownDragHandlers;
-    /**
-     * Set up wheel event handling for trackpad pinch-to-zoom and scroll-wheel zoom.
-     *
-     * Trackpad pinch gestures on macOS/Chrome are reported as `wheel` events with
-     * `ctrlKey: true` and `deltaY` indicating zoom direction. Regular scroll-wheel
-     * events (ctrl+scroll) use the same mechanism. Both zoom around the pointer
-     * position for natural, cursor-anchored zoom behavior.
-     */
-    private setupWheelHandler;
-    private teardownWheelHandler;
-    /** Ensure the ROI overlay container exists and is sized correctly. */
-    private ensureROIOverlayContainer;
-    /**
-     * Render ROI overlays as DOM elements positioned over the track viewport.
-     *
-     * Creates/updates/removes DOM elements for each visible ROI.
-     * DOM-based (not canvas) for easy hover/click interaction without
-     * re-rendering track canvases.
-     */
+    private setupUndoKeyboardHandler;
+    private teardownUndoKeyboardHandler;
+    private renderROIOverlays;
     /** Update all feature overlays after render. */
     private updateFeatureOverlays;
     /** Update the feature overlay for a single track. */
     private updateFeatureOverlay;
-    private renderROIOverlays;
-    /** Create a styled DOM element for an ROI region. */
-    private createROIElement;
-    /** Show context menu for an ROI. */
-    private showROIContextMenu;
-    /** Clean up ROI overlay elements. */
-    private clearROIOverlay;
     /**
      * Export the current view as an SVG string, including axis columns.
-     *
-     * Overrides HeadlessGenomeBrowser.toSVG() to add axis rendering on the
-     * left side of each track, matching igv.js Browser.toSVG() which calls
-     * renderSVGAxis() for each TrackView (js/browser.ts lines 352-388).
+     * Overrides HeadlessGenomeBrowser.toSVG() to add axis rendering.
      */
     toSVG(options?: {
         width?: number;
@@ -222,23 +161,11 @@ export declare class GenomeBrowser extends HeadlessGenomeBrowser {
     }): string;
     /**
      * Export the current view as a PNG data URL.
-     *
      * Pipeline: toSVG() → Blob → Image → Canvas (DPR-scaled) → toDataURL.
-     * Matches igv.js Browser.savePNGtoFile() (js/browser.ts lines 407-440).
-     *
-     * Returns a promise that resolves to a `data:image/png;base64,...` string.
      */
     toPNG(): Promise<string>;
-    /**
-     * Download the current view as an SVG file.
-     * Matches igv.js Browser.saveSVGtoFile() (js/browser.ts lines 390-405).
-     */
+    /** Download the current view as an SVG file. */
     saveSVGtoFile(filename?: string): void;
-    /**
-     * Download the current view as a PNG file.
-     * Matches igv.js Browser.savePNGtoFile() (js/browser.ts lines 407-440).
-     */
+    /** Download the current view as a PNG file. */
     savePNGtoFile(filename?: string): Promise<void>;
-    /** Trigger a file download via a temporary anchor element. */
-    private downloadURL;
 }