@vninvestcharts/widget 0.0.0-stage → 0.2.0

package/dist/dts/widget/utils/headerSync.d.ts

@@ -0,0 +1,12 @@
+export interface HeaderTimeframeDeps {
+    getHandle: (chartId: string) => {
+        setTimeframe?: (timeframe: any, sourceChartId?: string) => void;
+    } | undefined;
+    broadcastTimeframe?: (chartId: string, timeframe: string) => void;
+    onConfigChange: (chartId: string, timeframe: string) => void;
+    /** syncSettings.timeframe (global toggle). */
+    syncEnabled: boolean;
+    /** syncOverrideMap?.[chartId]?.timeframe === false (source opted out). */
+    sourceOptedOut: boolean;
+}
+export declare function applyHeaderTimeframe(chartId: string, timeframe: string, deps: HeaderTimeframeDeps): void;

package/dist/dts/widget/utils/numberFormat.d.ts

@@ -0,0 +1,13 @@
+/**
+ * SSOT number formatting (V-02). One module, one output per input.
+ * Grouping is international (en-US); vi-VN locale is a P2 follow-up.
+ * Non-finite inputs render "n/a" (shared with resolveDisplayValue contract).
+ */
+/** Full-precision price: "81,325.38". Replaces d3 ",.2f" + toFixed(2) copies. */
+export declare function formatPrice(v: number): string;
+/** Volume: "1.2M" / "13K" / raw below 1000 (grid semantics, kept verbatim). */
+export declare function formatVolume(v: number): string;
+/** Signed change value: "+2,700.00" / "-300.50". */
+export declare function formatChangeValue(diff: number): string;
+/** Signed percent: "+2.04%" / "-0.62%". */
+export declare function formatPercent(pct: number): string;

package/dist/dts/widget/utils/paperTradeAdapters.d.ts

@@ -0,0 +1,11 @@
+/**
+ * WE2 P2-09: paperTradeAdapters
+ *
+ * Map engine replay types (ReplayPosition / ReplayExecutedTrade) → panel types
+ * (PaperTradePosition / PaperTradeJournalEntry) để PaperTradePanel render data thật.
+ * Không duplicate logic — chỉ mapping field.
+ */
+import type { ReplayPosition, ReplayExecutedTrade } from "../../lib/core/replay/replayTradingTypes";
+import type { PaperTradePosition, PaperTradeJournalEntry } from "../components/trading/PaperTradePanel";
+export declare function toPaperPosition(pos: ReplayPosition): PaperTradePosition;
+export declare function toPaperJournal(trade: ReplayExecutedTrade): PaperTradeJournalEntry;

package/dist/dts/widget/utils/pineSeriesData.d.ts

@@ -0,0 +1,71 @@
+import type { DataSourceConfig } from "@vninvestcharts/engine-core";
+import type { EnrichedDatum } from "../../lib/core/calculators/types";
+import type { PaneDescriptor } from "../../lib/core/types/pane-descriptor";
+/**
+ * Pine -> engine delivery channel (plan item 1.3).
+ *
+ * The engine already has an extension channel: `KernelEngine.resolveSeriesValues` reads
+ * `this.dataSource?.seriesData?.[series.id]` as PRIORITY 1, before its own closed
+ * `INDICATOR_ACCESSORS` table (`engine/KernelEngine.ts:3391`). Its table cannot name a type
+ * generated at runtime, so a `pine_<scriptId>` series falls through to `return []`
+ * (`engine/KernelEngine.ts:3447`) and draws nothing.
+ *
+ * Two hard constraints, both load-bearing:
+ *
+ * 1. The arrays are anchored to GLOBAL candle index, not to the visible window — the engine
+ *    slices the window itself (`engine/KernelEngine.ts:3393-3396`). Returning a window-length
+ *    array is what makes a value "drift when you zoom".
+ * 2. `na` must stay `undefined`. `missingValueFallback` (`engine/KernelEngine.ts:3357`) exists to
+ *    handle it. Substituting 0 would draw a line along the floor — a silent wrong answer that
+ *    looks plausible, which is the worst failure mode on a chart.
+ */
+export interface PineSeriesData {
+    /** Keyed by `series.id`, which is what the engine looks up. */
+    seriesData: Record<string, readonly (number | null | undefined)[]>;
+    /** Stable string of the Pine series currently present; drives the 1.3b re-push. */
+    signature: string;
+}
+/**
+ * Pure. Walks the pane descriptors, keeps only runtime-generated Pine series, and projects
+ * each one onto a global-index value array taken from `plotData`.
+ *
+ * `plotData` must be the widget's React-state array (memoised at `useWidgetData.ts:1283`), NOT
+ * `engine.enrichedData`: the latter is behind two hash-guarded push chokepoints
+ * (`VNInvestCharts.tsx:593,603` and `useWidgetData.ts:1336`), so reading it here would make
+ * this function silently return stale data. See plan M-1.
+ */
+export declare function buildPineSeriesData(panes: readonly PaneDescriptor[] | undefined, plotData: readonly EnrichedDatum[] | undefined): PineSeriesData;
+export interface PineCompileBars {
+    open: number[];
+    high: number[];
+    low: number[];
+    close: number[];
+    volume: number[];
+}
+/**
+ * Columnar OHLCV view of the enriched datums, which is what the compiler and the Pine worker
+ * expect. The single-chart mount site used to pass nothing at all, so the worker validated every
+ * script against ZERO bars — a second silent no-op next to the one Stage 1.1/1.2 fixed.
+ */
+export declare function toPineCompileBars(bars: readonly {
+    open?: number;
+    high?: number;
+    low?: number;
+    close?: number;
+    volume?: number;
+}[] | undefined): PineCompileBars;
+/** Ordered list of Pine series types present, independent of value. Cheap (O(#series)). */
+export declare function pineSeriesSignature(panes: readonly PaneDescriptor[] | undefined): string;
+export interface EngineDataSourceIdentity {
+    adapterLabel: string;
+    /** Optional upstream: `useForkRuntime` declares `activeSymbol?: string`. */
+    activeSymbol?: string;
+    activeTimeframe: string;
+}
+/**
+ * Builds the object handed to `EngineHost` -> `engine.setDataSource(...)`. Pure so that the
+ * caller can memoise on its inputs; `DataSourceConfig` is entirely optional
+ * (`vn-kline-engine-core/src/types.ts:88-94`), so omitting `seriesData` when there is no Pine
+ * script keeps the payload byte-identical to the pre-Pine shape.
+ */
+export declare function buildEngineDataSource(identity: EngineDataSourceIdentity, pine: PineSeriesData): DataSourceConfig;

package/dist/dts/widget/utils/rangeSync.d.ts

@@ -0,0 +1,29 @@
+export interface RelativePositionInput {
+    startRatio: number;
+    spanRatio: number;
+}
+export interface SyncRangeInput {
+    fromTs: number;
+    toTs: number;
+    relativePosition?: RelativePositionInput | null;
+}
+export type SyncResolveMethod = 'timestamp' | 'ratio-fallback' | 'no-data';
+export interface SyncRangeResolution {
+    fromIdx: number;
+    toIdx: number;
+    method: SyncResolveMethod;
+}
+export declare function resolveSyncIndexes(datesMs: number[], input: SyncRangeInput): SyncRangeResolution;
+export interface TimeRangeMs {
+    from: number;
+    to: number;
+}
+export declare function isEchoOfRange(incoming: TimeRangeMs | null | undefined, applied: TimeRangeMs | null | undefined): boolean;
+export declare function isContainedEcho(own: TimeRangeMs | null | undefined, applied: TimeRangeMs | null | undefined): boolean;
+export interface AnchorResolution {
+    fromIdx: number;
+    toIdx: number;
+    /** True when the timestamp fell outside local data and got clamped. */
+    clamped: boolean;
+}
+export declare function resolveAnchorIndexes(datesMs: number[], timestamp: number, spanBars: number): AnchorResolution;

package/dist/dts/widget/utils/telemetry.d.ts

@@ -0,0 +1,19 @@
+/**
+ * BL-18: library-safe observability hook (opt-in, zero bundled SDK).
+ * Hosts plug their own Sentry/Datadog/PostHog via the `onTelemetry` prop;
+ * without a handler this module is a no-op and adds 0 bytes of vendor code.
+ */
+export type WidgetTelemetryKind = "data-error" | "render-error" | "action";
+export interface WidgetTelemetryEvent {
+    kind: WidgetTelemetryKind;
+    /** Machine-readable code when available (see widgetErrors taxonomy). */
+    code?: string;
+    message: string;
+    context?: Record<string, unknown>;
+    timestamp: number;
+}
+export type WidgetTelemetryHandler = (event: WidgetTelemetryEvent) => void;
+export declare function emitTelemetry(handler: WidgetTelemetryHandler | undefined | null, kind: WidgetTelemetryKind, message: string, extra?: {
+    code?: string;
+    context?: Record<string, unknown>;
+}): void;

package/dist/dts/widget/utils/widgetEquality.d.ts

@@ -0,0 +1,57 @@
+import { type AxisSide, type ScaleSlotRuntimeState } from "@vninvestcharts/engine-core";
+import { type WidgetPaneRuntimeSnapshot, type WidgetRuntimeCapabilities } from "./widgetHelpers";
+export declare function areBoundsEqual(left: {
+    top: number;
+    left: number;
+    width: number;
+    height: number;
+}, right: {
+    top: number;
+    left: number;
+    width: number;
+    height: number;
+}): boolean;
+export declare function areHeaderAnchorEqual(left: {
+    top: number;
+    left: number;
+    width: number;
+}, right: {
+    top: number;
+    left: number;
+    width: number;
+}): boolean;
+export declare function areLabelAnchorEqual(left: {
+    top: number;
+    left: number;
+    height: number;
+}, right: {
+    top: number;
+    left: number;
+    height: number;
+}): boolean;
+export declare function areAxisBoundsEqual(left: Partial<Record<AxisSide, {
+    top: number;
+    left: number;
+    width: number;
+    height: number;
+}>>, right: Partial<Record<AxisSide, {
+    top: number;
+    left: number;
+    width: number;
+    height: number;
+}>>): boolean;
+export declare function areBoundsMapEqual(left: Record<string, {
+    top: number;
+    left: number;
+    width: number;
+    height: number;
+}>, right: Record<string, {
+    top: number;
+    left: number;
+    width: number;
+    height: number;
+}>): boolean;
+export declare function areDomainTupleEqual(left: readonly [number, number] | undefined, right: readonly [number, number] | undefined): boolean;
+export declare function areScaleSlotStatesEqual(left: Record<string, ScaleSlotRuntimeState>, right: Record<string, ScaleSlotRuntimeState>): boolean;
+export declare function arePaneSnapshotsEqual(left: readonly WidgetPaneRuntimeSnapshot[], right: readonly WidgetPaneRuntimeSnapshot[]): boolean;
+export declare function areRuntimeCapabilitiesEqual(left: WidgetRuntimeCapabilities | null | undefined, right: WidgetRuntimeCapabilities | null | undefined): boolean;

package/dist/dts/widget/utils/widgetErrors.d.ts

@@ -0,0 +1,29 @@
+/**
+ * BL-10: central error taxonomy for widget data/runtime failures.
+ * Every surfaced error carries a machine-readable `code`; UI layers map
+ * codes to i18n messages (see ERROR_MESSAGE_KEYS) instead of interpolating
+ * raw exception text.
+ */
+export type WidgetErrorCode = "DATA_FETCH" | "DATA_TIMEOUT" | "ADAPTER_AUTH" | "CACHE" | "VALIDATION" | "STORAGE" | "UNKNOWN";
+export declare const RETRYABLE_CODES: ReadonlySet<WidgetErrorCode>;
+export declare function isRetryableCode(code: WidgetErrorCode): boolean;
+/** i18n keys for user-facing messages (both locales must define them). */
+export declare const ERROR_MESSAGE_KEYS: Record<WidgetErrorCode, string>;
+export declare class WidgetError extends Error {
+    readonly code: WidgetErrorCode;
+    readonly context?: Record<string, unknown>;
+    constructor(code: WidgetErrorCode, message: string, context?: Record<string, unknown>);
+}
+export declare function toWidgetError(error: unknown, fallback?: WidgetErrorCode): WidgetError;
+export interface RetryOptions {
+    attempts?: number;
+    baseMs?: number;
+    maxMs?: number;
+    signal?: AbortSignal;
+}
+/**
+ * Retry wrapper with exponential backoff + jitter. Aborts immediately when
+ * `signal` fires (no retry on user cancellation). Non-retryable WidgetError
+ * codes (auth/validation) fail fast on the first attempt.
+ */
+export declare function withRetry<T>(fn: () => Promise<T>, options?: RetryOptions): Promise<T>;

package/dist/dts/widget/utils/widgetHelpers.d.ts

@@ -0,0 +1,395 @@
+import { type CSSProperties, type ReactNode } from "react";
+import { type PaneRuntimeSnapshot, type AxisSide, type VisibleRange as EngineVisibleRange } from "@vninvestcharts/engine-core";
+import { type EngineHostProps, type ChartHandle } from "@vninvestcharts/engine-react";
+import { type PaneDescriptor, type SeriesConfig, type ChartTheme, type SeriesTypeId, type VisibleRange } from "../../lib/core";
+import type { DrawingWorkspaceController, DrawingDockTab } from "@vninvestcharts/engine-react";
+import type { DrawingObject, DrawingAlertCondition, Point } from "@vninvestcharts/engine-drawing";
+import type { MagnetSensitivity } from "@vninvestcharts/engine-drawing";
+import type { ThemeConfig } from "../theme/ThemeConfig";
+import type { MeasurementPoint } from "@vninvestcharts/engine-drawing";
+import type { MeasurementCoordinateBridge } from "@vninvestcharts/engine-drawing";
+import { type StockDataAdapter, type Timeframe } from "../../lib/types/adapter";
+import { type OHLCVBar } from "../../lib/types/ohlcv";
+import { type EnrichedDatum } from "../../lib/core/calculators/types";
+import { type WhaleOrder, type CVDPoint, type DarkFlowSignalType, type AdvisoryResult, type TapeEntry } from "../../lib/types/vninvest";
+import { type BackfillWorkerFlags } from "../BackfillWorkerFlags";
+import { type RollbackEvent } from "../CanaryRollbackHelper";
+import { type WidgetLocale, type WidgetMessages } from "../i18n/types";
+import { type WidgetTimezone } from "../../lib/utils/timezoneFormatter";
+import { type RequestedWidgetRuntime, type ResolvedWidgetRuntime, type WidgetRuntimeReasonCode } from "../runtimePolicy";
+import { type DrawingDockProps } from "../components/drawing/DrawingDock";
+import { type SettingsModalProps } from "../components/settings/SettingsModal";
+import { type PaperTradePanelProps } from "../components/trading/PaperTradePanel";
+export declare const priceFormat: (value: number) => string;
+export declare const volumeFormat: (value: number) => string;
+export declare const dateFormat: (d: Date, p?: "yyyy-mm-dd" | "dd/mm/yyyy" | "mm/dd/yyyy") => string;
+export declare const intradayAxisFormat: (d: Date) => string;
+export declare const mixedAxisFormat: (d: Date, p?: string) => string;
+export declare const dailyAxisFormat: (d: Date, p?: "yyyy-mm-dd" | "dd/mm/yyyy" | "mm/dd/yyyy") => string;
+export declare const CHART_MARGIN: {
+    readonly left: 60;
+    readonly right: 68;
+    readonly top: 8;
+    readonly bottom: 28;
+};
+export declare const HISTORY_BACKFILL_PAGE_LIMIT = 5000;
+export declare const HISTORY_RECONCILE_MAX_PAGES = 12;
+export declare const HISTORY_MIN_RESIDENT_BARS = 240;
+export declare const FORK_DEGRADE_PIXEL_CHECK_DELAY_MS = 900;
+export declare const FORK_DEGRADE_PIXEL_RECHECK_DELAY_MS = 350;
+export declare const FORK_DEGRADE_REQUIRED_BLANK_CHECKS = 2;
+export type WidgetHistorySessionMode = "controlled" | "uncontrolled";
+export interface WidgetHistorySessionState {
+    requestKey: string;
+    mode: WidgetHistorySessionMode;
+    revision: number;
+}
+export interface ForkTooltipToken {
+    key: string;
+    label: string;
+    value: string;
+    color: string;
+}
+export interface ForkXAxisTick {
+    key: string;
+    x: number;
+    label: string;
+}
+export interface ForkXAxisHoverLabel {
+    x: number;
+    label: string;
+}
+export type WidgetPaneRuntimeSnapshot = PaneRuntimeSnapshot;
+export interface WidgetRuntimeCapabilities {
+    engineRuntime: ResolvedWidgetRuntime;
+    forkSupported: boolean;
+    paneToolbar: boolean;
+    paneSplitters: boolean;
+    chartCanvasOverlays: boolean;
+    measurementOverlay: boolean;
+    drawingOverlays: boolean;
+}
+export interface WidgetPaneToolbarActions {
+    toggleVisibility: () => void;
+    removePane: () => void;
+    addSeries: () => void;
+    toggleSeries: (seriesType: SeriesTypeId, seriesIndex?: number) => void;
+    removeSeries: (seriesType: SeriesTypeId, seriesIndex?: number) => void;
+}
+export interface WidgetPaneToolbarRenderContext {
+    pane: PaneDescriptor;
+    snapshot: WidgetPaneRuntimeSnapshot;
+    hovered: boolean;
+    actions: WidgetPaneToolbarActions;
+}
+export interface WidgetPaneSplitterRenderContext {
+    pane: PaneDescriptor;
+    snapshot: WidgetPaneRuntimeSnapshot;
+    splitterIndex: number;
+    top: number;
+    left: number;
+    right: number;
+}
+export interface WidgetDrawingChromeRenderContext {
+    activeTool: string;
+    drawingWorkspace: DrawingWorkspaceController | null;
+    isDark: boolean;
+    magnetSensitivity: MagnetSensitivity;
+    paneSnapshots: readonly WidgetPaneRuntimeSnapshot[];
+    selectedDrawing: DrawingObject | null;
+    visibleRange: VisibleRange | EngineVisibleRange | null;
+    size: {
+        width: number;
+        height: number;
+    };
+}
+export interface WidgetCoordinateBridge extends MeasurementCoordinateBridge {
+    engineRuntime: ResolvedWidgetRuntime;
+    paneSnapshots: readonly WidgetPaneRuntimeSnapshot[];
+    visibleRange: EngineVisibleRange;
+}
+export type WidgetRuntimeResolutionReason = WidgetRuntimeReasonCode | "FORK_RUNTIME_DEGRADED_NO_RENDER_OUTPUT";
+export interface VNInvestChartsRef {
+    exportDrawings(): DrawingObject[];
+    importDrawings(drawings: DrawingObject[]): void;
+    setTheme(config: ThemeConfig): void;
+    getTheme(): ThemeConfig;
+    getPlotData(): EnrichedDatum[];
+    getActiveIndicators(): SeriesConfig[];
+    onDataChange(callback: (data: EnrichedDatum[]) => void): () => void;
+    onIndicatorsChange(callback: (indicators: SeriesConfig[]) => void): () => void;
+    addIndicator(config: SeriesConfig): void;
+    addCompareSymbol: (symbolId: string) => void;
+    removeCompareSymbol: (symbolId: string) => void;
+    getCompareOverlaySymbols: () => string[];
+    getCompareOverlayEntries: () => Array<{
+        symbolId: string;
+        normalizeToBaseline: boolean;
+        visible: boolean;
+        color: string;
+        yAxis: "left" | "right";
+        lineWidth: number;
+    }>;
+    updateCompareOverlay: (symbolId: string, partial: Record<string, unknown>) => void;
+}
+/**
+ * Widget-level handle used by VNInvestMultiCharts to control individual charts.
+ * Extends the engine ChartHandle with replay + compare methods.
+ * Eliminates handle-as-any casts in proxy/delegation layers.
+ */
+export interface ReplayStateSnapshot {
+    playing: boolean;
+    speed: number;
+    currentBar: number;
+    totalBars: number;
+    currentBarTimestamp?: number;
+}
+export interface WidgetChartHandle extends ChartHandle {
+    getReplayState?(): ReplayStateSnapshot;
+    replayPlay?(): void;
+    replayPause?(): void;
+    replayStepForward?(): void;
+    replayStepBack?(): void;
+    replayRewind?(): void;
+    replayStop?(): void;
+    replaySetSpeed?(speed: number): void;
+    replaySeek?(barIndex: number): void;
+    replaySeekByTimestamp?(timestamp: number): void;
+    replaySelectStartBar?(): void;
+    replayCancelSelection?(): void;
+    getReplayTotalPnl?(): number;
+    getReplayAnalytics?(): import("../../lib/core/replay/ReplaySessionAnalytics").ReplayAnalyticsStats | undefined;
+    getReplayAwaitingStartBar?(): boolean;
+    addCompareSymbol?(symbolId: string): void;
+    removeCompareSymbol?(symbolId: string): void;
+    getCompareOverlaySymbols?(): string[];
+    getCompareOverlayEntries?(): Array<{
+        symbolId: string;
+        normalizeToBaseline?: boolean;
+        visible?: boolean;
+        color?: string;
+        yAxis?: "left" | "right";
+        lineWidth?: number;
+    }>;
+    updateCompareOverlay?(symbolId: string, partial: Record<string, unknown>): void;
+}
+export type ForkPointerContext = Parameters<NonNullable<EngineHostProps["onPointerDown"]>>[0];
+export type ForkManipulationSession = {
+    mode: "move" | "resize";
+    objectId: string;
+    objectIds: readonly string[];
+    baseDrawings: readonly DrawingObject[];
+    startChartPoint?: Point;
+    handleIndex?: number;
+    started: boolean;
+};
+export type ForkPointerOwner = "pane-toolbar" | "pane-splitter" | "drawing-chrome";
+export type ForkRubberBandSelection = {
+    startPixel: readonly [number, number];
+    currentPixel: readonly [number, number];
+};
+export interface VNInvestChartsProps {
+    adapter?: StockDataAdapter;
+    data?: readonly OHLCVBar[];
+    symbol?: string;
+    timeframe?: Timeframe;
+    drawingUiEnabled?: boolean;
+    drawingActiveTool?: string;
+    drawings?: readonly DrawingObject[];
+    defaultDrawings?: readonly DrawingObject[];
+    drawingStorageKey?: string;
+    defaultDrawingDockTab?: DrawingDockTab;
+    engineRuntime?: RequestedWidgetRuntime;
+    useWebGL?: boolean;
+    locale?: WidgetLocale;
+    messages?: Partial<WidgetMessages>;
+    theme?: ChartTheme;
+    timezone?: WidgetTimezone;
+    defaultTimezone?: WidgetTimezone;
+    onTimezoneChange?: (timezone: WidgetTimezone) => void;
+    panes?: readonly PaneDescriptor[];
+    xExtents?: readonly [Date | number, Date | number];
+    children?: ReactNode;
+    className?: string;
+    style?: CSSProperties;
+    measurementEnabled?: boolean;
+    selectedDrawing?: DrawingObject | null;
+    showDrawingPriceMarkers?: boolean;
+    showNonTradingDays?: boolean;
+    enableWhale?: boolean;
+    whaleThreshold?: number;
+    whaleOrders?: readonly WhaleOrder[];
+    enableCVD?: boolean;
+    cvdMode?: "oscillator" | "histogram";
+    externalCvdSeries?: readonly CVDPoint[];
+    darkFlowStrength?: number | null;
+    darkFlowSignalType?: DarkFlowSignalType;
+    suppressForkCanvasFallback?: boolean;
+    onClick?: (moreProps: {
+        currentItem?: EnrichedDatum;
+        currentCharts?: number[];
+        mouseXY?: [number, number];
+    }, event: unknown) => void;
+    onContextMenu?: (moreProps: {
+        currentItem?: EnrichedDatum;
+        currentCharts?: number[];
+        mouseXY?: [number, number];
+    }, event: unknown) => void;
+    onDrawingsChange?: (drawings: readonly DrawingObject[]) => void;
+    onSelectedDrawingChange?: (drawing: DrawingObject | null) => void;
+    onDrawingWorkspaceChange?: (workspace: DrawingWorkspaceController | null) => void;
+    onVisibleDomainChange?: (domain: [Date | number, Date | number]) => void;
+    onVisibleRangeChange?: (range: VisibleRange) => void;
+    onHistorySyncBusyChange?: (busy: boolean) => void;
+    onBarsChange?: (bars: readonly OHLCVBar[]) => void;
+    resetKey?: number;
+    onPaneSnapshotsChange?: (snapshots: readonly WidgetPaneRuntimeSnapshot[]) => void;
+    onPaneHover?: (paneId: string | null) => void;
+    onPaneToggleVisibleRequest?: (paneId: string) => void;
+    onPaneRemoveRequest?: (paneId: string) => void;
+    onPaneAddSeriesRequest?: (paneId: string) => void;
+    onPaneToggleSeriesRequest?: (paneId: string, seriesType: SeriesTypeId, seriesIndex?: number) => void;
+    onPaneRemoveSeriesRequest?: (paneId: string, seriesType: SeriesTypeId, seriesIndex?: number) => void;
+    onRuntimeCapabilitiesChange?: (capabilities: WidgetRuntimeCapabilities) => void;
+    onRuntimeResolved?: (runtime: ResolvedWidgetRuntime, reason: WidgetRuntimeResolutionReason) => void;
+    onCoordinateBridgeChange?: (bridge: WidgetCoordinateBridge | null) => void;
+    renderPaneToolbar?: (context: WidgetPaneToolbarRenderContext) => ReactNode;
+    renderPaneSplitter?: (context: WidgetPaneSplitterRenderContext) => ReactNode;
+    renderDrawingChrome?: (context: WidgetDrawingChromeRenderContext) => ReactNode;
+    onError?: (error: Error) => void;
+    onDrawingAlert?: (drawing: DrawingObject, condition: DrawingAlertCondition, currentPrice: number) => void;
+    showAdvisoryPanel?: boolean;
+    advisoryResult?: AdvisoryResult | null;
+    isAdvisoryLoading?: boolean;
+    onAdvisoryRefresh?: () => void;
+    showTapePanel?: boolean;
+    tapeEntries?: readonly TapeEntry[];
+    isTapeLoading?: boolean;
+    tapeFilterBillions?: number;
+    onTapeFilterChange?: (billions: number) => void;
+    showToolbar?: boolean;
+    showHeader?: boolean;
+    showFooter?: boolean;
+    renderToolbar?: (ctx: {
+        activeTool?: string;
+        onToolSelect: (tool: string) => void;
+    }) => ReactNode;
+    renderHeader?: (ctx: {
+        symbol?: string;
+        timeframe?: string;
+    }) => ReactNode;
+    renderFooter?: (ctx: {
+        timeframe?: string;
+        range?: string;
+    }) => ReactNode;
+    showDrawingDock?: boolean;
+    settingsOpen?: boolean;
+    onSettingsClose?: () => void;
+    onPaperTradePanelClose?: () => void;
+    /** @deprecated ReplayControlBarProps type preserved for backward compatibility. Was from ReplayControlBar (deleted S0.1) */
+    renderReplayBar?: (ctx: {
+        playing: boolean;
+        speed: number;
+        currentBar: number;
+        totalBars: number;
+        onPlay?: () => void;
+        onPause?: () => void;
+        onRewind?: () => void;
+        onStepBack?: () => void;
+        onStepForward?: () => void;
+        onSpeedChange?: (speed: number) => void;
+        onClose?: () => void;
+        onJumpToLatest?: () => void;
+    }) => ReactNode;
+    renderPaperTradePanel?: (ctx: PaperTradePanelProps) => ReactNode;
+    renderSettings?: (ctx: SettingsModalProps) => ReactNode;
+    renderDrawingDock?: (ctx: DrawingDockProps) => ReactNode;
+    historyMinResidentBars?: number;
+    maxVisibleBars?: number;
+    localCacheRoot?: string;
+    backfillWorkerFlags?: BackfillWorkerFlags;
+    canaryLevel?: 10 | 30 | 100;
+    onCanaryGateDecision?: (decision: {
+        previousLevel: 10 | 30 | 100;
+        currentLevel: 10 | 30 | 100;
+        metrics: {
+            visibleBarsTotal: number;
+            visibleBarsAfterFilter: number;
+            workersActive: {
+                externalBarsWorker: boolean;
+                lodWorker: boolean;
+            };
+            p95FrameTimeMs?: number;
+            requestCount?: number;
+        };
+        recommendation: "GO" | "NO-GO";
+        reason: string;
+    }) => void;
+    onCanaryRollbackEvent?: (event: RollbackEvent) => void;
+}
+export interface VNInvestChartsContentProps extends VNInvestChartsProps {
+    adapter: StockDataAdapter;
+    onRuntimeDegraded?: (reason: "fork-no-render-output") => void;
+}
+export declare function isWidgetTestEnvironment(): boolean;
+export declare function isPrimaryPriceSeries(type: SeriesTypeId): boolean;
+export declare function resolveTooltipSeriesColor(series: PaneDescriptor["series"][number], fallback: string): string;
+export declare function formatTooltipValue(value: number | undefined, formatter: ((value: number) => string) | undefined): string;
+export declare function buildForkTooltipTokens(pane: PaneDescriptor, datum: EnrichedDatum, textColor: string): ForkTooltipToken[];
+export declare function resolveDiscontinuousXExtents(extents: readonly [Date | number, Date | number] | undefined, data: readonly EnrichedDatum[], xAccessor: (datum: EnrichedDatum) => number): [number, number] | undefined;
+export declare function resolveDateDomainFromDiscontinuous(domain: [Date | number, Date | number], data: readonly EnrichedDatum[], xAccessor: (datum: EnrichedDatum) => number): [Date, Date];
+export declare function resolveEngineSeriesValueForRuntime(datum: EnrichedDatum, series: PaneDescriptor["series"][number]): number | undefined;
+export declare function buildLegacyPaneSnapshots(panes: readonly PaneDescriptor[], heights: readonly number[], canvasSize: {
+    width: number;
+    height: number;
+}, scaleSlotDomains: Record<string, [number, number]>): readonly WidgetPaneRuntimeSnapshot[];
+export declare function normalizePaneDescriptorsForExplicitScaleSlots(panes: readonly PaneDescriptor[]): PaneDescriptor[];
+export declare const FALLBACK_ADAPTER: StockDataAdapter;
+/**
+ * Wrap a StockDataAdapter to ensure correct source semantics for backfill.
+ *
+ * Problem: adapters that declare `coverageMode: "finite-snapshot"` cause
+ * `classifyGapReason` to tag ALL gaps as `boundary-exhausted`, which the
+ * backfill filter excludes — so no fetch ever happens even when the adapter
+ * supports `fetchBarsBefore`.
+ *
+ * This wrapper preserves the original adapter's semantics but corrects
+ * `coverageMode` to `anchor-before` and sets `supportsBackwardAnchor: true`
+ * when the adapter provides `fetchBarsBefore`.
+ */
+export declare function wrapAdapterForBackfill(adapter: StockDataAdapter): StockDataAdapter;
+export declare const NORMALIZED_DEFAULT_PANES: PaneDescriptor[];
+export declare function resolveVisiblePanes(panes: readonly PaneDescriptor[] | undefined): readonly PaneDescriptor[];
+export declare function inferAxisSideFromScaleSlotId(scaleSlotId: string): "left" | "right";
+export declare function mergePaneSnapshotDomains(snapshots: readonly WidgetPaneRuntimeSnapshot[], scaleSlotDomains: Record<string, [number, number]>, options?: {
+    preferSnapshotPriceDomains?: boolean;
+}): {
+    scaleSlotStates: {
+        [k: string]: {
+            side: AxisSide;
+            mode: "fixed" | "auto" | "normalized";
+            visible: boolean;
+            domain: readonly [number, number];
+        };
+    };
+    paneId: string;
+    bounds: import("@vninvestcharts/engine-core").Bounds;
+    plotBounds: import("@vninvestcharts/engine-core").Bounds;
+    axisBounds: Partial<Record<AxisSide, import("@vninvestcharts/engine-core").Bounds>>;
+    scaleSlotBounds: Record<string, import("@vninvestcharts/engine-core").Bounds>;
+    headerAnchor: {
+        top: number;
+        left: number;
+        width: number;
+    };
+    labelAnchor: {
+        top: number;
+        left: number;
+        height: number;
+    };
+}[];
+export declare function resolvePreferredScaleSlotId(snapshot: WidgetPaneRuntimeSnapshot, requestedScaleSlotId?: string): string | undefined;
+export declare function findPlotDataIndex(point: MeasurementPoint, data: readonly EnrichedDatum[]): number;
+export declare function findPlotDataIndexByTime(timestamp: number, data: readonly EnrichedDatum[]): number;
+export declare function resolveForkChartConfigScaleSlotId(snapshot: WidgetPaneRuntimeSnapshot): string;
+export { areBoundsEqual, areHeaderAnchorEqual, areLabelAnchorEqual, areAxisBoundsEqual, areBoundsMapEqual, areDomainTupleEqual, areScaleSlotStatesEqual, arePaneSnapshotsEqual, areRuntimeCapabilitiesEqual, } from "./widgetEquality";