@vninvestcharts/widget 0.0.0-stage → 0.2.0

package/dist/dts/widget/index.d.ts

@@ -0,0 +1,56 @@
+export { VNInvestCharts } from "./VNInvestCharts";
+export { VNInvestMultiCharts } from "./VNInvestMultiCharts";
+export { default as MeasurementOverlay } from "./MeasurementOverlay";
+export { WidgetErrorBoundary } from "./WidgetErrorBoundary";
+export { WidgetEmptyState } from "./WidgetEmptyState";
+export { WidgetI18nContext, WidgetI18nProvider, useWidgetI18n } from "./context/WidgetI18nContext";
+export { VNInvestChartsProvider, useHoverEmitterRef, VNInvestChartsConfigContext, VNInvestChartsConfigProvider, VNInvestChartsStateContext, VNInvestChartsStateProvider, useVNInvestChartsState, createHoverEmitter, emitHover, clearHover, useHoverSubscription, useHoverState, type HoverEventPayload, type HoverEmitter, } from "./context/VNInvestChartsContext";
+export type { VNInvestChartsProviderProps } from "./context/VNInvestChartsContext";
+export type { VNInvestChartsConfigContextValue } from "./context/VNInvestChartsConfigContext";
+export type { VNInvestChartsStateContextValue, PaneState, DrawingInteraction, ActiveToolState } from "./context/VNInvestChartsStateContext";
+export { resolveRequestedRuntime, shouldForceLegacyRuntime } from "./runtimePolicy";
+export type { WidgetI18nContextValue, WidgetI18nProviderProps } from "./context/WidgetI18nContext";
+export { widgetMessagesEn } from "./i18n/messages.en";
+export { widgetMessagesVi } from "./i18n/messages.vi";
+export type { WidgetLocale, WidgetMessages } from "./i18n/types";
+export type { RequestedWidgetRuntime, ResolvedWidgetRuntime, WidgetRuntimeReasonCode } from "./runtimePolicy";
+export type { VNInvestChartsProps, } from "./VNInvestCharts";
+export type { VNInvestMultiChartsProps, VNInvestMultiChartsRef, MultiChartConfig, ChartLayout, } from "./VNInvestMultiCharts";
+export type { VNInvestChartsRef } from "./utils/widgetHelpers";
+export type { WidgetCoordinateBridge, WidgetPaneRuntimeSnapshot, WidgetPaneSplitterRenderContext, WidgetPaneToolbarActions, WidgetPaneToolbarRenderContext, WidgetRuntimeCapabilities, WidgetRuntimeResolutionReason, } from "./utils/widgetHelpers";
+export type { DrawingWorkspaceController } from "@vninvestcharts/engine-react";
+export { createLocalStorageAdapter, createRESTStorageAdapter } from "@vninvestcharts/engine-drawing";
+export type { StockDataAdapter, Timeframe } from "../lib/types/adapter";
+export { toCacheKey, LocalCacheMatrixFactoryImpl } from "./history/cache";
+export type { CacheCoverageIndex, CacheEvictPolicy, CacheEvictResult, CacheInvalidateReason, CacheKey, CacheKeyParts, CacheReadResult, CacheSemanticScope, CacheSegmentMeta, CacheWriteMeta, CacheWriteResult, LocalCacheMatrix, LocalCacheMatrixFactory, TimeRange, } from "./history/cache";
+export { default as DrawingDock } from "./components/drawing/DrawingDock";
+export { default as DrawingInspector } from "./components/drawing/DrawingInspector";
+export { default as DrawingListPanel, generateDrawingLabel, filterDrawings, reorderDrawings } from "./components/drawing/DrawingListPanel";
+export { default as DrawingSemanticPointLegend } from "./components/drawing/DrawingSemanticPointLegend";
+export type { DrawingDockLabels, DrawingDockProps } from "./components/drawing/DrawingDock";
+export type { DrawingListPanelLabels, DrawingListPanelProps } from "./components/drawing/DrawingListPanel";
+export type { DrawingSemanticPointLegendLabels, DrawingSemanticPointLegendProps } from "./components/drawing/DrawingSemanticPointLegend";
+export type { DrawingInspectorLabels, DrawingInspectorProps, DrawingInspectorTextEditorLabels, DrawingInspectorTextEditorProps } from "./components/drawing/DrawingInspector";
+export { PaperTradePanel } from "./components/trading/PaperTradePanel";
+export type { PaperTradePanelProps, PaperTradePosition, PaperTradeJournalEntry } from "./components/trading/PaperTradePanel";
+export { SettingsModal } from "./components/settings/SettingsModal";
+export type { SettingsModalProps } from "./components/settings/SettingsModal";
+export { SnapshotPreviewModal } from "./components/settings/SnapshotPreviewModal";
+export type { SnapshotPreviewModalProps } from "./components/settings/SnapshotPreviewModal";
+export { MultiSourceDataAdapter } from "./adapters/MultiSourceDataAdapter";
+export type { MultiSourceDataAdapterConfig, SourceRoute } from "./adapters/MultiSourceDataAdapter";
+export { BottomPanelHost } from "./components/BottomPanelHost";
+export type { BottomPanelHostProps, BottomTab } from "./components/BottomPanelHost";
+export { VNSymbolSearch, SymbolSearch } from "./components/search/VNSymbolSearch";
+export type { VNSymbolSearchProps } from "./components/search/VNSymbolSearch";
+export type { SymbolSearchItem } from "./types/symbolSearch";
+export { WhalePanel } from "./components/overlays/WhalePanel";
+export type { WhalePanelProps } from "./components/overlays/WhalePanel";
+export { SaaSFeatureProvider, SaaSFeatureContext } from "./contexts/SaaSFeatureContext";
+export { useFeatureGate } from "./hooks/useFeatureGate";
+export { PremiumFeatureGate } from "./components/PremiumFeatureGate";
+export type { SaaSFeatureFlags, TenantMetadata, SaaSFeatureContextValue } from "./types/saas";
+export type { PremiumFeatureGateProps } from "./components/PremiumFeatureGate";
+export { WorkspaceSerializer } from "./runtime/WorkspaceSerializer";
+export type { WorkspaceSchema, WorkspaceSettings } from "./runtime/WorkspaceSerializer";
+export { injectVNInvestChartsCSS } from "./styles/injectStyles";

package/dist/dts/widget/multiChartDefaults.d.ts

@@ -0,0 +1,18 @@
+import { type PatTier } from "@vninvestcharts/engine-core";
+import type { ChartLayout } from "@vninvestcharts/engine-react";
+import type { GridLayout } from "./grid/types";
+import type { MultiChartConfig } from "./VNInvestMultiCharts.types";
+export declare const DEFAULT_LAYOUTS: Record<string, ChartLayout>;
+/**
+ * S5a: số chart tối đa theo tier (ma trận chốt, sửa đổi 2026-09-24 theo quyết
+ * định user: Free/Starter/unknown = 2 để nếm, Pro = 4 (mở 1x3 + 2x2),
+ * Enterprise+ = full).
+ * Enterprise KHÔNG kẹp 4–6 để giữ nguyên preset 8 ô (2x4) sẵn có cho khách trả phí.
+ */
+export declare function resolveMaxChartsForTier(tier: PatTier | undefined): number;
+/** S5a: đếm chart của layout (slots tường minh, không thì rows*cols). */
+export declare function countLayoutCharts(layout: ChartLayout): number;
+/** S5a: kẹp layout về 1x2 khi vượt max (giữ nguyên khi đủ). */
+export declare function clampChartLayoutToMax(layout: ChartLayout, maxCharts: number): ChartLayout;
+export declare function chartLayoutToGridLayout(chartLayout: ChartLayout, charts: MultiChartConfig[]): GridLayout;
+export declare function gridLayoutToChartLayout(gl: GridLayout): ChartLayout;

package/dist/dts/widget/paneInteractionUtils.d.ts

@@ -0,0 +1,25 @@
+type PaneSnapshotLike = {
+    paneId: string;
+    bounds: {
+        left: number;
+        width: number;
+        top: number;
+        height: number;
+    };
+    headerAnchor: {
+        top: number;
+    };
+};
+type PanePointerEventLike = {
+    currentTarget: {
+        getBoundingClientRect: () => {
+            left: number;
+            top: number;
+        };
+    };
+    clientX: number;
+    clientY: number;
+};
+export declare function resolveHoveredPaneId(event: PanePointerEventLike, snapshots: readonly PaneSnapshotLike[]): string | null;
+export declare function findPaneSnapshotAtPosition<T extends PaneSnapshotLike>(snapshots: readonly T[], localX: number, localY: number): T | undefined;
+export {};

package/dist/dts/widget/patterns/autoPatternScan.d.ts

@@ -0,0 +1,77 @@
+/**
+ * A10 — the scan policy, i.e. the plan's runtime constraints expressed as
+ * one pure function the UI and the tests both go through.
+ *
+ * PLAN_FRONTEND_PROPLUS_TRACKA_2026-09-28 §3.9:
+ *   §3.9.1 anti-look-ahead → `asOf` is the last **closed** bar.
+ *   §3.9.3 off on mobile and at `free` → the caller passes `enabled`, which
+ *          comes from the `auto_pattern` capability (already `DEVICE_HEAVY`
+ *          and already `pro`-gated in `CapabilityResolver`).
+ *   §3.9.4 never in the background while panning or zooming → `idle` must be
+ *          true. A scan is a decision the user made, not a background job.
+ *   §3.9.5 at most 12 patterns per series.
+ *
+ * Kept pure so every one of those is testable without a chart, and so the
+ * rule "no scan during a gesture" cannot be satisfied in the UI and broken in
+ * the engine.
+ */
+import { detectChartPatterns, type DetectedPattern, type PatternBar, type PatternShapeId } from "@vninvestcharts/engine-core";
+export interface ScanRequest {
+    readonly bars: readonly PatternBar[];
+    /** Capability gate result. `false` covers both `free` and narrow devices. */
+    readonly enabled: boolean;
+    /**
+     * `true` when the scan was triggered deliberately — the panel is open, or
+     * the host's idle callback fired. A pan or zoom in progress sets this
+     * `false` and the scan is skipped entirely.
+     */
+    readonly idle: boolean;
+    /**
+     * Shapes the user has selected. `undefined` means all shipped shapes;
+     * an **empty array means none**. Collapsing `[]` to "everything" would
+     * make "Clear all" followed by "Scan" quietly draw every pattern the user
+     * had just switched off.
+     */
+    readonly shapes?: readonly PatternShapeId[];
+    /**
+     * How many trailing bars are still forming. `1` on a live chart, `0` on
+     * a historical one. Those bars are excluded from the scan so a live bar
+     * can never confirm a pattern.
+     */
+    readonly formingBars?: number;
+    /** Plan §3.9.5. */
+    readonly maxPatterns?: number;
+    /** Extra detector options, for hosts that want to tune the noise floor. */
+    readonly detector?: Parameters<typeof detectChartPatterns>[1];
+}
+export type ScanSkipReason = "disabled" | "busy" | "no-data";
+export interface ScanResult {
+    readonly patterns: readonly DetectedPattern[];
+    readonly skipped: ScanSkipReason | null;
+}
+/**
+ * Run a scan, or explain why not.
+ *
+ * `skipped` is returned rather than an empty `patterns` array so a caller
+ * can tell "scanned, found nothing" from "did not scan" — the difference
+ * matters for the empty-state copy, and for the test that asserts the
+ * gesture rule.
+ */
+export declare function runAutoPatternScan(request: ScanRequest): ScanResult;
+/** Human-facing numbers for the picker; kept here so the panel stays dumb. */
+export interface PatternSummary {
+    readonly id: string;
+    readonly shape: PatternShapeId;
+    readonly direction: "bullish" | "bearish";
+    /** 0..1, as reported by the detector. */
+    readonly confidence: number;
+    readonly rSquared: number;
+    readonly barsInPattern: number;
+    /**
+     * `true` when the gating R² had fewer than three samples and so carries
+     * no information. Surfaced rather than hidden: a "R² 1.00" badge on a
+     * two-point neckline is a claim the number cannot support.
+     */
+    readonly degenerateFit: boolean;
+}
+export declare function summarizePatterns(patterns: readonly DetectedPattern[]): PatternSummary[];

package/dist/dts/widget/patterns/patternDrawingFactory.d.ts

@@ -0,0 +1,87 @@
+/**
+ * A10 — turn detected patterns into drawings.
+ *
+ * PLAN_FRONTEND_PROPLUS_TRACKA_2026-09-28 §3.9. The engine's detector
+ * describes shapes in *data* space (bar index + price) and knows nothing
+ * about renderers; this module is the seam that maps them onto drawings the
+ * existing layer already knows how to draw, hit-test, persist and list.
+ *
+ * ## Why the shape → drawing-type map is what it is
+ *
+ * - `headAndShoulders` / `inverseHeadAndShoulders` → the existing manual
+ *   `headAndShoulders` tool. Its 7-point layout is LS·LV·H·RV·RS·NL·NR and
+ *   the detector emits exactly those seven anchors, so a detected H&S and a
+ *   hand-placed one are literally the same drawing. That is the geometry
+ *   reuse the brief asked for, and it also inherits the tool's dashed
+ *   neckline rendering.
+ * - `doubleTop` / `doubleBottom` / `triangle` → `polyline`. `polyline` has no
+ *   segment-registry entry, so the generic branch walks all N-1 edges of the
+ *   detected anchors with nothing dropped.
+ *
+ *   The manual `trianglePattern` tool is the obvious host and is wrong on two
+ *   independent counts, both measured in
+ *   `__tests__/harmonicPatternSegments.test.ts`:
+ *
+ *   1. It drops edges. Its registry entry declares 2 segment keys for a
+ *      5-point closed shape, so `buildHarmonicPatternPrimitive` draws one
+ *      sequential edge plus the dashed closing line and discards the other
+ *      three. (Same defect class, same builder, also affects `cypherPattern`,
+ *      `threeDrivesPattern` and `headAndShoulders`.)
+ *   2. Fixing (1) would NOT make it a valid host, because the geometries do
+ *      not match. The detector's `triangle` emits FOUR anchors
+ *      (`upperA·upperB·lowerB·lowerA`); the tool takes FIVE points
+ *      (`H1·L1·H2·L2·apex`). Fed four anchors, the tool emits five labels —
+ *      `H1 L1 H2 L2 apex` — against four pixels, so `apex` has no coordinate
+ *      at all and the shape is silently wrong. A detected triangle is an open
+ *      four-point wedge; it has no apex point to give.
+ *
+ *   So `polyline` stays, and (2) is the reason that outlives an engine fix.
+ *   Re-hosting these on the pattern primitives is a detector-side change
+ *   (either emit the 5th anchor, or add a 4-point triangle tool), not a
+ *   widget-side one.
+ *
+ * The cost of that choice is that the anchors carry no per-point role
+ * badges, so the pattern's meaning travels in the drawing `label` — which
+ * is also where the confidence and R² are surfaced, and what the objects
+ * list shows.
+ */
+import type { DrawingObject, DrawingToolType } from "@vninvestcharts/engine-drawing";
+import type { DetectedPattern, PatternShapeId } from "@vninvestcharts/engine-core";
+export interface PatternDrawingLabels {
+    /** e.g. "Head & shoulders" — resolved through i18n by the caller. */
+    shape: (shape: PatternShapeId) => string;
+    /** e.g. "confirmed · 82% · R²0.91" */
+    detail: (pattern: DetectedPattern) => string;
+}
+/** Drawing type each detected shape is rendered as. */
+export declare const PATTERN_DRAWING_TYPE: Readonly<Record<PatternShapeId, DrawingToolType>>;
+/**
+ * Anchor role sequence per shape, in the order the polyline should walk.
+ *
+ * The detector already emits anchors in drawing order, so this is a
+ * *contract* rather than a transform: a pattern whose role sequence does not
+ * match is refused rather than drawn approximately. It is a sequence and not
+ * a set on purpose — `doubleBottom` legitimately contains the role `trough`
+ * twice (its two bottoms), which a role→anchor map would silently collapse
+ * into one point and draw a broken shape.
+ */
+export declare const PATTERN_ANCHOR_ORDER: Readonly<Record<PatternShapeId, readonly string[]>>;
+/** Group id so every auto-detected pattern collapses to one tree entry. */
+export declare const AUTO_PATTERN_GROUP_ID = "vnsc-auto-patterns";
+export interface PatternDrawingOptions {
+    readonly labels: PatternDrawingLabels;
+    readonly stroke?: string;
+    /** Existing drawings, so ids and z-order can be derived deterministically. */
+    readonly existing?: readonly DrawingObject[];
+    readonly zIndex?: number;
+}
+/**
+ * Convert one detected pattern into a drawing.
+ *
+ * Returns `null` for a pattern whose anchors do not match the shape's
+ * documented layout — a mismatch here would silently draw a wrong shape, so
+ * it is refused rather than approximated.
+ */
+export declare function toPatternDrawing(pattern: DetectedPattern, options: PatternDrawingOptions): DrawingObject | null;
+/** Convert a scan result, dropping anything that will not map. */
+export declare function toPatternDrawings(patterns: readonly DetectedPattern[], options: PatternDrawingOptions): DrawingObject[];

package/dist/dts/widget/plugin/ProPluginRegistry.d.ts

@@ -0,0 +1,40 @@
+import type { DrawingToolDefinition } from "@vninvestcharts/engine-drawing";
+import type { RegistryEntry } from "../../lib/core/registry/SeriesRegistry";
+import type { SeriesTypeId } from "../../lib/core/types/pane-descriptor";
+export interface ProSeriesDefinition {
+    type: SeriesTypeId;
+    entry: RegistryEntry;
+}
+/** Module Pro do engine-pro cung cấp (caller tự import trong dự án của họ). */
+export interface ProExtensionModule {
+    drawingTools: readonly DrawingToolDefinition[];
+    series: readonly ProSeriesDefinition[];
+}
+export declare function isProExtensionActive(): boolean;
+/** Gỡ cờ active (chỉ dùng cho test; registry Map không hỗ trợ unregister từng key). */
+export declare function resetProExtensionForTests(): void;
+/**
+ * Nạp Pro extension vào registry. **Fail-closed**: chỉ khi license verify được
+ * (chữ ký hợp lệ, chưa hết hạn, tier ∈ {pro, enterprise}) **và** license đó cấp
+ * capability `pro_plugin` thì mới nạp. Mọi lỗi — kể cả `verifyLicenseKey` ném —
+ * đều trả `false` và **không nạp gì cả**.
+ *
+ * ## Về `host` — ĐỌC TRƯỚC KHI GỌI
+ *
+ * `verifyLicenseKey` **bỏ qua** kiểm tra domain khi `opts.host` là falsy
+ * (`licenseValidator.ts:353` — `if (opts.host && domains.length > 0 && …)`). Nên
+ * "không truyền host" KHÔNG phải là "không kiểm domain": đó là **bỏ qua kiểm
+ * domain** — một license ghim cho `buyer.example` vẫn verify ở mọi host.
+ *
+ * Vì `.eslintrc` cấm đọc `window`/`document`/`globalThis` trực tiếp trong `src/**`
+ * (quy tắc này bắt buộc truyền adapter từ ngoài vào), hàm này **không tự đọc
+ * `location`**. Người gọi phải truyền `host`.
+ *
+ * Hệ quả cần biết trước khi tích hợp: nếu license có `d` (ghim domain) mà
+ * `host` không được truyền, license **bị từ chối**. Đây là hành vi cố ý — không biết
+ * host không phải lý do để lọt license qua. License **không** ghim `d` thì không
+ * cần `host` và vẫn verify bình thường.
+ */
+export declare function registerProExtension(extension: ProExtensionModule | null | undefined, licenseKey: string, opts?: {
+    host?: string;
+}): Promise<boolean>;

package/dist/dts/widget/runtime/ChartScaleAdapter.d.ts

@@ -0,0 +1,73 @@
+import { type EnrichedDatum } from "../../lib/core/calculators/types";
+import { type WidgetPaneRuntimeSnapshot, type WidgetCoordinateBridge } from "../utils/widgetHelpers";
+import { type IRuntimeEngine, type IRuntimeScale } from "./IRuntimeEngine";
+/**
+ * L4: runtime-agnostic LIVE chart scale provider (renamed from LegacyRuntimeAdapter).
+ * Despite the old name, this feeds the main DynamicChart surface in ALL modes
+ * (useWidgetCoordinateBridge → VNInvestCharts). Discontinuous gap handling lives here.
+ *
+ * ## READ THIS BEFORE CHANGING ANYTHING ABOUT GAPS — `showNonTradingDays` is a NO-OP FOR X
+ *
+ * Coordinator decision 2026-10-05 (`G3_DEFER_GATE_HARDEN_B2_2026-10-05` D1) closes G3 as
+ * **DEFERRED**. This file is *not* where the X axis is projected, and the flag below does not
+ * reach it. Three separate sessions have now written a confident causal sentence here and been
+ * wrong; the measurements are in the plan and they are unambiguous.
+ *
+ * - **The live projection is index-domain.** `showNonTradingDays` does not affect the rendered X
+ *   axis at this commit. The fork renderer projects through
+ *   `src/widget/utils/coordinateBridge.ts:316-326` → `resolvePanePixelAtDataIndex` →
+ *   `indexToPixelX`, which is `left + (index - from) / span * width`. Measured on a weekend
+ *   fixture (Fri 2026-09-18, Mon 09-21, Tue 09-22, Wed 09-23; `plotBounds = {left: 0, width:
+ *   1000}`; `visibleRange {from: 0, to: 4}`): bar centres at **125, 375, 625, 875 px**, deltas
+ *   **250, 250, 250**, while the wall-clock deltas are **3 d, 1 d, 1 d**. Equal pixel steps over an
+ *   unequal wall-clock gap *is* the compression. A wall-clock projection would give unequal
+ *   steps. The lock is `src/widget/runtime/chartScaleAdapter.gap.test.ts`.
+ *
+ * - **`usesDiscontinuousScale` reads backwards.** `true` means gaps are **COMPRESSED** (the
+ *   discontinuous provider packs bars at `index + initialIndex`), not "shown". Do not use the name
+ *   as a definition.
+ *
+ * - **This class's only consumer is a dead `useCallback`.** `getChartScale`'s result is read at
+ *   `VNInvestCharts.tsx:1384` and `:1386`, inside `handleLegacyVisibleDomainChange`, declared at
+ *   `:1383` and referenced nowhere else in that file. `useForkRuntime.ts:276` destructures the
+ *   value and never uses it.
+ *
+ * - **What the flag DOES do** (all measured, none of it a pixel): it is a React remount key at
+ *   `VNInvestCharts.tsx:2876`; it re-runs this `getChartScale` memo, producing a new `data` array
+ *   identity per toggle; and it round-trips through `localStorage` and the workspace file.
+ *
+ * - **The engine does not know the flag at all** — 0 hits for `showNonTradingDays` across the
+ *   whole of `packages` + `src` in `vninvestcharts-engine` at `6264903` (351 files scanned).
+ *
+ * To actually make gaps appear, the work is a time-scale projection in the engine
+ * (`PaneRuntimeSnapshot.time`, `paneProjector`, the X tick generator, `AxisGridRenderCache` keys,
+ * both `barWidth` sources, zoom pivot, pan) — plan
+ * `G3_ENGINE_TIMESCALE_PLAN_2026-10-03.md`, audit verdict **NEED_REVISION** with 6 open
+ * objections. It was **not** done, deliberately, because it could not be verified in a browser.
+ * Start by reading that audit, not by editing this file.
+ */
+export declare class ChartScaleAdapter implements IRuntimeEngine {
+    getChartScale(options: {
+        plotData: readonly EnrichedDatum[];
+        enrichedData: readonly EnrichedDatum[];
+        controlledXExtents: readonly [Date | number, Date | number] | undefined;
+        computedXExtents: readonly [Date | number, Date | number] | undefined;
+        showNonTradingDays: boolean;
+    }): IRuntimeScale;
+    buildPaneSnapshots(options: {
+        visiblePanes: any[];
+        activeHeights: number[];
+        size: {
+            width: number;
+            height: number;
+        };
+        scaleSlotDomains: Record<string, [number, number]>;
+    }): readonly WidgetPaneRuntimeSnapshot[];
+    createCoordinateBridge(options: {
+        paneSnapshots: readonly WidgetPaneRuntimeSnapshot[];
+        visibleRange: any;
+        plotData: readonly EnrichedDatum[];
+    }): WidgetCoordinateBridge | null;
+}
+/** L4: deprecated alias kept for old host/test imports (use ChartScaleAdapter). */
+export { ChartScaleAdapter as LegacyRuntimeAdapter };

package/dist/dts/widget/runtime/ChartSerializer.d.ts

@@ -0,0 +1,12 @@
+export interface ChartTemplate {
+    name: string;
+    activeSeriesConfigs: any[];
+    isDark: boolean;
+    timeframe: string;
+}
+export declare class ChartSerializer {
+    static saveTemplate(name: string, data: Omit<ChartTemplate, "name">): void;
+    static loadTemplate(name: string): ChartTemplate | null;
+    static getAllTemplates(): Map<string, ChartTemplate>;
+    static deleteTemplate(name: string): void;
+}

package/dist/dts/widget/runtime/ForkRuntimeAdapter.d.ts

@@ -0,0 +1,19 @@
+import { type EnrichedDatum } from "../../lib/core/calculators/types";
+import { type WidgetPaneRuntimeSnapshot, type WidgetCoordinateBridge } from "../utils/widgetHelpers";
+import { type IRuntimeEngine } from "./IRuntimeEngine";
+export declare class ForkRuntimeAdapter implements IRuntimeEngine {
+    buildPaneSnapshots(options: {
+        visiblePanes: any[];
+        activeHeights: number[];
+        size: {
+            width: number;
+            height: number;
+        };
+        scaleSlotDomains: Record<string, [number, number]>;
+    }): readonly WidgetPaneRuntimeSnapshot[];
+    createCoordinateBridge(options: {
+        paneSnapshots: readonly WidgetPaneRuntimeSnapshot[];
+        visibleRange: any;
+        plotData: readonly EnrichedDatum[];
+    }): WidgetCoordinateBridge | null;
+}

package/dist/dts/widget/runtime/IRuntimeEngine.d.ts

@@ -0,0 +1,40 @@
+import { type EnrichedDatum } from "../../lib/core/calculators/types";
+import { type WidgetCoordinateBridge, type WidgetPaneRuntimeSnapshot } from "../utils/widgetHelpers";
+export interface IRuntimeScale {
+    data: readonly EnrichedDatum[];
+    xAccessor: (datum: EnrichedDatum) => number;
+    displayXAccessor: (datum: EnrichedDatum) => Date;
+    xExtents: readonly [Date, Date] | undefined;
+    /**
+     * `xScale` was removed from this interface on 2026-10-05.
+     *
+     * It had **zero readers**. Both branches of `ChartScaleAdapter.getChartScale` produced one —
+     * `scaleUtc()` and `financeDiscontinuousScale` — and nothing in the repo ever called it. The
+     * only live readers of this object are `VNInvestCharts.tsx:1384` and `:1386`, and both sit
+     * inside `handleLegacyVisibleDomainChange`, a `useCallback` declared at `:1383` whose
+     * identifier occurs exactly once in the file: it is dead.
+     *
+     * Removing the field is enforced by the compiler, not by a grep. `legacyChartScale` was typed
+     * `any` at both holders, so `tsc` could not see a read; both are now typed `IRuntimeScale`, so
+     * any future read of a field that does not exist here is TS2339. `npm run type-check` is the
+     * gate. Do not re-add a scale without a consumer — see the docblock at the top of
+     * `ChartScaleAdapter.ts` for why the gap feature does not live here.
+     */
+    usesDiscontinuousScale: boolean;
+}
+export interface IRuntimeEngine {
+    buildPaneSnapshots(options: {
+        visiblePanes: any[];
+        activeHeights: number[];
+        size: {
+            width: number;
+            height: number;
+        };
+        scaleSlotDomains: Record<string, [number, number]>;
+    }): readonly WidgetPaneRuntimeSnapshot[];
+    createCoordinateBridge(options: {
+        paneSnapshots: readonly WidgetPaneRuntimeSnapshot[];
+        visibleRange: any;
+        plotData: readonly EnrichedDatum[];
+    }): WidgetCoordinateBridge | null;
+}

package/dist/dts/widget/runtime/WorkspaceSerializer.d.ts

@@ -0,0 +1,31 @@
+import { type PaneDescriptor, type ChartTheme } from "../../lib/core";
+import type { DrawingObject } from "@vninvestcharts/engine-drawing";
+export interface WorkspaceSettings {
+    theme?: ChartTheme;
+    timezone?: string;
+    timeframe?: string;
+    symbol?: string;
+    maxVisiblePanes?: number;
+    maxVisibleBars?: number;
+    showNonTradingDays?: boolean;
+    showDrawingPriceMarkers?: boolean;
+    enableWhale?: boolean;
+    whaleThreshold?: number;
+    enableCVD?: boolean;
+    cvdMode?: "oscillator" | "histogram";
+    alertAudioEnabled?: boolean;
+    overlayTimeframe?: string;
+    overlayStyle?: "hollow" | "step" | "area" | "candle";
+}
+export interface WorkspaceSchema {
+    version: number;
+    timestamp: number;
+    panes: readonly PaneDescriptor[];
+    drawings: readonly DrawingObject[];
+    settings: WorkspaceSettings;
+}
+export declare class WorkspaceSerializer {
+    private static CURRENT_VERSION;
+    static serialize(panes: readonly PaneDescriptor[], drawings: readonly DrawingObject[], settings: WorkspaceSettings): string;
+    static deserialize(jsonString: string): WorkspaceSchema | null;
+}

package/dist/dts/widget/runtimePolicy.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Runtime a host may ask for.
+ *
+ * `"legacy"` was removed on 2026-10-03 along with the DynamicChart lane
+ * (G4). `"auto"` stays as a deprecated alias of fork, so hosts that still pass it
+ * keep working. See ledger `G4_LEGACY_CUT_2026-10-03`.
+ */
+export type RequestedWidgetRuntime = "fork" | "auto";
+/**
+ * Runtime a host can observe.
+ *
+ * Narrowed to `"fork"` in 0.1.0, when the legacy lane was removed (the version was
+ * 3.0.0 until 05d67df renamed it). It stayed a two-member union through the lane's
+ * existence purely so existing
+ * `onRuntimeResolved` consumers kept compiling, which is why the demo's own policy
+ * return type could not be narrowed either.
+ */
+export type ResolvedWidgetRuntime = "fork";
+export type WidgetRuntimeReasonCode = "EXPLICIT_FORK_REQUEST" | "DEFAULT_FORK_RUNTIME" | "DRAWING_UI_DISABLED" | "TOOL_NOT_REGISTERED" | "TOOL_AUTHORING_UNSUPPORTED" | "SELECTED_TOOL_MANIPULATION_UNSUPPORTED" | "TOOL_STATUS_DISABLED" | "AUTO_DEFAULT_FORK_RUNTIME" | "FORK_CAPABILITY_OK";
+export interface WidgetRuntimePolicyInput {
+    engineRuntime?: RequestedWidgetRuntime;
+    drawingUiEnabled?: boolean;
+    drawingActiveTool?: string;
+    selectedDrawingType?: string | null;
+}
+export interface WidgetRuntimePolicyOutput {
+    resolvedRuntime: ResolvedWidgetRuntime;
+    reasonCode: WidgetRuntimeReasonCode;
+}
+export declare function evaluateRuntimePolicy(input: WidgetRuntimePolicyInput): WidgetRuntimePolicyOutput;
+/**
+ * @deprecated Always `false` since the legacy lane was removed on 2026-10-03.
+ * Removed from the public API in the same release that dropped DynamicChart.
+ */
+export declare function shouldForceLegacyRuntime(_input: Pick<WidgetRuntimePolicyInput, "drawingUiEnabled" | "drawingActiveTool" | "selectedDrawingType">): boolean;
+export declare function resolveRequestedRuntime(input: WidgetRuntimePolicyInput): ResolvedWidgetRuntime;

package/dist/dts/widget/styles/injectStyles.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Auto-inject VNInvestCharts CSS styling into <head> or ShadowRoot at runtime.
+ * This ensures layouts remain intact when importing via React ESM module or IIFE Shadow DOM.
+ *
+ * Imports combined CSS as raw string for runtime injection.
+ * Components use CSS Modules (.module.css) for scoped styles.
+ */
+/** Inject widget CSS into Document, ShadowRoot or HTMLElement if not already present. Safe for SSR. */
+export declare function injectVNInvestChartsCSS(target: Document | ShadowRoot | HTMLElement): HTMLStyleElement | null;

package/dist/dts/widget/theme/ThemeConfig.d.ts

@@ -0,0 +1,21 @@
+export interface ThemeConfig {
+    mode: "dark" | "light";
+    presetName?: string;
+    colors?: Partial<{
+        bullish: string;
+        bearish: string;
+        primary: string;
+        accent: string;
+        bgPrimary: string;
+        bgSecondary: string;
+        textPrimary: string;
+        textSecondary: string;
+        border: string;
+        grid: string;
+        gridSubtle: string;
+        gridDash: string;
+        gridWidth: string;
+        crosshair: string;
+        indicators: string[];
+    }>;
+}

package/dist/dts/widget/theme/applyTheme.d.ts

@@ -0,0 +1,3 @@
+import type { ThemeConfig } from "./ThemeConfig";
+export declare function applyTheme(element: HTMLElement, config: ThemeConfig): void;
+export declare function readThemeFromElement(element: HTMLElement): ThemeConfig;

package/dist/dts/widget/trading/chart/DraggableOrderHandles.d.ts

@@ -0,0 +1,15 @@
+import type { OverlayBounds } from "./InteractivePositionOverlay";
+export interface DraggableOrderHandlesProps {
+    kind: "SL" | "TP";
+    price: number;
+    baseQuantity: number;
+    contractMultiplier?: number;
+    accountEquity: number;
+    toY: (price: number) => number | null;
+    toPrice: (pixelY: number) => number | null;
+    bounds: OverlayBounds;
+    tickSize: number;
+    disabled?: boolean;
+    onCommit?: (nextPrice: number) => void;
+}
+export declare function DraggableOrderHandles({ kind, price, baseQuantity, contractMultiplier, accountEquity, toY, toPrice, bounds, tickSize, disabled, onCommit, }: DraggableOrderHandlesProps): import("react").JSX.Element | null;

package/dist/dts/widget/trading/chart/InteractivePositionOverlay.d.ts

@@ -0,0 +1,19 @@
+import type { TradingPosition } from "../../../lib/core/trading/types";
+export interface OverlayBounds {
+    top: number;
+    bottom: number;
+}
+export interface AxisTagPlacement {
+    left: number;
+    width: number;
+}
+export interface InteractivePositionOverlayProps {
+    position: TradingPosition;
+    toY: (price: number) => number | null;
+    bounds: OverlayBounds;
+    axis?: AxisTagPlacement | null;
+    disabled?: boolean;
+    onClose?: () => void;
+    onReverse?: () => void;
+}
+export declare function InteractivePositionOverlay({ position, toY, bounds, axis, disabled, onClose, onReverse, }: InteractivePositionOverlayProps): import("react").JSX.Element | null;

package/dist/dts/widget/trading/chart/PendingOrderOverlay.d.ts

@@ -0,0 +1,11 @@
+import type { TradingOrder } from "../../../lib/core/trading/types";
+import type { AxisTagPlacement, OverlayBounds } from "./InteractivePositionOverlay";
+export interface PendingOrderOverlayProps {
+    order: TradingOrder;
+    toY: (price: number) => number | null;
+    bounds: OverlayBounds;
+    axis?: AxisTagPlacement | null;
+    disabled?: boolean;
+    onCancel?: () => void;
+}
+export declare function PendingOrderOverlay({ order, toY, bounds, axis, disabled, onCancel }: PendingOrderOverlayProps): import("react").JSX.Element | null;

package/dist/dts/widget/trading/chart/QuickTradingHeader.d.ts

@@ -0,0 +1,20 @@
+import type { MarketQuote } from "../../../lib/core/trading/MarketDataPort";
+export interface QuickTradingHeaderProps {
+    symbol: string;
+    quote?: MarketQuote | null;
+    defaultQuantity?: number;
+    lotSize?: number;
+    maxQuantity?: number;
+    defaultOneClick?: boolean;
+    onQuantityChange?: (quantity: number) => void;
+    onToggleOneClick?: (enabled: boolean) => void;
+    onBuy?: (quantity: number) => void;
+    onSell?: (quantity: number) => void;
+    onOpenTicket?: (side: "buy" | "sell", quantity: number) => void;
+    /** Task M4: ẩn/hiện paper trading của chart (mắt). Bật lại từ Settings. */
+    tradingEnabled?: boolean;
+    onToggleTradingEnabled?: (enabled: boolean) => void;
+    disabled?: boolean;
+    spreadUnit?: string;
+}
+export declare function QuickTradingHeader({ symbol, quote, defaultQuantity, lotSize, maxQuantity, defaultOneClick, onQuantityChange, onToggleOneClick, onBuy, onSell, onOpenTicket, tradingEnabled, onToggleTradingEnabled, disabled, spreadUnit, }: QuickTradingHeaderProps): import("react").JSX.Element;

package/dist/dts/widget/trading/chart/TradingChartSurface.d.ts

@@ -0,0 +1,8 @@
+import type { PaneRuntimeSnapshot, VisibleRange as EngineVisibleRange } from "@vninvestcharts/engine-react";
+export interface TradingChartSurfaceProps {
+    snapshot?: PaneRuntimeSnapshot | null;
+    visibleRange?: EngineVisibleRange | null;
+    scaleSlotId?: string;
+    drawingActive?: boolean;
+}
+export declare function TradingChartSurface({ snapshot, visibleRange, scaleSlotId, drawingActive }: TradingChartSurfaceProps): import("react").JSX.Element;