@abdullahjaswal/tickyr-charts-solid 0.1.0

package/dist/rendering/draw/candle.d.ts

@@ -0,0 +1,101 @@
+export interface DrawCandleBodyArgs {
+    readonly ctx: CanvasRenderingContext2D;
+    /** Body center x in CSS px. */
+    readonly x: number;
+    /** Half body width in CSS px. Total body footprint = 2 * halfBodyW. */
+    readonly halfBodyW: number;
+    /** Top y (smaller pixel value; canvas y grows downward). */
+    readonly bodyTop: number;
+    /** Bottom y (larger pixel value). Must be ≥ bodyTop (caller-clamped). */
+    readonly bodyBottom: number;
+    /** Per-corner radius (uniform on candle bodies). 0 = sharp. */
+    readonly cornerRadius: number;
+    /** Fill style. `null` skips the fill (Outline + opacity-0 case). */
+    readonly fillStyle: string | null;
+    /** Stroke color. `null` skips the stroke. */
+    readonly strokeStyle: string | null;
+    /** Stroke width in CSS px. Ignored when strokeStyle is null. */
+    readonly strokeWidth: number;
+}
+/** Draws a candle body - a rounded-rectangle delegated to drawBar.
+ *  Bodies always have all-round corners (cornerRadius applies uniformly to
+ *  all four; this differs from BarChart's bar-on-baseline rule because a
+ *  candle body doesn't sit on a baseline - it spans open ↔ close). */
+/** @ZeroAlloc - per-bar primitive. No heap allocation per call. */
+export declare function drawCandleBody(args: DrawCandleBodyArgs & {
+    readonly patternFill?: CanvasPattern | null;
+}): void;
+export interface DrawCandleWickArgs {
+    readonly ctx: CanvasRenderingContext2D;
+    /** Wick center x in CSS px (matches body center). */
+    readonly x: number;
+    /** Top y (smaller pixel value, corresponds to the high). */
+    readonly wickTop: number;
+    /** Bottom y (larger pixel value, corresponds to the low). */
+    readonly wickBottom: number;
+    /** Body's top y (smaller pixel value). The wick is SPLIT around the
+     *  body - the upper segment ends here and the lower segment never
+     *  enters here. Required because Outline-mode bodies have a translucent
+     *  interior and any wick drawn through them would visibly bleed
+     *  through (canonical candle rendering: wick is logically outside the
+     *  body - the body's edges already convey open/close). */
+    readonly bodyTop: number;
+    /** Body's bottom y (larger pixel value). The lower wick segment
+     *  starts here. */
+    readonly bodyBottom: number;
+    /** Stroke width in CSS px (default 1.4). */
+    readonly lineWidth: number;
+    /** Stroke color. */
+    readonly strokeStyle: string;
+}
+/** Draws a candle wick as TWO segments around the body - upper from the
+ *  high to the body's top edge, lower from the body's bottom edge to the
+ *  low. The wick never crosses the body interior, so translucent
+ *  (Outline-style) bodies don't get visible bleed-through and opaque
+ *  bodies don't waste overdraw. Either segment skips when its length
+ *  collapses to zero (e.g. high == body-top, low == body-bottom).
+ *
+ *  No pixel-snapping: the wick renders at exactly the input `x` so it
+ *  stays centered on the body (which doesn't pixel-snap either - body
+ *  width can be any sub-pixel value via `bodyWidthRatio` × slot, and
+ *  slot pitch is rarely integer at typical viewport sizes). At sub-
+ *  pixel `x` the canvas anti-aliases the stroke; that's acceptable
+ *  because the alternative - snapping the wick alone - drifts up to
+ *  0.8 px off the body's visible center, which is visibly wrong. */
+/** @ZeroAlloc - per-bar primitive. No heap allocation per call. */
+export declare function drawCandleWick(args: DrawCandleWickArgs): void;
+export interface DrawOhlcBarArgs {
+    readonly ctx: CanvasRenderingContext2D;
+    /** Bar center x in CSS px. */
+    readonly x: number;
+    /** Half tick width in CSS px. Total open/close tick footprint =
+     *  2 * halfTickW (each tick spans halfTickW pixels from x). Each
+     *  tick = 0.5 × bodyWidthRatio × slotWidth, so halfTickW =
+     *  0.5 × halfBodyW. The caller computes this. */
+    readonly halfTickW: number;
+    /** Top y (smaller pixel value, corresponds to the high). */
+    readonly highY: number;
+    /** Bottom y (larger pixel value, corresponds to the low). */
+    readonly lowY: number;
+    /** Open-tick y (the y at which the open price renders). Tick extends
+     *  LEFT of x by halfTickW. */
+    readonly openY: number;
+    /** Close-tick y. Tick extends RIGHT of x by halfTickW. */
+    readonly closeY: number;
+    /** Stroke width in CSS px. */
+    readonly lineWidth: number;
+    /** Stroke color (direction-aware: palette.up if close ≥ open, else
+     *  palette.down - caller resolves; this primitive just paints). */
+    readonly strokeStyle: string;
+}
+/** Draws a Western-style OHLC bar - vertical High–Low line, open tick to
+ *  the left, close tick to the right. Three line ops in a single
+ *  beginPath/stroke (one canvas op for the whole bar).
+ *
+ *  No pixel-snapping (consistent with `drawCandleWick`): renders at the
+ *  input `x` / `openY` / `closeY` exactly. Pixel-snapping the bar
+ *  centerline while leaving body geometry unsnapped causes visible
+ *  centering drift (see candle wick rationale); for OHLC there's no
+ *  body but consistency matters for cross-chart visual stability and
+ *  for accurately representing the open / close prices' actual y. */
+export declare function drawOhlcBar(args: DrawOhlcBarArgs): void;

package/dist/rendering/draw/connection-indicator.d.ts

@@ -0,0 +1,30 @@
+import { LiveState } from '../../domain';
+import { ConnectionIndicator, LegendPosition, VisualStyle } from '../../personalization';
+export interface DrawConnectionIndicatorArgs {
+    readonly ctx: CanvasRenderingContext2D;
+    readonly mode: ConnectionIndicator;
+    readonly state: LiveState;
+    readonly position: LegendPosition;
+    readonly visualStyle: VisualStyle;
+    /** Pre-resolved CSS rgba strings per state (caller picks from palette). */
+    readonly liveColor: string;
+    readonly staleColor: string;
+    readonly disconnectedColor: string;
+    /** Chart background color - used for pill Outline fill + behind-text. */
+    readonly bgColor: string;
+    /** Pre-resolved foreground (label text). */
+    readonly textColor: string;
+    /** Inner draw rect - anchor sits inside this with a small inset. */
+    readonly innerLeft: number;
+    readonly innerRight: number;
+    readonly innerTop: number;
+    readonly innerBottom: number;
+    /** Font + size for the indicator text. */
+    readonly font: string;
+    readonly fontSize: number;
+    /** ms clock for halo pulse phase. */
+    readonly now: number;
+    /** Collapse halo pulse to static when true. */
+    readonly reducedMotion: boolean;
+}
+export declare function drawConnectionIndicator(args: DrawConnectionIndicatorArgs): void;

package/dist/rendering/draw/crosshair.d.ts

@@ -0,0 +1,27 @@
+import { GridStyle } from './grid';
+export type CrosshairMarker = "none" | "circle" | "square";
+export interface DrawCrosshairArgs {
+    ctx: CanvasRenderingContext2D;
+    x: number;
+    y: number;
+    innerLeftPx: number;
+    innerRightPx: number;
+    innerTopPx: number;
+    innerBottomPx: number;
+    lineColor: string;
+    lineWidth: number;
+    lineStyle: GridStyle;
+    marker: CrosshairMarker;
+    markerSize: number;
+    /** Inner color (the "dot in the middle"). Typically the chart background
+     *  so the marker reads as a donut on top of the line. */
+    markerFill: string;
+    /** Outer ring color (typically the series line color). */
+    markerStroke: string;
+    /** Ring thickness in CSS px. Default 2 - wide enough that the donut
+     *  reads at a glance against a busy chart. */
+    markerStrokeWidth?: number;
+}
+/** @ZeroAlloc - runs on every pointermove + dynamic-layer frame. No
+ *  heap allocation; canvas primitives only. */
+export declare function drawCrosshair(args: DrawCrosshairArgs): void;

package/dist/rendering/draw/drawings.d.ts

@@ -0,0 +1,64 @@
+import { Drawing } from '../../domain/drawings';
+export interface DrawCtx {
+    ctx: CanvasRenderingContext2D;
+    /** Project a data-anchor (t, y) into pixel coords. */
+    toPxX: (t: number) => number;
+    toPxY: (y: number) => number;
+    /** Plot rect (in CSS px) - used for full-width / full-height lines
+     *  and for clipping. */
+    innerLeft: number;
+    innerRight: number;
+    innerTop: number;
+    innerBottom: number;
+    /** Default stroke + fill resolved by the chart from palette /
+     *  drawingDefault* axes. The drawing's own `style.color` overrides. */
+    defaultColor: string;
+    defaultLineWidth: number;
+    defaultLineStyle: "solid" | "dashed" | "dotted";
+    defaultFillOpacity: number;
+    /** Selected? Adds a subtle highlight + shows handles. */
+    selected: boolean;
+}
+export declare function drawTrendLine(d: Drawing, dctx: DrawCtx): void;
+export declare function drawHorizontalLine(d: Drawing, dctx: DrawCtx): void;
+export declare function drawVerticalLine(d: Drawing, dctx: DrawCtx): void;
+export declare function drawRectangle(d: Drawing, dctx: DrawCtx): void;
+export declare function drawEllipse(d: Drawing, dctx: DrawCtx): void;
+export declare function drawArrow(d: Drawing, dctx: DrawCtx): void;
+export declare function drawTextDrawing(d: Drawing, dctx: DrawCtx): void;
+export declare function drawFibRetracement(d: Drawing, dctx: DrawCtx): void;
+export declare function drawFibExtension(d: Drawing, dctx: DrawCtx): void;
+export declare function drawPitchfork(d: Drawing, dctx: DrawCtx): void;
+export declare function drawChannel(d: Drawing, dctx: DrawCtx): void;
+export declare function drawBrush(d: Drawing, dctx: DrawCtx): void;
+/** Single dispatch entry point. Switches on `type` and calls the
+ *  per-type primitive. Dispatch via discriminated
+ *  union - no Object.keys / iteration / typeof checks. */
+export declare function drawDrawing(d: Drawing, dctx: DrawCtx): void;
+/** Distance from point (px, py) to the closest pixel on drawing `d`.
+ *  Used by the chart's hit-test path. Returns Infinity when the point
+ *  is outside the drawing's bounding region. */
+export declare function distanceToDrawing(d: Drawing, px: number, py: number, dctx: DrawCtx): number;
+/** Fast bounding-box pre-filter for hit-test pipelines that iterate
+ *  many drawings (100+). Returns the px-space bbox of `d` plus a small
+ *  margin equal to `hitRadius`. Drawings whose bbox excludes the pointer
+ *  can skip the more expensive `distanceToDrawing` compute.
+ *
+ *  Coarse spatial filter; full quadtree integration
+ *  would need an async WASM Quadtree per drawings update which is heavier
+ *  than this O(N) bbox scan justifies for typical N < 1000. */
+export declare function drawingBoundsPx(d: Drawing, dctx: DrawCtx, hitRadius?: number): {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+};
+/** Optimized multi-drawing hit-test. Iterates drawings once, applying
+ *  the bbox prefilter; only drawings whose bbox encloses the pointer
+ *  fall through to the full `distanceToDrawing` compute. Returns the
+ *  closest hit within `hitRadius` (CSS px), or null. */
+export declare function findDrawingAt(drawings: readonly Drawing[], px: number, py: number, dctx: DrawCtx, hitRadius?: number): {
+    id: string;
+    distance: number;
+} | null;
+export declare function drawHandles(d: Drawing, dctx: DrawCtx): void;

package/dist/rendering/draw/grid.d.ts

@@ -0,0 +1,20 @@
+import { LinearScale } from '../../viewport/scales/linear';
+import { YAxisTickLike, XAxisTickLike } from './axis';
+export type GridStyle = "solid" | "dashed" | "dotted";
+export interface DrawGridArgs {
+    ctx: CanvasRenderingContext2D;
+    innerLeftPx: number;
+    innerRightPx: number;
+    innerTopPx: number;
+    innerBottomPx: number;
+    yTicks: readonly YAxisTickLike[];
+    yScale: LinearScale;
+    xTicks: readonly XAxisTickLike[];
+    xToPx: (tMs: number) => number;
+    color: string;
+    width: number;
+    style: GridStyle;
+    horizontalsVisible: boolean;
+    verticalsVisible: boolean;
+}
+export declare function drawGrid(args: DrawGridArgs): void;

package/dist/rendering/draw/indicator-band.d.ts

@@ -0,0 +1,17 @@
+export interface DrawIndicatorBandArgs {
+    readonly ctx: CanvasRenderingContext2D;
+    readonly times: Float64Array;
+    /** Upper bound (e.g. Bollinger +2σ). */
+    readonly upper: Float64Array;
+    /** Lower bound (e.g. Bollinger -2σ). */
+    readonly lower: Float64Array;
+    readonly startIdx: number;
+    readonly endIdx: number;
+    readonly xToPx: (t: number) => number;
+    readonly yScale: {
+        toPx(v: number): number;
+    };
+    /** Pre-resolved CSS color (rgba) - caller picks the alpha. */
+    readonly fillStyle: string;
+}
+export declare function drawIndicatorBand(args: DrawIndicatorBandArgs): void;

package/dist/rendering/draw/indicator-line.d.ts

@@ -0,0 +1,15 @@
+import { LinearScale } from '../../viewport/scales/linear';
+export interface DrawIndicatorLineArgs {
+    ctx: CanvasRenderingContext2D;
+    times: Float64Array;
+    values: Float64Array;
+    startIdx: number;
+    endIdx: number;
+    xToPx: (t: number) => number;
+    yScale: LinearScale;
+    strokeStyle: string;
+    lineWidth: number;
+    /** Reusable Path2D - caller-owned. */
+    path: Path2D;
+}
+export declare function drawIndicatorLine(args: DrawIndicatorLineArgs): void;

package/dist/rendering/draw/last-price.d.ts

@@ -0,0 +1,36 @@
+import { VisualStyle } from '../../personalization';
+export type LastPriceLineStyle = "off" | "solid" | "dashed" | "dotted";
+export interface DrawLastPriceLineArgs {
+    ctx: CanvasRenderingContext2D;
+    innerLeftPx: number;
+    innerRightPx: number;
+    yPx: number;
+    style: Exclude<LastPriceLineStyle, "off">;
+    color: string;
+    lineWidth: number;
+}
+export declare function drawLastPriceLine(args: DrawLastPriceLineArgs): void;
+export type PillSide = "left" | "right";
+export interface DrawLastPricePillArgs {
+    ctx: CanvasRenderingContext2D;
+    spineXPx: number;
+    side: PillSide;
+    yPx: number;
+    text: string;
+    directionColor: string;
+    chartBgColor: string;
+    fillTextColor: string;
+    visualStyle: VisualStyle;
+    font: string;
+    fontSize: number;
+    paddingX?: number;
+    paddingY?: number;
+    cornerRadius?: number;
+}
+export interface PillBox {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export declare function drawLastPricePill(args: DrawLastPricePillArgs): PillBox;

package/dist/rendering/draw/line.d.ts

@@ -0,0 +1,16 @@
+import { LinearScale } from '../../viewport/scales/linear';
+export interface DrawSparklineLineArgs {
+    ctx: CanvasRenderingContext2D;
+    times: Float64Array;
+    values: Float64Array;
+    startIdx: number;
+    endIdx: number;
+    xToPx: (t: number) => number;
+    yScale: LinearScale;
+    strokeStyle: string;
+    lineWidth: number;
+    path: Path2D;
+    areaBaselineY?: number | undefined;
+    areaFillStyle?: string | undefined;
+}
+export declare function drawSparklineLine(args: DrawSparklineLineArgs): void;

package/dist/rendering/draw/live-bar.d.ts

@@ -0,0 +1,31 @@
+import { LiveBarIndicator } from '../../personalization/personalization';
+export interface DrawLiveBarArgs {
+    readonly ctx: CanvasRenderingContext2D;
+    readonly mode: LiveBarIndicator;
+    /** Pixel position of the live point. */
+    readonly lastX: number;
+    readonly lastY: number;
+    /** Pre-resolved CSS color string for the directional accent (palette up/down). */
+    readonly directionColor: string;
+    /** Pre-resolved CSS color string for the palette accent tint (used by `outline`). */
+    readonly accentColor: string;
+    /** Chart background color (used by `outline` core cap + `badge` Outline fill). */
+    readonly bgColor: string;
+    /** Pre-resolved foreground / contrast color (used by `badge` Fill text). */
+    readonly fgColor: string;
+    /** visualStyle - Fill or Outline (only consumed by `badge`). */
+    readonly visualStyle: "Fill" | "Outline";
+    /** ms clock for animation phase. */
+    readonly now: number;
+    /** When true, collapse pulses to a static appearance. */
+    readonly reducedMotion: boolean;
+    /** Inner draw rect - used by `badge` to clamp pill placement. */
+    readonly innerLeft: number;
+    readonly innerRight: number;
+    readonly innerTop: number;
+    readonly innerBottom: number;
+    /** Font and size for `badge` text. */
+    readonly font: string;
+    readonly fontSize: number;
+}
+export declare function drawLiveBarIndicator(args: DrawLiveBarArgs): void;

package/dist/rendering/draw/markers.d.ts

@@ -0,0 +1,53 @@
+import { SignalMarker, OrderMarker, PositionMarker, EventMarker } from '../../domain/markers';
+export type SignalMarkerMode = "off" | "arrows + letter" | "arrows" | "flags" | "dots" | "arrows + label";
+export type OrderMarkerMode = "off" | "lines" | "arrows-only" | "lines + zone";
+export type PositionMarkerMode = "off" | "line + pnl-pill" | "arrows-only";
+export type EventMarkerMode = "off" | "glyph-axis" | "vertical-line" | "banner-strip";
+export interface MarkerPaintCtx {
+    ctx: CanvasRenderingContext2D;
+    toPxX: (t: number) => number;
+    toPxY: (y: number) => number;
+    innerLeft: number;
+    innerRight: number;
+    innerTop: number;
+    innerBottom: number;
+    upColor: string;
+    downColor: string;
+    neutralColor: string;
+    warnColor: string;
+    font: string;
+    fontSize: number;
+    /** Pre-formatted `${fontSize}px ${font}` for marker draws that don't
+     *  need bold/size variants. Caller pre-computes once per draw call.
+     *  Avoids per-marker template-string
+     *  allocation on charts with many markers. */
+    fontSpec: string;
+    /** Pre-formatted `bold ${fontSize}px ${font}`. */
+    fontSpecBold: string;
+    /** Pre-formatted `${fontSize - 1}px ${font}` - signal label size. */
+    fontSpecSmall: string;
+    /** Pre-formatted `bold ${fontSize - 2}px ${font}` - event/order ticker
+     *  badge size. */
+    fontSpecBoldSmaller: string;
+    /** Event-kind colors. When the host's palette includes `events.{kind}`
+     *  the chart resolves them; otherwise these default to the built-in
+     *  E=blue / D=green / S=purple / N=amber set. */
+    eventColors?: {
+        earnings?: string | undefined;
+        dividend?: string | undefined;
+        split?: string | undefined;
+        news?: string | undefined;
+    } | undefined;
+}
+export declare function drawSignalMarker(m: SignalMarker, mode: SignalMarkerMode, pctx: MarkerPaintCtx, 
+/** Bar's high y in px (where ▲ is anchored for sell). */
+barHighY: number, 
+/** Bar's low y in px (where ▲ is anchored for buy). */
+barLowY: number): void;
+export declare function drawOrderMarker(m: OrderMarker, mode: OrderMarkerMode, pctx: MarkerPaintCtx, 
+/** When true, draw the entry/SL/TP zone tints. */
+outlineFillOpacity: number): void;
+export declare function drawPositionMarker(m: PositionMarker, mode: PositionMarkerMode, pctx: MarkerPaintCtx, 
+/** Live last close - used to compute P&L pill. */
+lastClose: number): void;
+export declare function drawEventMarker(m: EventMarker, mode: EventMarkerMode, pctx: MarkerPaintCtx): void;

package/dist/rendering/draw/pane-divider.d.ts

@@ -0,0 +1,22 @@
+export interface DrawPaneDividerArgs {
+    readonly ctx: CanvasRenderingContext2D;
+    /** Divider y in CSS px. */
+    readonly yPx: number;
+    /** Inner-chart left edge. */
+    readonly innerLeftPx: number;
+    /** Inner-chart right edge. */
+    readonly innerRightPx: number;
+    /** Stroke color (typically a muted neutral from the palette). */
+    readonly lineColor: string;
+    /** Base stroke width. */
+    readonly lineWidth: number;
+    /** When `true`, an accent stroke is drawn underneath the line to
+     *  hint at the drag affordance. */
+    readonly hovered: boolean;
+}
+export declare function drawPaneDivider(args: DrawPaneDividerArgs): void;
+/** Returns `true` if `pointerY` is within `dragHandlePx` of the divider's
+ *  y-coordinate. Used by the pointer handler to decide whether the
+ *  cursor is over the drag-affordance band (cursor:row-resize, drag
+ *  starts on pointerdown). */
+export declare function paneDividerHitTest(pointerY: number, dividerY: number, dragHandlePx: number): boolean;

package/dist/rendering/draw/point-markers.d.ts

@@ -0,0 +1,23 @@
+import { MarkerStyle, ResolvedMarkerConfig } from '../../personalization/axes/point-markers';
+export declare function getShapePath(style: Exclude<MarkerStyle, "direction" | "custom">): Path2D;
+export declare function drawShapeAt(ctx: CanvasRenderingContext2D, shape: Path2D, x: number, y: number, halfSize: number, fillStyle: string | "none", strokeStyle: string | "none", strokeWidthPx: number): void;
+export interface DrawPointMarkersArgs {
+    readonly ctx: CanvasRenderingContext2D;
+    readonly times: Float64Array;
+    readonly values: Float64Array;
+    readonly startIdx: number;
+    readonly endIdx: number;
+    readonly xToPx: (t: number) => number;
+    readonly yScale: {
+        toPx(v: number): number;
+    };
+    readonly config: ResolvedMarkerConfig;
+    /** Pre-resolved CSS color for `'auto'` fill / stroke. Typically the
+     *  series line's resolved direction color. */
+    readonly autoColor: string;
+    /** Resolved palette.up color for `'direction'` style up-icons. */
+    readonly upColor: string;
+    /** Resolved palette.down color for `'direction'` style down-icons. */
+    readonly downColor: string;
+}
+export declare function drawPointMarkers(args: DrawPointMarkersArgs): void;

package/dist/rendering/glow/glow.d.ts

@@ -0,0 +1,40 @@
+import { Theme } from '../../personalization/palette';
+import { ResolvedGlow } from '../../personalization/axes/glow';
+/** Plot-rect (CSS px) - the glow's offscreen surface matches this region
+ *  exactly so blur stays clipped to the plot. */
+export interface GlowPlotRect {
+    readonly x: number;
+    readonly y: number;
+    readonly w: number;
+    readonly h: number;
+}
+/** Glow-pass draw callback. Called once per pass:
+ *  - `isGlowPass = true` → the caller draws into `ctx` using the halo
+ *    color resolver (or a constant color when `glow.color !== 'auto'`).
+ *    The draw should produce only the *shape mass* of the marks; strokes
+ *    can be thicker than normal for a fuller aura, but no axis chrome.
+ *  - `isGlowPass = false` → the caller draws the actual marks normally on
+ *    top of the glow.
+ *  The `ctx` is already translated so plot-rect origin maps to (0,0) on
+ *  glow passes; the caller does not need to re-apply the translate.
+ */
+export type GlowDrawCallback = (ctx: CanvasRenderingContext2D, isGlowPass: boolean) => void;
+export interface GlowOptions {
+    readonly glow: ResolvedGlow;
+    readonly theme: Theme;
+    readonly plotRect: GlowPlotRect;
+    /** Device-pixel ratio multiplier for the offscreen surface. Passed
+     *  separately so glow renders crisp on high-DPR displays without
+     *  forcing the caller to re-apply `setTransform`. */
+    readonly dpr: number;
+}
+/** Drop every cached offscreen surface. Hosts call this on
+ *  `onLowMemory` / `didReceiveMemoryWarning`. */
+export declare function clearGlowPool(): void;
+/** Run the glow compositor. When `glow.strength === 0`, this is a thin
+ *  pass-through that only invokes the sharp pass on the main context. */
+export declare function drawWithGlow(mainCtx: CanvasRenderingContext2D, opts: GlowOptions, draw: GlowDrawCallback): void;
+/** Resolve the halo stroke/fill color used in glow passes for a given
+ *  mark direction. Returns a CSS color string ready to assign to
+ *  `ctx.strokeStyle` / `ctx.fillStyle`. */
+export declare function resolveGlowHaloColor(glow: ResolvedGlow, theme: Theme, directionRgba: string): string;

package/dist/rendering/index.d.ts

@@ -0,0 +1,9 @@
+export { mountCanvas, type MountedCanvas } from './canvas';
+export { Slot, type SlotValue, COLOR_TABLE_SIZE, buildColorTable, packedToCssRgba, oklchToCssRgba, } from './color-tables';
+export { drawSparklineLine, type DrawSparklineLineArgs } from './draw/line';
+export { drawYAxis, drawXAxis, type DrawYAxisArgs, type DrawXAxisArgs, type YAxisPosition, type XAxisPosition, type XAxisTick, } from './draw/axis';
+export { drawGrid, type DrawGridArgs, type GridStyle, } from './draw/grid';
+export { drawCrosshair, type DrawCrosshairArgs, type CrosshairMarker, } from './draw/crosshair';
+export { drawIndicatorLine, type DrawIndicatorLineArgs, } from './draw/indicator-line';
+export { RenderPipeline, type FrameContext, type PipelineMiddleware, type DrawStage, } from './pipeline';
+export { DirtyRectAccumulator, type Rect } from './dirty-rect';

package/dist/rendering/layers/should-split.d.ts

@@ -0,0 +1,12 @@
+declare const SPLIT_MIN_PX = 200;
+export interface LayerSplitOptions {
+    readonly cssWidth: number;
+    readonly cssHeight: number;
+    /** When `true`, the chart is in sparkline mode; sparklines never use
+     *  the dynamic layer (no hover affordances). */
+    readonly sparkline?: boolean;
+}
+/** Decide whether to engage the two-canvas split. Returns `false` when
+ *  the chart is too small or in sparkline mode; `true` otherwise. */
+export declare function shouldUseLayerSplit(opts: LayerSplitOptions): boolean;
+export { SPLIT_MIN_PX };

package/dist/rendering/patterns/cross-hatch.d.ts

@@ -0,0 +1,4 @@
+/** Create or reuse a cross-hatch `CanvasPattern` for the given theme + DPR.
+ *  The pattern transforms with the receiving canvas's transform, so callers
+ *  use it directly as a fillStyle on the chart context. */
+export declare function getCrossHatchPattern(ctx: CanvasRenderingContext2D, themeIsDark: boolean, dpr: number): CanvasPattern | null;

package/dist/rendering/patterns/pattern-tiles.d.ts

@@ -0,0 +1,25 @@
+import { ResolvedPattern } from '../../personalization/axes/pattern';
+export declare function clearPatternTileCache(): void;
+/** Resolve a `CanvasPattern` for the given resolved pattern. Caches the
+ *  tile app-wide. Returns `null` for `'solid'` (no pattern → caller uses
+ *  the mark's plain fill style).
+ *
+ *  `colorOverride` lets the caller supply a per-mark resolved color
+ *  (e.g. computed via `resolvePatternColorAuto`) WITHOUT having to
+ *  spread/clone the whole `resolved` config. This
+ *  eliminates the per-mark `{ ...personalization.pattern, color }`
+ *  object literal that previously sat inside the candle / bar / pie /
+ *  histogram / sunburst / treemap draw loops.
+ *  - `colorOverride === null`: behave as before - use `resolved.color`,
+ *    falling back to `fillColor` when `resolved.color === "auto"`.
+ *  - `colorOverride !== null`: use it directly. */
+export declare function getPattern(ctx: CanvasRenderingContext2D, resolved: ResolvedPattern, fillColor: string, dpr: number, colorOverride?: string | null): CanvasPattern | null;
+/** OKLCH `L`-shift for `patternColor: 'auto'` resolution. In
+ *  Fill mode: shift up ~0.30 in light, down ~0.30 in dark, at ~40-45%
+ *  alpha. In Outline mode: ~55% alpha, no `L` shift.
+ *
+ *  For v1 we approximate via simple rgba math; the OKLCH-accurate
+ *  helper lands with 14.4 custom-palette helpers. The caller passes the
+ *  mark's CSS fill string and we return a shifted CSS color.
+ */
+export declare function resolvePatternColorAuto(fillCss: string, themeIsDark: boolean, outlineMode: boolean): string;

package/dist/rendering/pipeline.d.ts

@@ -0,0 +1,21 @@
+export interface FrameContext {
+    ctx: CanvasRenderingContext2D;
+    width: number;
+    height: number;
+    dpr: number;
+    nowMs: number;
+}
+export type DrawStage = (ctx: FrameContext) => void;
+export interface PipelineMiddleware {
+    name: string;
+    before?: DrawStage;
+    after?: DrawStage;
+}
+export declare class RenderPipeline {
+    private readonly middleware;
+    private primary;
+    use(mw: PipelineMiddleware): void;
+    setPrimary(fn: DrawStage): void;
+    run(ctx: FrameContext): void;
+    reset(): void;
+}

package/dist/rendering/stacked-layout.d.ts

@@ -0,0 +1,23 @@
+export type StackingResolved = "additive" | "normalized";
+export interface StackingInput {
+    /** Per-series values arrays. All MUST share the same length (validated at
+     *  the public API boundary by `validateStackingAlignment`). */
+    readonly values: readonly Float64Array[];
+}
+export interface StackingLayout {
+    /** Cumulative-top per series (same shape as input). NaN at column j when
+     *  any input series had NaN at j. */
+    readonly tops: readonly Float64Array[];
+    /** Cumulative-bottom per series. `baselines[0]` is all-zeros (or all-NaN
+     *  where a column is invalidated). */
+    readonly baselines: readonly Float64Array[];
+    /** Final cumulative top across all series at each column - i.e., the
+     *  topmost edge of the stack. Used for y-domain extension. NaN-propagating. */
+    readonly stackTop: Float64Array;
+    /** Mode used to build this layout (mirrors caller intent). */
+    readonly mode: StackingResolved;
+}
+/** Build a stacked layout from aligned series. `mode` derives from the
+ *  user-facing `stacked` axis - call sites translate `true` → 'additive'
+ *  and `'normalized'` → 'normalized'. */
+export declare function computeStackedLayout(input: StackingInput, mode: StackingResolved): StackingLayout;

package/dist/rendering/standardization-tokens.d.ts

@@ -0,0 +1,26 @@
+/** Minimum gap (in CSS px) between adjacent rectangular marks at slot
+ *  widths that allow it. Below this gap, the gap rule is suppressed
+ *  (the lib doesn't shrink bars below `MIN_MARK_SIZE_PX` to satisfy gap). */
+export declare const GAP_UNIT_PX = 2;
+/** Floor for any single visible mark in CSS px. Below this, marks would
+ *  go sub-pixel and disappear at deep zoom-out. The lib enforces this
+ *  even when the requested ratio would produce a smaller mark. */
+export declare const MIN_MARK_SIZE_PX = 1.5;
+/** Ceiling for any single mark in CSS px. Above this, the user is at
+ *  extreme zoom-in and individual marks become absurdly fat. The lib
+ *  caps here even when the slot would allow more. */
+export declare const MAX_MARK_SIZE_PX = 32;
+/** Resolve the visible width (CSS px) of a single mark inside a slot.
+ *  Used by BarChart, CandleChart, HistogramChart, RenkoChart bricks,
+ *  etc. - anything that lives in a per-x-slot rhythm.
+ *
+ *  Priority (highest first):
+ *    1. `MIN_MARK_SIZE_PX` floor - visible always wins over absent.
+ *    2. `MAX_MARK_SIZE_PX` ceiling - cap at extreme zoom-in.
+ *    3. `GAP_UNIT_PX` gap rule - if the slot has room, leave a 2px gap.
+ *    4. The user-supplied ratio.
+ *
+ *  At very small slots (`slotWidth < MIN + GAP`) the gap rule is
+ *  suppressed and the lib favors mark visibility over inter-mark gap.
+ */
+export declare function resolveMarkWidth(slotWidth: number, ratio: number): number;