loom-browser 0.0.9 → 0.0.11

package/dist/types/browser/headless/trackFactories.d.ts

@@ -0,0 +1,145 @@
+/**
+ * Track convenience factories — create and wire tracks with data sources.
+ *
+ * Extracted from HeadlessGenomeBrowser to isolate repetitive track creation
+ * boilerplate. Each factory:
+ * 1. Creates a canvas via CanvasProvider
+ * 2. Creates a TrackCanvas instance
+ * 3. Builds a DataSourceConfig
+ * 4. Creates a worker proxy or direct data source
+ * 5. Wires chromosome alias resolution + cumulative offsets
+ * 6. Returns the track + data source + config for the browser to register
+ *
+ * Layer 3 (Headless): no DOM dependencies.
+ */
+import type { Locus, DataSource, DataSourceConfig, WindowFunction, WigFeature, BedFeature, WigRenderConfig, AnnotationRenderConfig, RulerRenderConfig, SequenceRenderConfig, InteractionRenderConfig, TextFileFormat, SequenceProvider, Genome } from '../../types';
+import type { CanvasProvider } from '../../canvasProvider';
+import type { DataSourceWorkerProvider } from '../../dataSourceWorkerProvider';
+import type { RenderTheme } from '../../themes/renderTheme';
+import type { ChromSizes, CumulativeOffsets } from '../../genome/chromSizes';
+import { WorkerDataSource } from '../../workerDataSource';
+import { RulerTrackCanvas } from '../../tracks/ruler/rulerTrackCanvas';
+import { WigTrackCanvas } from '../../tracks/wig/wigTrackCanvas';
+import { AnnotationTrackCanvas } from '../../tracks/annotation/annotationTrackCanvas';
+import { InteractionTrackCanvas } from '../../tracks/interaction/interactionTrackCanvas';
+export interface AddRulerOptions {
+    config?: Partial<RulerRenderConfig>;
+    maxTrackHeight?: number;
+}
+export interface AddWigTrackOptions {
+    config?: Partial<WigRenderConfig>;
+    height?: number;
+    background?: string;
+    windowFunction?: WindowFunction;
+    maxTrackHeight?: number;
+    name?: string;
+    metadata?: Record<string, string>;
+}
+export interface AddGtxTrackOptions {
+    experimentId: string;
+    config?: Partial<WigRenderConfig>;
+    height?: number;
+    background?: string;
+    windowFunction?: WindowFunction;
+    maxTrackHeight?: number;
+    name?: string;
+    metadata?: Record<string, string>;
+}
+export interface AddSequenceTrackOptions {
+    config?: Partial<SequenceRenderConfig>;
+    maxTrackHeight?: number;
+}
+export interface AddBedTrackOptions {
+    config?: Partial<AnnotationRenderConfig>;
+    height?: number;
+    background?: string;
+    format?: TextFileFormat;
+    indexURL?: string;
+    indexed?: boolean;
+    maxTrackHeight?: number;
+    name?: string;
+    metadata?: Record<string, string>;
+}
+export interface AddInteractionTrackOptions {
+    config?: Partial<InteractionRenderConfig>;
+    background?: string;
+    format?: TextFileFormat;
+    indexURL?: string;
+    indexed?: boolean;
+    name?: string;
+    metadata?: Record<string, string>;
+}
+export interface AddAnnotationTrackOptions {
+    config?: Partial<AnnotationRenderConfig>;
+    height?: number;
+    background?: string;
+    genome?: string;
+    track?: string;
+    maxTrackHeight?: number;
+    name?: string;
+    metadata?: Record<string, string>;
+}
+export interface AddWigTrackWithFeaturesOptions {
+    config?: Partial<WigRenderConfig>;
+    height?: number;
+    background?: string;
+    maxTrackHeight?: number;
+    name?: string;
+    metadata?: Record<string, string>;
+}
+export interface AddBedTrackWithFeaturesOptions {
+    config?: Partial<AnnotationRenderConfig>;
+    height?: number;
+    background?: string;
+    maxTrackHeight?: number;
+    name?: string;
+    metadata?: Record<string, string>;
+}
+/** Context needed by all factories — passed from HeadlessGenomeBrowser. */
+export interface TrackFactoryContext {
+    locus: Locus;
+    canvasProvider: CanvasProvider;
+    theme: RenderTheme;
+    genome?: Genome;
+    chromSizes?: ChromSizes;
+    cumulativeOffsets?: CumulativeOffsets;
+    sequenceProvider?: SequenceProvider;
+    dataSourceWorkerProvider?: DataSourceWorkerProvider;
+}
+/** Result of a factory — the browser registers this via addTrack(). */
+export interface FactoryResult<T> {
+    track: T;
+    dataSource?: DataSource;
+    dataSourceConfig?: DataSourceConfig;
+    maxTrackHeight?: number;
+    metadata?: Record<string, string>;
+    order?: number;
+    /** Post-registration callback (e.g., wiring onWindowFunctionChange). */
+    onRegistered?: (findMT: () => {
+        cache: null | unknown;
+        dataSourceConfig: DataSourceConfig | null;
+    }) => void;
+}
+/**
+ * Create a WorkerDataSource proxy for worker-eligible configs, or return null
+ * if dataSourceWorkerProvider is not set. Handles create + chrom alias + offsets wiring.
+ */
+export declare function createWorkerDataSource<F>(config: DataSourceConfig, ctx: Pick<TrackFactoryContext, 'dataSourceWorkerProvider' | 'genome' | 'cumulativeOffsets'>): WorkerDataSource<F> | null;
+/**
+ * Wire chromosome alias resolution and cumulative offsets on a direct (non-worker) data source.
+ * Consolidates the pattern repeated 7+ times in the old HeadlessGenomeBrowser.
+ */
+export declare function wireDataSource(ds: DataSource, ctx: Pick<TrackFactoryContext, 'genome' | 'cumulativeOffsets'>): void;
+/**
+ * Wire a WigTrackCanvas's window function change callback to trigger a data reload.
+ * Wraps the existing callback (set by the factory) so the original still fires.
+ */
+export declare function wireWindowFunctionReload(track: WigTrackCanvas, reloadFn: () => void): void;
+export declare function createRuler(ctx: TrackFactoryContext, options?: AddRulerOptions): FactoryResult<RulerTrackCanvas>;
+export declare function createWigTrack(ctx: TrackFactoryContext, url: string, options?: AddWigTrackOptions): FactoryResult<WigTrackCanvas>;
+export declare function createGtxTrack(ctx: TrackFactoryContext, url: string, options: AddGtxTrackOptions): FactoryResult<WigTrackCanvas>;
+export declare function createGeneTrack(ctx: TrackFactoryContext, options?: AddAnnotationTrackOptions): FactoryResult<AnnotationTrackCanvas>;
+export declare function createBedTrack(ctx: TrackFactoryContext, url: string, options?: AddBedTrackOptions): FactoryResult<AnnotationTrackCanvas>;
+export declare function createInteractionTrack(ctx: TrackFactoryContext, url: string, options?: AddInteractionTrackOptions): FactoryResult<InteractionTrackCanvas>;
+export declare function createWigTrackWithFeatures(ctx: TrackFactoryContext, features: WigFeature[], options?: AddWigTrackWithFeaturesOptions): FactoryResult<WigTrackCanvas>;
+export declare function createBedTrackWithFeatures(ctx: TrackFactoryContext, features: BedFeature[], options?: AddBedTrackWithFeaturesOptions): FactoryResult<AnnotationTrackCanvas>;

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.