loom-browser 0.0.1

package/dist/types/trackSelector.d.ts

@@ -0,0 +1,31 @@
+/**
+ * TrackSelector — SQL-ish WHERE clause for matching tracks by metadata.
+ *
+ * Selectors support matching on track ID, name (string or RegExp), type,
+ * and arbitrary metadata key-value pairs. All provided fields use AND semantics:
+ * a track must match every specified criterion.
+ *
+ * ```ts
+ * // Remove all ATAC-seq tracks
+ * browser.removeTracks({ where: { assay: 'ATAC-seq' } })
+ *
+ * // Find wig tracks from K562
+ * browser.findTracks({ type: 'wig', where: { biosample: 'K562' } })
+ * ```
+ */
+import type { ManagedTrack } from './headlessGenomeBrowser';
+/** Selector for matching tracks by ID, name, type, and/or metadata. */
+export interface TrackSelector {
+    /** Exact match against track ID. */
+    id?: string;
+    /** String: case-insensitive substring match. RegExp: test against track name. */
+    name?: string | RegExp;
+    /** Exact match against track type (e.g. 'wig', 'annotation', 'interact'). */
+    type?: string;
+    /** Metadata key-value matching. Every entry must match (AND semantics). */
+    where?: Record<string, string>;
+}
+/** Test whether a single managed track matches all criteria in a selector. */
+export declare function matchesSelector(mt: ManagedTrack, selector: TrackSelector): boolean;
+/** Select all managed tracks matching a selector. */
+export declare function selectTracks(tracks: readonly ManagedTrack[], selector: TrackSelector): ManagedTrack[];

package/dist/types/tracks/annotation/annotationRenderer.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Standalone annotation feature renderer.
+ *
+ * Adapted from js/feature/render/renderFeature.ts but with no `this` context —
+ * all configuration is passed as explicit parameters.
+ *
+ * Renders gene, BED, GFF, and peak features with exon/UTR/CDS structure,
+ * intron lines, strand arrows, labels, and per-feature colors.
+ */
+import type { AnnotationFeature, AnnotationRenderConfig, RenderContext } from '../../types';
+/**
+ * Render a set of annotation features onto a canvas context.
+ *
+ * Features should already have `.row` assigned (via `pack()`).
+ * The canvas should be sized and cleared before calling this.
+ */
+export declare function renderAnnotationTrack(ctx: CanvasRenderingContext2D, features: AnnotationFeature[], config: AnnotationRenderConfig, rc: RenderContext): void;

package/dist/types/tracks/annotation/annotationThemes.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Preset render themes for annotation tracks.
+ *
+ * Each theme is a Partial<AnnotationRenderConfig> that can be spread over defaults.
+ * Usage: { ...defaultAnnotationRenderConfig(), ...modernTheme }
+ */
+import type { AnnotationRenderConfig } from '../../types';
+/** Modern theme — softer colors, rounded exons, strand-based coloring. */
+export declare const modernTheme: Partial<AnnotationRenderConfig>;
+/** Dark theme — modern theme adapted for dark backgrounds. */
+export declare const darkTheme: Partial<AnnotationRenderConfig>;

package/dist/types/tracks/annotation/annotationTrackCanvas.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Canvas manager for rendering annotation features (gene, BED, GFF, peaks).
+ *
+ * Extends BaseTrackCanvas — canvas lifecycle (DPR, resize, attach/detach,
+ * background) is handled by the base class. This class only implements
+ * annotation-specific logic: feature packing, height computation, and rendering.
+ *
+ * Usage:
+ *   const canvas = document.createElement('canvas')
+ *   const track = new AnnotationTrackCanvas(canvas, { locus, features })
+ *   track.attachTo(containerDiv)
+ */
+import type { AnnotationFeature, AnnotationRenderConfig, Locus, RenderContext, AnnotationTrackSessionConfig, HitTestResult, AxisInfo, ContextMenuItem } from '../../types';
+import type { CanvasProvider } from '../../canvasProvider';
+import type { WorkerProvider } from '../../workerProvider';
+import type { RenderTheme } from '../../themes/renderTheme';
+import { BaseTrackCanvas } from '../baseTrackCanvas';
+export type { Locus } from '../../types';
+export interface AnnotationTrackCanvasOptions {
+    locus: Locus;
+    features: AnnotationFeature[];
+    /** Per-track config overrides. Applied after theme-derived defaults. */
+    config?: Partial<AnnotationRenderConfig>;
+    /** Unified render theme. Palette drives default colors/fonts. */
+    theme?: Partial<RenderTheme>;
+    /** Fixed pixel height. If not set, computed from row count. */
+    height?: number;
+    /** Background color. Default: palette.background. */
+    background?: string;
+    /** Canvas provider for environment abstraction. Default: DOMCanvasProvider. */
+    canvasProvider?: CanvasProvider;
+    /** Worker provider for offloading CPU-intensive tasks (packing). */
+    workerProvider?: WorkerProvider;
+    /** Track name for axis label. */
+    name?: string;
+}
+export declare class AnnotationTrackCanvas extends BaseTrackCanvas<AnnotationRenderConfig> {
+    private features;
+    private fixedHeight;
+    private background;
+    private _name;
+    private workerProvider?;
+    /** Most recently packed features, available after render(). */
+    private packedFeatures;
+    /** Whether packedFeatures was pre-computed by async worker (skip sync pack in computeHeight). */
+    private packedReady;
+    readonly type = "annotation";
+    constructor(canvas: HTMLCanvasElement, options: AnnotationTrackCanvasOptions);
+    /** Update features and re-render. Dispatches async pack when workerProvider is set. */
+    setFeatures(features: AnnotationFeature[]): void;
+    protected computeHeight(_width: number): number;
+    protected getBackground(): string;
+    protected doRender(ctx: CanvasRenderingContext2D, _width: number, _height: number, rc: RenderContext): void;
+    getAxisInfo(): AxisInfo | undefined;
+    getContextMenuItems(_x: number, _y: number): ContextMenuItem[];
+    hitTest(x: number, y: number): HitTestResult<AnnotationFeature>[];
+    serializeConfig(theme: RenderTheme): AnnotationTrackSessionConfig;
+}

package/dist/types/tracks/annotation/index.d.ts

@@ -0,0 +1,4 @@
+export { renderAnnotationTrack } from './annotationRenderer';
+export { AnnotationTrackCanvas } from './annotationTrackCanvas';
+export type { AnnotationTrackCanvasOptions } from './annotationTrackCanvas';
+export { modernTheme, darkTheme } from './annotationThemes';

package/dist/types/tracks/axis/axisRenderer.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Stateless axis renderers for the left-hand axis column.
+ *
+ * These are pure canvas renderers — they take a 2D context, axis info, and
+ * dimensions, and paint the axis. No DOM, no state, no side effects.
+ *
+ * Two variants:
+ * - renderQuantitativeAxis: tick marks + data range labels for numeric tracks (wig)
+ * - renderLabelAxis: centered rotated text label for annotation tracks (gene)
+ */
+import type { AxisInfo } from '../../types';
+/** Format a number for axis labels (ported from igv.js paintAxis.ts). */
+export declare function prettyPrintNumber(n: number): string;
+export declare function renderQuantitativeAxis(ctx: CanvasRenderingContext2D, info: AxisInfo, width: number, height: number): void;
+/**
+ * Paint a label-only axis (e.g., gene track name).
+ * Renders a vertically-rotated centered text label.
+ */
+export declare function renderLabelAxis(ctx: CanvasRenderingContext2D, info: AxisInfo, width: number, height: number): void;

package/dist/types/tracks/axis/index.d.ts

@@ -0,0 +1 @@
+export { renderQuantitativeAxis, renderLabelAxis, prettyPrintNumber } from './axisRenderer';

package/dist/types/tracks/baseTrackCanvas.d.ts

@@ -0,0 +1,113 @@
+/**
+ * Base class for canvas-based genomic track renderers.
+ *
+ * Handles all shared canvas lifecycle: DPR scaling, sizing, resize observation,
+ * attach/detach, background fill, and RenderContext construction.
+ *
+ * Subclasses implement:
+ *   - type (track type identifier)
+ *   - computeHeight(width) — return CSS pixel height for current state
+ *   - getBackground() — return background fill color
+ *   - doRender(ctx, width, height, rc) — the actual drawing logic
+ *
+ * This eliminates ~80 lines of identical boilerplate per track type.
+ */
+import type { Locus, RenderContext, Track, TrackSessionConfig, HitTestResult, ContextMenuItem } from '../types';
+import type { RenderTheme } from '../themes/renderTheme';
+import type { CanvasProvider } from '../canvasProvider';
+export declare abstract class BaseTrackCanvas<TConfig> implements Track {
+    protected _canvas: HTMLCanvasElement;
+    protected _locus: Locus;
+    protected _config: TConfig;
+    protected _height: number;
+    protected canvasProvider: CanvasProvider;
+    private resizeObserver;
+    private container;
+    private _renderSuspended;
+    private _renderPending;
+    private _error;
+    private _zoomedOut;
+    /**
+     * Visibility window in base pairs. When the viewport spans more than this
+     * many bp, data is not fetched and "Zoom in to see features" is shown.
+     * Mirrors igv.js TrackBase.visibilityWindow (js/trackViewport.ts checkZoomIn).
+     *
+     * Set to undefined or 0 to disable (always fetch). Set > 0 to enable.
+     */
+    visibilityWindow?: number;
+    abstract readonly type: string;
+    get canvas(): HTMLCanvasElement;
+    get locus(): Locus;
+    get height(): number;
+    /** Current track config (read-only). Use setConfig() to update. */
+    get config(): TConfig;
+    constructor(canvas: HTMLCanvasElement, locus: Locus, config: TConfig, canvasProvider?: CanvasProvider);
+    /** Update locus and re-render. */
+    setLocus(locus: Locus): void;
+    /** Merge partial config and re-render. */
+    setConfig(config: Partial<TConfig>): void;
+    /** Suspend rendering — calls to render() will be deferred until resumeRendering(). */
+    suspendRendering(): void;
+    /** Resume rendering. If render() was called while suspended, flushes now. */
+    resumeRendering(): void;
+    /** Set an error state to render on the track canvas. Pass null to clear. */
+    setError(error: Error | null): void;
+    /**
+     * Mark this track as zoomed out beyond its visibility window.
+     * When true, render() shows "Zoom in to see features" instead of track content.
+     * Called by HeadlessGenomeBrowser during data lifecycle.
+     */
+    setZoomedOut(zoomedOut: boolean): void;
+    /**
+     * Hit-test at canvas-relative pixel coordinates.
+     * Returns features at that point with pre-formatted popup data.
+     * Default: empty (no interactive features). Subclasses override.
+     */
+    hitTest(_x: number, _y: number): HitTestResult[];
+    /**
+     * Return context menu items for a right-click at canvas-relative coordinates.
+     * Default: undefined (no track-specific items). Subclasses override.
+     */
+    getContextMenuItems(_x: number, _y: number): ContextMenuItem[] | undefined;
+    /**
+     * Attach the canvas to a container element.
+     * Appends the canvas and sets up a ResizeObserver for automatic re-renders.
+     */
+    attachTo(container: HTMLElement): void;
+    /** Detach from container and stop observing resizes. */
+    detach(): void;
+    /** Render the track. Handles DPR, sizing, background, then delegates to doRender(). */
+    render(): void;
+    /** Draw a centered error message on the canvas. */
+    protected renderError(ctx: CanvasRenderingContext2D, width: number, height: number): void;
+    /**
+     * Draw a centered "Zoom in to see features" notice.
+     * Mirrors igv.js TrackViewport.createZoomInNotice (js/trackViewport.ts).
+     */
+    protected renderZoomInNotice(ctx: CanvasRenderingContext2D, width: number, height: number): void;
+    /**
+     * Render this track onto an arbitrary context (e.g. Canvas2SVG for SVG export).
+     * Skips DPR scaling and canvas-element lifecycle — draws directly at the given
+     * dimensions using the track's current locus and state.
+     *
+     * Mirrors igv.js TrackViewport.renderSVGContext() which calls track.draw()
+     * with a C2S context (js/trackViewport.ts lines 525-579).
+     */
+    renderToContext(ctx: CanvasRenderingContext2D, width: number, height: number): void;
+    /**
+     * Compute the track height in CSS pixels for the current state.
+     * Called at the start of each render(). The width parameter is provided
+     * in case height depends on layout (e.g., gene packing).
+     */
+    protected abstract computeHeight(width: number): number;
+    /** Return the background fill color for the canvas. */
+    protected abstract getBackground(): string;
+    /** Perform the actual track-specific rendering onto the prepared canvas. */
+    protected abstract doRender(ctx: CanvasRenderingContext2D, width: number, height: number, rc: RenderContext): void;
+    /**
+     * Serialize this track's config for session save/restore.
+     * Each subclass diffs its config against theme defaults and returns
+     * a typed TrackSessionConfig with only overridden fields.
+     */
+    abstract serializeConfig(theme: RenderTheme): TrackSessionConfig;
+}

package/dist/types/tracks/dynseq/dynseqRenderer.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Dynamic sequence (dynseq) renderer for wig tracks.
+ *
+ * Renders DNA base letters (A, C, G, T, N) as filled glyphs whose height
+ * is proportional to the wig signal value. Only activates at high zoom
+ * (bpPerPixel < 2) where individual bases are resolvable.
+ *
+ * Ported from js/feature/wigTrack.ts renderDynSeq/drawLetterGlyph/drawSVGPath.
+ */
+/** Default nucleotide color scheme matching igv.js. */
+export declare const defaultNucleotideColors: Readonly<Record<string, string>>;
+/**
+ * Draw a single DNA base letter as a filled glyph.
+ *
+ * @param ctx - Canvas context
+ * @param base - The base character (A, C, G, T, N)
+ * @param x - Left edge pixel position
+ * @param y - Top edge pixel position
+ * @param width - Glyph width in pixels
+ * @param height - Glyph height in pixels
+ * @param color - Fill color
+ * @param flipVertical - Flip the glyph vertically (for negative values)
+ */
+export declare function drawLetterGlyph(ctx: CanvasRenderingContext2D, base: string, x: number, y: number, width: number, height: number, color: string, flipVertical?: boolean, backgroundColor?: string): void;
+/**
+ * Render a single wig feature as dynseq (DNA base glyphs scaled by value).
+ *
+ * @param ctx - Canvas context
+ * @param sequence - DNA sequence string for this feature's region
+ * @param x - Left edge pixel position of the feature
+ * @param width - Pixel width of the feature
+ * @param y - Y pixel of the data value
+ * @param y0 - Y pixel of the zero line
+ * @param value - The wig data value (for determining negative/flip)
+ * @param colors - Nucleotide color map
+ * @param backgroundColor - Background color for glyph cutouts (e.g. hole in 'A')
+ */
+export declare function renderDynSeqFeature(ctx: CanvasRenderingContext2D, sequence: string, x: number, width: number, y: number, y0: number, value: number, colors?: Readonly<Record<string, string>>, backgroundColor?: string): void;

package/dist/types/tracks/dynseq/index.d.ts

@@ -0,0 +1 @@
+export { renderDynSeqFeature, drawLetterGlyph, defaultNucleotideColors } from './dynseqRenderer';

package/dist/types/tracks/gene/geneRenderer.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Standalone gene feature renderer.
+ *
+ * Adapted from js/feature/render/renderFeature.ts but with no `this` context —
+ * all configuration is passed as explicit parameters.
+ *
+ * Scope: exon/UTR/CDS rendering, intron lines, strand arrows, labels.
+ * Deferred: amino acid rendering, QTL selection highlighting.
+ */
+import type { GeneFeature, GeneRenderConfig, RenderContext } from '../../types';
+/**
+ * Render a set of gene features onto a canvas context.
+ *
+ * Features should already have `.row` assigned (via `pack()`).
+ * The canvas should be sized and cleared before calling this.
+ */
+export declare function renderGeneTrack(ctx: CanvasRenderingContext2D, features: GeneFeature[], config: GeneRenderConfig, rc: RenderContext): void;

package/dist/types/tracks/gene/geneThemes.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Preset render themes for gene tracks.
+ *
+ * Each theme is a Partial<GeneRenderConfig> that can be spread over defaults.
+ * Usage: { ...defaultGeneRenderConfig(), ...modernTheme }
+ */
+import type { GeneRenderConfig } from '../../types';
+/** Modern theme — softer colors, rounded exons, strand-based coloring. */
+export declare const modernTheme: Partial<GeneRenderConfig>;
+/** Dark theme — modern theme adapted for dark backgrounds. */
+export declare const darkTheme: Partial<GeneRenderConfig>;

package/dist/types/tracks/gene/geneTrackCanvas.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Canvas manager for rendering gene features.
+ *
+ * Extends BaseTrackCanvas — canvas lifecycle (DPR, resize, attach/detach,
+ * background) is handled by the base class. This class only implements
+ * gene-specific logic: feature packing, height computation, and rendering.
+ *
+ * Usage:
+ *   const canvas = document.createElement('canvas')
+ *   const track = new GeneTrackCanvas(canvas, { locus, features })
+ *   track.attachTo(containerDiv)
+ */
+import type { GeneFeature, GeneRenderConfig, Locus, RenderContext, GeneTrackSessionConfig, HitTestResult, AxisInfo, ContextMenuItem } from '../../types';
+import type { CanvasProvider } from '../../canvasProvider';
+import type { WorkerProvider } from '../../workerProvider';
+import type { RenderTheme } from '../../themes/renderTheme';
+import { BaseTrackCanvas } from '../baseTrackCanvas';
+export type { Locus } from '../../types';
+export interface GeneTrackCanvasOptions {
+    locus: Locus;
+    features: GeneFeature[];
+    /** Per-track config overrides. Applied after theme-derived defaults. */
+    config?: Partial<GeneRenderConfig>;
+    /** Unified render theme. Palette drives default colors/fonts. */
+    theme?: Partial<RenderTheme>;
+    /** Fixed pixel height. If not set, computed from row count. */
+    height?: number;
+    /** Background color. Default: palette.background. */
+    background?: string;
+    /** Canvas provider for environment abstraction. Default: DOMCanvasProvider. */
+    canvasProvider?: CanvasProvider;
+    /** Worker provider for offloading CPU-intensive tasks (packing). */
+    workerProvider?: WorkerProvider;
+    /** Track name for axis label. */
+    name?: string;
+}
+export declare class GeneTrackCanvas extends BaseTrackCanvas<GeneRenderConfig> {
+    private features;
+    private fixedHeight;
+    private background;
+    private _name;
+    private workerProvider?;
+    /** Most recently packed features, available after render(). */
+    private packedFeatures;
+    /** Whether packedFeatures was pre-computed by async worker (skip sync pack in computeHeight). */
+    private packedReady;
+    readonly type = "gene";
+    constructor(canvas: HTMLCanvasElement, options: GeneTrackCanvasOptions);
+    /** Update features and re-render. Dispatches async pack when workerProvider is set. */
+    setFeatures(features: GeneFeature[]): void;
+    protected computeHeight(_width: number): number;
+    protected getBackground(): string;
+    protected doRender(ctx: CanvasRenderingContext2D, _width: number, _height: number, rc: RenderContext): void;
+    getAxisInfo(): AxisInfo | undefined;
+    getContextMenuItems(_x: number, _y: number): ContextMenuItem[];
+    hitTest(x: number, y: number): HitTestResult<GeneFeature>[];
+    serializeConfig(theme: RenderTheme): GeneTrackSessionConfig;
+}

package/dist/types/tracks/gene/index.d.ts

@@ -0,0 +1,4 @@
+export { renderGeneTrack } from './geneRenderer';
+export { GeneTrackCanvas } from './geneTrackCanvas';
+export type { GeneTrackCanvasOptions } from './geneTrackCanvas';
+export { modernTheme, darkTheme } from './geneThemes';

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

@@ -0,0 +1,7 @@
+export { BaseTrackCanvas } from './baseTrackCanvas';
+export * from './axis';
+export * from './annotation';
+export * from './wig';
+export * from './ruler';
+export * from './dynseq';
+export * from './interaction';

package/dist/types/tracks/interaction/index.d.ts

@@ -0,0 +1,4 @@
+export { renderInteractionTrack, positionString } from './interactionRenderer';
+export type { DrawnInteractionFeature, InteractionDrawState } from './interactionRenderer';
+export { InteractionTrackCanvas } from './interactionTrackCanvas';
+export type { InteractionTrackCanvasOptions } from './interactionTrackCanvas';

package/dist/types/tracks/interaction/interactionRenderer.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Stateless renderer for interaction (arc/BEDPE) tracks.
+ *
+ * Draws pairwise genomic contacts as arcs connecting two regions.
+ * Two display modes:
+ * - "nested": arc height proportional to genomic distance (ctx.arc)
+ * - "proportional": arc height proportional to score/value (ctx.ellipse)
+ *
+ * Inter-chromosome interactions are drawn as colored rectangles.
+ *
+ * Port of js/feature/interactionTrack.ts draw methods.
+ * Layer 2 (Track Canvas): uses CanvasRenderingContext2D, no DOM.
+ */
+import type { InteractionFeature, InteractionRenderConfig, RenderContext } from '../../types';
+/** Draw state stored on features during rendering for hit-testing. */
+export type InteractionDrawState = NestedDrawState | ProportionalDrawState | RectDrawState;
+interface NestedDrawState {
+    type: 'nested';
+    xc: number;
+    yc: number;
+    r: number;
+}
+interface ProportionalDrawState {
+    type: 'proportional';
+    xc: number;
+    yc: number;
+    radiusX: number;
+    radiusY: number;
+}
+interface RectDrawState {
+    type: 'rect';
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}
+/** Feature with transient draw state attached during rendering. */
+export interface DrawnInteractionFeature extends InteractionFeature {
+    drawState?: InteractionDrawState;
+}
+/**
+ * Render interaction features onto a canvas context.
+ *
+ * Stateless: all state is passed in, no side effects beyond canvas drawing
+ * and attaching drawState to features for hit-testing.
+ */
+export declare function renderInteractionTrack(ctx: CanvasRenderingContext2D, features: DrawnInteractionFeature[], config: InteractionRenderConfig, rc: RenderContext): void;
+/**
+ * Format a genomic position for popup display.
+ */
+export declare function positionString(chr: string, start: number, end: number, strand?: string): string;
+export {};

package/dist/types/tracks/interaction/interactionTrackCanvas.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Canvas manager for rendering interaction (arc/BEDPE) tracks.
+ *
+ * Extends BaseTrackCanvas — canvas lifecycle is handled by the base class.
+ * This class implements interaction-specific logic: arc rendering, hit-testing,
+ * and popup data.
+ *
+ * Usage:
+ *   const canvas = document.createElement('canvas')
+ *   const track = new InteractionTrackCanvas(canvas, { locus, features: [] })
+ *   track.attachTo(containerDiv)
+ */
+import type { InteractionFeature, InteractionRenderConfig, Locus, RenderContext, InteractionTrackSessionConfig, HitTestResult, AxisInfo, ContextMenuItem, NumericState } from '../../types';
+import type { CanvasProvider } from '../../canvasProvider';
+import type { RenderTheme } from '../../themes/renderTheme';
+import { BaseTrackCanvas } from '../baseTrackCanvas';
+export interface InteractionTrackCanvasOptions {
+    locus: Locus;
+    features: InteractionFeature[];
+    /** Per-track config overrides. Applied after theme-derived defaults. */
+    config?: Partial<InteractionRenderConfig>;
+    /** Unified render theme. Palette drives default colors/fonts. */
+    theme?: Partial<RenderTheme>;
+    /** Background color. Overrides config.background if set. */
+    background?: string;
+    /** Canvas provider for environment abstraction. Default: DOMCanvasProvider. */
+    canvasProvider?: CanvasProvider;
+    /** Track name for axis label. */
+    name?: string;
+}
+export declare class InteractionTrackCanvas extends BaseTrackCanvas<InteractionRenderConfig> {
+    private features;
+    private _name;
+    readonly type = "interact";
+    constructor(canvas: HTMLCanvasElement, options: InteractionTrackCanvasOptions);
+    /** Update features and re-render. */
+    setFeatures(features: InteractionFeature[]): void;
+    protected computeHeight(_width: number): number;
+    protected getBackground(): string;
+    protected doRender(ctx: CanvasRenderingContext2D, _width: number, _height: number, rc: RenderContext): void;
+    /** Hit-test: find features at canvas-relative pixel coordinates. */
+    hitTest(x: number, y: number): HitTestResult<InteractionFeature>[];
+    private buildPopupData;
+    /** Serialize config for session save/restore, diffed against theme defaults. */
+    serializeConfig(theme: RenderTheme): InteractionTrackSessionConfig;
+    /** Return axis info for proportional display mode. */
+    getAxisInfo(): AxisInfo | undefined;
+    /** Context menu items for arc display settings. */
+    getContextMenuItems(_x: number, _y: number): ContextMenuItem[];
+    /** Return numeric state for proportional mode (data range, log scale). */
+    getNumericState(): NumericState | undefined;
+    /** Render onto an arbitrary context (e.g. SVG export). */
+    renderToContext(ctx: CanvasRenderingContext2D, width: number, height: number): void;
+}

package/dist/types/tracks/ruler/index.d.ts

@@ -0,0 +1,3 @@
+export { renderRulerTrack } from './rulerRenderer';
+export { RulerTrackCanvas } from './rulerTrackCanvas';
+export type { RulerTrackCanvasOptions } from './rulerTrackCanvas';

package/dist/types/tracks/ruler/rulerRenderer.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Stateless ruler track renderer.
+ *
+ * Draws genomic coordinate tick marks and labels onto a canvas context.
+ * Ported from js/rulerTrack.ts but with no igv.js dependencies.
+ */
+import type { RulerRenderConfig, RenderContext } from '../../types';
+import type { CumulativeOffsets } from '../../genome/chromSizes';
+/**
+ * Render a genomic coordinate ruler onto a canvas context.
+ *
+ * Stateless — all state is passed as parameters.
+ * Draws tick marks, labels with SI-prefix units, and a baseline.
+ */
+export declare function renderRulerTrack(ctx: CanvasRenderingContext2D, config: RulerRenderConfig, rc: RenderContext): void;
+/** Whole genome context needed by the WG ruler renderer. */
+export interface WholeGenomeRulerContext {
+    cumulativeOffsets: CumulativeOffsets;
+    chromSizes: Record<string, number>;
+}
+/**
+ * Render a whole genome ruler showing chromosome rectangles with labels and dividers.
+ * Port of js/rulerTrack.ts drawWholeGenome() + renderChromosomeRect().
+ */
+export declare function renderWholeGenomeRuler(ctx: CanvasRenderingContext2D, config: RulerRenderConfig, rc: RenderContext, wg: WholeGenomeRulerContext): void;

package/dist/types/tracks/ruler/rulerTrackCanvas.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Canvas manager for rendering a genomic coordinate ruler.
+ *
+ * Extends BaseTrackCanvas — canvas lifecycle is handled by the base class.
+ * This class only implements ruler-specific rendering.
+ *
+ * Usage:
+ *   const canvas = document.createElement('canvas')
+ *   const ruler = new RulerTrackCanvas(canvas, { locus })
+ *   ruler.attachTo(containerDiv)
+ */
+import type { Locus, RulerRenderConfig, RenderContext, RulerTrackSessionConfig } from '../../types';
+import type { CanvasProvider } from '../../canvasProvider';
+import type { RenderTheme } from '../../themes/renderTheme';
+import type { CumulativeOffsets, ChromSizes } from '../../genome/chromSizes';
+import { BaseTrackCanvas } from '../baseTrackCanvas';
+export interface RulerTrackCanvasOptions {
+    locus: Locus;
+    /** Per-track config overrides. Applied after theme-derived defaults. */
+    config?: Partial<RulerRenderConfig>;
+    /** Unified render theme. Palette drives default colors/fonts. */
+    theme?: Partial<RenderTheme>;
+    /** Canvas provider for environment abstraction. Default: DOMCanvasProvider. */
+    canvasProvider?: CanvasProvider;
+    /** Cumulative offsets for whole genome view. */
+    cumulativeOffsets?: CumulativeOffsets;
+    /** Chromosome sizes for whole genome view. */
+    chromSizes?: ChromSizes;
+}
+export declare class RulerTrackCanvas extends BaseTrackCanvas<RulerRenderConfig> {
+    readonly type = "ruler";
+    private _cumulativeOffsets?;
+    private _chromSizes?;
+    constructor(canvas: HTMLCanvasElement, options: RulerTrackCanvasOptions);
+    /** Set cumulative offsets for whole genome view (called by browser). */
+    setCumulativeOffsets(offsets: CumulativeOffsets): void;
+    /** Set chromosome sizes for whole genome view (called by browser). */
+    setChromSizes(sizes: ChromSizes): void;
+    protected computeHeight(_width: number): number;
+    protected getBackground(): string;
+    protected doRender(ctx: CanvasRenderingContext2D, _width: number, _height: number, rc: RenderContext): void;
+    serializeConfig(theme: RenderTheme): RulerTrackSessionConfig;
+}

package/dist/types/tracks/sequence/index.d.ts

@@ -0,0 +1,5 @@
+export { renderSequenceTrack } from './sequenceRenderer';
+export type { SequenceFeature } from './sequenceRenderer';
+export { SequenceTrackCanvas } from './sequenceTrackCanvas';
+export type { SequenceTrackCanvasOptions } from './sequenceTrackCanvas';
+export { modernSequenceTheme, darkSequenceTheme } from './sequenceThemes';

package/dist/types/tracks/sequence/sequenceRenderer.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Pure sequence track renderer — stateless, no DOM, no side effects.
+ *
+ * Layer 2 (Track Canvas + Themed Renderers): Takes a CanvasRenderingContext2D
+ * and draws. All rendering decisions are driven by the config and render context.
+ *
+ * Port of js/sequenceTrack.ts draw() method with full feature parity:
+ * - Base rendering as colored rectangles (zoomed out) or text (zoomed in)
+ * - Reverse complement display
+ * - Three-frame amino acid translation with START/STOP highlighting
+ *
+ * The BP_PER_PIXEL_THRESHOLD (1/10 = 0.1) controls text vs block rendering,
+ * matching igv.js exactly.
+ */
+import type { RenderContext, SequenceRenderConfig } from '../../types';
+/** Sequence data passed from the data lifecycle to the renderer. */
+export interface SequenceFeature {
+    /** Genomic position of the first base in the sequence string. */
+    bpStart: number;
+    /** The nucleotide sequence string. */
+    sequence: string;
+}
+/**
+ * Render the sequence track onto a canvas context.
+ *
+ * Pure function — no state, no side effects, no DOM. Matches igv.js
+ * SequenceTrack.draw() (js/sequenceTrack.ts) with exact feature parity.
+ *
+ * @param ctx - Canvas 2D rendering context (already DPR-scaled by BaseTrackCanvas)
+ * @param seqFeature - The sequence data (bpStart + sequence string), or null if no data
+ * @param config - Full resolved SequenceRenderConfig
+ * @param rc - Render context (bpStart, bpPerPixel, pixelWidth)
+ */
+export declare function renderSequenceTrack(ctx: CanvasRenderingContext2D, seqFeature: SequenceFeature | null, config: SequenceRenderConfig, rc: RenderContext): void;