@christtrade/depth 0.12.21

package/types/components/toolbar/timeframe-selector.d.ts

@@ -0,0 +1,15 @@
+import { type Timeframe } from '../../lib/timeframes';
+import type { FeaturesOptions } from '../../core/DepthChart';
+import type { TypedEventBus } from '../../core/TypedEventBus';
+interface TimeframeSelectorProps {
+    eventBus: TypedEventBus;
+    value: Timeframe;
+    customTimeframes: Timeframe[];
+    features: FeaturesOptions;
+    onChange: (tf: Timeframe) => void;
+    onAddCustom: (tf: Timeframe) => void;
+    onRemoveCustom: (label: string) => void;
+    onOpenChange?: (open: boolean) => void;
+}
+export declare function TimeframeSelector({ eventBus, value, customTimeframes, features, onChange, onAddCustom, onRemoveCustom, onOpenChange, }: TimeframeSelectorProps): import("react").JSX.Element;
+export {};

package/types/components/trading/OrderPanel.d.ts

@@ -0,0 +1,36 @@
+import React from 'react';
+import type { TypedEventBus } from '../../core/TypedEventBus';
+import type { ContractSpec } from '../../interfaces/IDataAdapter';
+import type { PlaceOrderRequest } from '../../lib/matchingEngine';
+import type { ActiveDrawingTool } from '../../lib/types/drawing-types';
+export interface OrderPanelProps {
+    eventBus: TypedEventBus;
+    spec: ContractSpec;
+    symbol?: string;
+    /** Send the order. Wire to `chart.executionEngine.placeOrder` */
+    onPlaceOrder: (req: PlaceOrderRequest) => void;
+    onClose?: () => void;
+    /** Seed balance; kept current from `account:update` after mount */
+    balance?: number;
+    currencySymbol?: string;
+    /** Viewport pixels, clamped. Only used the first open; after that the panel
+     * reopens wherever it was last dragged. */
+    initialPosition?: {
+        x: number;
+        y: number;
+    };
+    /**
+     * How the panel reads the chart's drawings, so it can build the ticket from
+     * a long/short box and stay linked to it. Functions rather than values, so a
+     * box dragged since it was selected reads as it now stands.
+     */
+    drawings?: {
+        /** `() => chart.getSelectedDrawing()` */
+        selected: () => ActiveDrawingTool | null;
+        /** `(id) => chart.getDrawing(id)` - null once deleted */
+        byId: (id: string) => ActiveDrawingTool | null;
+        /** `(fn) => chart.onDrawingsChanged(fn)` */
+        subscribe: (fn: () => void) => () => void;
+    };
+}
+export declare function OrderPanel({ eventBus, spec, symbol, onPlaceOrder, onClose, balance: initialBalance, currencySymbol, initialPosition, drawings, }: OrderPanelProps): React.JSX.Element;

package/types/components/trading/QuickTradingButtons.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import type { TypedEventBus } from '../../core/TypedEventBus';
+interface QuickTradingButtonsProps {
+    eventBus: TypedEventBus;
+}
+export declare function QuickTradingButtons({ eventBus }: QuickTradingButtonsProps): React.JSX.Element;
+export {};

package/types/components/trading/order-math.d.ts

@@ -0,0 +1,94 @@
+import type { ContractSpec, SymbolInfo } from '../../interfaces/IDataAdapter';
+import type { OrderSide, OrderType } from '../../lib/types/trading-types';
+export declare const tickSizeOf: (spec: ContractSpec) => number;
+export declare function tickValueOf(spec: ContractSpec): number;
+export declare function specForSymbol(info: SymbolInfo | null | undefined): ContractSpec;
+export declare const qtyStepOf: (spec: ContractSpec) => number;
+export declare const minQtyOf: (spec: ContractSpec) => number;
+export declare const qtyDecimals: (spec: ContractSpec) => number;
+export declare function roundQty(qty: number, spec: ContractSpec): number;
+export declare function priceDecimals(spec: ContractSpec): number;
+export declare function roundToTick(price: number, spec: ContractSpec): number;
+export declare const ticksBetween: (from: number, to: number, spec: ContractSpec) => number;
+export declare const moneyPerTick: (qty: number, spec: ContractSpec) => number;
+export declare const contractValue: (price: number, qty: number, spec: ContractSpec) => number;
+export declare function levelPrice(kind: 'tp' | 'sl', entry: number, ticks: number, side: OrderSide, spec: ContractSpec): number;
+export declare function levelTicks(kind: 'tp' | 'sl', entry: number, price: number, side: OrderSide, spec: ContractSpec): number;
+export type AmountMode = 'contracts' | 'value' | 'balancePct' | 'riskUsd' | 'riskPct';
+export declare const AMOUNT_MODES: {
+    id: AmountMode;
+    label: string;
+    needsStop?: true;
+}[];
+export declare const modeNeedsStop: (mode: AmountMode) => boolean;
+export interface SizingContext {
+    entry: number;
+    /** Ticks from entry to the stop. 0 when no stop is set */
+    stopTicks: number;
+    balance: number;
+    spec: ContractSpec;
+}
+export declare function qtyFromAmount(mode: AmountMode, amount: number, ctx: SizingContext): number;
+export declare function amountFromQty(mode: AmountMode, qty: number, ctx: SizingContext): number;
+export interface TicketInput {
+    side: OrderSide;
+    type: OrderType;
+    /** Ignored for market orders, which price off `mark` */
+    limitPrice: number;
+    stopPrice: number;
+    mark: number;
+    bid: number;
+    ask: number;
+    amountMode: AmountMode;
+    amount: number;
+    tpEnabled: boolean;
+    tpTicks: number;
+    slEnabled: boolean;
+    slTicks: number;
+    balance: number;
+    spec: ContractSpec;
+}
+export interface TicketProblem {
+    field: 'amount' | 'entry' | 'tp' | 'sl';
+    message: string;
+}
+export interface Ticket {
+    entry: number;
+    qty: number;
+    tickValue: number;
+    contractValue: number;
+    tpPrice: number | null;
+    slPrice: number | null;
+    risk: {
+        usd: number;
+        pct: number;
+    } | null;
+    reward: {
+        usd: number;
+        pct: number;
+    } | null;
+    /** Reward divided by risk. Null unless both sides are set */
+    rr: number | null;
+    spread: {
+        ticks: number;
+        usd: number;
+    };
+    problems: TicketProblem[];
+    ok: boolean;
+}
+export interface PositionGeometry {
+    entry: number;
+    upAmount: number;
+    downAmount: number;
+    qty: number;
+}
+export interface CopiedTicket {
+    side: OrderSide;
+    type: OrderType;
+    entry: number;
+    target: number;
+    stop: number;
+    qty: number;
+}
+export declare function ticketFromPosition(side: OrderSide, box: PositionGeometry, mark: number, spec: ContractSpec): CopiedTicket;
+export declare function deriveTicket(input: TicketInput): Ticket;

package/types/components/ui/button.d.ts

@@ -0,0 +1,11 @@
+import * as React from 'react';
+import { type VariantProps } from 'class-variance-authority';
+declare const buttonVariants: (props?: {
+    variant?: "link" | "default" | "destructive" | "outline" | "secondary" | "ghost";
+    size?: "icon" | "default" | "sm" | "lg";
+} & import("class-variance-authority/types").ClassProp) => string;
+export interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {
+    asChild?: boolean;
+}
+declare const Button: React.ForwardRefExoticComponent<ButtonProps & React.RefAttributes<HTMLButtonElement>>;
+export { Button, buttonVariants };

package/types/components/ui/checkbox.d.ts

@@ -0,0 +1,4 @@
+import * as React from "react";
+import * as CheckboxPrimitive from "@radix-ui/react-checkbox";
+declare const Checkbox: React.ForwardRefExoticComponent<Omit<CheckboxPrimitive.CheckboxProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+export { Checkbox };

package/types/components/ui/color-picker.d.ts

@@ -0,0 +1,12 @@
+import type { ButtonProps } from './button';
+interface ColorPickerProps {
+    value: string;
+    onChange: (value: string) => void;
+    onBlur?: () => void;
+    presets?: string[];
+    hideButton?: boolean;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+}
+declare const ColorPicker: import("react").ForwardRefExoticComponent<Omit<ButtonProps, "value" | "onBlur" | "onChange"> & ColorPickerProps & import("react").RefAttributes<HTMLInputElement>>;
+export { ColorPicker };

package/types/components/ui/dialog.d.ts

@@ -0,0 +1,19 @@
+import * as React from 'react';
+import * as DialogPrimitive from '@radix-ui/react-dialog';
+declare const Dialog: React.FC<DialogPrimitive.DialogProps>;
+declare const DialogTrigger: React.ForwardRefExoticComponent<DialogPrimitive.DialogTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const DialogPortal: React.FC<DialogPrimitive.DialogPortalProps>;
+declare const DialogClose: React.ForwardRefExoticComponent<DialogPrimitive.DialogCloseProps & React.RefAttributes<HTMLButtonElement>>;
+declare const DialogOverlay: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogOverlayProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DialogContent: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DialogHeader: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): React.JSX.Element;
+    displayName: string;
+};
+declare const DialogFooter: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): React.JSX.Element;
+    displayName: string;
+};
+declare const DialogTitle: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogTitleProps & React.RefAttributes<HTMLHeadingElement>, "ref"> & React.RefAttributes<HTMLHeadingElement>>;
+declare const DialogDescription: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogDescriptionProps & React.RefAttributes<HTMLParagraphElement>, "ref"> & React.RefAttributes<HTMLParagraphElement>>;
+export { Dialog, DialogPortal, DialogOverlay, DialogTrigger, DialogClose, DialogContent, DialogHeader, DialogFooter, DialogTitle, DialogDescription, };

package/types/components/ui/dropdown-menu.d.ts

@@ -0,0 +1,27 @@
+import * as React from "react";
+import * as DropdownMenuPrimitive from "@radix-ui/react-dropdown-menu";
+declare const DropdownMenu: React.FC<DropdownMenuPrimitive.DropdownMenuProps>;
+declare const DropdownMenuTrigger: React.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const DropdownMenuGroup: React.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuPortal: React.FC<DropdownMenuPrimitive.DropdownMenuPortalProps>;
+declare const DropdownMenuSub: React.FC<DropdownMenuPrimitive.DropdownMenuSubProps>;
+declare const DropdownMenuRadioGroup: React.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuRadioGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSubTrigger: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubTriggerProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSubContent: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuContent: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuItem: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuCheckboxItem: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuCheckboxItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuRadioItem: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuRadioItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuLabel: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuLabelProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSeparator: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSeparatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuShortcut: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLSpanElement>): React.JSX.Element;
+    displayName: string;
+};
+export { DropdownMenu, DropdownMenuTrigger, DropdownMenuContent, DropdownMenuItem, DropdownMenuCheckboxItem, DropdownMenuRadioItem, DropdownMenuLabel, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuGroup, DropdownMenuPortal, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuRadioGroup, };

package/types/components/ui/hover-card.d.ts

@@ -0,0 +1,6 @@
+import * as React from "react";
+import * as HoverCardPrimitive from "@radix-ui/react-hover-card";
+declare const HoverCard: React.FC<HoverCardPrimitive.HoverCardProps>;
+declare const HoverCardTrigger: React.ForwardRefExoticComponent<HoverCardPrimitive.HoverCardTriggerProps & React.RefAttributes<HTMLAnchorElement>>;
+declare const HoverCardContent: React.ForwardRefExoticComponent<Omit<HoverCardPrimitive.HoverCardContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { HoverCard, HoverCardTrigger, HoverCardContent };

package/types/components/ui/input.d.ts

@@ -0,0 +1,4 @@
+import * as React from 'react';
+declare const Input: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "ref"> & React.RefAttributes<HTMLInputElement>>;
+declare const InputWO: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "ref"> & React.RefAttributes<HTMLInputElement>>;
+export { Input, InputWO };

package/types/components/ui/popover.d.ts

@@ -0,0 +1,7 @@
+import * as React from "react";
+import * as PopoverPrimitive from "@radix-ui/react-popover";
+declare const Popover: React.FC<PopoverPrimitive.PopoverProps>;
+declare const PopoverTrigger: React.ForwardRefExoticComponent<PopoverPrimitive.PopoverTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const PopoverAnchor: React.ForwardRefExoticComponent<PopoverPrimitive.PopoverAnchorProps & React.RefAttributes<HTMLDivElement>>;
+declare const PopoverContent: React.ForwardRefExoticComponent<Omit<PopoverPrimitive.PopoverContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { Popover, PopoverTrigger, PopoverContent, PopoverAnchor };

package/types/components/ui/resizable.d.ts

@@ -0,0 +1,23 @@
+import * as ResizablePrimitive from 'react-resizable-panels';
+declare const ResizablePanelGroup: ({ className, ...props }: React.ComponentProps<typeof ResizablePrimitive.PanelGroup>) => import("react").JSX.Element;
+declare const ResizablePanel: import("react").ForwardRefExoticComponent<Omit<import("react").HTMLAttributes<HTMLDivElement | HTMLElement | HTMLSpanElement | HTMLCanvasElement | HTMLImageElement | HTMLVideoElement | HTMLButtonElement | HTMLObjectElement | HTMLAreaElement | HTMLLabelElement | HTMLMapElement | HTMLOptionElement | HTMLTitleElement | HTMLStyleElement | HTMLLinkElement | HTMLInputElement | HTMLAnchorElement | HTMLAudioElement | HTMLBaseElement | HTMLQuoteElement | HTMLBodyElement | HTMLBRElement | HTMLTableColElement | HTMLDataElement | HTMLDataListElement | HTMLModElement | HTMLDetailsElement | HTMLDialogElement | HTMLDListElement | HTMLEmbedElement | HTMLFieldSetElement | HTMLFormElement | HTMLHeadingElement | HTMLHeadElement | HTMLHRElement | HTMLHtmlElement | HTMLIFrameElement | HTMLLegendElement | HTMLLIElement | HTMLMetaElement | HTMLMeterElement | HTMLOListElement | HTMLOptGroupElement | HTMLOutputElement | HTMLParagraphElement | HTMLPreElement | HTMLProgressElement | HTMLSlotElement | HTMLScriptElement | HTMLSelectElement | HTMLSourceElement | HTMLTableElement | HTMLTemplateElement | HTMLTableSectionElement | HTMLTableCellElement | HTMLTextAreaElement | HTMLTimeElement | HTMLTableRowElement | HTMLTrackElement | HTMLUListElement | HTMLTableCaptionElement | HTMLMenuElement | HTMLPictureElement>, "id" | "onResize"> & {
+    className?: string | undefined;
+    collapsedSize?: number | undefined;
+    collapsible?: boolean | undefined;
+    defaultSize?: number | undefined;
+    id?: string | undefined;
+    maxSize?: number | undefined;
+    minSize?: number | undefined;
+    onCollapse?: ResizablePrimitive.PanelOnCollapse | undefined;
+    onExpand?: ResizablePrimitive.PanelOnExpand | undefined;
+    onResize?: ResizablePrimitive.PanelOnResize | undefined;
+    order?: number | undefined;
+    style?: object | undefined;
+    tagName?: keyof HTMLElementTagNameMap | undefined;
+} & {
+    children?: import("react").ReactNode;
+} & import("react").RefAttributes<ResizablePrimitive.ImperativePanelHandle>>;
+declare const ResizableHandle: ({ withHandle, className, ...props }: React.ComponentProps<typeof ResizablePrimitive.PanelResizeHandle> & {
+    withHandle?: boolean;
+}) => import("react").JSX.Element;
+export { ResizablePanelGroup, ResizablePanel, ResizableHandle };

package/types/components/ui/separator.d.ts

@@ -0,0 +1,4 @@
+import * as React from 'react';
+import * as SeparatorPrimitive from '@radix-ui/react-separator';
+declare const Separator: React.ForwardRefExoticComponent<Omit<SeparatorPrimitive.SeparatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { Separator };

package/types/components/ui/slider.d.ts

@@ -0,0 +1,4 @@
+import * as React from "react";
+import * as SliderPrimitive from "@radix-ui/react-slider";
+declare const Slider: React.ForwardRefExoticComponent<Omit<SliderPrimitive.SliderProps & React.RefAttributes<HTMLSpanElement>, "ref"> & React.RefAttributes<HTMLSpanElement>>;
+export { Slider };

package/types/components/ui/switch.d.ts

@@ -0,0 +1,4 @@
+import * as React from "react";
+import * as SwitchPrimitives from "@radix-ui/react-switch";
+declare const Switch: React.ForwardRefExoticComponent<Omit<SwitchPrimitives.SwitchProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+export { Switch };

package/types/components/ui/tooltip.d.ts

@@ -0,0 +1,7 @@
+import * as React from "react";
+import * as TooltipPrimitive from "@radix-ui/react-tooltip";
+declare const TooltipProvider: React.FC<TooltipPrimitive.TooltipProviderProps>;
+declare const Tooltip: React.FC<TooltipPrimitive.TooltipProps>;
+declare const TooltipTrigger: React.ForwardRefExoticComponent<Omit<TooltipPrimitive.TooltipTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const TooltipContent: React.ForwardRefExoticComponent<Omit<TooltipPrimitive.TooltipContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { Tooltip, TooltipTrigger, TooltipContent, TooltipProvider };

package/types/core/AccountManager.d.ts

@@ -0,0 +1,142 @@
+import type { TypedEventBus } from './TypedEventBus';
+import type { Fill, Order, Position } from '../lib/types/trading-types';
+import type { IAccountAdapter, AccountSnapshot } from '../interfaces/IAccountAdapter';
+import type { ExecutionEngine } from './ExecutionEngine';
+import type { FillSearchOptions } from '../lib/matchingEngine';
+export interface LedgerFill extends Fill {
+    /** Playhead timestamp (ns bigint) used for ledger ordering. Separate from Fill.ts. */
+    playheadTs: bigint;
+}
+export interface LedgerOrder {
+    id: string;
+    order: Order;
+    /** Playhead timestamp when the order was first placed (ns). */
+    placedAt: bigint;
+    /** Playhead timestamp of the most recent status update (ns). */
+    updatedAt: bigint;
+}
+export interface LedgerPosition {
+    id: string;
+    position: Position;
+    /** Playhead timestamp when this position was first opened (ns). */
+    openedAt: bigint;
+    /** Playhead timestamp when this position was closed (ns). Undefined = still open. */
+    closedAt?: bigint;
+    /** Realized P&L booked at close, in cash. Only set when closedAt is. */
+    realizedPnlAtClose?: number;
+}
+export interface LedgerAdjustment {
+    /** Positive = deposit, negative = withdrawal. */
+    amount: number;
+    ts: bigint;
+    note?: string;
+}
+/** One equity snapshot - recorded after every position close and balance adjustment. */
+export interface EquityPoint {
+    ts: bigint;
+    balance: number;
+    equity: number;
+    realizedPnl: number;
+}
+/** Performance stats derived from the visible closed-position set. */
+export interface AccountStats {
+    /** Positions closed with realizedPnlAtClose > 0. */
+    winCount: number;
+    /** Positions closed with realizedPnlAtClose <= 0. */
+    lossCount: number;
+    /** winCount / (winCount + lossCount). NaN when no closed positions. */
+    winRate: number;
+    /** Sum of winning P&L / |sum of losing P&L|. Infinity when no losers. */
+    profitFactor: number;
+    /** Mean realized risk-reward ratio across closed positions. */
+    avgRR: number;
+    /** Largest single-position winning P&L. */
+    largestWin: number;
+    /** Largest single-position losing P&L (negative number). */
+    largestLoss: number;
+    /** Average hold duration in nanoseconds for closed positions. */
+    avgHoldTimeNs: bigint;
+    /** Total exchange + clearing fees across all fills. */
+    totalFees: number;
+    /** Total broker commissions across all fills. */
+    totalCommission: number;
+    /** Number of orders currently in a terminal state (filled). */
+    filledOrderCount: number;
+    /** Number of orders cancelled or rejected. */
+    cancelledOrderCount: number;
+}
+export interface AccountOptions {
+    eventBus: TypedEventBus;
+    /** Execution engine, so the account can expose fill-search controls. */
+    executionEngine?: ExecutionEngine;
+    /** Starting cash balance. Default: 100_000 */
+    initialBalance?: number;
+    /**
+     * Settlement currency the balance is denominated in. Display only - contract
+     * details live on SymbolInfo, and nothing here converts between currencies.
+     * Default: 'USD'
+     */
+    currency?: string;
+    /** Custom adapter (e.g. live broker). If omitted, uses eventBus trading events. */
+    adapter?: IAccountAdapter;
+    adjustments?: LedgerAdjustment[];
+    fills?: LedgerFill[];
+    positions?: LedgerPosition[];
+    orders?: LedgerOrder[];
+}
+export declare class AccountManager {
+    private readonly eventBus;
+    readonly currency: string;
+    private initialBalance;
+    private fills;
+    private orders;
+    /** Keyed by position id for O(1) upsert. */
+    private positionMap;
+    /** Manual deposits / withdrawals - sorted by ts. */
+    private adjustments;
+    private horizonNs;
+    private adapter;
+    private executionEngine;
+    private unsubs;
+    private destroyed;
+    constructor(options: AccountOptions);
+    setFillSearch(patch: Partial<FillSearchOptions>): void;
+    getFillSearch(): FillSearchOptions | null;
+    setAdapter(adapter: IAccountAdapter | null): void;
+    deposit(amount: number, ts?: bigint, note?: string): void;
+    withdraw(amount: number, ts?: bigint, note?: string): void;
+    reset(): void;
+    /** Move the account view to time t. Everything derived recomputes. */
+    seekTo(tNs: bigint): void;
+    getSnapshot(): AccountSnapshot & {
+        fills: LedgerFill[];
+        orders: LedgerOrder[];
+        openPositions: LedgerPosition[];
+        closedPositions: LedgerPosition[];
+        stats: AccountStats;
+        equityCurve: EquityPoint[];
+    };
+    private _ingestFill;
+    private _ingestOrder;
+    private _ingestPositionUpdate;
+    private _ingestPositionClose;
+    private _ingestAdjustment;
+    private _deriveTotals;
+    private _deriveBalance;
+    private _buildEquityCurve;
+    private _buildStats;
+    private _emit;
+    private _subscribeEventBus;
+    private _insertIdxByPlayheadTs;
+    private _insertIdxByTs;
+    serialize(): AccountSaveState;
+    restore(state: AccountSaveState): void;
+    destroy(): void;
+}
+export interface AccountSaveState {
+    initialBalance: number;
+    fills: LedgerFill[];
+    orders: LedgerOrder[];
+    positions: LedgerPosition[];
+    adjustments: LedgerAdjustment[];
+}

package/types/core/ChartModel.d.ts

@@ -0,0 +1,84 @@
+import { type Timeframe } from '../lib/timeframes';
+import type { DrawingTool } from '../lib/types/drawing-types';
+import type { FootprintOptions } from '../lib/types/footprint';
+import type { ChartSettings } from '../lib/types/chart-settings';
+/**
+ * A pane's reference to a plugin from the shared pool. The plugin's code lives
+ * once in the pool; the pane only stores which one it uses and how.
+ */
+export interface ChartPluginRef {
+    /** Plugin id in the shared pool. */
+    id: string;
+    /** Unique per activation, so the same plugin can be added more than once. */
+    instanceId: string;
+    /** User inputs for this instance (e.g. an indicator's `settings`). */
+    config?: Record<string, unknown>;
+    /**
+     * State the plugin explicitly persisted through its storage. Never derived
+     * series - those recompute from price action on restore.
+     */
+    state?: Record<string, unknown>;
+}
+export interface ChartModelInit {
+    id?: string;
+    symbol: string;
+    timeframe: Timeframe;
+    settings?: ChartSettings;
+    activeTool?: DrawingTool;
+    fpOptions?: FootprintOptions;
+    plugins?: ChartPluginRef[];
+}
+/**
+ * Serializable snapshot of one pane. Drawings aren't here - they belong to the
+ * symbol, see DrawingStore. `settings` is a diff against
+ * DEFAULT_CHART_SETTINGS, and `timeframe` is the label, re-resolved on restore.
+ */
+export interface ChartPaneState {
+    id: string;
+    symbol: string;
+    timeframe: string;
+    settings: Partial<ChartSettings>;
+    plugins: ChartPluginRef[];
+}
+type Listener = (model: ChartModel) => void;
+export declare class ChartModel {
+    readonly id: string;
+    private _symbol;
+    private _timeframe;
+    private _settings;
+    private _activeTool;
+    private _fpOptions;
+    private _plugins;
+    private _restoredPlugins;
+    private listeners;
+    constructor(init: ChartModelInit);
+    get symbol(): string;
+    setSymbol(symbol: string): void;
+    get timeframe(): Timeframe;
+    setTimeframe(tf: Timeframe): void;
+    get activeTool(): DrawingTool;
+    setActiveTool(tool: DrawingTool): void;
+    get fpOptions(): FootprintOptions;
+    setFpOptions(fpOptions: FootprintOptions): void;
+    get settings(): Readonly<ChartSettings>;
+    /** Merge a patch into this pane's settings. Independent per pane. */
+    setSettings(patch: Partial<ChartSettings>): void;
+    get plugins(): readonly ChartPluginRef[];
+    /** Activate a pool plugin on this pane, or replace an existing instance. */
+    use(ref: ChartPluginRef): void;
+    unuse(instanceId: string): void;
+    /** Replace the whole set of refs, e.g. mirrored from a pane's live list. */
+    setPlugins(refs: ChartPluginRef[]): void;
+    /** Plugin refs from a restore awaiting reconstruction into live indicators. */
+    get restoredPlugins(): readonly ChartPluginRef[];
+    /** Drop a restored ref once its indicator is back, so removing it later
+     *  doesn't re-add it. */
+    consumeRestoredPlugin(instanceId: string): void;
+    serialize(): ChartPaneState;
+    /** Apply a saved pane snapshot. Panes read this on init, and the live owner
+     *  mirrors it back out from then on. */
+    restore(state: ChartPaneState): void;
+    subscribe(fn: Listener): () => void;
+    private _notify;
+}
+export {};

package/types/core/ChartState.d.ts

@@ -0,0 +1,51 @@
+import type { TypedEventBus } from './TypedEventBus';
+import type { ActiveDrawingTool } from '../lib/types/drawing-types';
+import type { FootprintOptions } from '../lib/types/footprint';
+import { Timeframe } from '../lib/timeframes';
+import type { SyncInLayout } from '../lib/types/layout-sync';
+export interface ChartStateShape {
+    /** Drawing tool armed for creation. `cursor` when nothing is armed. */
+    activeTool: ActiveDrawingTool;
+    /** Id of the selected drawing, or null. Kept apart from activeTool, since
+     *  selecting a drawing must not arm its tool. */
+    selectedDrawingId: string | null;
+    /** Symbol being charted. */
+    symbol: string;
+    /** Footprint display options. */
+    fpOptions: FootprintOptions;
+    /** Whether playback is currently running. */
+    isPlaying: boolean;
+    /** ISO horizon string, used by DataEngine to align the initial data. */
+    horizonIso: string;
+    timeframe: Timeframe;
+    layout: {
+        id: string;
+        label: string;
+        count: number;
+        cols: number;
+        rows: number;
+        areas: string;
+    };
+    /** Which properties a layout's cells share - crosshair, symbol, interval,
+     *  time, date range. */
+    syncInLayout?: SyncInLayout;
+    /** Divider sizes (fr) for the grid, plus the focused pane index. */
+    gridColSizes?: number[];
+    gridRowSizes?: number[];
+    focusedPane?: number;
+}
+export declare class ChartState {
+    private _state;
+    constructor(initial: ChartStateShape);
+    get<K extends keyof ChartStateShape>(key: K): ChartStateShape[K];
+    /** Shallow-frozen snapshot of the whole state. For plugins and debugging,
+     *  not a hot path. */
+    snapshot(): Readonly<ChartStateShape>;
+    set<K extends keyof ChartStateShape>(key: K, value: ChartStateShape[K], eventBus?: TypedEventBus): void;
+    /**
+     * Update several fields at once, emitting for each changed one that has a
+     * mapping. For when fields move together, like a timeframe switch touching
+     * both barNs and fpOptions.
+     */
+    patch(partial: Partial<ChartStateShape>, eventBus?: TypedEventBus): void;
+}

package/types/core/ChartTypeRegistry.d.ts

@@ -0,0 +1,27 @@
+export interface PluginChartTypeInitContext {
+    data: unknown;
+}
+export interface PluginChartTypeUpdateContext {
+    data: unknown;
+}
+export interface PluginChartTypeDrawContext {
+    ctx: CanvasRenderingContext2D;
+    width: number;
+    height: number;
+}
+export interface PluginChartTypeDef {
+    id: string;
+    name: string;
+    icon?: any;
+    init(ctx: PluginChartTypeInitContext): void;
+    update(ctx: PluginChartTypeUpdateContext): void;
+    draw(ctx: PluginChartTypeDrawContext): void;
+}
+export declare class ChartTypeRegistry {
+    private types;
+    register(def: PluginChartTypeDef): () => void;
+    get(id: string): PluginChartTypeDef | undefined;
+    getAll(): PluginChartTypeDef[];
+    has(id: string): boolean;
+}
+export declare const chartTypeRegistry: ChartTypeRegistry;