loom-browser 0.0.1 → 0.0.3

package/dist/types/agent/stateProjection.d.ts

@@ -1,115 +0,0 @@
-/**
- * StateProjection — agent-friendly state snapshots with record/diff support.
- *
- * Wraps a HeadlessGenomeBrowser to produce concise, LLM-optimized state objects.
- * Supports snapshotting (record) and incremental diffs against prior snapshots.
- *
- * Feature summarization reads from the browser's cache via getCachedFeatures(),
- * filters to the visible viewport, and applies type-specific summarization.
- *
- * Swappable: consumers can extend or replace this class for custom projection logic.
- */
-import type { Locus, TrackFeatureSummary, ROISetConfig } from '../types';
-import type { HeadlessGenomeBrowser, ManagedTrack } from '../headlessGenomeBrowser';
-/** Zoom level classification based on viewport span. */
-export type ZoomLevel = 'base' | 'element' | 'gene' | 'region' | 'chromosome' | 'genome';
-/** Concise summary of a single track, suitable for LLM consumption. */
-export interface TrackSummary {
-    id: string;
-    type: string;
-    name?: string;
-    metadata?: Record<string, string>;
-    /** True when a data source exists but no cached data is available yet. */
-    loading?: boolean;
-    featureSummary?: TrackFeatureSummary;
-}
-/** Full projected state of the browser — concise, JSON-serializable. */
-export interface ProjectedState {
-    locus: Locus;
-    /** Formatted locus string, e.g. "chr17:7,668,421-7,687,490" */
-    locusString: string;
-    /** Viewport span in base pairs. */
-    span: number;
-    zoomLevel: ZoomLevel;
-    genome?: string;
-    tracks: TrackSummary[];
-    rois: ROISetConfig[];
-}
-/** Per-field [before, after] diff for a track whose feature summary changed. */
-export interface TrackChangeDiff {
-    id: string;
-    type: string;
-    featureCount?: [number, number];
-    signalRange?: [{
-        min: number;
-        max: number;
-    }, {
-        min: number;
-        max: number;
-    }];
-    featureNames?: [string[], string[]];
-    packingDepth?: [number, number];
-    valueRange?: [{
-        min: number;
-        max: number;
-    }, {
-        min: number;
-        max: number;
-    }];
-}
-/** Diff between two projected states — only includes what changed. */
-export interface StateDiff {
-    /** Present if locus changed. */
-    locus?: [Locus, Locus];
-    /** Present if zoom level changed. */
-    zoomLevel?: [ZoomLevel, ZoomLevel];
-    /** Tracks added since the snapshot. */
-    tracksAdded?: TrackSummary[];
-    /** Track IDs removed since the snapshot. */
-    tracksRemoved?: string[];
-    /** Tracks whose feature summary changed, with per-field [before, after] tuples. */
-    tracksChanged?: TrackChangeDiff[];
-    /** Present if ROIs changed. */
-    roisChanged?: boolean;
-    /** True if nothing changed. */
-    unchanged: boolean;
-}
-export interface GetStateOptions {
-    /** If provided, record the state under this key for future diff() calls. */
-    record?: string;
-}
-export declare class StateProjection {
-    private browser;
-    private snapshots;
-    constructor(browser: HeadlessGenomeBrowser);
-    /** Get the current projected state. Optionally record it under a key. */
-    getState(options?: GetStateOptions): ProjectedState;
-    /**
-     * Diff the current state against a named snapshot.
-     * Returns an object describing only what changed.
-     * Throws if the key doesn't exist.
-     */
-    diff(key: string): StateDiff;
-    /** Record the current state under a key without returning it. */
-    record(key: string): void;
-    /** Delete a snapshot by key. */
-    deleteSnapshot(key: string): boolean;
-    /** Get a previously recorded snapshot by key. */
-    getSnapshot(key: string): ProjectedState | undefined;
-    /** List all snapshot keys. */
-    snapshotKeys(): string[];
-    /** Clear all snapshots. */
-    clearSnapshots(): void;
-    private project;
-    private projectTrack;
-    /**
-     * Summarize cached features for a track, filtered to the visible viewport.
-     * Reads from the browser's cache via getCachedFeatures() and applies
-     * type-specific summarization. Override this method in subclasses for
-     * custom summary formats.
-     */
-    protected summarizeFeatures(mt: ManagedTrack, locus: Locus): TrackFeatureSummary | undefined;
-    private summarizeWig;
-    private summarizeAnnotation;
-    private summarizeInteraction;
-}

package/dist/types/agent/trackSelector.d.ts

@@ -1,31 +0,0 @@
-/**
- * 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/baseTrackCanvas.d.ts

@@ -1,62 +0,0 @@
-/**
- * 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 } from './types';
-import type { RenderTheme } from './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;
-    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;
-    /**
-     * 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;
-    /**
-     * 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/bigwig/binaryParser.d.ts

@@ -1,25 +0,0 @@
-/**
- * Binary data parser for reading structured binary data from a DataView.
- * Port of js/binary.ts, simplified for BigWig reading (no VPointer).
- */
-export declare class BinaryParser {
-    littleEndian: boolean;
-    position: number;
-    readonly view: DataView;
-    readonly length: number;
-    constructor(dataView: DataView, littleEndian?: boolean);
-    setPosition(position: number): void;
-    available(): number;
-    remLength(): number;
-    getByte(): number;
-    getShort(): number;
-    getUShort(): number;
-    getInt(): number;
-    getUInt(): number;
-    getLong(): number;
-    getString(len?: number): string;
-    getFixedLengthString(len: number): string;
-    getFloat(): number;
-    getDouble(): number;
-    skip(n: number): number;
-}

package/dist/types/bigwig/bpTree.d.ts

@@ -1,40 +0,0 @@
-/**
- * B+ tree implementation for BigWig/BigBed chromosome name lookup.
- * Port of js/bigwig/bpTree.ts, simplified:
- * - Only supports 'BPChromTree' type (for chromosome ID lookup)
- * - Uses native fetch via rangeReader
- * - Strict types, no `any`
- */
-export interface ChromLeafValue {
-    id: number;
-    size: number;
-}
-interface LeafItem {
-    key: string;
-    value: ChromLeafValue;
-}
-interface NonLeafItem {
-    key: string;
-    offset: number;
-}
-type BPTreeItem = LeafItem | NonLeafItem;
-interface BPTreeNode {
-    type: number;
-    count: number;
-    items: BPTreeItem[];
-}
-export declare class BPTree {
-    private littleEndian;
-    private readonly nodeCache;
-    private readonly url;
-    private header;
-    private readonly startOffset;
-    constructor(url: string, startOffset: number);
-    init(signal?: AbortSignal): Promise<void>;
-    getItemCount(): number;
-    search(term: string, signal?: AbortSignal): Promise<ChromLeafValue | undefined>;
-    private walkTreeNode;
-    readTreeNode(offset: number, signal?: AbortSignal): Promise<BPTreeNode>;
-    private getParserFor;
-}
-export {};

package/dist/types/bigwig/bwReader.d.ts

@@ -1,69 +0,0 @@
-/**
- * BigWig file reader.
- * Port of js/bigwig/bwReader.ts, simplified for BigWig only (no BigBed).
- *
- * Reads a BigWig file via HTTP range requests, parses the binary header,
- * zoom level headers, total summary, chromosome tree, and data sections.
- */
-import type { WigFeature, WindowFunction } from '../types';
-import type { WorkerProvider } from '../workerProvider';
-export interface BigWigHeader {
-    bwVersion: number;
-    nZoomLevels: number;
-    chromTreeOffset: number;
-    fullDataOffset: number;
-    fullIndexOffset: number;
-    fieldCount: number;
-    definedFieldCount: number;
-    autoSqlOffset: number;
-    totalSummaryOffset: number;
-    uncompressBuffSize: number;
-    extensionOffset: number;
-}
-export interface BigWigTotalSummary {
-    basesCovered: number;
-    minVal: number;
-    maxVal: number;
-    sumData: number;
-    sumSquares: number;
-    mean: number;
-    stddev: number;
-}
-export declare class BigWigReader {
-    private readonly url;
-    private littleEndian;
-    private header;
-    private chromTree;
-    private zoomLevelHeaders;
-    private totalSummary;
-    private readonly rpTreeCache;
-    /** Optional worker provider for offloading CPU-intensive decode work. */
-    private readonly workerProvider?;
-    constructor(url: string, workerProvider?: WorkerProvider);
-    /** Load and parse the BigWig header. Idempotent. */
-    loadHeader(signal?: AbortSignal): Promise<BigWigHeader>;
-    /** Get the total summary statistics (if available). */
-    getTotalSummary(): Promise<BigWigTotalSummary | undefined>;
-    /**
-     * Read BigWig features for a genomic range.
-     *
-     * @param chr - Chromosome name (e.g., 'chr17')
-     * @param bpStart - Start position (0-based)
-     * @param bpEnd - End position
-     * @param bpPerPixel - Resolution (used to select zoom level)
-     * @param windowFunction - Aggregation function for zoom data ('mean', 'min', 'max')
-     */
-    readFeatures(chr: string, bpStart: number, bpEnd: number, bpPerPixel?: number, windowFunction?: WindowFunction, signal?: AbortSignal): Promise<WigFeature[]>;
-    /**
-     * Read features across all main chromosomes for whole genome view.
-     * Resolves chromosome IDs, finds min/max range, and does a cross-chromosome R-tree query.
-     * Port of js/bigwig/bwReader.ts readWGFeatures().
-     */
-    readWGFeatures(chromNames: string[], bpPerPixel: number, windowFunction?: WindowFunction, signal?: AbortSignal): Promise<WigFeature[]>;
-    /**
-     * Internal: read features for a range that may span multiple chromosomes.
-     */
-    private readFeaturesRange;
-    private zoomLevelForScale;
-    private loadRPTree;
-}

package/dist/types/bigwig/chromTree.d.ts

@@ -1,28 +0,0 @@
-/**
- * Chromosome name ↔ ID mapping backed by a B+ tree.
- * Port of js/bigwig/chromTree.ts.
- */
-export declare class ChromTree {
-    private readonly nameToId;
-    private readonly idToName;
-    private readonly bpTree;
-    private readonly startOffset;
-    constructor(url: string, startOffset: number);
-    init(signal?: AbortSignal): Promise<void>;
-    getItemCount(): number;
-    /** Return the chromosome ID for the given name, or undefined if not found. */
-    getIdForName(chr: string, signal?: AbortSignal): Promise<number | undefined>;
-    /** Return all cached chromosome ID → name mappings. */
-    getAllNames(): Map<number, string>;
-    /**
-     * Pre-resolve a list of chromosome names to IDs, populating the cache.
-     * Returns a map of name → ID for successfully resolved chromosomes.
-     */
-    resolveAll(names: string[], signal?: AbortSignal): Promise<Map<string, number>>;
-    /**
-     * Return the chromosome name for the given ID.
-     * Potentially expensive — walks the tree until the matching leaf is found.
-     */
-    getNameForId(id: number, signal?: AbortSignal): Promise<string | undefined>;
-    private reverseSearch;
-}

package/dist/types/bigwig/inflate.d.ts

@@ -1,9 +0,0 @@
-/**
- * Zlib inflate (decompress) utility.
- *
- * Uses the Web Streams API DecompressionStream when available (all modern
- * browsers), with a manual raw-deflate fallback for environments that only
- * support 'deflate' format (the BigWig format stores raw deflate data without
- * a zlib header, but some implementations add the header).
- */
-export declare function inflate(compressedData: Uint8Array): Promise<Uint8Array>;

package/dist/types/bigwig/rangeReader.d.ts

@@ -1,48 +0,0 @@
-/**
- * HTTP range request reader using native fetch.
- * Replaces igvxhr + BufferedReader for BigWig file reading.
- *
- * Handles cross-origin 307/302 redirects that strip the Range header.
- * When a redirect causes the server to return 200 (full content) instead of
- * 206 (partial), we either retry against the final URL or slice the correct
- * bytes from the full response — matching igvxhr behavior.
- */
-export interface ByteRange {
-    start: number;
-    size: number;
-}
-/**
- * Fetch a byte range from a URL as an ArrayBuffer.
- *
- * Handles two redirect failure modes:
- * 1. Cross-origin redirect strips Range header → server returns 200 (full file).
- *    We retry directly against response.url (the final URL post-redirect).
- * 2. If retry still returns 200, we slice the requested bytes from the full
- *    response (matching igvxhr's fallback behavior).
- *
- * On HTTP 416 (Range Not Satisfiable), fetches the actual file size via HEAD
- * and retries once with a clamped range.
- */
-export declare function fetchRange(url: string, range: ByteRange, signal?: AbortSignal): Promise<ArrayBuffer>;
-/**
- * Fetch the Content-Length of a URL via a HEAD request.
- * If redirected and Content-Length is missing, retries against the final URL.
- */
-export declare function getContentLength(url: string, signal?: AbortSignal): Promise<number>;
-/**
- * Buffered reader that caches fetched data to minimize HTTP requests.
- * When a requested range is within the cached buffer, no fetch is needed.
- *
- * On HTTP 416, recovers by fetching the file's Content-Length and retrying,
- * matching js/bigwig/bufferedReader.ts behavior.
- */
-export declare class BufferedRangeReader {
-    private readonly url;
-    private readonly bufferSize;
-    private cachedRange;
-    private cachedData;
-    private contentLength;
-    constructor(url: string, bufferSize?: number);
-    dataViewForRange(requestedRange: ByteRange, signal?: AbortSignal, retries?: number): Promise<DataView>;
-    loadArrayBuffer(range: ByteRange, signal?: AbortSignal): Promise<ArrayBuffer>;
-}

package/dist/types/bigwig/rpTree.d.ts

@@ -1,27 +0,0 @@
-/**
- * R-tree implementation for BigWig spatial range queries.
- * Port of js/bigwig/rpTree.ts.
- */
-export interface RPTreeLeafItem {
-    isLeaf: boolean;
-    startChrom: number;
-    startBase: number;
-    endChrom: number;
-    endBase: number;
-    childOffset: number;
-    dataSize: number;
-    dataOffset: number;
-}
-export declare class RPTree {
-    private littleEndian;
-    private readonly nodeCache;
-    private readonly url;
-    private readonly startOffset;
-    private header;
-    constructor(url: string, startOffset: number);
-    init(signal?: AbortSignal): Promise<void>;
-    /** Find all leaf items that overlap the given genomic range. */
-    findLeafItemsOverlapping(chrIdx1: number, startBase: number, chrIdx2: number, endBase: number, signal?: AbortSignal): Promise<RPTreeLeafItem[]>;
-    private readNode;
-    private getParserFor;
-}

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

@@ -1,20 +0,0 @@
-/**
- * Data source for dynseq wig tracks.
- *
- * Wraps a BigWig data source and attaches DNA sequence to each feature
- * at fetch time — matching the igv.js pattern where sequence is fetched
- * during getFeatures(), not during rendering.
- *
- * At high zoom (bpPerPixel < 2), fetches the region's sequence in a
- * single call and slices it per-feature. At low zoom, returns features
- * without sequence (the renderer falls back to bars).
- */
-import type { DataSource, Locus, WigFeature } from '../types';
-/** A function that fetches DNA sequence for a genomic region. */
-export type SequenceProvider = (locus: Locus) => Promise<string>;
-export declare class DynseqDataSource implements DataSource<WigFeature> {
-    private wigSource;
-    private sequenceProvider;
-    constructor(wigSource: DataSource<WigFeature>, sequenceProvider: SequenceProvider);
-    fetch(locus: Locus, bpPerPixel: number, signal: AbortSignal): Promise<WigFeature[]>;
-}

package/dist/types/dynseqRenderer.d.ts

@@ -1,37 +0,0 @@
-/**
- * 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): 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
- */
-export declare function renderDynSeqFeature(ctx: CanvasRenderingContext2D, sequence: string, x: number, width: number, y: number, y0: number, value: number, colors?: Readonly<Record<string, string>>): void;

package/dist/types/geneRenderer.d.ts

@@ -1,17 +0,0 @@
-/**
- * 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/geneThemes.d.ts

@@ -1,11 +0,0 @@
-/**
- * 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/geneTrackCanvas.d.ts

@@ -1,46 +0,0 @@
-/**
- * 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 } from './types';
-import type { CanvasProvider } from './canvasProvider';
-import type { RenderTheme } from './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;
-}
-export declare class GeneTrackCanvas extends BaseTrackCanvas<GeneRenderConfig> {
-    private features;
-    private fixedHeight;
-    private background;
-    /** Most recently packed features, available after render(). */
-    private packedFeatures;
-    readonly type = "gene";
-    constructor(canvas: HTMLCanvasElement, options: GeneTrackCanvasOptions);
-    /** Update features and re-render. */
-    setFeatures(features: GeneFeature[]): void;
-    protected computeHeight(_width: number): number;
-    protected getBackground(): string;
-    protected doRender(ctx: CanvasRenderingContext2D, _width: number, _height: number, rc: RenderContext): void;
-    serializeConfig(theme: RenderTheme): GeneTrackSessionConfig;
-}

package/dist/types/renderTheme.d.ts

@@ -1,72 +0,0 @@
-/**
- * Unified RenderTheme system — shadcn-style palette-driven theming.
- *
- * Users define a global palette (primary, secondary, background, foreground, etc.)
- * and each track type knows how to derive its specific config defaults from that
- * palette. Everything is overridable at three levels:
- *
- *   1. Palette-derived defaults   (gene.color = palette.primary)
- *   2. Per-track-type overrides   (theme.gene.borderRadius = 3)
- *   3. Per-track instance overrides (options.config.color = 'red')
- *
- * Renderers never see RenderTheme directly — they still consume GeneRenderConfig,
- * WigRenderConfig, etc. The theme system produces those configs.
- */
-import type { GeneRenderConfig, WigRenderConfig, RulerRenderConfig } from './types';
-/** Global color palette — the primary customization surface. */
-export interface ThemePalette {
-    /** Main track color (CDS exons, wig bars, signal fill). */
-    primary: string;
-    /** Alternate strand, negative values. */
-    secondary: string;
-    /** Highlights, selections, active states. */
-    accent: string;
-    /** Track canvas background. */
-    background: string;
-    /** Text, labels, tick marks. */
-    foreground: string;
-    /** Subtle elements: baselines, introns, borders. */
-    muted: string;
-}
-/**
- * Unified render theme. Defines a global palette, typography, and nucleotide
- * colors. Each track type derives its config defaults from the palette, with
- * optional per-track-type overrides.
- */
-export interface RenderTheme {
-    palette: ThemePalette;
-    /** CSS font-family string. Default: 'sans-serif'. */
-    fontFamily: string;
-    /** Base font size in pixels. Default: 10. */
-    fontSize: number;
-    /** Nucleotide color mapping (A, C, G, T, N). */
-    nucleotideColors: Record<string, string>;
-    gene?: Partial<GeneRenderConfig>;
-    wig?: Partial<WigRenderConfig>;
-    ruler?: Partial<RulerRenderConfig>;
-}
-/** Returns the default render theme matching classic igv.js appearance. */
-export declare function defaultRenderTheme(): RenderTheme;
-/**
- * Deep-merge a partial theme into the defaults.
- * If no overrides provided, returns the default theme.
- */
-export declare function resolveTheme(overrides?: Partial<RenderTheme>): RenderTheme;
-/**
- * Resolve a full GeneRenderConfig from a theme + optional per-track overrides.
- *
- * Resolution: palette-derived defaults → theme.gene overrides → per-track overrides.
- */
-export declare function resolveGeneConfig(theme: RenderTheme, overrides?: Partial<GeneRenderConfig>): GeneRenderConfig;
-/**
- * Resolve a full WigRenderConfig from a theme + optional per-track overrides.
- *
- * Resolution: palette-derived defaults → theme.wig overrides → per-track overrides.
- */
-export declare function resolveWigConfig(theme: RenderTheme, overrides?: Partial<WigRenderConfig>): WigRenderConfig;
-/**
- * Resolve a full RulerRenderConfig from a theme + optional per-track overrides.
- *
- * Resolution: palette-derived defaults → theme.ruler overrides → per-track overrides.
- */
-export declare function resolveRulerConfig(theme: RenderTheme, overrides?: Partial<RulerRenderConfig>): RulerRenderConfig;