@abdullahjaswal/tickyr-charts-solid 0.1.0

package/dist/personalization/palette/types.d.ts

@@ -0,0 +1,63 @@
+import { Oklch } from './oklch';
+export type Theme = "light" | "dark";
+export type ThemeInput = "inherit" | "light" | "dark" | "system";
+export type VisualStyle = "Fill" | "Outline";
+export interface PaletteVariant {
+    up: Oklch;
+    down: Oklch;
+    doji: Oklch;
+    neutral: Oklch;
+    /** Caution / amber - used for stale state (connection indicator + stale
+     *  banner). Must read as "warning" without competing with `up`/`down`. */
+    warn: Oklch;
+    accentTint: Oklch;
+    categorical: readonly Oklch[];
+    indicators: {
+        sma: Oklch;
+        ema: Oklch;
+        wma: Oklch;
+        bb: Oklch;
+        fib: Oklch;
+        rsi: Oklch;
+        macd: Oklch;
+        stochastic: Oklch;
+        atr: Oklch;
+        vwap: Oklch;
+    };
+    drawings: {
+        stroke: Oklch;
+        fill: Oklch;
+        handle: Oklch;
+        label: Oklch;
+    };
+    /** Optional event-kind colors. When absent,
+     *  the chart falls back to a built-in default for each kind. */
+    events?: {
+        earnings?: Oklch;
+        dividend?: Oklch;
+        split?: Oklch;
+        news?: Oklch;
+    };
+}
+/** Per-palette declaration of the tonal-symmetry rule.
+ *  When `'positive'` or `'negative'`, the
+ *  chosen direction renders with the opposite-direction's color as
+ *  its stroke and a fully-transparent interior (regardless of
+ *  `visualStyle`). The non-chosen direction renders normally per
+ *  `visualStyle`. `'none'` disables the rule - both directions render
+ *  by their own palette color per `visualStyle`. */
+export type TonalSymmetrySide = "positive" | "negative" | "none";
+export interface Palette {
+    name: string;
+    light: PaletteVariant;
+    dark: PaletteVariant;
+    tonalSymmetrySide: TonalSymmetrySide;
+    tonalSymmetryFlipInDarkMode: boolean;
+}
+export declare class PaletteValidationError extends Error {
+    readonly paletteName: string;
+    readonly missingSlot: string;
+    readonly name = "PaletteValidationError";
+    constructor(paletteName: string, missingSlot: string);
+}
+export declare function validatePaletteOrThrow(palette: Palette): void;

package/dist/personalization/personalization.d.ts

@@ -0,0 +1,137 @@
+import { Palette, Theme, ThemeInput, VisualStyle } from './palette';
+import { DigitGrouping, NumberAbbreviation, DecimalPlaces, CurrencyDisplay, PercentPrecision, DateFormat, TimeFormat } from './locale/formatter';
+import { BarEntryAnimation, BarUpdateAnimation, ThemeSwitchTransition } from './axes/animation';
+import { GlowInput, GlowColorInput, ResolvedGlow } from './axes/glow';
+import { PatternInput, PatternColorInput, ResolvedPattern } from './axes/pattern';
+import { NumberFormatInput, ResolvedNumberFormat } from './axes/number-format';
+/** Live-bar indicator modes. */
+export type LiveBarIndicator = "none" | "dot" | "badge" | "glow" | "outline" | "pulse-bar";
+/** Connection-indicator modes. */
+export type ConnectionIndicator = "off" | "dot" | "pill";
+/** Corner anchor for the legend. */
+export type LegendPosition = "top-left" | "top-right" | "bottom-left" | "bottom-right";
+/** Legend visibility. */
+export type LegendVisibility = "always" | "on-hover" | "off";
+/** Chart-wide stale-state visual treatment. */
+export type StaleVisualization = "none" | "desaturate-pulse" | "banner" | "desaturate-pulse + banner";
+export interface PersonalizationInput {
+    theme?: ThemeInput;
+    palette?: string;
+    osTheme?: Theme;
+    appTheme?: Theme;
+    visualStyle?: VisualStyle;
+    /** Interior fill color for outline-style marks.
+     *  `'auto'` derives from each mark's own stroke (up bodies tint up-color,
+     *  down tint down-color, etc.); a literal hex gives a uniform tint
+     *  regardless of direction. */
+    outlineFillColor?: "auto" | string | undefined;
+    /** Interior fill opacity for outline-style
+     *  marks, expressed as 0–100 (percent). Default 15. The lib internally
+     *  doubles the effective opacity in dark mode (so `15` renders at 30%
+     *  in dark) for perceived-contrast parity with light mode. */
+    outlineFillOpacity?: number | undefined;
+    /** Corner roundness in CSS px for rectangular
+     *  + arc-segment marks (BarChart bars, CandleChart bodies, RenkoChart
+     *  bricks, TreemapChart tiles, Pie/Donut arc tips, etc.). Default `3`
+     *  - modern aesthetic; bar-on-baseline / stacked-segment / Renko
+     *  adjacency rules suppress rounding on edges that meet a neighbor or
+     *  the axis baseline, so the visible result reads as one cohesive
+     *  shape regardless of grouping. `0` = sharp (legacy broker look). */
+    cornerRadius?: number | undefined;
+    /** Body / segment border width (CSS px,
+     *  ≥ 0). Default `1.4`. Applied uniformly in BOTH `Fill` and
+     *  `Outline` visualStyles: Fill mode strokes with the same color as
+     *  the fill (visual uniform), Outline mode strokes with the direction
+     *  color around the faintly-tinted interior. `0` = no border. */
+    borderWidth?: number | undefined;
+    liveBarIndicator?: LiveBarIndicator | undefined;
+    /** ms; 0 disables auto-detection. */
+    staleThreshold?: number | undefined;
+    connectionIndicator?: ConnectionIndicator | undefined;
+    legendPosition?: LegendPosition | undefined;
+    staleVisualization?: StaleVisualization | undefined;
+    legend?: LegendVisibility | undefined;
+    /** ISO 3166-1 alpha-3 country code. */
+    locale?: string | undefined;
+    digitGrouping?: DigitGrouping | undefined;
+    numberAbbreviation?: NumberAbbreviation | undefined;
+    decimalPlaces?: DecimalPlaces | undefined;
+    /** ISO 4217. Defaults to the country's default currency from the resolver. */
+    currency?: string | undefined;
+    currencyDisplay?: CurrencyDisplay | undefined;
+    percentPrecision?: PercentPrecision | undefined;
+    dateFormat?: DateFormat | undefined;
+    timeFormat?: TimeFormat | undefined;
+    /** IANA TZ identifier; falls through to the platform's default. */
+    timeZone?: string | undefined;
+    barEntryAnimation?: BarEntryAnimation | undefined;
+    barUpdateAnimation?: BarUpdateAnimation | undefined;
+    crosshairFadeDuration?: number | undefined;
+    tooltipFadeDuration?: number | undefined;
+    panZoomSmoothing?: boolean | undefined;
+    themeSwitchTransition?: ThemeSwitchTransition | undefined;
+    glow?: GlowInput | undefined;
+    glowColor?: GlowColorInput | undefined;
+    /** Host signal - when true, every "extra GPU work" axis collapses to its
+     *  cheapest setting. Glow is the first axis to honor this; later sweeps
+     *  (pattern, animations, DPR cap) follow the same convention. */
+    fastMode?: boolean | undefined;
+    pattern?: PatternInput | undefined;
+    patternScale?: number | undefined;
+    patternColor?: PatternColorInput | undefined;
+    numberFormat?: NumberFormatInput | undefined;
+    /** IANA TZ for market hours / session boundaries. Distinct from
+     *  `timeZone` (which formats user-facing labels). */
+    marketTimeZone?: string | undefined;
+    /** CSS font-family override for chart text. */
+    font?: string | undefined;
+}
+export interface Personalization {
+    theme: Theme;
+    palette: Palette;
+    visualStyle: VisualStyle;
+    outlineFillColor: "auto" | string;
+    /** 0–100. The dark-mode doubling rule is applied at draw time, not here
+     *  - consumers read this value as-is and call `effectiveOutlineAlpha`. */
+    outlineFillOpacity: number;
+    /** Corner roundness in CSS px (≥ 0). */
+    cornerRadius: number;
+    /** Body / segment border width in CSS px (≥ 0). */
+    borderWidth: number;
+    liveBarIndicator: LiveBarIndicator;
+    staleThreshold: number;
+    connectionIndicator: ConnectionIndicator;
+    legendPosition: LegendPosition;
+    staleVisualization: StaleVisualization;
+    legend: LegendVisibility;
+    /** ISO 3166-1 alpha-3 country code. */
+    locale: string;
+    digitGrouping: DigitGrouping;
+    numberAbbreviation: NumberAbbreviation;
+    decimalPlaces: DecimalPlaces;
+    /** ISO 4217. */
+    currency: string | undefined;
+    currencyDisplay: CurrencyDisplay;
+    percentPrecision: PercentPrecision;
+    dateFormat: DateFormat;
+    timeFormat: TimeFormat;
+    timeZone: string | undefined;
+    barEntryAnimation: BarEntryAnimation;
+    barUpdateAnimation: BarUpdateAnimation;
+    crosshairFadeDuration: number;
+    tooltipFadeDuration: number;
+    panZoomSmoothing: boolean;
+    themeSwitchTransition: ThemeSwitchTransition;
+    glow: ResolvedGlow;
+    fastMode: boolean;
+    pattern: ResolvedPattern;
+    numberFormat: ResolvedNumberFormat;
+    marketTimeZone: string | undefined;
+    font: string | undefined;
+}
+/** Apply the dark-mode-doubling rule to the
+ *  configured `outlineFillOpacity` (0–100) and clamp to [0, 1]. Returns the
+ *  alpha consumers should pass to color resolvers. */
+export declare function effectiveOutlineAlpha(personalization: Personalization): number;
+export declare function resolveTheme(input: ThemeInput, app: Theme, os: Theme): Theme;
+export declare function resolvePersonalization(input: PersonalizationInput): Personalization;

package/dist/personalization/tooltip-props.d.ts

@@ -0,0 +1,40 @@
+/** Common props every tooltip in the lib receives. Chart-specific
+ *  tooltips extend this with their `target` payload (hovered point,
+ *  candle, slice, etc.). */
+export interface BaseTooltipProps {
+    /** Pointer position relative to the chart container, CSS px. */
+    readonly pointerX: number;
+    readonly pointerY: number;
+    /** Container dimensions, CSS px. */
+    readonly containerWidth: number;
+    readonly containerHeight: number;
+    /** Active theme + palette at the time of hover. */
+    readonly theme: import('./palette').Theme;
+    readonly palette: import('./palette').Palette;
+    /** Active locale + timezone for value formatting. */
+    readonly locale: string;
+    readonly timeZone: string | undefined;
+}
+/** A tooltip slot's polymorphic input form. Used uniformly across
+ *  every tooltip prop (`tooltip`, `markerTooltip`, `signalTooltip`,
+ *  `orderTooltip`, `positionTooltip`, `eventTooltip`, `drawingTooltip`,
+ *  `extremeTooltip`, `volumeBarTooltip`, `livePriceLineTooltip`,
+ *  `indicatorTooltip`). Generic `P` is the chart-specific tooltip
+ *  props extending `BaseTooltipProps`. */
+export type TooltipInput<P> = false | true | ((props: P) => unknown);
+/** Resolved + normalized tooltip slot - the chart calls `mode === 'render'`
+ *  and invokes `render(props)` to materialise the tooltip, or skips when
+ *  `mode === 'off'`. */
+export type ResolvedTooltip<P> = {
+    readonly mode: "off";
+} | {
+    readonly mode: "default";
+} | {
+    readonly mode: "render";
+    readonly render: (p: P) => unknown;
+};
+export declare function resolveTooltip<P>(input: TooltipInput<P> | undefined): ResolvedTooltip<P>;
+/** Canonical list of tooltip-slot names the lib exposes.
+ *  Stored for audit + documentation; not used at runtime. */
+export declare const TOOLTIP_SLOT_NAMES: readonly ["tooltip", "markerTooltip", "signalTooltip", "orderTooltip", "positionTooltip", "eventTooltip", "drawingTooltip", "extremeTooltip", "volumeBarTooltip", "livePriceLineTooltip", "indicatorTooltip"];
+export type TooltipSlotName = (typeof TOOLTIP_SLOT_NAMES)[number];

package/dist/rendering/canvas.d.ts

@@ -0,0 +1,6 @@
+import { Viewport } from '../viewport';
+export interface MountedCanvas {
+    ctx: CanvasRenderingContext2D;
+    viewport: Viewport;
+}
+export declare function mountCanvas(canvas: HTMLCanvasElement, viewport: Viewport): MountedCanvas;

package/dist/rendering/color-tables.d.ts

@@ -0,0 +1,52 @@
+import { Oklch } from '../personalization/palette/oklch';
+import { Palette, Theme } from '../personalization/palette/types';
+export declare const Slot: {
+    readonly Up: 0;
+    readonly Down: 1;
+    readonly Doji: 2;
+    readonly Neutral: 3;
+    readonly AccentTint: 4;
+    readonly Warn: 5;
+    readonly IndicatorSma: 6;
+    readonly IndicatorEma: 7;
+    readonly IndicatorWma: 8;
+    readonly IndicatorBb: 9;
+    readonly IndicatorVwap: 10;
+    readonly IndicatorRsi: 11;
+    readonly IndicatorMacd: 12;
+    readonly IndicatorStochastic: 13;
+    readonly IndicatorAtr: 14;
+    readonly IndicatorFib: 15;
+    readonly DrawingStroke: 16;
+    readonly DrawingFill: 17;
+    readonly DrawingHandle: 18;
+    readonly DrawingLabel: 19;
+};
+export type SlotValue = (typeof Slot)[keyof typeof Slot];
+export declare const COLOR_TABLE_SIZE: number;
+export declare function buildColorTable(palette: Palette, theme: Theme): Uint32Array;
+/** Pre-cached CSS strings keyed by Slot enum + lazy per-alpha. Built
+ *  once per palette/theme change in each controller. Per-frame draws
+ *  read `get(slot)` (zero-alloc - returns the same cached string ref)
+ *  or `withAlpha(slot, alpha)` (cached per `(slot, alpha)` tuple after
+ *  the first call). Replaces ~100 per-draw `oklchToCssRgba(variant.X)`
+ *  call sites with one indexed read.
+ *
+ *  Contiguous Memory + Data-Oriented Design
+ *  (color packing as Uint32Array → string array) + Zero-Allocation
+ *  Fast Paths (no per-frame string allocation). */
+export declare class ColorStringTable {
+    private readonly fullAlpha;
+    private readonly alphaCache;
+    constructor(packed: Uint32Array);
+    /** Zero-alloc fast-path - returns the cached `rgba(r,g,b,1)` string. */
+    get(slot: SlotValue): string;
+    /** Allocating once per `(slot, alpha)` pair; cached thereafter. Use
+     *  when alpha varies per chart (e.g. faint fills, gradient stops). */
+    withAlpha(slot: SlotValue, alpha: number): string;
+}
+/** Convenience - build a packed table + string table together. */
+export declare function buildColorStringTable(palette: Palette, theme: Theme): ColorStringTable;
+export declare function packedToCssRgba(packed: number): string;
+export declare function oklchToCssRgba(o: Oklch, alpha?: number): string;
+export declare function withAlpha(css: string, alpha: number): string;

package/dist/rendering/dirty-rect-tracker.d.ts

@@ -0,0 +1,49 @@
+export interface Rect {
+    readonly x: number;
+    readonly y: number;
+    readonly w: number;
+    readonly h: number;
+}
+/** Fixed-capacity ring of dirty rects. Caller pushes rects throughout
+ *  the frame; the consumer calls `flushCoalesced()` to get the merged
+ *  rect (null when empty). */
+export declare class DirtyRectRing {
+    private xs;
+    private ys;
+    private ws;
+    private hs;
+    private idx;
+    private filled;
+    push(x: number, y: number, w: number, h: number): void;
+    /** Merge all pending rects into a single bounding box. Resets the
+     *  ring. Returns `null` when there's nothing pending. */
+    flushCoalesced(): Rect | null;
+    /** Flush all pending rects into `out` (length = number of rects).
+     *  The caller owns the array - pass a reused
+     *  scratch to avoid allocation. Returns count of populated entries.
+     *  Resets the ring. */
+    flushAll(out: Rect[]): number;
+    /** Discard any pending rects without producing a flush. */
+    clear(): void;
+    size(): number;
+}
+/** Centralised decision - should this chart use partial dirty-rect
+ *  repaints? Same threshold as the two-layer split for consistency. */
+export declare function shouldUseDirtyRects(cssWidth: number, cssHeight: number): boolean;
+/** Clip the canvas to the given rect + clear it. Caller must follow with
+ *  the draw commands, then `restoreDirtyClip(ctx)` once done. The
+ *  dynamic layer's per-frame clear is scoped to
+ *  the union of dirty rects, not the full canvas. */
+export declare function applyDirtyClip(ctx: CanvasRenderingContext2D, r: Rect): void;
+/** Multi-rect variant of `applyDirtyClip`. Composes N disjoint rects
+ *  into a single clip region by adding each as a sub-path before
+ *  `ctx.clip()` (canvas2d unions sub-paths into the clip). Clears each
+ *  rect individually so non-clipped pixels stay untouched.
+ *
+ *  This is the win-path for crosshair-style overlays where the bbox of
+ *  the union spans the whole plot area but the actual disturbed pixels
+ *  fit in a thin V-strip + H-strip + small marker dot. */
+export declare function applyDirtyClipMulti(ctx: CanvasRenderingContext2D, rects: readonly Rect[], count: number): void;
+/** Tear down the matching `ctx.save()` paired with `applyDirtyClip`
+ *  or `applyDirtyClipMulti`. */
+export declare function restoreDirtyClip(ctx: CanvasRenderingContext2D): void;

package/dist/rendering/dirty-rect.d.ts

@@ -0,0 +1,17 @@
+export interface Rect {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}
+export declare class DirtyRectAccumulator {
+    private dirty;
+    private minX;
+    private minY;
+    private maxX;
+    private maxY;
+    add(x: number, y: number, w: number, h: number): void;
+    get isDirty(): boolean;
+    union(out: Rect): boolean;
+    reset(): void;
+}

package/dist/rendering/draw/area-fill-threshold.d.ts

@@ -0,0 +1,19 @@
+import { CurveFactory } from 'd3-shape';
+export interface DrawAreaFillThresholdArgs {
+    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;
+    };
+    /** Domain-space threshold y. Polygons close down/up to this y. */
+    readonly thresholdY: number;
+    readonly aboveFill: string | CanvasGradient | CanvasPattern;
+    readonly belowFill: string | CanvasGradient | CanvasPattern;
+    /** Curve interpolator. Defaults to `curveLinear` if omitted. */
+    readonly curveFactory?: CurveFactory;
+}
+export declare function drawAreaFillThreshold(args: DrawAreaFillThresholdArgs): void;

package/dist/rendering/draw/area-fill.d.ts

@@ -0,0 +1,47 @@
+import { CurveFactory } from 'd3-shape';
+export interface DrawAreaFillArgs {
+    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;
+    };
+    /** Domain-space y baseline. Same value used for every column in the run. */
+    readonly baselineY: number;
+    /** Pre-resolved CSS color (rgba / hex / CanvasGradient string). */
+    readonly fillStyle: string | CanvasGradient | CanvasPattern;
+    /** Curve interpolator. Defaults to `curveLinear` if omitted. */
+    readonly curveFactory?: CurveFactory;
+    /** Pattern overlay. When non-null, drawn on top of
+     *  `fillStyle` using the same shape path. */
+    readonly patternFill?: CanvasPattern | null;
+}
+/** Stacked-band fill: per-x top + bottom (both curve-interpolated so the
+ *  two edges align cleanly). NaN at any column splits the band into
+ *  separate runs (same semantics as `drawAreaFill` for the top edge -
+ *  the upstream `computeStackedLayout` propagates NaN to both arrays so a
+ *  bad column shows on both edges).
+ *
+ *  Args are pre-validated parallel arrays; render
+ *  loop trusts the contract and emits canvas calls directly. */
+export interface DrawStackedAreaFillArgs {
+    readonly ctx: CanvasRenderingContext2D;
+    readonly times: Float64Array;
+    readonly tops: Float64Array;
+    readonly baselines: Float64Array;
+    readonly startIdx: number;
+    readonly endIdx: number;
+    readonly xToPx: (t: number) => number;
+    readonly yScale: {
+        toPx(v: number): number;
+    };
+    readonly fillStyle: string | CanvasGradient | CanvasPattern;
+    readonly curveFactory?: CurveFactory;
+    /** Pattern overlay. */
+    readonly patternFill?: CanvasPattern | null;
+}
+export declare function drawAreaFill(args: DrawAreaFillArgs): void;
+export declare function drawStackedAreaFill(args: DrawStackedAreaFillArgs): void;

package/dist/rendering/draw/area-gradient.d.ts

@@ -0,0 +1,35 @@
+export interface CreateAreaGradientArgs {
+    readonly ctx: CanvasRenderingContext2D;
+    readonly values: Float64Array;
+    readonly startIdx: number;
+    readonly endIdx: number;
+    readonly yScale: {
+        toPx(v: number): number;
+    };
+    /** Domain-space baseline y. Resolved upstream. */
+    readonly baselineY: number;
+    /** Line color at full opacity (rgba string). Top stop alpha is
+     *  multiplied by `fillOpacity`. */
+    readonly fullColor: string;
+    /** Same line color at zero alpha (rgba string). */
+    readonly transparentColor: string;
+}
+/** Returns null if the value range is empty (no finite values in window). */
+export declare function createAreaGradient(args: CreateAreaGradientArgs): CanvasGradient | null;
+/** Stacked-band gradient - fades from `fullColor` at the band's top edge
+ *  toward `transparentColor` at the band's bottom edge. Bounds derive from
+ *  the per-x `tops` and `baselines` (the band's pixel-y extent across the
+ *  visible window). NaN columns skipped. */
+export interface CreateStackedAreaGradientArgs {
+    readonly ctx: CanvasRenderingContext2D;
+    readonly tops: Float64Array;
+    readonly baselines: Float64Array;
+    readonly startIdx: number;
+    readonly endIdx: number;
+    readonly yScale: {
+        toPx(v: number): number;
+    };
+    readonly fullColor: string;
+    readonly transparentColor: string;
+}
+export declare function createStackedAreaGradient(args: CreateStackedAreaGradientArgs): CanvasGradient | null;

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

@@ -0,0 +1,65 @@
+import { LinearScale } from '../../viewport/scales/linear';
+export type YAxisPosition = "left" | "right";
+export type XAxisPosition = "top" | "bottom";
+/** Polymorphic tick shape accepted by `drawYAxis` + `drawGrid`'s `yTicks`.
+ *  Lets callers pass either `NiceTick { value, label }` or a tick with
+ *  `atMs` (category ticks projected as y-axis labels on horizontal bar
+ *  charts) without per-static-draw `.map()` adaptation. */
+export interface YAxisTickLike {
+    readonly value?: number;
+    readonly atMs?: number;
+    readonly label: string;
+}
+export interface DrawYAxisArgs {
+    ctx: CanvasRenderingContext2D;
+    ticks: readonly YAxisTickLike[];
+    yScale: LinearScale;
+    position: YAxisPosition;
+    innerLeftPx: number;
+    innerRightPx: number;
+    labelGap: number;
+    tickLength: number;
+    spineColor: string;
+    textColor: string;
+    font: string;
+    fontSize: number;
+    spineVisible: boolean;
+    ticksVisible: boolean;
+}
+export declare function drawYAxis(args: DrawYAxisArgs): void;
+export interface XAxisTick {
+    atMs: number;
+    label: string;
+    kind: number;
+}
+/** Polymorphic tick shape accepted by `drawXAxis`. Lets callers pass
+ *  either the engine's `XAxisTick { atMs, kind, label }` or a `NiceTick
+ *  { value, label }` without per-static-draw `.map()` adaptation
+ *  (zero-allocation static-draw paths). The function
+ *  reads `atMs ?? value` to resolve the numeric position. */
+export interface XAxisTickLike {
+    readonly atMs?: number;
+    readonly value?: number;
+    readonly label: string;
+    readonly kind?: number;
+}
+export interface DrawXAxisArgs {
+    ctx: CanvasRenderingContext2D;
+    ticks: readonly XAxisTickLike[];
+    xToPx: (tMs: number) => number;
+    position: XAxisPosition;
+    innerLeftPx: number;
+    innerRightPx: number;
+    innerTopPx: number;
+    innerBottomPx: number;
+    labelGap: number;
+    tickLength: number;
+    spineColor: string;
+    textColor: string;
+    font: string;
+    fontSize: number;
+    spineVisible: boolean;
+    ticksVisible: boolean;
+    rotationDeg: number;
+}
+export declare function drawXAxis(args: DrawXAxisArgs): void;

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

@@ -0,0 +1,31 @@
+export interface DrawBarArgs {
+    readonly ctx: CanvasRenderingContext2D;
+    /** Top-left x in CSS px. */
+    readonly x: number;
+    /** Top-left y in CSS px. */
+    readonly y: number;
+    /** Width in CSS px. Must be ≥ 0 (caller-clamped). */
+    readonly w: number;
+    /** Height in CSS px. Must be ≥ 0. */
+    readonly h: number;
+    /** Per-corner radii in CSS px. 0 = sharp. */
+    readonly tl: number;
+    readonly tr: number;
+    readonly br: number;
+    readonly bl: number;
+    /** Fill style. `null` skips the fill (e.g. Outline mode could go fill-
+     *  free, though by default Outline still draws the tinted interior). */
+    readonly fillStyle: string | CanvasGradient | CanvasPattern | null;
+    /** Stroke color. `null` skips the stroke. */
+    readonly strokeStyle: string | null;
+    /** Stroke width in CSS px. Ignored when strokeStyle is null. */
+    readonly strokeWidth: number;
+    /** Optional pattern overlay. When non-null, drawn on top
+     *  of `fillStyle` using the same shape path, letting both layers read
+     *  (base color + textured tile). The pattern's own alpha
+     *  ensures the base color shows through. */
+    readonly patternFill?: CanvasPattern | null;
+}
+/** @ZeroAlloc - per-bar draw primitive. No heap allocation per call.
+ *  Verified by `bun run lint:zero-alloc`. */
+export declare function drawBar(args: DrawBarArgs): void;

package/dist/rendering/draw/candle-live-treatment.d.ts

@@ -0,0 +1,43 @@
+import { LiveBarIndicator, VisualStyle } from '../../personalization';
+export interface CandleLiveTreatmentArgs {
+    ctx: CanvasRenderingContext2D;
+    mode: LiveBarIndicator;
+    /** Last bar's center x in CSS px. */
+    lastX: number;
+    /** Last bar's close y in CSS px. */
+    lastY: number;
+    /** Resolved body top y (after doji floor). */
+    bodyTop: number;
+    /** Resolved body bottom y. */
+    bodyBottom: number;
+    /** Last bar's wick top (= y of high). */
+    wickTop: number;
+    /** Last bar's wick bottom (= y of low). */
+    wickBottom: number;
+    /** Half body width in CSS px. */
+    halfBodyW: number;
+    /** Candle body's `cornerRadius` (in CSS px). The dotted-border
+     *  treatment matches this so the border traces the candle's actual
+     *  rounded silhouette instead of cutting across with sharp corners. */
+    cornerRadius: number;
+    /** Direction-aware accent color (already routed through tonal symmetry). */
+    directionColor: string;
+    /** Palette accent for badges. */
+    accentColor: string;
+    /** Chart background color (for badge fills). */
+    bgColor: string;
+    visualStyle: VisualStyle;
+    /** Current rAF time for animated modes. */
+    now: number;
+    /** When true, animated modes collapse to a static / non-pulsing form. */
+    reducedMotion: boolean;
+    /** Plot-rect bounds for badge clamping. */
+    innerLeft: number;
+    innerRight: number;
+    innerTop: number;
+    innerBottom: number;
+    /** Font + size for badge labels. */
+    font: string;
+    fontSize: number;
+}
+export declare function drawCandleLiveTreatment(args: CandleLiveTreatmentArgs): void;