@vninvestcharts/widget 0.0.0-stage → 0.2.0

package/dist/dts/lib/core/trading/MarketDataPort.d.ts

@@ -0,0 +1,41 @@
+import type { ReplayOHLCBar } from "../replay/replayTradingTypes";
+export interface MarketQuote {
+    symbol: string;
+    lastPrice: number;
+    bidPrice: number;
+    askPrice: number;
+    spread: number;
+    spreadBps: number;
+    /** Luôn true với nguồn OHLC (không có sổ lệnh tick L1 thật). */
+    isSyntheticSpread: boolean;
+    timestamp: number;
+}
+export interface SyntheticSpreadConfig {
+    /** Spread mặc định theo bps của last khi không có tick provider. Default 10. */
+    spreadBps?: number;
+    /** Nếu có: spread = đúng 1 tick, bid/ask làm tròn theo tick. */
+    tickSizeProvider?: (symbol: string, price: number) => number;
+}
+export type QuoteCallback = (quote: MarketQuote) => void;
+export interface IMarketDataPort {
+    getLatestQuote(symbol: string): MarketQuote | undefined;
+    feedBar(symbol: string, bar: ReplayOHLCBar): void;
+    subscribeQuote(symbol: string, callback: QuoteCallback): () => void;
+}
+/**
+ * Tính synthetic quote từ last price. Quy tắc xác định (deterministic):
+ * - last không hợp lệ (<= 0 / NaN): spread = 0, bid = ask = last.
+ * - có tickSizeProvider: spread = đúng 1 tick, bid/ask làm tròn theo tick.
+ * - ngược lại: spread = last * spreadBps / 10000, bid/ask giữ nguyên.
+ */
+export declare function computeSyntheticQuote(symbol: string, lastPrice: number, timestamp: number, config?: SyntheticSpreadConfig): MarketQuote;
+export declare class MarketDataPort implements IMarketDataPort {
+    private readonly config;
+    private readonly latest;
+    private readonly subscribers;
+    constructor(config?: SyntheticSpreadConfig);
+    getLatestQuote(symbol: string): MarketQuote | undefined;
+    feedBar(symbol: string, bar: ReplayOHLCBar): void;
+    subscribeQuote(symbol: string, callback: QuoteCallback): () => void;
+}
+export declare function createMarketDataPort(config?: SyntheticSpreadConfig): IMarketDataPort;

package/dist/dts/lib/core/trading/MarketRules.d.ts

@@ -0,0 +1,58 @@
+import type { OrderRejectCode, OrderValidationInput } from "./types";
+export type MarketProfileType = "VN_SPOT" | "VN_DERIVATIVES" | "GLOBAL_MARGIN";
+/**
+ * P1.2c: true cho HOSE/HNX/UPCOM + phái sinh VN (có phiên đấu giá, lô chẵn,
+ * biên độ trần/sàn). Crypto/global không có khái niệm này.
+ */
+export declare function isVnProfile(profile: MarketProfileType): boolean;
+export type ExchangeType = "HOSE" | "HNX" | "UPCOM" | "GLOBAL";
+/** Vốn paper mặc định — đủ mua thoải mái, khỏi nạp liên tục (BTC ~81k mua được 1 + dư). */
+export declare const DEFAULT_PAPER_BALANCE_USD = 100000;
+export declare const DEFAULT_PAPER_BALANCE_VND = 1000000000;
+/** Vốn tối đa cho phép nhập ở dialog nạp vốn (chống typo thừa số 0). */
+export declare const MAX_PAPER_BALANCE = 1000000000000;
+export interface MarketRules {
+    profile: MarketProfileType;
+    baseCurrency: string;
+    lotSize: number;
+    contractMultiplier?: number;
+    allowShortSelling: boolean;
+    settlementDays: number;
+    maxLeverage: number;
+    initialMarginRate?: number;
+    brokerBufferMultiplier?: number;
+    maxOrderQuantity?: number;
+    maxPositionQuantity?: number;
+    getTickSize(price: number, exchange?: ExchangeType): number;
+    getPriceBand(referencePrice: number, exchange?: ExchangeType): {
+        ceilingPrice: number;
+        floorPrice: number;
+    };
+    validateOrder(order: OrderValidationInput): {
+        valid: boolean;
+        reason?: string;
+        code?: OrderRejectCode;
+    };
+}
+export declare const VN_SPOT_RULES: MarketRules;
+export declare const CRYPTO_SPOT_RULES: MarketRules;
+/**
+ * Phân loại thị trường theo mã: VN30F* -> phái sinh; mã crypto (kết thúc bằng
+ * USDT, USDC, USD, BTC, ETH, hoặc chứa "/" hay ":") -> crypto spot; còn lại VN cơ sở.
+ */
+export declare function resolveMarketProfile(symbol: string): MarketRules;
+/**
+ * S4: true when a symbol falls back to VN_SPOT without looking like a VN
+ * ticker (exactly 3 A-Z letters). UI shows a fallback banner (override via
+ * settings) instead of silently applying lot-100/T+2.
+ */
+export declare function isUnclassifiedMarketSymbol(symbol: string): boolean;
+export declare const VN_DERIVATIVES_RULES: MarketRules;
+/**
+ * Task 11: replay-scoped VN rules — VN_SPOT nhưng settlementDays = 0.
+ * Lý do: replay mô phỏng chiến thuật, không mô phỏng thanh toán T+2;
+ * nếu giữ T+2, TP khớp nến kế tiếp bị throw (available 0), regression nặng
+ * so với legacy (đóng ngay). Derivatives T+0 sẵn nên không cần override.
+ */
+export declare const REPLAY_SPOT_RULES: MarketRules;
+export declare const GLOBAL_MARGIN_RULES: MarketRules;

package/dist/dts/lib/core/trading/OrderManagementSystem.d.ts

@@ -0,0 +1,57 @@
+import type { OrderSide, OrderType, TradingOrder, OrderValidationInput } from "./types";
+import type { ReplayOHLCBar } from "../replay/replayTradingTypes";
+/**
+ * P1.2c: nhóm market-like VN (đơn giản hóa có chủ ý, engine full-or-nothing
+ * không depth/phiên đấu giá nên MP/MTL/ATO ≡ market, ATC ≡ close — đã khóa test).
+ */
+export declare function isMarketLikeOrderType(type: OrderType): boolean;
+export interface OrderManagementSystemOptions {
+    tickSizeProvider?: (symbol: string) => number;
+}
+export interface OrderFill {
+    orderId: string;
+    symbol: string;
+    side: OrderSide;
+    fillPrice: number;
+    filledQuantity: number;
+    timestamp: number;
+}
+export type PlaceOrderRequest = OrderValidationInput & {
+    clientOrderId?: string;
+};
+export declare class OrderManagementSystem {
+    private readonly tickSizeProvider;
+    private readonly orders;
+    private readonly trailingPeak;
+    private seq;
+    constructor(options?: OrderManagementSystemOptions);
+    listOrders(): TradingOrder[];
+    getOrder(orderId: string): TradingOrder | undefined;
+    getTrailingPeaks(): Record<string, number>;
+    cancelOrder(orderId: string): boolean;
+    /**
+     * Sửa giá lệnh working (drag SL/TP — Task 08). Đổi quantity phải
+     * cancel + đặt lại (giữ nguyên id cho đường vẽ trên chart).
+     */
+    modifyOrder(orderId: string, patch: {
+        price?: number;
+        stopPrice?: number;
+    }): TradingOrder;
+    clear(): void;
+    /** Hydrate từ storage (Task 06). trailingPeaks persist kèm để SL đã ratchet không tụt sau refresh. */
+    restoreState(orders: TradingOrder[], trailingPeaks?: Record<string, number>): void;
+    placeOrder(request: PlaceOrderRequest): TradingOrder;
+    /**
+     * P1.2b: khóa ngày UTC (yyyy-mm-dd) của nến — deterministic, không phụ thuộc
+     * timezone runtime. Phiên VN (02:00–08:00 UTC) không bao giờ cắt nửa đêm UTC
+     * nên so sánh UTC đúng cho cả HOSE/HNX/UPCOM lẫn crypto 24/7 (ngày UTC).
+     */
+    static utcDayKey(date: Date | number): string;
+    processBar(symbol: string, bar: ReplayOHLCBar, now?: number): OrderFill[];
+    private tickDelta;
+    private ratchetTrailing;
+    private resolveFill;
+    private fillOrder;
+    private spawnBracketChildren;
+    private addChild;
+}

package/dist/dts/lib/core/trading/PositionManager.d.ts

@@ -0,0 +1,79 @@
+import type { ExitReason, PositionSide, TradingPosition } from "./types";
+export interface PositionManagerOptions {
+    hedgingMode?: boolean;
+    /** Hệ số nhân hợp đồng (phái sinh VN30: 100000). Default 1 cho spot. */
+    contractMultiplier?: number;
+    /** S5: phương pháp giá vốn cho vị thế MỞ MỚI ("average" mặc định). */
+    costBasisMethod?: CostBasisMethod;
+}
+export type CostBasisMethod = "average" | "fifo";
+/** S5: một lô mua/bán của vị thế FIFO (timestamp immutable để audit). */
+export interface PositionLot {
+    lotId: string;
+    quantity: number;
+    price: number;
+    timestamp: number;
+}
+export interface OpenPositionRequest {
+    symbol: string;
+    side: PositionSide;
+    quantity: number;
+    price: number;
+    timestamp: number;
+    settlementDate?: number;
+    /** S5: commission + tax already charged for this fill. Carried to the close. */
+    entryFees?: number;
+}
+export interface ClosePositionResult {
+    closedQuantity: number;
+    realizedPnl: number;
+    /**
+     * S5: fees charged when this position was OPENED, attributed to the close.
+     *
+     * `realizedPnl` is the price difference only. The fee for the ENTRY leg was
+     * already taken out of cash when the position opened, so a consumer that reports
+     * "net P&L for this round trip" has to subtract it too - otherwise the entry fee
+     * is missing from the trade record while still being missing from the cash total,
+     * and the two never reconcile. That gap was exactly 12,850 on a 100-share FPT
+     * round trip, which is what the netPnl invariant test caught.
+     */
+    entryFees: number;
+    remaining: TradingPosition | null;
+}
+export declare class PositionManager {
+    private readonly hedgingMode;
+    private readonly multiplier;
+    private costBasisMethod;
+    private readonly positions;
+    /**
+     * S5: sidecar FIFO lots keyed by position id (không đụng TradingPosition
+     * type → storage tương thích; vị thế mở trước khi bật fifo giữ average).
+     */
+    private readonly lots;
+    private seq;
+    private lotSeq;
+    constructor(options?: PositionManagerOptions);
+    /** S2/S5: đổi method — chỉ áp dụng vị thế MỞ MỚI (prospective, §10 Q2). */
+    setCostBasisMethod(method: CostBasisMethod): void;
+    clear(): void;
+    /**
+     * S5: khớp đóng `quantity` vào các lô cũ nhất, trả realized + cập nhật
+     * entryPrice = bình quân gia quyền các lô còn lại (giữ updateMarkPrice
+     * và mọi công thức hiển thị nguyên vẹn ở cả 2 mode).
+     */
+    private matchCloseLots;
+    private trackLot;
+    /** Hydrate từ storage (Task 06). */
+    restoreState(positions: TradingPosition[]): void;
+    listPositions(): TradingPosition[];
+    getPositionById(positionId: string): TradingPosition | undefined;
+    getPosition(symbol: string): TradingPosition | undefined;
+    openPosition(request: OpenPositionRequest): TradingPosition;
+    private offsetOpposite;
+    private createPosition;
+    closePosition(positionId: string, quantity: number, exitPrice: number, timestamp: number, _reason?: ExitReason, options?: {
+        enforceAvailable?: boolean;
+    }): ClosePositionResult;
+    updateMarkPrice(symbol: string, price: number, timestamp: number): void;
+    applySettlement(now: number): void;
+}

package/dist/dts/lib/core/trading/RiskEngine.d.ts

@@ -0,0 +1,40 @@
+import type { BrokerAccount, OrderRejectCode, OrderValidationInput, TradingPosition } from "./types";
+import type { MarketRules } from "./MarketRules";
+export interface MarginRequirement {
+    vsdMargin: number;
+    totalRequiredMargin: number;
+}
+export interface RiskValidationResult {
+    valid: boolean;
+    rejectCode?: OrderRejectCode;
+    reason?: string;
+    requiredMargin?: number;
+    availableBuyingPower?: number;
+}
+export type AccountRiskStatus = "safe" | "warning" | "call_margin" | "liquidation";
+export interface AccountRiskAssessment {
+    status: AccountRiskStatus;
+    marginLevelPercent: number;
+}
+export declare class RiskEngine {
+    /**
+     * Ký quỹ cho một lệnh/vị thế. Spot = tiền mặt đủ giá trị (vsd = 0);
+     * derivatives/margin tách vsdMargin và totalRequiredMargin (F-01).
+     */
+    calculateOrderMargin(order: {
+        quantity: number;
+    }, rules: MarketRules, price: number): MarginRequirement;
+    validateOrderRisk(order: OrderValidationInput, account: BrokerAccount, rules: MarketRules, markPrice?: number, currentPosition?: TradingPosition): RiskValidationResult;
+    /**
+     * Ký quỹ TĂNG THÊM của lệnh (Trap 2): lệnh đóng/giảm vị thế được miễn
+     * (giải phóng ký quỹ thay vì chiếm thêm); đảo chiều chỉ tính phần dôi.
+     */
+    private additionalMargin;
+    recalculateAccount(account: BrokerAccount, positions: TradingPosition[], rules: MarketRules, markPrices: Record<string, number>): BrokerAccount;
+    evaluateAccountRisk(account: BrokerAccount): AccountRiskAssessment;
+    /**
+     * Giá thanh lý ước tính: balance + (liq-entry)*dir*qty*mult = 50% * marginUsed.
+     * Spot (không đòn bẩy) trả +Infinity — không bao giờ thanh lý.
+     */
+    calculateLiquidationPrice(position: TradingPosition, account: BrokerAccount, rules: MarketRules): number;
+}

package/dist/dts/lib/core/trading/SettlementCalendar.d.ts

@@ -0,0 +1,10 @@
+export declare class SettlementCalendar {
+    private static holidaysVN;
+    static configure(holidaysVN: string[]): void;
+    static isTradingDay(date: Date): boolean;
+    /**
+     * Timestamp chứng khoán về khả dụng. T+0 trả ngay; T+N cộng N ngày giao dịch
+     * rồi chốt 13:00 ngày cuối (giờ địa phương, tránh lệch TZ của toISOString).
+     */
+    static calculateSettlementTimestamp(tradeTimestamp: number, settlementDays?: number): number;
+}

package/dist/dts/lib/core/trading/VirtualBrokerEngine.d.ts

@@ -0,0 +1,92 @@
+import type { AsyncStorageAdapter } from "@vninvestcharts/engine-react";
+import type { BrokerAccount, ExecutionTicket, OrderValidationInput, TradingOrder, TradingPosition } from "./types";
+import type { ClosePositionOptions, IBrokerAPI, PlaceOrderOptions, TradingEventCallback, TradingEventKey } from "./BrokerAPI";
+import type { MarketRules } from "./MarketRules";
+import type { ReplayOHLCBar } from "../replay/replayTradingTypes";
+import type { IMarketDataPort } from "./MarketDataPort";
+import { type ExecutionSimulatorOptions } from "./ExecutionSimulator";
+import { type TradingAnalytics } from "./AnalyticsEngine";
+export interface VirtualBrokerOptions {
+    rules: MarketRules;
+    marketDataPort?: IMarketDataPort;
+    storageAdapter?: AsyncStorageAdapter;
+    storageNamespace?: string;
+    initialBalance?: number;
+    simulatorOptions?: ExecutionSimulatorOptions;
+    hedgingMode?: boolean;
+    /**
+     * P1.1 (D-01 live-fill, verdict-scoped): khi true, lệnh market khớp ngay
+     * tại mark price hiện tại qua synthetic tick-bar (tái dùng toàn bộ pipeline
+     * onBar: matching/settlement/analytics/events — 0 logic khớp mới, 0 đụng OMS).
+     * CHỈ bật cho live paper broker. Default false: backtest/replay/standalone
+     * giữ quy ước fill-open-nến-kế chống lookahead (OMS test khóa).
+     */
+    fillMarketOnPlace?: boolean;
+}
+export interface BrokerRuntimePatch {
+    /** Merged rules copy (never a shared frozen constant — see applyRuntimeConfig). */
+    rules?: MarketRules;
+    simulatorOptions?: ExecutionSimulatorOptions;
+}
+export interface BrokerRuntimeSummary {
+    appliedAt: number;
+    profile: string;
+    simulator: Required<ExecutionSimulatorOptions>;
+}
+export declare class VirtualBrokerEngine implements IBrokerAPI {
+    private rules;
+    private readonly fillMarketOnPlace;
+    private readonly port?;
+    private readonly oms;
+    private readonly pms;
+    private readonly risk;
+    private readonly sim;
+    private readonly settlement;
+    private readonly analytics;
+    private readonly bus;
+    private readonly storage;
+    private account;
+    private history;
+    private readonly lastClose;
+    private rejSeq;
+    constructor(options: VirtualBrokerOptions);
+    private static freshAccount;
+    getAccount(): BrokerAccount;
+    getPositions(): TradingPosition[];
+    /** Task 11: lookup trực tiếp cho rewired hooks (markers/panel join). */
+    getPositionById(positionId: string): TradingPosition | undefined;
+    getOrders(): TradingOrder[];
+    getHistory(): ExecutionTicket[];
+    getAnalytics(): TradingAnalytics;
+    on<K extends TradingEventKey>(event: K, callback: TradingEventCallback<K>): () => void;
+    private markPrice;
+    private books;
+    placeOrder(input: OrderValidationInput, options?: PlaceOrderOptions): TradingOrder;
+    cancelOrder(orderId: string): boolean;
+    modifyOrder(orderId: string, patch: {
+        price?: number;
+        stopPrice?: number;
+        quantity?: number;
+    }): TradingOrder;
+    closePosition(positionId: string, options?: ClosePositionOptions): boolean;
+    closeAllPositions(reason?: string, symbol?: string): number;
+    private rejected;
+    onBar(symbol: string, bar: ReplayOHLCBar, now?: number): void;
+    private exitReasonOf;
+    updateMarkPrice(symbol: string, price: number): void;
+    resetAccount(initialBalance?: number): void;
+    /**
+     * S2: apply runtime config without recreating the broker. Positions,
+     * orders, WS subscriptions and booked history survive; only NEW fills use
+     * the updated pricing/rules (prospective-only, §10 Q2). The rules object
+     * must be a private merged copy — never a shared frozen constant.
+     */
+    applyRuntimeConfig(patch: BrokerRuntimePatch): BrokerRuntimeSummary;
+    flush(): Promise<void>;
+    hydrate(): Promise<boolean>;
+    private hydrated;
+    private syncAccount;
+    private persist;
+    private afterMutation;
+    private emitAll;
+}

package/dist/dts/lib/core/trading/orderMargin.d.ts

@@ -0,0 +1,3 @@
+import type { MarketRules } from "./MarketRules";
+import type { TradingOrder, TradingPosition } from "./types";
+export declare function workingOrdersMargin(orders: TradingOrder[], positions: TradingPosition[], rules: MarketRules, markPrices: Record<string, number>): number;

package/dist/dts/lib/core/trading/storage/InMemoryStorageAdapter.d.ts

@@ -0,0 +1,10 @@
+import type { AsyncStorageAdapter } from "@vninvestcharts/engine-react";
+export declare class InMemoryStorageAdapter implements AsyncStorageAdapter {
+    private readonly store;
+    getItem(key: string): Promise<string | null>;
+    setItem(key: string, value: string): Promise<void>;
+    removeItem(key: string): Promise<void>;
+    clear(): Promise<void>;
+    getAllKeys(): Promise<string[]>;
+    getSize(): Promise<number>;
+}

package/dist/dts/lib/core/trading/storage/TradingStorage.d.ts

@@ -0,0 +1,34 @@
+import type { AsyncStorageAdapter } from "@vninvestcharts/engine-react";
+import type { ClosedTradeRecord, EquityPoint } from "../AnalyticsEngine";
+import type { BrokerAccount, ExecutionTicket, TradingOrder, TradingPosition } from "../types";
+export declare const TRADING_STORAGE_VERSION = 2;
+export interface SerializedTradingState {
+    version: number;
+    savedAt: number;
+    account: BrokerAccount;
+    orders: TradingOrder[];
+    positions: TradingPosition[];
+    trailingPeaks: Record<string, number>;
+    history: ExecutionTicket[];
+    closedTrades: ClosedTradeRecord[];
+    equityCurve: EquityPoint[];
+}
+/**
+ * S6: version-2 state. `config` carries the user runtime config snapshot
+ * (fee/tax/slippage/leverage/method/display, see PaperRuntimeConfig —
+ * Record-typed here to keep lib/ independent of widget/ imports).
+ * `isChartOverride` marks per-chart override ledgers (Tier 3).
+ */
+export interface TradingStateV2 extends SerializedTradingState {
+    version: 2;
+    config?: Record<string, unknown>;
+    isChartOverride?: boolean;
+}
+export declare class TradingStorage {
+    private readonly adapter;
+    private readonly storageKey;
+    constructor(adapter: AsyncStorageAdapter, storageKey?: string);
+    saveState(state: SerializedTradingState): Promise<void>;
+    loadState(): Promise<TradingStateV2 | null>;
+    clearState(): Promise<void>;
+}

package/dist/dts/lib/core/trading/types.d.ts

@@ -0,0 +1,99 @@
+export type OrderSide = "buy" | "sell";
+export type OrderType = "market" | "limit" | "stop" | "stop_limit" | "trailing_stop"
+/** P1.2c VN: ATO/ATC (khớp giá mở/đóng phiên), MP/MTL (market khớp ngay). */
+ | "ato" | "atc" | "mp" | "mtl"
+/** PLO (Post Limit Order) — khớp lệnh dư chuyển LO phiên sau (đơn giản hóa: LO). */
+ | "plo";
+export type OrderStatus = "pending" | "working" | "filled" | "partially_filled" | "cancelled" | "rejected" | "expired";
+export type TimeInForce = "GTC" | "DAY" | "IOC" | "FOK";
+export type PositionSide = "long" | "short";
+export type ExitReason = "tp" | "sl" | "trailing_stop" | "manual" | "liquidation" | "session_end";
+export type OrderRejectCode = "UNSUPPORTED_TIF" | "UNSUPPORTED_ORDER_TYPE" | "INSUFFICIENT_BUYING_POWER" | "INVALID_QUANTITY" | "INVALID_PRICE" | "SHORT_NOT_ALLOWED" | "PRICE_OUT_OF_BAND";
+export interface BracketOrderSpec {
+    takeProfitPrice?: number;
+    stopLossPrice?: number;
+    trailingStopDeltaTicks?: number;
+}
+export interface TradingOrder {
+    id: string;
+    clientOrderId: string;
+    symbol: string;
+    side: OrderSide;
+    type: OrderType;
+    status: OrderStatus;
+    quantity: number;
+    filledQuantity: number;
+    price?: number;
+    stopPrice?: number;
+    bracket?: BracketOrderSpec;
+    timeInForce: TimeInForce;
+    /**
+     * P1.2b: ngày UTC (yyyy-mm-dd) của nến đầu tiên xử lý lệnh DAY — lười gán
+     * tại processBar đầu tiên để deterministic trong test và đúng phiên
+     * VN (phiên không bao giờ cắt nửa đêm UTC). null = chưa gặp nến nào.
+     */
+    dayKey?: string | null;
+    parentOrderId?: string;
+    rejectCode?: OrderRejectCode;
+    createdAt: number;
+    updatedAt: number;
+}
+export interface TradingPosition {
+    id: string;
+    symbol: string;
+    side: PositionSide;
+    quantity: number;
+    availableQuantity: number;
+    entryPrice: number;
+    currentPrice: number;
+    unrealizedPnl: number;
+    realizedPnl: number;
+    /**
+     * S5: commission + tax charged when this position was opened.
+     *
+     * Those fees left cash at entry time, so they belong to the round trip that closes
+     * here. Without them a "net P&L" per trade is short by the entry fee while the cash
+     * total has already paid it - the two never reconcile. Pro-rated on a partial close.
+     */
+    entryFees?: number;
+    settlementDate?: number;
+    liquidationPrice?: number;
+    createdAt: number;
+    updatedAt: number;
+}
+export interface ExecutionTicket {
+    orderId: string;
+    symbol: string;
+    side: OrderSide;
+    fillPrice: number;
+    fillQuantity: number;
+    commission: number;
+    tax: number;
+    pnl: number;
+    exitReason?: ExitReason;
+    timestamp: number;
+    ambiguousIntrabarFill?: boolean;
+    tieBreakReason?: string;
+}
+export interface BrokerAccount {
+    accountId: string;
+    balance: number;
+    equity: number;
+    marginUsed: number;
+    freeMargin: number;
+    buyingPower: number;
+    currency: string;
+    pnl: number;
+    pnlPercent: number;
+}
+export interface OrderValidationInput {
+    symbol: string;
+    side: OrderSide;
+    type: OrderType;
+    quantity: number;
+    price?: number;
+    stopPrice?: number;
+    bracket?: BracketOrderSpec;
+    timeInForce?: TimeInForce;
+    isClosingPosition?: boolean;
+}

package/dist/dts/lib/core/types/chart.d.ts

@@ -0,0 +1,21 @@
+export interface VisibleRange {
+    startIndex: number;
+    endIndex: number;
+    startDate: Date | number;
+    endDate: Date | number;
+    timeRange: {
+        from: number;
+        to: number;
+    };
+    barCount: number;
+    relativePosition?: {
+        startRatio: number;
+        spanRatio: number;
+    };
+}
+export type VisibleRangeSource = "pan" | "zoom" | "programmatic";
+export interface ChartHandle {
+    scrollToIndex(index: number, align?: "left" | "center" | "right"): void;
+    zoomToRange(startIndex: number, endIndex: number): void;
+    scrollToDate(date: Date, align?: "left" | "center" | "right"): void;
+}

package/dist/dts/lib/core/types/indicator-catalog.d.ts

@@ -0,0 +1,38 @@
+export type IndicatorCategory = "trend" | "momentum" | "volatility" | "orderflow" | "strength" | "volume";
+export type RepaintPolicy = "no-repaint" | "repaint-on-close" | "repaint-always";
+export type PanePolicy = "overlay" | "separate" | "either";
+export type ScalePolicy = "percent" | "price" | "normalized" | "volume";
+export interface SeriesSettingField {
+    key: string;
+    labelKey: string;
+    type: "number" | "text" | "color" | "select";
+    defaultValue: number | string;
+    min?: number;
+    max?: number;
+    step?: number;
+    options?: {
+        value: string;
+        labelKey: string;
+    }[];
+}
+export interface IndicatorCatalogEntry {
+    id: string;
+    displayName?: {
+        vi: string;
+        en: string;
+    };
+    description?: {
+        vi: string;
+        en: string;
+    };
+    category?: IndicatorCategory;
+    tags?: string[];
+    inputSchema?: readonly SeriesSettingField[];
+    outputSchema?: {
+        type: "scalar" | "band" | "histogram" | "macd" | "stochastic";
+        fields?: readonly string[];
+    };
+    panePolicy?: PanePolicy;
+    scalePolicy?: ScalePolicy;
+    repaintPolicy?: RepaintPolicy;
+}

package/dist/dts/lib/core/types/indicator-set.d.ts

@@ -0,0 +1,19 @@
+import type { PaneDescriptor } from "./pane-descriptor";
+export interface IndicatorSet {
+    id: string;
+    name: string;
+    createdAt: number;
+    updatedAt: number;
+    panes: readonly PaneDescriptor[];
+    isBuiltin?: boolean;
+}
+export interface IndicatorSetsStorage {
+    version: 1;
+    sets: readonly IndicatorSet[];
+}
+export interface IndicatorSetStorageLike {
+    getItem: (key: string) => string | null;
+    setItem: (key: string, value: string) => void;
+    removeItem: (key: string) => void;
+}
+export declare const INDICATOR_SETS_STORAGE_KEY = "vnsc:indicator-sets-v1";

package/dist/dts/lib/core/types/pane-descriptor.d.ts

@@ -0,0 +1,46 @@
+export type SeriesTypeId = "Candlestick" | "HollowCandle" | "OHLC" | "HeikinAshi" | "Line" | "Area" | "Volume" | "Histogram" | "Baseline" | "Renko" | "Kagi" | "PointAndFigure" | "LineBreak" | "EMA" | "BollingerBand" | "RSI" | "MACD" | "CVDApprox" | "CVDRealtime" | "StrengthElder" | "StrengthRelative" | "Whale" | "MA" | "BBI" | "SAR" | "OBV" | "WR" | "VR" | "KDJ" | "CCI" | "DMI" | "BIAS" | "BRAR" | "MTM" | "EMV" | "AO" | "ROC" | "TRIX" | "DMA" | "PVT" | "PSY" | "CR" | "WMA" | "VWMA" | "HMA" | "DEMA" | "TEMA" | "MARibbon" | "Ichimoku" | "Supertrend" | "Keltner" | "Donchian" | "ChaikinVol" | "StdDev" | "HV" | "CI" | "CMF" | "ChaikinOscillator" | "MFI" | "VolOsc" | "VWAP" | "AnchoredVWAP" | "Alligator" | "Fractals" | "Gator" | "AC" | "PivotStandard" | "PivotHighLow" | "MarketProfile" | "VolumeProfile" | "Footprint" | "DeltaProfile" | "SMFI" | "WyckoffWave" | (string & {});
+export type YAxisSide = "left" | "right";
+/**
+ * Canonicalize legacy series-type aliases to their canonical SeriesTypeId.
+ * Currently only "BollingerBands" (plural, exposed historically via the
+ * SeriesRegistry demo alias + settings composer) → "BollingerBand".
+ * Central SSOT so compute/resolve/render/label paths cannot diverge again.
+ */
+export declare function normalizeSeriesTypeId(type: SeriesTypeId): SeriesTypeId;
+export interface SeriesConfig {
+    id?: string;
+    type: SeriesTypeId;
+    params?: Record<string, unknown>;
+    yAxis: YAxisSide;
+    /** Optional explicit scale-slot id for native-style grouping. */
+    scaleSlotId?: string;
+    overlay?: boolean;
+    color?: string;
+    lineWidth?: number;
+    lineStyle?: "solid" | "dashed" | "dotted";
+    /** Per-component color overrides for multi-line indicators (MACD, BB, KDJ, …) */
+    subColors?: Record<string, string>;
+    visible?: boolean;
+    sourceType?: "price" | "indicator";
+    sourceId?: string;
+    sourceKey?: string;
+    overlaySymbolId?: string;
+    normalizeToBaseline?: boolean;
+}
+export type TooltipMode = "ohlc" | "value" | "none";
+export interface PaneDescriptor {
+    id: string;
+    label: string;
+    pinned: boolean;
+    visible: boolean;
+    heightRatio: number;
+    series: SeriesConfig[];
+    splitScale: boolean;
+    tooltip: TooltipMode;
+    /** Optional per-pane minimum height (px). Fallback to getPaneMinHeight() */
+    minHeight?: number;
+}
+export declare const PANE_LAYOUT_STORAGE_KEY = "rsc-pane-layout-v2";
+export declare const PANE_MAX_VISIBLE = 5;
+export declare const DEFAULT_PANES: PaneDescriptor[];
+export declare function isDefaultPaneId(id: string): boolean;