@christtrade/depth 0.12.21

package/types/lib/types/indicator-types.d.ts

@@ -0,0 +1,123 @@
+import { LiveTransformer } from '../../core';
+import type { DataLevel } from '../../interfaces/IDataAdapter';
+import type { Crosshair } from '../renderers/renderer';
+/** Pixel region a pane occupies on the canvas (absolute coordinates). */
+export type Rect = {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+};
+export interface ChartPane {
+    id: string;
+    isMain: boolean;
+    heightRatio: number;
+    label?: string;
+    yMin: number;
+    yMax: number;
+    yAxisAuto: boolean;
+    collapsed: boolean;
+    savedHeightRatio?: number;
+    symbol?: string;
+    tf?: string;
+    exchange?: string;
+}
+/**
+ * Everything an indicator needs to draw itself.
+ * `rect` uses LOCAL coordinates (origin = top-left of this pane).
+ *
+ * `horizon` is the current playback horizon in nanoseconds.
+ * Indicators MUST use this to clip their output - never draw data beyond
+ * horizon. This is the only way to guarantee no future data leaks at
+ * sub-bar precision. tMax is the rightmost visible timestamp of the view
+ * and is unrelated to horizon.
+ */
+export interface RenderContext {
+    ctx: CanvasRenderingContext2D;
+    /** Local rect - origin is (0, 0) after ctx.translate has been applied. */
+    rect: Rect;
+    /** Shared time axis (nanoseconds). */
+    tMin: bigint;
+    tMax: bigint;
+    /** Pane-local price / value axis. */
+    yMin: number;
+    yMax: number;
+    /** Active bar duration in nanoseconds (0n = tick/raw mode). */
+    barNs: bigint;
+    /**
+     * Current playback horizon in nanoseconds.
+     * Clip all drawing to ts <= horizon. Do not draw anything beyond this
+     * timestamp - doing so leaks future data.
+     *
+     * 0n means no horizon is active (live / full-history mode), in which
+     * case you can draw everything.
+     */
+    horizon: bigint;
+    transformer: LiveTransformer;
+}
+export interface Indicator {
+    id: string;
+    name: string;
+    visible: boolean;
+    layout: 'overlay' | 'pane';
+    paneId?: string;
+    category?: string;
+    shortName?: string;
+    description?: string;
+    /**
+     * Minimum data level this indicator can be computed from. Defaults to
+     * 'ohlcv'. Activation is refused on a symbol that serves less than this -
+     * the alternative is an indicator that draws nothing and looks broken.
+     */
+    require?: DataLevel;
+    settings: any;
+    /**
+     * Serialized init function - runs in the indicator worker on full load
+     * (initial data load, backward seek, timeframe change).
+     *
+     * Signature: (input: { trades: SerialTrade[], barNs: bigint, params?: unknown }) => State
+     *
+     * Returns the full computed state. Must be pure - no imports, no closures.
+     * The returned State is stored in the worker and passed to workerUpdate
+     * on every horizon tick.
+     */
+    workerInit: string;
+    /**
+     * Serialized incremental update function - runs in the indicator worker
+     * on every horizon advance tick (hot path: called up to 1200 times/s at 20x).
+     *
+     * Signature: (input: { newTrades: SerialTrade[], state: State, barNs: bigint, horizon: bigint, params?: unknown }) => { points: OutputPoints, state: State }
+     *
+     * `newTrades` contains only the trades since the last horizon position.
+     * `state` is whatever workerInit (or the previous workerUpdate) returned.
+     * Returns new output points to append, plus the updated state.
+     *
+     * Must be pure - no imports, no closures.
+     */
+    workerUpdate: string;
+    /**
+     * Called on the main thread after workerInit completes (full load /
+     * backward seek). Replaces all stored output data.
+     *
+     * `data` is whatever workerInit returned.
+     */
+    hydrate(data: unknown, barNs: bigint): void;
+    /**
+     * Called on the main thread after workerUpdate completes (horizon advance).
+     * Appends the new output points to existing stored data - never replaces.
+     *
+     * `points` is whatever workerUpdate returned in the `points` field.
+     */
+    appendHydrate(points: unknown, barNs: bigint): void;
+    drawBase?(ctx: RenderContext): void;
+    drawUI?(ctx: RenderContext, crosshair: Crosshair): void;
+    getAutoYBounds?(tMin: bigint, tMax: bigint, horizon: bigint): {
+        min: number;
+        max: number;
+    } | null;
+}
+export declare const PANE_DIVIDER_HIT = 6;
+export declare const PANE_MIN_HEIGHT_RATIO = 0.05;
+export declare function getPaneLayouts(panes: ChartPane[], totalH: number, canvasW: number, yAxisWidth: number): Record<string, Rect>;
+export declare function hitTestDivider(mouseY: number, panes: ChartPane[], layouts: Record<string, Rect>): number;
+export declare function hitTestPane(mouseY: number, panes: ChartPane[], layouts: Record<string, Rect>): ChartPane | null;

package/types/lib/types/layout-sync.d.ts

@@ -0,0 +1,43 @@
+/** Which properties are shared between the cells of a layout. */
+export type SyncInLayout = {
+    /** Changing a cell's symbol changes every cell's symbol. */
+    symbol: boolean;
+    /** Changing a cell's timeframe changes every cell's timeframe. */
+    interval: boolean;
+    /** The hovered cell's crosshair is mirrored (by time/price) onto the others. */
+    crosshair: boolean;
+    /** Scrolling a cell scrolls the others to the same right edge - each keeps its own zoom. */
+    time: boolean;
+    /** Panning/zooming a cell gives the others the exact same visible range. */
+    dateRange: boolean;
+};
+export declare const DEFAULT_SYNC_IN_LAYOUT: SyncInLayout;
+/**
+ * A crosshair position expressed in *data* space so any other cell can place it
+ * on its own axes, whatever it is showing or however it is zoomed.
+ *
+ * Sent once per pointer move by the hovered cell - never per frame. Receivers
+ * keep the payload and re-project it every time they paint, so panning or
+ * zooming a follower keeps the mirrored crosshair pinned to the same bar
+ * without another message.
+ */
+export type CrosshairSync = {
+    /** Cell that owns the pointer. Receivers ignore their own id. */
+    id: number;
+    /** Time under the cursor (ns). Drives the mirrored vertical line. */
+    ts: bigint;
+    /** Value under the cursor, in the source pane's own scale. */
+    price: number;
+    /** Pane the cursor is in ('main' or an indicator pane id). */
+    paneId: string;
+    /** Cursor position inside that pane, 0 (top) -> 1 (bottom). */
+    yFrac: number;
+    /** Source symbol - the price only carries over to cells showing the same one. */
+    symbol: string | null;
+};
+/** The visible time range of the cell the user is scrolling/zooming. */
+export type TimeRangeSync = {
+    id: number;
+    tMin: bigint;
+    tMax: bigint;
+};

package/types/lib/types/trading-types.d.ts

@@ -0,0 +1,323 @@
+export type OrderSide = 'long' | 'short';
+export type PositionSide = 'long' | 'short' | 'flat';
+export type OrderType = 'market' | 'limit' | 'stop' | 'stop_limit';
+export type OrderStatus = 'pending' | 'working' | 'partial' | 'filled' | 'cancelled' | 'rejected';
+export type PositionStatus = 'open' | 'closed' | 'partially_closed';
+export type TimeInForce = 'gtc' | 'day' | 'ioc' | 'fok' | 'gtd';
+export type CloseReason = 'manual' | 'tp' | 'sl' | 'order' | 'market' | 'limit' | 'stop';
+export type CommissionConfig = {
+    type: 'fixed' | 'percent';
+    /** fixed: $ per fill - percent: % of notional */
+    value: number;
+};
+export type SlippageConfig = {
+    type: 'ticks' | 'percent';
+    /** ticks: number of ticks - percent: % of price */
+    value: number;
+};
+export type BracketLevel = {
+    /** Stable id - use nanoid(). Lets the engine match broker updates without
+     *  relying on array position. Required when round-tripping through a broker. */
+    id: string;
+    /** Price to trigger the TP or SL order. */
+    price: number;
+    /** Contracts / shares to close at this level. Must be > 0. */
+    qty: number;
+    /** Set by the engine when the bracket order is triggered. */
+    triggered: boolean;
+    /** Unix ns when triggered. 0 = not yet triggered. */
+    triggeredAt: number;
+};
+export type BracketSpec = {
+    takeProfits?: BracketLevel[];
+    stopLosses?: BracketLevel[];
+};
+export type Order = {
+    id: string;
+    symbol: string;
+    side: OrderSide;
+    type: OrderType;
+    /** Total order quantity (contracts / shares). Always positive. */
+    quantity: number;
+    /** Limit price - required for 'limit' and 'stop_limit'. */
+    price: number;
+    /** Stop trigger price - required for 'stop' and 'stop_limit'. */
+    stopPrice: number;
+    tif: TimeInForce;
+    /** If true, will only reduce an existing position; will never open or flip. */
+    reduceOnly: boolean;
+    /** Apply reduce logic to this specific position first (multi-position setups). */
+    targetPositionId?: string;
+    /** Bracket to attach to the position this order opens. */
+    bracket: BracketSpec;
+    status: OrderStatus;
+    filledQuantity: number;
+    /** Volume-weighted average fill price. */
+    avgPrice: number;
+    /** Internal flag for STOP_LIMIT - set by engine when stop is triggered. */
+    triggered: boolean;
+    createdAt: number;
+    updatedAt: number;
+    fees: number;
+    commission: number;
+    slippage: number;
+    metadata: Record<string, any>;
+};
+export type Fill = {
+    id: string;
+    orderId: string;
+    symbol: string;
+    side: OrderSide;
+    price: number;
+    quantity: number;
+    ts: number;
+    fee: number;
+    feeCurrency: string;
+    /** Id of the position opened by this fill. */
+    openedPositionId?: string;
+    /** Ids of positions reduced by this fill. */
+    reducedPositionIds?: string[];
+};
+export type PositionClose = {
+    timestamp: number;
+    price: number;
+    quantity: number;
+    /** Gross PnL for this close (price diff x qty x tickValue). */
+    pnl: number;
+    /** Net PnL after per-close costs and allocated open-leg costs. */
+    pnlNet: number;
+    reason: CloseReason;
+    orderId: string;
+    orderType: OrderType;
+    tpId?: string;
+    slId?: string;
+    /** Realized risk-reward ratio after this close. */
+    realizedRRAfter: number;
+    fees: number;
+    commission: number;
+    slippage: number;
+    spread: number;
+    /** Portion of open-leg costs allocated to this close (for auditing). */
+    openCostAllocated?: number;
+    notes?: object[];
+    tags?: object[];
+};
+export type Position = {
+    id: string;
+    symbol: string;
+    side: PositionSide;
+    type: OrderType;
+    status: PositionStatus;
+    /** Quantity at open. Immutable after creation. */
+    startingQuantity: number;
+    /** Current open quantity (startingQuantity minus qty from closes[]). */
+    remainingQuantity: number;
+    /** Volume-weighted average entry price. */
+    entryPrice: number;
+    /** Mark price for live PnL - updated by tick(). */
+    currentPrice?: number;
+    unrealizedPnl: number;
+    unrealizedPnlPct: number;
+    /** Cumulative gross realized PnL across all closes[]. */
+    realizedPnl: number;
+    /** Initial risk per unit (|entry - initialSL|). Set once at open. */
+    initialRiskPerUnit: number;
+    /** Total initial risk (initialRiskPerUnit x startingQuantity). */
+    initialRiskTotal: number;
+    /** Unix ns when initialRisk was locked in. 0 = not yet locked. */
+    initialRiskLockedAt: number;
+    /** Intended RR at open (set by the user pre-trade). */
+    initialRR: number;
+    /** Running realized RR (realizedPnl / initialRiskTotal). */
+    realizedRR: number;
+    /** Best realized RR reached while the position was open. */
+    maxFavorableR: number;
+    /** Worst realized RR reached while the position was open. */
+    maxAdverseR: number;
+    /** Highest mark price seen (long) / lowest mark price seen (short). */
+    highWatermark: number;
+    /** Lowest mark price seen (long) / highest mark price seen (short). */
+    lowWatermark: number;
+    /** Maximum adverse excursion - worst price against the position. */
+    maeAbs: number;
+    /** Maximum favorable excursion - best price in favour. */
+    mfeAbs: number;
+    /** Largest drawdown from the high-watermark in price units. */
+    maxDrawdownAbs: number;
+    maxDrawdownPct: number;
+    takeProfits: BracketLevel[];
+    stopLosses: BracketLevel[];
+    /** Break-even level - single price, does not close quantity. */
+    bePrice?: number;
+    /** One entry per partial or full close. */
+    closes: PositionClose[];
+    spread: number;
+    feesTotal: number;
+    commissionTotal: number;
+    slippageTotal: number;
+    /** (commission_open + fees_open) / startingQuantity - for proportional allocation on partial closes. */
+    openCostPerUnit: number;
+    openCostTotal: number;
+    openedAt: number;
+    closedAt?: number;
+    updatedAt: number;
+    notes?: object[];
+    tags?: object[];
+    checklist?: object[];
+    rating?: number;
+    emotion?: object[];
+    images?: object[];
+    tradeType?: string;
+    confidence?: number;
+    playbookAdherence?: number;
+    metadata?: Record<string, any>;
+};
+export type CreatePositionParams = {
+    symbol: string;
+    side: PositionSide;
+    type: OrderType;
+    entryPrice: number;
+    quantity: number;
+    timestamp: number;
+    takeProfits?: Array<{
+        price: number;
+        qty: number;
+    }>;
+    stopLosses?: Array<{
+        price: number;
+        qty: number;
+    }>;
+    metadata: Record<string, any>;
+    notes?: object[];
+    tags?: object[];
+    checklist?: object[];
+    rating?: number;
+    emotion?: object[];
+    images?: object[];
+    confidence?: number;
+    playbookAdherence?: number;
+    tradeType?: string;
+};
+export type ClosePositionParams = {
+    positionId: string;
+    price: number;
+    /** Defaults to full remainingQuantity if omitted. */
+    quantity: number;
+    timestamp: number;
+    reason: CloseReason;
+    orderId?: string;
+    orderType?: OrderType;
+    tpId?: string;
+    slId?: string;
+    fees: number;
+    commission: number;
+    slippage: number;
+};
+export type CreateOrderParams = {
+    symbol: string;
+    side: OrderSide;
+    type: OrderType;
+    quantity: number;
+    price: number;
+    stopPrice: number;
+    tif: TimeInForce;
+    reduceOnly: boolean;
+    timestamp: number;
+    targetPositionId?: string;
+    bracket?: BracketSpec;
+    metadata: Record<string, any>;
+    fees: number;
+    commission: number;
+    slippage: number;
+    notes?: object[];
+    tags?: object[];
+};
+export type PriceTick = {
+    symbol: string;
+    bid: number;
+    ask: number;
+    last?: number;
+    ts: number;
+};
+export type BracketAmendment = {
+    positionId: string;
+    which: 'tp' | 'sl' | 'be';
+    /** 0-based array index in takeProfits / stopLosses. */
+    index: number;
+    /** BracketLevel.id */
+    levelId: string;
+    price: number;
+    qty: number;
+    /**
+     * Drop this level instead of repricing it (the x on a TP/SL line).
+     *
+     * Removal goes through the same call as a move on purpose: whoever is
+     * managing the position - the built-in engine or a broker adapter - has to
+     * hear about it, or the level stays armed after the user has taken it off
+     * the chart. `price` and `qty` are ignored when this is set.
+     */
+    remove?: boolean;
+};
+export type TradingEventKind = 'order:placed' | 'order:updated' | 'order:cancelled' | 'order:filled' | 'order:rejected' | 'position:opened' | 'position:updated' | 'position:closed' | 'fill:received';
+export type TradingEvent = {
+    kind: 'order:placed';
+    order: Order;
+} | {
+    kind: 'order:updated';
+    order: Order;
+} | {
+    kind: 'order:cancelled';
+    order: Order;
+} | {
+    kind: 'order:filled';
+    order: Order;
+    fill: Fill;
+} | {
+    kind: 'order:rejected';
+    order: Order;
+    reason?: string;
+} | {
+    kind: 'position:opened';
+    position: Position;
+} | {
+    kind: 'position:updated';
+    position: Position;
+} | {
+    kind: 'position:closed';
+    position: Position;
+    realizedPnl: number;
+} | {
+    kind: 'fill:received';
+    fill: Fill;
+};
+export type PositionsSnapshot = {
+    positions: Position[];
+    orders: Order[];
+    positionCounter: number;
+    orderCounter: number;
+    lastState: {
+        lastPriceBySymbol: Record<string, number>;
+        lastSpreadBySymbol: Record<string, number>;
+        lastBarEndBySymbol: Record<string, number>;
+        currentTimeBySymbol: Record<string, number>;
+        tradeCosts: {
+            commission: CommissionConfig;
+            slippage: SlippageConfig;
+            fees: number;
+        };
+        defaultNonFuturesTickSize?: number;
+    };
+};
+/**
+ * What one point is worth on one contract, for a symbol with no spec attached.
+ *
+ * Micros are tested first: every micro's ticker contains its mini's, so "MNQ"
+ * matched the NQ branch and a micro trade was valued at ten times its size.
+ * A symbol that carries a `ContractSpec` never reaches here - this is only the
+ * floor under adapters that supply nothing.
+ */
+export declare function getTickValue(symbol: string): number;
+export declare function calcUnrealizedPnl(position: Position, markPrice: number, tickValue: number): number;
+export declare function calcUnrealizedPnlPct(position: Position, markPrice: number, tickValue: number): number;
+export declare function formatPnl(pnl: number, decimals?: number): string;
+export declare function formatPnlPct(pct: number): string;

package/types/lib/use-forwarded-ref.d.ts

@@ -0,0 +1 @@
+export declare function useForwardedRef<T>(forwardedRef: React.ForwardedRef<T>): React.MutableRefObject<T | null>;

package/types/lib/utils.d.ts

@@ -0,0 +1,2 @@
+import { type ClassValue } from 'clsx';
+export declare function cn(...inputs: ClassValue[]): string;

package/types/plugins/alligator.d.ts

@@ -0,0 +1 @@
+export declare const alligatorIndi = "\nconst alligatorIndi = plugin({\n    name: \"Alligator\",\n    shortName: \"ALLI\",\n    description: \"Bill Williams' three displaced balance lines\",\n    type: PluginType.indicator,\n    require: DataLevel.ohlcv,\n    version: \"1.0.0\",\n    lookback: 100,\n    params: {\n        jawShift:   { label: \"Jaw shift\", type: \"stepperInt\", default: 8, min: 0, max: 50 },\n        teethShift: { label: \"Teeth shift\", type: \"stepperInt\", default: 5, min: 0, max: 50 },\n        lipsShift:  { label: \"Lips shift\", type: \"stepperInt\", default: 3, min: 0, max: 50 }\n    }\n})\n\nconst JAW = \"#08b3de\"\nconst TEETH = \"#ef5350\"\nconst LIPS = \"#26a69a\"\n\nalligatorIndi.init = function({ data, barNs, params }) {\n    const bars = data.ohlcv\n    const n = bars.length\n    if (!n) return { jaw: [], teeth: [], lips: [] }\n\n    const { jaw, teeth, lips } = alligator(bars)\n    const tsAt = i => i < n ? bars[i].ts : bars[n - 1].ts + BigInt(i - n + 1) * barNs\n\n    const shifted = (values, shift) => {\n        const step = barNs > 0n ? shift : 0\n        const out = []\n        for (let i = 0; i < n; i++) {\n            if (isNaN(values[i])) continue\n            out.push({ t: tsAt(i + step), price: values[i] })\n        }\n        return out\n    }\n\n    return {\n        jaw: shifted(jaw, params.jawShift),\n        teeth: shifted(teeth, params.teethShift),\n        lips: shifted(lips, params.lipsShift)\n    }\n}\n\nalligatorIndi.draw = function(s) {\n    return [\n        drawLine(s.jaw, JAW, 1),\n        drawLine(s.teeth, TEETH, 1),\n        drawLine(s.lips, LIPS, 1)\n    ]\n}";

package/types/plugins/atr.d.ts

@@ -0,0 +1 @@
+export declare const atrIndi = "\nconst atrIndi = plugin({\n    name: \"Average True Range\",\n    shortName: \"ATR\",\n    description: \"Wilder-smoothed range, in price units\",\n    type: PluginType.indicator,\n    require: DataLevel.ohlcv,\n    layout: Layout.pane,\n    version: \"1.0.0\",\n    lookback: 150,\n    params: {\n        length: { label: \"Length\", type: \"number\", default: 14, min: 1, max: 300 },\n        smoothing: { label: \"Average\", type: \"number\", default: 0, min: 0, max: 300 },\n        line:   { label: \"ATR\", type: \"color\", default: \"#f5a623\" },\n        avg:    { label: \"Average\", type: \"color\", default: \"#787b86\" }\n    }\n})\n\natrIndi.init = function({ data, params }) {\n    const bars = data.ohlcv\n    const ts = bars.map(b => b.ts)\n    const values = atr(bars, params.length)\n\n    return {\n        atr: toPoints(ts, values),\n        avg: params.smoothing >= 2 ? toPoints(ts, sma(values, params.smoothing)) : [],\n        line: params.line,\n        avgColor: params.avg\n    }\n}\n\natrIndi.draw = function(s) {\n    const out = [\n        fillBetween(s.atr, 0, { mode: 'solid', color: s.line + '14' }),\n        drawLine(s.atr, s.line, 2)\n    ]\n\n    if (s.avg.length) out.push(drawLine(s.avg, s.avgColor, 1, [4, 4]))\n    return out\n}";

package/types/plugins/awesome-oscillator.d.ts

@@ -0,0 +1 @@
+export declare const awesomeIndi = "\nconst awesome = plugin({\n    name: \"Awesome Oscillator\",\n    shortName: \"AO\",\n    description: \"Fast minus slow median-price average\",\n    type: PluginType.indicator,\n    require: DataLevel.ohlcv,\n    layout: Layout.pane,\n    version: \"1.0.0\",\n    lookback: 150,\n    params: {\n        fast: { label: \"Fast\", type: \"number\", default: 5, min: 1, max: 200 },\n        slow: { label: \"Slow\", type: \"number\", default: 34, min: 2, max: 400 },\n        up:   { label: \"Rising\", type: \"color\", default: \"#26a69a\" },\n        down: { label: \"Falling\", type: \"color\", default: \"#ef5350\" }\n    }\n})\n\nawesome.init = function({ data, params }) {\n    const bars = data.ohlcv\n    const hl2 = bars.map(b => (b.high + b.low) / 2)\n    const fast = sma(hl2, params.fast)\n    const slow = sma(hl2, params.slow)\n\n    const pts = []\n    const colors = []\n    let prev = NaN\n\n    for (let i = 0; i < bars.length; i++) {\n        const v = fast[i] - slow[i]\n        if (isNaN(v)) continue\n        pts.push({ t: bars[i].ts, price: v })\n        colors.push(isNaN(prev) || v >= prev ? params.up : params.down)\n        prev = v\n    }\n\n    return { pts, colors }\n}\n\nawesome.draw = function(s) {\n    return [\n        drawHistogram(s.pts, s.colors, 0, 0.25),\n        drawHLine(0, \"#ffffff1f\", 1)\n    ]\n}";

package/types/plugins/bollinger-bands.d.ts

@@ -0,0 +1 @@
+export declare const bbIndi = "\nconst bollinger = plugin({\n    name: \"Bollinger Bands\",\n    shortName: \"BB\",\n    description: \"Standard-deviation envelope around a moving average\",\n    type: PluginType.indicator,\n    require: DataLevel.ohlcv,\n    version: \"1.0.0\",\n    lookback: 120,\n    params: {\n        length: { label: \"Length\", type: \"number\", default: 20, min: 2, max: 500 },\n        mult:   { label: \"Std dev\", type: \"number\", default: 2, min: 0.1, max: 10, step: 0.1 },\n        band:   { label: \"Bands\", type: \"color\", default: \"#08b3de\" },\n        basis:  { label: \"Basis\", type: \"color\", default: \"#f5a623\" },\n        fill:   { label: \"Shade channel\", type: \"boolean\", default: true }\n    }\n})\n\nbollinger.init = function({ data, params }) {\n    const bars = data.ohlcv\n    const ts = bars.map(b => b.ts)\n    const { upper, mid, lower } = bb(bars, params.length, params.mult)\n\n    return {\n        upper: toPoints(ts, upper),\n        mid: toPoints(ts, mid),\n        lower: toPoints(ts, lower),\n        band: params.band,\n        basis: params.basis,\n        fill: params.fill\n    }\n}\n\nbollinger.draw = function(s) {\n    const out = []\n\n    if (s.fill) {\n        out.push(fillBetween(s.upper, s.lower, { mode: 'solid', color: s.band + '12' }))\n    }\n\n    out.push(drawLine(s.upper, s.band, 1))\n    out.push(drawLine(s.lower, s.band, 1))\n    out.push(drawLine(s.mid, s.basis, 1, [5, 4]))\n\n    return out\n}";

package/types/plugins/cci.d.ts

@@ -0,0 +1 @@
+export declare const cciIndi = "\nconst cciIndi = plugin({\n    name: \"Commodity Channel Index\",\n    shortName: \"CCI\",\n    description: \"Typical price against its mean deviation\",\n    type: PluginType.indicator,\n    require: DataLevel.ohlcv,\n    layout: Layout.pane,\n    version: \"1.0.0\",\n    lookback: 100,\n    params: {\n        length: { label: \"Length\", type: \"number\", default: 20, min: 2, max: 300 },\n        level:  { label: \"Level\", type: \"number\", default: 100, min: 10, max: 400 },\n        line:   { label: \"CCI\", type: \"color\", default: \"#08b3de\" }\n    }\n})\n\ncciIndi.init = function({ data, params }) {\n    const bars = data.ohlcv\n    const values = cci(bars, params.length)\n\n    return {\n        cci: toPoints(bars.map(b => b.ts), values),\n        level: params.level,\n        line: params.line\n    }\n}\n\ncciIndi.draw = function(s) {\n    return [\n        fillBetween(s.level, -s.level, { mode: 'solid', color: '#ffffff08' }),\n        drawHLine(s.level, \"#ffffff1f\", 1, [4, 4]),\n        drawHLine(0, \"#ffffff12\", 1),\n        drawHLine(-s.level, \"#ffffff1f\", 1, [4, 4]),\n        drawLine(s.cci, s.line, 2)\n    ]\n}";

package/types/plugins/cvd.d.ts

@@ -0,0 +1 @@
+export declare const cvdIndi = "\nconst cvd = plugin({\n    name: \"Cumulative Volume Delta\",\n    shortName: \"CVD\",\n    description: \"Running aggressor imbalance, bucketed per bar\",\n    type: PluginType.indicator,\n    require: DataLevel.l3,\n    layout: Layout.pane,\n    version: \"1.0.0\",\n    params: {\n        up:   { label: \"Rising\", type: \"color\", default: \"#26a69a\" },\n        down: { label: \"Falling\", type: \"color\", default: \"#ef5350\" },\n        deltaBars: { label: \"Per-bar delta\", type: \"checkbox\", default: true }\n    }\n})\n\n// Trades arrive as { ts, price, size, side } - 'B' lifted the ask, 'A' hit the bid.\n// Everything is folded in place: only the bar the trade lands in is touched, and\n// draw() reads the arrays as they stand.\nfunction fold(state, trades) {\n    for (const trade of trades) {\n        const bar = state.barNs > 0n ? trade.ts / state.barNs * state.barNs : trade.ts\n        const signed = trade.side === 'B' ? trade.size : -trade.size\n        state.total += signed\n\n        const i = state.pts.length - 1\n        if (i >= 0 && state.pts[i].t === bar) {\n            state.pts[i].price = state.total\n            state.delta[i].price += signed\n        } else {\n            state.pts.push({ t: bar, price: state.total })\n            state.delta.push({ t: bar, price: signed })\n            state.lineColors.push(state.up)\n            state.barColors.push(state.up)\n        }\n\n        const j = state.pts.length - 1\n        state.lineColors[j] = j > 0 && state.pts[j].price < state.pts[j - 1].price ? state.down : state.up\n        state.barColors[j] = state.delta[j].price >= 0 ? state.upFaded : state.downFaded\n    }\n\n    return state\n}\n\ncvd.init = function({ data, barNs, params }) {\n    return fold({\n        pts: [],\n        delta: [],\n        lineColors: [],\n        barColors: [],\n        total: 0,\n        barNs,\n        up: params.up,\n        down: params.down,\n        upFaded: params.up + '4d',\n        downFaded: params.down + '4d',\n        deltaBars: params.deltaBars\n    }, data.trades)\n}\n\n// Only the trades since the last horizon step arrive here, so the running total\n// carries forward instead of being rebuilt from scratch.\ncvd.update = function({ newData, state }) {\n    return { points: {}, state: fold(state, newData.trades) }\n}\n\ncvd.draw = function(s) {\n    const out = []\n    if (s.deltaBars) out.push(drawHistogram(s.delta, s.barColors, 0, 0.3))\n    out.push(drawHLine(0, \"#ffffff1f\", 1))\n    out.push(drawLine(s.pts, s.lineColors, 2))\n    return out\n}";

package/types/plugins/donchian.d.ts

@@ -0,0 +1 @@
+export declare const donchianIndi = "\nconst donchianIndi = plugin({\n    name: \"Donchian Channels\",\n    shortName: \"DC\",\n    description: \"Rolling highest high and lowest low\",\n    type: PluginType.indicator,\n    require: DataLevel.ohlcv,\n    version: \"1.0.0\",\n    lookback: 100,\n    params: {\n        length: { label: \"Length\", type: \"number\", default: 20, min: 2, max: 500 },\n        upper:  { label: \"Upper\", type: \"color\", default: \"#26a69a\" },\n        lower:  { label: \"Lower\", type: \"color\", default: \"#ef5350\" },\n        showMid:{ label: \"Show midline\", type: \"checkbox\", default: true }\n    }\n})\n\ndonchianIndi.init = function({ data, params }) {\n    const bars = data.ohlcv\n    const ts = bars.map(b => b.ts)\n    const { upper, mid, lower } = donchian(bars, params.length)\n\n    return {\n        upper: toPoints(ts, upper),\n        mid: params.showMid ? toPoints(ts, mid) : [],\n        lower: toPoints(ts, lower),\n        upperColor: params.upper,\n        lowerColor: params.lower\n    }\n}\n\ndonchianIndi.draw = function(s) {\n    const out = [\n        fillBetween(s.upper, s.lower, { mode: 'solid', color: '#ffffff08' }),\n        drawLine(s.upper, s.upperColor, 1),\n        drawLine(s.lower, s.lowerColor, 1)\n    ]\n\n    if (s.mid.length) out.push(drawLine(s.mid, '#787b86', 1, [4, 4]))\n    return out\n}";

package/types/plugins/ichimoku.d.ts

@@ -0,0 +1 @@
+export declare const ichimokuIndi = "\nconst ichimoku = plugin({\n    name: \"Ichimoku Cloud\",\n    shortName: \"ICH\",\n    description: \"Tenkan, Kijun and the forward-projected kumo\",\n    type: PluginType.indicator,\n    require: DataLevel.ohlcv,\n    version: \"1.0.0\",\n    lookback: 200,\n    params: {\n        conversion: { label: \"Conversion\", type: \"number\", default: 9, min: 1, max: 200 },\n        base:       { label: \"Base\", type: \"number\", default: 26, min: 1, max: 400 },\n        spanB:      { label: \"Span B\", type: \"number\", default: 52, min: 1, max: 600 },\n        displace:   { label: \"Displacement\", type: \"number\", default: 26, min: 0, max: 200 },\n        lagging:    { label: \"Lagging span\", type: \"checkbox\", default: true }\n    }\n})\n\nconst TENKAN = \"#08b3de\"\nconst KIJUN  = \"#ef5350\"\nconst SPAN_A = \"#26a69a\"\nconst SPAN_B = \"#f5a623\"\nconst LAG    = \"#9d8cd6\"\n\nfunction midChannel(highs, lows, period) {\n    const hi = highest(highs, period)\n    const lo = lowest(lows, period)\n    const out = new Array(highs.length)\n    for (let i = 0; i < out.length; i++) out[i] = (hi[i] + lo[i]) / 2\n    return out\n}\n\nichimoku.init = function({ data, barNs, params }) {\n    const bars = data.ohlcv\n    const n = bars.length\n    if (!n) return { tenkan: [], kijun: [], spanA: [], spanB: [], lagging: [], cloud: [] }\n\n    const highs = bars.map(b => b.high)\n    const lows = bars.map(b => b.low)\n\n    const tenkan = midChannel(highs, lows, params.conversion)\n    const kijun = midChannel(highs, lows, params.base)\n    const spanBRaw = midChannel(highs, lows, params.spanB)\n    const spanARaw = new Array(n)\n    for (let i = 0; i < n; i++) spanARaw[i] = (tenkan[i] + kijun[i]) / 2\n\n    // The kumo is plotted `displace` bars ahead, so the last stretch sits past\n    // the newest bar - those timestamps have to be extrapolated from barNs.\n    const shift = barNs > 0n ? params.displace : 0\n    const tsAt = i => i < n ? bars[i].ts : bars[n - 1].ts + BigInt(i - n + 1) * barNs\n\n    // Both spans are pushed together so the two arrays stay index-aligned -\n    // cloudRuns pairs them positionally.\n    const spanA = []\n    const spanB = []\n    for (let i = 0; i < n; i++) {\n        if (isNaN(spanARaw[i]) || isNaN(spanBRaw[i])) continue\n        const t = tsAt(i + shift)\n        spanA.push({ t, price: spanARaw[i] })\n        spanB.push({ t, price: spanBRaw[i] })\n    }\n\n    const lagging = []\n    if (params.lagging) {\n        for (let i = shift; i < n; i++) lagging.push({ t: bars[i - shift].ts, price: bars[i].close })\n    }\n\n    return {\n        tenkan: toPoints(bars.map(b => b.ts), tenkan),\n        kijun: toPoints(bars.map(b => b.ts), kijun),\n        spanA,\n        spanB,\n        lagging,\n        cloud: cloudRuns(spanA, spanB)\n    }\n}\n\n// Split the kumo where A and B cross so each run can be filled on its own.\nfunction cloudRuns(spanA, spanB) {\n    const len = spanA.length\n    const runs = []\n    let start = 0\n\n    for (let i = 1; i < len; i++) {\n        const before = spanA[i - 1].price >= spanB[i - 1].price\n        if ((spanA[i].price >= spanB[i].price) === before) continue\n        runs.push({ a: spanA.slice(start, i), b: spanB.slice(start, i), bullish: before })\n        start = i\n    }\n\n    if (start < len) {\n        runs.push({\n            a: spanA.slice(start),\n            b: spanB.slice(start),\n            bullish: spanA[start].price >= spanB[start].price\n        })\n    }\n\n    return runs\n}\n\nichimoku.draw = function(s) {\n    const out = []\n\n    for (const run of s.cloud) {\n        out.push(fillBetween(run.a, run.b, {\n            mode: 'solid',\n            color: run.bullish ? SPAN_A + '20' : SPAN_B + '20'\n        }))\n    }\n\n    out.push(drawLine(s.spanA, SPAN_A, 1))\n    out.push(drawLine(s.spanB, SPAN_B, 1))\n    out.push(drawLine(s.kijun, KIJUN, 1))\n    out.push(drawLine(s.tenkan, TENKAN, 1))\n    if (s.lagging.length) out.push(drawLine(s.lagging, LAG, 1, [3, 3]))\n\n    return out\n}";

package/types/plugins/index.d.ts

@@ -0,0 +1,25 @@
+import { alligatorIndi } from './alligator';
+import { atrIndi } from './atr';
+import { awesomeIndi } from './awesome-oscillator';
+import { bbIndi } from './bollinger-bands';
+import { cciIndi } from './cci';
+import { cvdIndi } from './cvd';
+import { donchianIndi } from './donchian';
+import { ichimokuIndi } from './ichimoku';
+import { keltnerIndi } from './keltner';
+import { macdIndi } from './macd';
+import { maIndi } from './moving-average';
+import { mfiIndi } from './mfi';
+import { obvIndi } from './obv';
+import { psarIndi } from './psar';
+import { rsiIndi } from './rsi';
+import { sessionsIndi } from './sessions';
+import { stochasticIndi } from './stochastic';
+import { supertrendIndi } from './supertrend';
+import { volumeIndi } from './volume';
+import { vwapIndi } from './vwap';
+import { williamsRIndi } from './williams-r';
+/** [script, plugin id, picker category] */
+export type BuiltinIndicatorEntry = readonly [code: string, id: string, category: string];
+export declare const BUILTIN_INDICATORS: readonly BuiltinIndicatorEntry[];
+export { alligatorIndi, atrIndi, awesomeIndi, bbIndi, cciIndi, cvdIndi, donchianIndi, ichimokuIndi, keltnerIndi, macdIndi, maIndi, mfiIndi, obvIndi, psarIndi, rsiIndi, sessionsIndi, stochasticIndi, supertrendIndi, volumeIndi, vwapIndi, williamsRIndi, };

package/types/plugins/keltner.d.ts

@@ -0,0 +1 @@
+export declare const keltnerIndi = "\nconst keltnerIndi = plugin({\n    name: \"Keltner Channels\",\n    shortName: \"KC\",\n    description: \"ATR envelope around an exponential basis\",\n    type: PluginType.indicator,\n    require: DataLevel.ohlcv,\n    version: \"1.0.0\",\n    lookback: 150,\n    params: {\n        length:    { label: \"Length\", type: \"number\", default: 20, min: 2, max: 500 },\n        atrLength: { label: \"ATR length\", type: \"number\", default: 10, min: 1, max: 500 },\n        mult:      { label: \"Multiplier\", type: \"number\", default: 1.5, min: 0.1, max: 10, step: 0.1 },\n        band:      { label: \"Channel\", type: \"color\", default: \"#26a69a\" },\n        basis:     { label: \"Basis\", type: \"color\", default: \"#f5a623\" }\n    }\n})\n\nkeltnerIndi.init = function({ data, params }) {\n    const bars = data.ohlcv\n    const ts = bars.map(b => b.ts)\n    const { upper, mid, lower } = keltner(bars, params.length, params.atrLength, params.mult)\n\n    return {\n        upper: toPoints(ts, upper),\n        mid: toPoints(ts, mid),\n        lower: toPoints(ts, lower),\n        band: params.band,\n        basis: params.basis\n    }\n}\n\nkeltnerIndi.draw = function(s) {\n    return [\n        fillBetween(s.upper, s.lower, { mode: 'solid', color: s.band + '10' }),\n        drawLine(s.upper, s.band, 1),\n        drawLine(s.lower, s.band, 1),\n        drawLine(s.mid, s.basis, 1, [5, 4])\n    ]\n}";

package/types/plugins/macd.d.ts

@@ -0,0 +1 @@
+export declare const macdIndi = "\nconst macdIndi = plugin({\n    name: \"MACD\",\n    shortName: \"MACD\",\n    description: \"Moving average convergence / divergence\",\n    type: PluginType.indicator,\n    require: DataLevel.ohlcv,\n    layout: Layout.pane,\n    version: \"1.0.0\",\n    lookback: 200,\n    params: {\n        fast:   { label: \"Fast\", type: \"number\", default: 12, min: 1, max: 400 },\n        slow:   { label: \"Slow\", type: \"number\", default: 26, min: 1, max: 600 },\n        signal: { label: \"Signal\", type: \"number\", default: 9, min: 1, max: 200 },\n        macdColor:   { label: \"MACD\", type: \"color\", default: \"#08b3de\" },\n        signalColor: { label: \"Signal\", type: \"color\", default: \"#f5a623\" }\n    }\n})\n\nconst UP = \"#26a69a\"\nconst DOWN = \"#ef5350\"\n\nmacdIndi.init = function({ data, params }) {\n    const bars = data.ohlcv\n    const ts = bars.map(b => b.ts)\n    const { macd: line, signal, histogram } = macd(bars, params.fast, params.slow, params.signal)\n\n    // Four-tone histogram: shade by sign, brightness by whether it's growing.\n    const hist = []\n    const colors = []\n    for (let i = 0; i < histogram.length; i++) {\n        const v = histogram[i]\n        if (isNaN(v)) continue\n        const growing = i === 0 || isNaN(histogram[i - 1]) || Math.abs(v) >= Math.abs(histogram[i - 1])\n        hist.push({ t: ts[i], price: v })\n        colors.push((v >= 0 ? UP : DOWN) + (growing ? 'ff' : '66'))\n    }\n\n    return {\n        line: toPoints(ts, line),\n        signal: toPoints(ts, signal),\n        hist,\n        colors,\n        macdColor: params.macdColor,\n        signalColor: params.signalColor\n    }\n}\n\nmacdIndi.draw = function(s) {\n    return [\n        drawHistogram(s.hist, s.colors, 0, 0.25),\n        drawHLine(0, \"#ffffff1f\", 1),\n        drawLine(s.line, s.macdColor, 2),\n        drawLine(s.signal, s.signalColor, 1)\n    ]\n}";

package/types/plugins/mfi.d.ts

@@ -0,0 +1 @@
+export declare const mfiIndi = "\nconst mfiIndi = plugin({\n    name: \"Money Flow Index\",\n    shortName: \"MFI\",\n    description: \"Volume-weighted RSI of the typical price\",\n    type: PluginType.indicator,\n    require: DataLevel.ohlcv,\n    layout: Layout.pane,\n    version: \"1.0.0\",\n    lookback: 100,\n    params: {\n        length:     { label: \"Length\", type: \"number\", default: 14, min: 2, max: 200 },\n        overbought: { label: \"Overbought\", type: \"number\", default: 80, min: 50, max: 100 },\n        oversold:   { label: \"Oversold\", type: \"number\", default: 20, min: 0, max: 50 },\n        line:       { label: \"MFI\", type: \"color\", default: \"#26a69a\" }\n    }\n})\n\nmfiIndi.init = function({ data, params }) {\n    const bars = data.ohlcv\n\n    return {\n        mfi: toPoints(bars.map(b => b.ts), mfi(bars, params.length)),\n        overbought: params.overbought,\n        oversold: params.oversold,\n        line: params.line\n    }\n}\n\nmfiIndi.draw = function(s) {\n    return [\n        fillBetween(s.overbought, s.oversold, { mode: 'solid', color: '#ffffff08' }),\n        drawHLine(s.overbought, \"#ffffff1f\", 1, [4, 4]),\n        drawHLine(s.oversold, \"#ffffff1f\", 1, [4, 4]),\n        drawLine(s.mfi, s.line, 2)\n    ]\n}";

package/types/plugins/moving-average.d.ts

@@ -0,0 +1 @@
+export declare const maIndi = "\nconst movingAverage = plugin({\n    name: \"Moving Average\",\n    shortName: \"MA\",\n    description: \"Fast / slow pair, any method, any source\",\n    type: PluginType.indicator,\n    require: DataLevel.ohlcv,\n    version: \"1.0.0\",\n    lookback: 250,\n    params: {\n        method: { label: \"Method\", type: \"select\", default: \"EMA\", options: [\n            { value: \"SMA\", label: \"Simple\" },\n            { value: \"EMA\", label: \"Exponential\" },\n            { value: \"WMA\", label: \"Weighted\" },\n            { value: \"HMA\", label: \"Hull\" },\n            { value: \"RMA\", label: \"Wilder\" }\n        ] },\n        source: { label: \"Source\", type: \"select\", default: \"close\", options: [\n            { value: \"close\", label: \"Close\" },\n            { value: \"open\", label: \"Open\" },\n            { value: \"high\", label: \"High\" },\n            { value: \"low\", label: \"Low\" },\n            { value: \"hl2\", label: \"HL/2\" },\n            { value: \"hlc3\", label: \"HLC/3\" },\n            { value: \"ohlc4\", label: \"OHLC/4\" }\n        ] },\n        fast:      { label: \"Fast\", type: \"number\", default: 21, min: 2, max: 1000 },\n        slow:      { label: \"Slow\", type: \"number\", default: 50, min: 0, max: 1000 },\n        fastColor: { label: \"Fast\", type: \"color\", default: \"#08b3de\" },\n        slowColor: { label: \"Slow\", type: \"color\", default: \"#f5a623\" },\n        width:     { label: \"Width\", type: \"stepperInt\", default: 2, min: 1, max: 4 }\n    }\n})\n\nconst SOURCE = {\n    close: b => b.close,\n    open:  b => b.open,\n    high:  b => b.high,\n    low:   b => b.low,\n    hl2:   b => (b.high + b.low) / 2,\n    hlc3:  b => (b.high + b.low + b.close) / 3,\n    ohlc4: b => (b.open + b.high + b.low + b.close) / 4\n}\n\nconst METHOD = { SMA: sma, EMA: ema, WMA: wma, HMA: hma, RMA: rma }\n\nmovingAverage.init = function({ data, params }) {\n    const bars = data.ohlcv\n    const ts = bars.map(b => b.ts)\n    const src = bars.map(SOURCE[params.source] || SOURCE.close)\n    const avg = METHOD[params.method] || ema\n\n    return {\n        fast: toPoints(ts, avg(src, params.fast)),\n        slow: params.slow >= 2 ? toPoints(ts, avg(src, params.slow)) : [],\n        fastColor: params.fastColor,\n        slowColor: params.slowColor,\n        width: params.width\n    }\n}\n\nmovingAverage.draw = function(s) {\n    const out = [drawLine(s.fast, s.fastColor, s.width)]\n    if (s.slow.length) out.push(drawLine(s.slow, s.slowColor, s.width))\n    return out\n}";

package/types/plugins/obv.d.ts

@@ -0,0 +1 @@
+export declare const obvIndi = "\nconst obvIndi = plugin({\n    name: \"On-Balance Volume\",\n    shortName: \"OBV\",\n    description: \"Running volume signed by the close\",\n    type: PluginType.indicator,\n    require: DataLevel.ohlcv,\n    layout: Layout.pane,\n    version: \"1.0.0\",\n    lookback: 200,\n    params: {\n        smoothing: { label: \"Average\", type: \"number\", default: 20, min: 0, max: 500 },\n        line: { label: \"OBV\", type: \"color\", default: \"#08b3de\" },\n        avg:  { label: \"Average\", type: \"color\", default: \"#f5a623\" }\n    }\n})\n\nobvIndi.init = function({ data, params }) {\n    const bars = data.ohlcv\n    const ts = bars.map(b => b.ts)\n    const values = obv(bars)\n\n    return {\n        obv: toPoints(ts, values),\n        avg: params.smoothing >= 2 ? toPoints(ts, ema(values, params.smoothing)) : [],\n        line: params.line,\n        avgColor: params.avg\n    }\n}\n\nobvIndi.draw = function(s) {\n    const out = [drawLine(s.obv, s.line, 2)]\n    if (s.avg.length) out.push(drawLine(s.avg, s.avgColor, 1))\n    return out\n}";

package/types/plugins/psar.d.ts

@@ -0,0 +1 @@
+export declare const psarIndi = "\nconst psar = plugin({\n    name: \"Parabolic SAR\",\n    shortName: \"SAR\",\n    description: \"Accelerating stop-and-reverse dots\",\n    type: PluginType.indicator,\n    require: DataLevel.ohlcv,\n    version: \"1.0.0\",\n    lookback: 100,\n    params: {\n        step: { label: \"Step\", type: \"number\", default: 0.02, min: 0.001, max: 0.5, step: 0.001 },\n        max:  { label: \"Max step\", type: \"number\", default: 0.2, min: 0.01, max: 1, step: 0.01 },\n        up:   { label: \"Rising\", type: \"color\", default: \"#26a69a\" },\n        down: { label: \"Falling\", type: \"color\", default: \"#ef5350\" },\n        size: { label: \"Dot size\", type: \"stepperInt\", default: 2, min: 1, max: 6 }\n    }\n})\n\npsar.init = function({ data, params }) {\n    const bars = data.ohlcv\n    const pts = []\n    const colors = []\n    if (bars.length < 2) return { pts, colors, size: params.size }\n\n    let rising = bars[1].close >= bars[0].close\n    let sar = rising ? bars[0].low : bars[0].high\n    let extreme = rising ? bars[1].high : bars[1].low\n    let accel = params.step\n\n    for (let i = 1; i < bars.length; i++) {\n        const bar = bars[i]\n        sar = sar + accel * (extreme - sar)\n\n        // The stop may never sit inside the last two bars' range.\n        const prev = bars[i - 1]\n        if (rising) {\n            sar = Math.min(sar, prev.low, bars[i - 2] ? bars[i - 2].low : prev.low)\n        } else {\n            sar = Math.max(sar, prev.high, bars[i - 2] ? bars[i - 2].high : prev.high)\n        }\n\n        if (rising ? bar.low < sar : bar.high > sar) {\n            rising = !rising\n            sar = extreme\n            extreme = rising ? bar.high : bar.low\n            accel = params.step\n        } else if (rising ? bar.high > extreme : bar.low < extreme) {\n            extreme = rising ? bar.high : bar.low\n            accel = Math.min(accel + params.step, params.max)\n        }\n\n        pts.push({ t: bar.ts, price: sar })\n        colors.push(rising ? params.up : params.down)\n    }\n\n    return { pts, colors, size: params.size }\n}\n\npsar.draw = function(s) {\n    return [drawDots(s.pts, s.colors, s.size)]\n}";

package/types/plugins/rsi.d.ts

@@ -0,0 +1 @@
+export declare const rsiIndi = "\nconst rsiIndi = plugin({\n    name: \"Relative Strength Index\",\n    shortName: \"RSI\",\n    description: \"Momentum oscillator with overbought / oversold zones\",\n    type: PluginType.indicator,\n    require: DataLevel.ohlcv,\n    layout: Layout.pane,\n    version: \"1.0.0\",\n    lookback: 150,\n    params: {\n        length:    { label: \"Length\", type: \"number\", default: 14, min: 2, max: 200 },\n        smoothing: { label: \"Average\", type: \"number\", default: 14, min: 1, max: 200 },\n        overbought:{ label: \"Overbought\", type: \"number\", default: 70, min: 50, max: 100 },\n        oversold:  { label: \"Oversold\", type: \"number\", default: 30, min: 0, max: 50 },\n        line:      { label: \"RSI\", type: \"color\", default: \"#7e57c2\" },\n        signal:    { label: \"Average\", type: \"color\", default: \"#f5a623\" }\n    }\n})\n\nrsiIndi.init = function({ data, params }) {\n    const bars = data.ohlcv\n    const ts = bars.map(b => b.ts)\n    const values = rsi(bars, params.length)\n\n    return {\n        rsi: toPoints(ts, values),\n        ma: toPoints(ts, sma(values, params.smoothing)),\n        overbought: params.overbought,\n        oversold: params.oversold,\n        line: params.line,\n        signal: params.signal\n    }\n}\n\nrsiIndi.draw = function(s) {\n    const grid = \"#ffffff1f\"\n\n    return [\n        fillBetween(s.overbought, s.oversold, { mode: 'solid', color: s.line + '1a' }),\n\n        // Gradients fade out at the threshold, so only the excursion past it shows.\n        fillBetween(s.rsi, s.oversold, {\n            mode: 'vertical',\n            stops: [\n                { price: s.oversold, color: 'rgba(239,83,80,0)' },\n                { price: 0, color: 'rgba(239,83,80,0.55)' }\n            ]\n        }),\n        fillBetween(s.overbought, s.rsi, {\n            mode: 'vertical',\n            stops: [\n                { price: 100, color: 'rgba(38,166,154,0.55)' },\n                { price: s.overbought, color: 'rgba(38,166,154,0)' }\n            ]\n        }),\n\n        drawHLine(s.overbought, grid, 1, [4, 4]),\n        drawHLine(50, \"#ffffff12\", 1, [4, 4]),\n        drawHLine(s.oversold, grid, 1, [4, 4]),\n\n        drawLine(s.ma, s.signal, 1),\n        drawLine(s.rsi, s.line, 2)\n    ]\n}";

package/types/plugins/sessions.d.ts

@@ -0,0 +1 @@
+export declare const sessionsIndi = "\nconst sessionsIndi = plugin({\n    name: \"Trading Sessions\",\n    shortName: \"SESS\",\n    description: \"Asia / London / New York session ranges\",\n    type: PluginType.indicator,\n    require: DataLevel.ohlcv,\n    version: \"1.0.0\",\n    params: {\n        tz:       { label: \"Timezone\", type: \"select\", default: \"UTC\", options: [\n            { value: \"UTC\", label: \"UTC\" },\n            { value: \"America/New_York\", label: \"New York\" },\n            { value: \"Europe/London\", label: \"London\" },\n            { value: \"Asia/Tokyo\", label: \"Tokyo\" }\n        ] },\n        asia:     { label: \"Asia\", type: \"checkbox\", default: true },\n        london:   { label: \"London\", type: \"checkbox\", default: true },\n        newYork:  { label: \"New York\", type: \"checkbox\", default: true },\n        labels:   { label: \"Show labels\", type: \"checkbox\", default: true },\n        opacity:  { label: \"Shading\", type: \"opacity\", default: 12 }\n    }\n})\n\nconst SESSIONS = [\n    { key: \"asia\",    label: \"Asia\",    startHour: 0,  startMinute: 0,  endHour: 9,  endMinute: 0, color: \"#7e57c2\" },\n    { key: \"london\",  label: \"London\",  startHour: 7,  startMinute: 0,  endHour: 16, endMinute: 0, color: \"#08b3de\" },\n    { key: \"newYork\", label: \"New York\", startHour: 13, startMinute: 30, endHour: 22, endMinute: 0, color: \"#f5a623\" }\n]\n\nfunction alpha(hex, percent) {\n    const a = Math.round(Math.max(0, Math.min(100, percent)) * 2.55)\n    return hex + a.toString(16).padStart(2, '0')\n}\n\nsessionsIndi.init = function({ data, params }) {\n    const active = SESSIONS.filter(s => params[s.key])\n    const bands = active.length\n        ? sessionBoundaries(data.ohlcv, active, { tz: params.tz })\n        : []\n\n    return { bands, labels: params.labels, opacity: params.opacity }\n}\n\nsessionsIndi.draw = function(s) {\n    const out = []\n\n    for (const band of s.bands) {\n        out.push(drawRect(band.startTs, band.low, band.endTs, band.high, {\n            fillColor: alpha(band.color, s.opacity),\n            borderColor: alpha(band.color, 55),\n            radius: 3\n        }))\n\n        if (s.labels) {\n            out.push(drawLabel(band.label, band.startTs, band.high, band.color, 10, true, 'left', 'bottom'))\n        }\n    }\n\n    return out\n}";

package/types/plugins/stochastic.d.ts

@@ -0,0 +1 @@
+export declare const stochasticIndi = "\nconst stochastic = plugin({\n    name: \"Stochastic\",\n    shortName: \"STOCH\",\n    description: \"Close relative to the recent high / low range\",\n    type: PluginType.indicator,\n    require: DataLevel.ohlcv,\n    layout: Layout.pane,\n    version: \"1.0.0\",\n    lookback: 100,\n    params: {\n        k:      { label: \"%K length\", type: \"number\", default: 14, min: 1, max: 200 },\n        smooth: { label: \"%K smoothing\", type: \"number\", default: 3, min: 1, max: 50 },\n        d:      { label: \"%D length\", type: \"number\", default: 3, min: 1, max: 50 },\n        overbought: { label: \"Overbought\", type: \"number\", default: 80, min: 50, max: 100 },\n        oversold:   { label: \"Oversold\", type: \"number\", default: 20, min: 0, max: 50 },\n        kColor: { label: \"%K\", type: \"color\", default: \"#08b3de\" },\n        dColor: { label: \"%D\", type: \"color\", default: \"#f5a623\" }\n    }\n})\n\nstochastic.init = function({ data, params }) {\n    const bars = data.ohlcv\n    const ts = bars.map(b => b.ts)\n    const { k, d } = stoch(bars, params.k, params.d, params.smooth)\n\n    return {\n        k: toPoints(ts, k),\n        d: toPoints(ts, d),\n        overbought: params.overbought,\n        oversold: params.oversold,\n        kColor: params.kColor,\n        dColor: params.dColor\n    }\n}\n\nstochastic.draw = function(s) {\n    return [\n        fillBetween(s.overbought, s.oversold, { mode: 'solid', color: '#ffffff08' }),\n        drawHLine(s.overbought, \"#ffffff1f\", 1, [4, 4]),\n        drawHLine(s.oversold, \"#ffffff1f\", 1, [4, 4]),\n        drawLine(s.d, s.dColor, 1),\n        drawLine(s.k, s.kColor, 2)\n    ]\n}";

package/types/plugins/supertrend.d.ts

@@ -0,0 +1 @@
+export declare const supertrendIndi = "\nconst supertrendIndi = plugin({\n    name: \"Supertrend\",\n    shortName: \"ST\",\n    description: \"ATR trailing stop that flips with the trend\",\n    type: PluginType.indicator,\n    require: DataLevel.ohlcv,\n    version: \"1.0.0\",\n    lookback: 150,\n    params: {\n        length: { label: \"ATR length\", type: \"number\", default: 10, min: 1, max: 200 },\n        mult:   { label: \"Multiplier\", type: \"number\", default: 3, min: 0.1, max: 20, step: 0.1 },\n        up:     { label: \"Uptrend\", type: \"color\", default: \"#26a69a\" },\n        down:   { label: \"Downtrend\", type: \"color\", default: \"#ef5350\" },\n        markers:{ label: \"Flip markers\", type: \"checkbox\", default: true }\n    }\n})\n\nsupertrendIndi.init = function({ data, params }) {\n    const bars = data.ohlcv\n    const { trend, upper, lower } = supertrend(bars, params.length, params.mult)\n\n    // One continuous stop line; colour is per-point so the flip shows in place.\n    const pts = []\n    const colors = []\n    const flips = []\n\n    for (let i = 0; i < bars.length; i++) {\n        const up = trend[i] === 1\n        const value = up ? lower[i] : upper[i]\n        if (isNaN(value)) continue\n\n        pts.push({ t: bars[i].ts, price: value })\n        colors.push(up ? params.up : params.down)\n\n        if (i > 0 && trend[i] !== trend[i - 1]) {\n            flips.push({ t: bars[i].ts, price: value, up })\n        }\n    }\n\n    return { pts, colors, flips, up: params.up, down: params.down, markers: params.markers }\n}\n\nsupertrendIndi.draw = function(s) {\n    const out = [drawLine(s.pts, s.colors, 2)]\n\n    if (s.markers) {\n        for (const f of s.flips) {\n            out.push(drawLabel(f.up ? '\u25B2' : '\u25BC', f.t, f.price, f.up ? s.up : s.down, 11, true, 'center', f.up ? 'top' : 'bottom'))\n        }\n    }\n\n    return out\n}";