chartgpu 0.2.1 → 0.2.3

package/dist/core/renderCoordinator/annotations/processAnnotations.d.ts

@@ -0,0 +1,88 @@
+/**
+ * Annotation processing for the RenderCoordinator.
+ *
+ * Processes annotation configurations into GPU-renderable instances (reference lines,
+ * markers) and DOM label data. Supports layering (above/below series) and multiple
+ * annotation types (lineX, lineY, point, text).
+ *
+ * @module processAnnotations
+ */
+import type { AnnotationConfig } from '../../../config/types';
+import type { LinearScale } from '../../../utils/scales';
+import type { ThemeConfig } from '../../../themes/types';
+import type { ReferenceLineInstance } from '../../../renderers/createReferenceLineRenderer';
+import type { AnnotationMarkerInstance } from '../../../renderers/createAnnotationMarkerRenderer';
+/**
+ * Internal type for annotation label data (DOM overlay).
+ */
+export interface AnnotationLabelData {
+    readonly text: string;
+    readonly x: number;
+    readonly y: number;
+    readonly anchor?: 'start' | 'middle' | 'end';
+    readonly color?: string;
+    readonly fontSize?: number;
+    readonly background?: Readonly<{
+        readonly backgroundColor: string;
+        readonly padding?: readonly [number, number, number, number];
+        readonly borderRadius?: number;
+    }>;
+}
+/**
+ * Plot bounds in CSS pixels.
+ */
+export interface PlotBounds {
+    readonly leftCss: number;
+    readonly rightCss: number;
+    readonly topCss: number;
+    readonly bottomCss: number;
+    readonly widthCss: number;
+    readonly heightCss: number;
+}
+/**
+ * Context for annotation processing.
+ */
+export interface AnnotationContext {
+    readonly annotations: ReadonlyArray<AnnotationConfig>;
+    readonly xScale: LinearScale;
+    readonly yScale: LinearScale;
+    readonly plotBounds: PlotBounds;
+    readonly canvasCssWidth: number;
+    readonly canvasCssHeight: number;
+    readonly theme: ThemeConfig;
+    readonly offsetX?: number;
+    readonly offsetY?: number;
+}
+/**
+ * Result of annotation processing.
+ */
+export interface AnnotationResult {
+    readonly linesBelow: ReferenceLineInstance[];
+    readonly linesAbove: ReferenceLineInstance[];
+    readonly markersBelow: AnnotationMarkerInstance[];
+    readonly markersAbove: AnnotationMarkerInstance[];
+    readonly labels: AnnotationLabelData[];
+}
+/**
+ * Processes annotations into GPU-renderable instances and DOM labels.
+ *
+ * **Annotation Types:**
+ * - `lineX`: Vertical reference line at x coordinate
+ * - `lineY`: Horizontal reference line at y coordinate
+ * - `point`: Marker at (x, y) coordinate
+ * - `text`: Text annotation with flexible positioning
+ *
+ * **Layering:**
+ * - `belowSeries`: Rendered before series (occluded by data)
+ * - `aboveSeries`: Rendered after series (always visible, default)
+ *
+ * **Labels:**
+ * - Optional text labels for all annotation types
+ * - Template support with {x}, {y}, {value}, {name} placeholders
+ * - Background styling with padding and border radius
+ *
+ * @param context - Annotation processing context
+ * @returns Annotation result with lines, markers, and labels
+ */
+export declare function processAnnotations(context: AnnotationContext): AnnotationResult;
+//# sourceMappingURL=processAnnotations.d.ts.map

package/dist/core/renderCoordinator/annotations/processAnnotations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"processAnnotations.d.ts","sourceRoot":"","sources":["../../../../src/core/renderCoordinator/annotations/processAnnotations.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAC9D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,gDAAgD,CAAC;AAC5F,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,mDAAmD,CAAC;AAMlG;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,GAAG,QAAQ,GAAG,KAAK,CAAC;IAC7C,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,UAAU,CAAC,EAAE,QAAQ,CAAC;QAC7B,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;QACjC,QAAQ,CAAC,OAAO,CAAC,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;QAC7D,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;KAChC,CAAC,CAAC;CACJ;AAED;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,WAAW,EAAE,aAAa,CAAC,gBAAgB,CAAC,CAAC;IACtD,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC;IAC7B,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC;IAC7B,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAC;IAChC,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC;IAC5B,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,UAAU,EAAE,qBAAqB,EAAE,CAAC;IAC7C,QAAQ,CAAC,UAAU,EAAE,qBAAqB,EAAE,CAAC;IAC7C,QAAQ,CAAC,YAAY,EAAE,wBAAwB,EAAE,CAAC;IAClD,QAAQ,CAAC,YAAY,EAAE,wBAAwB,EAAE,CAAC;IAClD,QAAQ,CAAC,MAAM,EAAE,mBAAmB,EAAE,CAAC;CACxC;AA8FD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,iBAAiB,GAAG,gBAAgB,CAoP/E"}

package/dist/core/renderCoordinator/axis/axisLabelHelpers.d.ts

@@ -0,0 +1,91 @@
+/**
+ * Axis label positioning and layout helpers.
+ *
+ * Provides pure functions for calculating axis label positions, anchor points,
+ * and title placements without DOM manipulation. These helpers are used by the
+ * render coordinator to position axis labels and titles correctly.
+ *
+ * @module axisLabelHelpers
+ */
+import type { TextOverlayAnchor } from '../../../components/createTextOverlay';
+/**
+ * Default label padding in CSS pixels.
+ */
+export declare const LABEL_PADDING_CSS_PX = 4;
+/**
+ * Calculates the anchor point for an x-axis tick label.
+ *
+ * - Single tick: centered
+ * - First tick: left-aligned (start)
+ * - Last tick: right-aligned (end)
+ * - Middle ticks: centered (middle)
+ *
+ * @param tickIndex - Index of the current tick
+ * @param totalTicks - Total number of ticks
+ * @returns Text anchor for label positioning
+ */
+export declare function getXAxisTickLabelAnchor(tickIndex: number, totalTicks: number): TextOverlayAnchor;
+/**
+ * Calculates the Y position for x-axis labels.
+ *
+ * X-axis labels are positioned below the plot area, with spacing for tick marks.
+ *
+ * @param plotBottomCss - Bottom edge of plot area in CSS pixels
+ * @param tickLengthCssPx - Length of tick marks
+ * @param fontSize - Font size for labels
+ * @returns Y position in CSS pixels (canvas-local)
+ */
+export declare function getXAxisLabelY(plotBottomCss: number, tickLengthCssPx: number, fontSize: number): number;
+/**
+ * Calculates the X position for y-axis labels.
+ *
+ * Y-axis labels are positioned to the left of the plot area, with spacing for tick marks.
+ *
+ * @param plotLeftCss - Left edge of plot area in CSS pixels
+ * @param tickLengthCssPx - Length of tick marks
+ * @returns X position in CSS pixels (canvas-local)
+ */
+export declare function getYAxisLabelX(plotLeftCss: number, tickLengthCssPx: number): number;
+/**
+ * Calculates the Y position for the x-axis title.
+ *
+ * The title is centered vertically between the tick labels and the bottom edge
+ * (or zoom slider if present).
+ *
+ * @param xLabelY - Y position of x-axis tick labels
+ * @param fontSize - Font size for tick labels
+ * @param canvasCssHeight - Canvas height in CSS pixels
+ * @param hasSliderZoom - Whether a slider zoom control is present
+ * @param sliderHeightCssPx - Height of slider zoom control (default: 32)
+ * @returns Y position for x-axis title in CSS pixels
+ */
+export declare function getXAxisTitleY(xLabelY: number, fontSize: number, canvasCssHeight: number, hasSliderZoom: boolean, sliderHeightCssPx?: number): number;
+/**
+ * Calculates the X position for the y-axis title.
+ *
+ * The title is positioned to the left of the tick labels, accounting for their width.
+ *
+ * @param yLabelX - X position of y-axis tick labels
+ * @param maxTickLabelWidth - Maximum width of tick labels in CSS pixels
+ * @param titleFontSize - Font size for axis title
+ * @returns X position for y-axis title in CSS pixels
+ */
+export declare function getYAxisTitleX(yLabelX: number, maxTickLabelWidth: number, titleFontSize: number): number;
+/**
+ * Measures the maximum width of a set of rendered labels.
+ *
+ * @param labelSpans - Array of HTMLSpanElement labels
+ * @returns Maximum width in CSS pixels, or 0 if no labels
+ */
+export declare function measureMaxLabelWidth(labelSpans: readonly HTMLSpanElement[]): number;
+/**
+ * Calculates the center position between two coordinates.
+ *
+ * Utility for centering axis titles within plot area.
+ *
+ * @param a - First coordinate
+ * @param b - Second coordinate
+ * @returns Midpoint between a and b
+ */
+export declare function getCenterPosition(a: number, b: number): number;
+//# sourceMappingURL=axisLabelHelpers.d.ts.map

package/dist/core/renderCoordinator/axis/axisLabelHelpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"axisLabelHelpers.d.ts","sourceRoot":"","sources":["../../../../src/core/renderCoordinator/axis/axisLabelHelpers.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,uCAAuC,CAAC;AAE/E;;GAEG;AACH,eAAO,MAAM,oBAAoB,IAAI,CAAC;AAEtC;;;;;;;;;;;GAWG;AACH,wBAAgB,uBAAuB,CAAC,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,iBAAiB,CAKhG;AAED;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAAC,aAAa,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAEvG;AAED;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,WAAW,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM,GAAG,MAAM,CAEnF;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,cAAc,CAC5B,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,EAChB,eAAe,EAAE,MAAM,EACvB,aAAa,EAAE,OAAO,EACtB,iBAAiB,GAAE,MAAW,GAC7B,MAAM,CAUR;AAED;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,MAAM,CAGxG;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,UAAU,EAAE,SAAS,eAAe,EAAE,GAAG,MAAM,CAGnF;AAED;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAE9D"}

package/dist/core/renderCoordinator/axis/computeAxisTicks.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Axis tick computation and formatting.
+ *
+ * Generates tick values and formatting for linear axes. Handles decimal precision
+ * determination based on tick step size and provides number formatting utilities.
+ *
+ * @module computeAxisTicks
+ */
+/**
+ * Generates evenly-spaced tick values between domain min and max.
+ *
+ * @param domainMin - Minimum value of the domain
+ * @param domainMax - Maximum value of the domain
+ * @param tickCount - Number of ticks to generate (must be >= 1)
+ * @returns Array of tick values
+ */
+export declare function generateLinearTicks(domainMin: number, domainMax: number, tickCount: number): number[];
+/**
+ * Computes the maximum number of decimal places needed to display a tick step cleanly.
+ *
+ * Prefers "clean" decimal representations (e.g., 2.5, 0.25, 0.125) without relying on
+ * magnitude alone. Accepts floating-point noise and caps the search to keep formatting
+ * reasonable.
+ *
+ * @param tickStep - The step size between ticks
+ * @param cap - Maximum number of decimal places to consider (default: 8)
+ * @returns Number of decimal places (0 to cap)
+ */
+export declare function computeMaxFractionDigitsFromStep(tickStep: number, cap?: number): number;
+/**
+ * Creates an Intl.NumberFormat for tick value formatting.
+ *
+ * Automatically determines the appropriate number of decimal places based on the
+ * tick step size using `computeMaxFractionDigitsFromStep()`.
+ *
+ * @param tickStep - The step size between ticks
+ * @returns Intl.NumberFormat configured for tick formatting
+ */
+export declare function createTickFormatter(tickStep: number): Intl.NumberFormat;
+/**
+ * Formats a numeric tick value using the provided number formatter.
+ *
+ * Handles edge cases:
+ * - Non-finite values return null
+ * - Values near zero (< 1e-12) are normalized to 0 to avoid "-0" display
+ * - Unexpected "NaN" output from formatter is guarded against
+ *
+ * @param nf - Intl.NumberFormat to use for formatting
+ * @param v - Numeric value to format
+ * @returns Formatted string or null if value cannot be formatted
+ */
+export declare function formatTickValue(nf: Intl.NumberFormat, v: number): string | null;
+//# sourceMappingURL=computeAxisTicks.d.ts.map

package/dist/core/renderCoordinator/axis/computeAxisTicks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"computeAxisTicks.d.ts","sourceRoot":"","sources":["../../../../src/core/renderCoordinator/axis/computeAxisTicks.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAOH;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,EAAE,CASrG;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,gCAAgC,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,GAAE,MAAyC,GAAG,MAAM,CAiBzH;AAED;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC,YAAY,CAGvE;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,eAAe,CAAC,EAAE,EAAE,IAAI,CAAC,YAAY,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAO/E"}

package/dist/core/renderCoordinator/data/computeVisibleSlice.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Visible Slice Computation Utilities
+ *
+ * Provides efficient data slicing for zoom operations using binary search
+ * when data is monotonic, with fallback to linear filtering.
+ *
+ * Key features:
+ * - Binary search slicing for O(log n) performance on sorted data
+ * - WeakMap caching of monotonicity checks to avoid O(n) scans
+ * - Separate implementations for cartesian (x-based) and OHLC (timestamp-based) data
+ * - Support for both tuple and object data formats
+ */
+import type { DataPoint, DataPointTuple, OHLCDataPoint, OHLCDataPointTuple } from '../../../config/types';
+type TuplePoint = DataPointTuple;
+export declare function isTuplePoint(p: DataPoint): p is TuplePoint;
+export declare function isTupleDataArray(data: ReadonlyArray<DataPoint>): data is ReadonlyArray<TuplePoint>;
+export declare function isTupleOHLCDataPoint(p: OHLCDataPoint): p is OHLCDataPointTuple;
+/**
+ * Checks if cartesian data is monotonic non-decreasing by X coordinate with all finite values.
+ * Results are cached in a WeakMap to avoid repeated O(n) scans.
+ */
+export declare function isMonotonicNonDecreasingFiniteX(data: ReadonlyArray<DataPoint>, isTuple: boolean): boolean;
+/**
+ * Checks if OHLC data is monotonic non-decreasing by timestamp with all finite values.
+ * Results are cached in a WeakMap to avoid repeated O(n) scans.
+ */
+export declare function isMonotonicNonDecreasingFiniteTimestamp(data: ReadonlyArray<OHLCDataPoint>): boolean;
+/**
+ * Slices cartesian data to the visible X range [xMin, xMax].
+ *
+ * Uses binary search (O(log n)) when data is monotonic by X;
+ * otherwise falls back to linear filtering (O(n)).
+ *
+ * @param data - Cartesian data points (tuple or object format)
+ * @param xMin - Minimum X value (inclusive)
+ * @param xMax - Maximum X value (inclusive)
+ * @returns Sliced data array containing only points within [xMin, xMax]
+ */
+export declare function sliceVisibleRangeByX(data: ReadonlyArray<DataPoint>, xMin: number, xMax: number): ReadonlyArray<DataPoint>;
+/**
+ * Finds the index range of visible points in cartesian data.
+ *
+ * Returns { start, end } indices suitable for slicing or iteration.
+ * Only works correctly when data is monotonic; returns full range otherwise.
+ *
+ * @param data - Cartesian data points (tuple or object format)
+ * @param xMin - Minimum X value (inclusive)
+ * @param xMax - Maximum X value (inclusive)
+ * @returns Index range { start, end } for visible data
+ */
+export declare function findVisibleRangeIndicesByX(data: ReadonlyArray<DataPoint>, xMin: number, xMax: number): {
+    readonly start: number;
+    readonly end: number;
+};
+/**
+ * Slices OHLC/candlestick data to the visible timestamp range [xMin, xMax].
+ *
+ * Uses binary search (O(log n)) when timestamps are monotonic;
+ * otherwise falls back to linear filtering (O(n)).
+ *
+ * @param data - OHLC data points (tuple or object format)
+ * @param xMin - Minimum timestamp (inclusive)
+ * @param xMax - Maximum timestamp (inclusive)
+ * @returns Sliced data array containing only points within [xMin, xMax]
+ */
+export declare function sliceVisibleRangeByOHLC(data: ReadonlyArray<OHLCDataPoint>, xMin: number, xMax: number): ReadonlyArray<OHLCDataPoint>;
+export {};
+//# sourceMappingURL=computeVisibleSlice.d.ts.map

package/dist/core/renderCoordinator/data/computeVisibleSlice.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"computeVisibleSlice.d.ts","sourceRoot":"","sources":["../../../../src/core/renderCoordinator/data/computeVisibleSlice.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EACV,SAAS,EACT,cAAc,EACd,aAAa,EACb,kBAAkB,EACnB,MAAM,uBAAuB,CAAC;AAK/B,KAAK,UAAU,GAAG,cAAc,CAAC;AAKjC,wBAAgB,YAAY,CAAC,CAAC,EAAE,SAAS,GAAG,CAAC,IAAI,UAAU,CAE1D;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,aAAa,CAAC,SAAS,CAAC,GAAG,IAAI,IAAI,aAAa,CAAC,UAAU,CAAC,CAElG;AAED,wBAAgB,oBAAoB,CAAC,CAAC,EAAE,aAAa,GAAG,CAAC,IAAI,kBAAkB,CAE9E;AAMD;;;GAGG;AACH,wBAAgB,+BAA+B,CAAC,IAAI,EAAE,aAAa,CAAC,SAAS,CAAC,EAAE,OAAO,EAAE,OAAO,GAAG,OAAO,CAuCzG;AAED;;;GAGG;AACH,wBAAgB,uCAAuC,CAAC,IAAI,EAAE,aAAa,CAAC,aAAa,CAAC,GAAG,OAAO,CAqBnG;AAoGD;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,aAAa,CAAC,SAAS,CAAC,EAC9B,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,GACX,aAAa,CAAC,SAAS,CAAC,CA8B1B;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,0BAA0B,CACxC,IAAI,EAAE,aAAa,CAAC,SAAS,CAAC,EAC9B,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,GACX;IAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAuBlD;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,aAAa,CAAC,aAAa,CAAC,EAClC,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,GACX,aAAa,CAAC,aAAa,CAAC,CA8B9B"}

package/dist/core/renderCoordinator/gpu/textureManager.d.ts

@@ -0,0 +1,69 @@
+/**
+ * GPU texture management for the RenderCoordinator.
+ *
+ * Handles lazy allocation of render target textures and MSAA overlay management.
+ * Uses a multi-pass rendering strategy:
+ * 1. Main scene → single-sample texture
+ * 2. Blit to MSAA target + draw annotations (MSAA overlay pass)
+ * 3. Draw UI overlays on resolved swapchain (single-sample)
+ *
+ * @module textureManager
+ */
+/**
+ * Texture manager state exposed to the render coordinator.
+ */
+export interface TextureManagerState {
+    readonly mainColorView: GPUTextureView | null;
+    readonly overlayMsaaView: GPUTextureView | null;
+    readonly overlayBlitBindGroup: GPUBindGroup | null;
+    readonly overlayBlitPipeline: GPURenderPipeline;
+    readonly msaaSampleCount: number;
+}
+/**
+ * Configuration for texture manager creation.
+ */
+export interface TextureManagerConfig {
+    readonly device: GPUDevice;
+    readonly targetFormat: GPUTextureFormat;
+}
+/**
+ * Texture manager interface returned by factory function.
+ */
+export interface TextureManager {
+    /**
+     * Ensures textures are allocated for the given dimensions.
+     * Reallocates if size or format changes.
+     *
+     * @param width - Canvas width in device pixels
+     * @param height - Canvas height in device pixels
+     */
+    ensureTextures(width: number, height: number): void;
+    /**
+     * Gets current texture manager state for rendering.
+     *
+     * @returns Current state with texture views and bind groups
+     */
+    getState(): TextureManagerState;
+    /**
+     * Disposes all GPU resources.
+     * Textures, views, and bind groups are destroyed.
+     */
+    dispose(): void;
+}
+/**
+ * Creates a texture manager for render target allocation and management.
+ *
+ * The texture manager uses lazy allocation: textures are only created when
+ * first requested via ensureTextures(), and are reallocated if dimensions
+ * or format change.
+ *
+ * **Architecture:**
+ * - Main color texture: Single-sample render target for main scene
+ * - Overlay MSAA texture: Multi-sample render target for annotations
+ * - Blit pipeline: Copies main color to MSAA target for overlay pass
+ *
+ * @param config - Configuration with device and target format
+ * @returns Texture manager instance
+ */
+export declare function createTextureManager(config: TextureManagerConfig): TextureManager;
+//# sourceMappingURL=textureManager.d.ts.map

package/dist/core/renderCoordinator/gpu/textureManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"textureManager.d.ts","sourceRoot":"","sources":["../../../../src/core/renderCoordinator/gpu/textureManager.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAuCH;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,aAAa,EAAE,cAAc,GAAG,IAAI,CAAC;IAC9C,QAAQ,CAAC,eAAe,EAAE,cAAc,GAAG,IAAI,CAAC;IAChD,QAAQ,CAAC,oBAAoB,EAAE,YAAY,GAAG,IAAI,CAAC;IACnD,QAAQ,CAAC,mBAAmB,EAAE,iBAAiB,CAAC;IAChD,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;CAClC;AAgBD;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAC;IAC3B,QAAQ,CAAC,YAAY,EAAE,gBAAgB,CAAC;CACzC;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B;;;;;;OAMG;IACH,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IAEpD;;;;OAIG;IACH,QAAQ,IAAI,mBAAmB,CAAC;IAEhC;;;OAGG;IACH,OAAO,IAAI,IAAI,CAAC;CACjB;AAiBD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,oBAAoB,GAAG,cAAc,CA+HjF"}

package/dist/core/renderCoordinator/interaction/interactionHelpers.d.ts

@@ -0,0 +1,160 @@
+/**
+ * Interaction helper utilities for pointer tracking and interaction X management.
+ *
+ * Provides pure functions for transforming pointer states, managing interaction X
+ * in domain coordinates, and computing effective pointer positions for crosshair
+ * and tooltip rendering.
+ *
+ * @module interactionHelpers
+ */
+import type { LinearScale } from '../../../utils/scales';
+/**
+ * Source of pointer events - either real mouse input or externally synchronized.
+ */
+export type PointerSource = 'mouse' | 'sync';
+/**
+ * Pointer state tracking both canvas-local CSS pixels and plot-relative grid coordinates.
+ */
+export interface PointerState {
+    /** Source of the pointer event */
+    readonly source: PointerSource;
+    /** X position in canvas-local CSS pixels */
+    readonly x: number;
+    /** Y position in canvas-local CSS pixels */
+    readonly y: number;
+    /** X position in plot-relative grid CSS pixels */
+    readonly gridX: number;
+    /** Y position in plot-relative grid CSS pixels */
+    readonly gridY: number;
+    /** Whether the pointer is inside the plot grid */
+    readonly isInGrid: boolean;
+    /** Whether a pointer event has occurred */
+    readonly hasPointer: boolean;
+}
+/**
+ * Interaction scales for coordinate transformations between domain and grid space.
+ */
+export interface InteractionScales {
+    readonly xScale: LinearScale;
+    readonly yScale: LinearScale;
+    readonly plotWidthCss: number;
+    readonly plotHeightCss: number;
+}
+/**
+ * Grid area boundaries in CSS pixels.
+ */
+export interface GridArea {
+    readonly left: number;
+    readonly top: number;
+    readonly width: number;
+    readonly height: number;
+}
+/**
+ * Creates an initial empty pointer state.
+ *
+ * @returns Pointer state with no active pointer
+ */
+export declare function createPointerState(): PointerState;
+/**
+ * Updates pointer state from mouse move event payload.
+ *
+ * @param x - Canvas-local CSS pixel X
+ * @param y - Canvas-local CSS pixel Y
+ * @param gridX - Plot-relative grid CSS pixel X
+ * @param gridY - Plot-relative grid CSS pixel Y
+ * @param isInGrid - Whether pointer is inside plot grid
+ * @returns Updated pointer state with source 'mouse'
+ */
+export declare function updatePointerFromMouse(x: number, y: number, gridX: number, gridY: number, isInGrid: boolean): PointerState;
+/**
+ * Clears pointer state when mouse leaves canvas.
+ *
+ * Preserves source and coordinates but marks as not active.
+ *
+ * @param prevState - Previous pointer state
+ * @returns Updated pointer state with hasPointer=false
+ */
+export declare function clearPointer(prevState: PointerState): PointerState;
+/**
+ * Converts domain X coordinate to grid CSS pixel coordinate.
+ *
+ * @param interactionX - X coordinate in domain units
+ * @param xScale - Linear scale for X axis
+ * @returns Grid X in CSS pixels, or null if conversion fails
+ */
+export declare function domainToGridX(interactionX: number, xScale: LinearScale): number | null;
+/**
+ * Converts grid CSS pixel coordinate to domain X coordinate.
+ *
+ * @param gridX - X coordinate in grid CSS pixels
+ * @param xScale - Linear scale for X axis
+ * @returns Domain X, or null if conversion fails
+ */
+export declare function gridToDomainX(gridX: number, xScale: LinearScale): number | null;
+/**
+ * Computes effective pointer state for sync mode.
+ *
+ * When interaction is driven by external synchronization (not mouse), derives
+ * a synthetic pointer position from the interaction X in domain units. Y is
+ * arbitrary (midpoint) since sync mode only tracks X.
+ *
+ * Returns null if interactionX is null or coordinate conversion fails.
+ *
+ * @param interactionX - X coordinate in domain units (or null if inactive)
+ * @param scales - Interaction scales for coordinate transformations
+ * @param gridArea - Grid area boundaries for canvas-local coordinate calculation
+ * @returns Effective pointer state, or null if sync mode is inactive
+ */
+export declare function computeSyncPointer(interactionX: number | null, scales: InteractionScales, gridArea: GridArea): PointerState | null;
+/**
+ * Resolves effective pointer state based on source mode.
+ *
+ * - Mouse mode: use the provided pointer state as-is
+ * - Sync mode: compute synthetic pointer from interaction X
+ *
+ * This enables unified rendering logic for both mouse-driven and externally
+ * synchronized interactions (e.g., chart sync).
+ *
+ * @param pointerState - Current pointer state
+ * @param interactionX - X coordinate in domain units (for sync mode)
+ * @param scales - Interaction scales for coordinate transformations
+ * @param gridArea - Grid area boundaries
+ * @returns Effective pointer state for rendering
+ */
+export declare function computeEffectivePointer(pointerState: PointerState, interactionX: number | null, scales: InteractionScales | null, gridArea: GridArea): PointerState;
+/**
+ * Normalizes interaction X value.
+ *
+ * Returns null for null, NaN, or Infinity values. This ensures consistent
+ * null-checking throughout the interaction system.
+ *
+ * @param x - Interaction X value to normalize
+ * @returns Normalized value or null
+ */
+export declare function normalizeInteractionX(x: number | null): number | null;
+/**
+ * Creates a listener management system for interaction X changes.
+ *
+ * Returns utilities for adding, removing, and notifying listeners.
+ *
+ * @returns Listener management utilities
+ */
+export declare function createInteractionXListeners(): {
+    add: (callback: (x: number | null, source?: unknown) => void) => void;
+    remove: (callback: (x: number | null, source?: unknown) => void) => void;
+    emit: (x: number | null, source?: unknown) => void;
+    clear: () => void;
+};
+/**
+ * Determines if interaction X should be updated based on value equality.
+ *
+ * Prevents redundant updates when the value and source haven't changed.
+ *
+ * @param current - Current interaction X value
+ * @param currentSource - Current source identifier
+ * @param next - New interaction X value
+ * @param nextSource - New source identifier
+ * @returns True if update is needed
+ */
+export declare function shouldUpdateInteractionX(current: number | null, currentSource: unknown, next: number | null, nextSource: unknown): boolean;
+//# sourceMappingURL=interactionHelpers.d.ts.map

package/dist/core/renderCoordinator/interaction/interactionHelpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interactionHelpers.d.ts","sourceRoot":"","sources":["../../../../src/core/renderCoordinator/interaction/interactionHelpers.ts"],"names":[],"mappings":"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"}

package/dist/core/renderCoordinator/render/renderAnnotationLabels.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Annotation Label Rendering Utilities
+ *
+ * Generates DOM-based annotation labels for cartesian charts.
+ * Handles template rendering, coordinate transformations, and styling
+ * for lineX, lineY, point, and text annotations.
+ *
+ * @module renderAnnotationLabels
+ */
+import type { ResolvedChartGPUOptions } from '../../../config/OptionResolver';
+import type { LinearScale } from '../../../utils/scales';
+import type { TextOverlay } from '../../../components/createTextOverlay';
+export interface AnnotationLabelRenderContext {
+    currentOptions: ResolvedChartGPUOptions;
+    xScale: LinearScale;
+    yScale: LinearScale;
+    canvasCssWidthForAnnotations: number;
+    canvasCssHeightForAnnotations: number;
+    plotLeftCss: number;
+    plotTopCss: number;
+    plotWidthCss: number;
+    plotHeightCss: number;
+    canvas: HTMLCanvasElement | OffscreenCanvas;
+}
+/**
+ * Renders annotation labels to the text overlay.
+ *
+ * Processes annotations and generates DOM labels with template support,
+ * coordinate transformations, and background styling.
+ *
+ * @param annotationOverlay - Text overlay for rendering labels
+ * @param overlayContainer - DOM container for overlay positioning
+ * @param context - Rendering context with scales, options, and layout
+ */
+export declare function renderAnnotationLabels(annotationOverlay: TextOverlay | null, overlayContainer: HTMLElement | null, context: AnnotationLabelRenderContext): void;
+//# sourceMappingURL=renderAnnotationLabels.d.ts.map

package/dist/core/renderCoordinator/render/renderAnnotationLabels.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderAnnotationLabels.d.ts","sourceRoot":"","sources":["../../../../src/core/renderCoordinator/render/renderAnnotationLabels.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,gCAAgC,CAAC;AAC9E,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,KAAK,EAAE,WAAW,EAAqB,MAAM,uCAAuC,CAAC;AAK5F,MAAM,WAAW,4BAA4B;IAC3C,cAAc,EAAE,uBAAuB,CAAC;IACxC,MAAM,EAAE,WAAW,CAAC;IACpB,MAAM,EAAE,WAAW,CAAC;IACpB,4BAA4B,EAAE,MAAM,CAAC;IACrC,6BAA6B,EAAE,MAAM,CAAC;IACtC,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,MAAM,EAAE,iBAAiB,GAAG,eAAe,CAAC;CAC7C;AAyED;;;;;;;;;GASG;AACH,wBAAgB,sBAAsB,CACpC,iBAAiB,EAAE,WAAW,GAAG,IAAI,EACrC,gBAAgB,EAAE,WAAW,GAAG,IAAI,EACpC,OAAO,EAAE,4BAA4B,GACpC,IAAI,CAuMN"}

package/dist/core/renderCoordinator/render/renderAxisLabels.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Axis Label Rendering Utilities
+ *
+ * Generates DOM-based axis labels and titles for cartesian charts.
+ * Labels are positioned using canvas-local CSS coordinates and rendered
+ * into a text overlay element.
+ *
+ * @module renderAxisLabels
+ */
+import type { ResolvedChartGPUOptions } from '../../../config/OptionResolver';
+import type { LinearScale } from '../../../utils/scales';
+import type { TextOverlay } from '../../../components/createTextOverlay';
+export interface AxisLabelRenderContext {
+    gpuContext: {
+        canvas: HTMLCanvasElement | OffscreenCanvas | null;
+    };
+    currentOptions: ResolvedChartGPUOptions;
+    xScale: LinearScale;
+    yScale: LinearScale;
+    xTickValues: ReadonlyArray<number>;
+    plotClipRect: {
+        left: number;
+        right: number;
+        top: number;
+        bottom: number;
+    };
+    visibleXRangeMs: number;
+}
+/**
+ * Renders axis labels and titles to the text overlay.
+ *
+ * Generates X and Y axis tick labels with appropriate formatting,
+ * and renders axis titles if configured.
+ *
+ * @param axisLabelOverlay - Text overlay for rendering labels
+ * @param overlayContainer - DOM container for overlay positioning
+ * @param context - Rendering context with scales, options, and layout
+ */
+export declare function renderAxisLabels(axisLabelOverlay: TextOverlay | null, overlayContainer: HTMLElement | null, context: AxisLabelRenderContext): void;
+//# sourceMappingURL=renderAxisLabels.d.ts.map

package/dist/core/renderCoordinator/render/renderAxisLabels.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderAxisLabels.d.ts","sourceRoot":"","sources":["../../../../src/core/renderCoordinator/render/renderAxisLabels.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,gCAAgC,CAAC;AAC9E,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,KAAK,EAAE,WAAW,EAAqB,MAAM,uCAAuC,CAAC;AAW5F,MAAM,WAAW,sBAAsB;IACrC,UAAU,EAAE;QACV,MAAM,EAAE,iBAAiB,GAAG,eAAe,GAAG,IAAI,CAAC;KACpD,CAAC;IACF,cAAc,EAAE,uBAAuB,CAAC;IACxC,MAAM,EAAE,WAAW,CAAC;IACpB,MAAM,EAAE,WAAW,CAAC;IACpB,WAAW,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACnC,YAAY,EAAE;QACZ,IAAI,EAAE,MAAM,CAAC;QACb,KAAK,EAAE,MAAM,CAAC;QACd,GAAG,EAAE,MAAM,CAAC;QACZ,MAAM,EAAE,MAAM,CAAC;KAChB,CAAC;IACF,eAAe,EAAE,MAAM,CAAC;CACzB;AAiBD;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAC9B,gBAAgB,EAAE,WAAW,GAAG,IAAI,EACpC,gBAAgB,EAAE,WAAW,GAAG,IAAI,EACpC,OAAO,EAAE,sBAAsB,GAC9B,IAAI,CA6HN"}