@luxalgo/vela 0.5.0

package/dist/plugin.d.cts

@@ -0,0 +1,7 @@
+export { A as ACCENT, a as ACCENT_BRIGHT, B as BEARISH, b as BULLISH, c as BarTransform, C as CATEGORICAL, d as CROSSHAIR, e as ChartTypeDefinition, f as ChartTypeSettingsSection, D as DrawingTypeMeta, H as HIGHLIGHT, I as INFO, g as INVALID, h as IdentifiableKind, M as MARKER, N as NEUTRAL, R as RendererLayerArgs, i as RendererLayerDefinition, j as RendererLayerInstance, S as SERIES_LINE, k as SESSION_OFF, l as SESSION_POST, m as SESSION_PRE, n as SLATE, o as SLATE_DEEP, p as SeriesDataEngine, q as SeriesDataEngineHost, r as SettingsRowDescriptor, T as TRADE_EXIT, s as TRADE_LONG, t as TRADE_SHORT, V as VALID, W as WARNING, u as categoricalColor, v as chartType, w as chartTypes, z as drawingTypes, E as getDrawingType, F as registerChartType, J as registerRendererDefaults, K as registerRendererLayer, L as rendererDefaults, O as rendererLayers, P as stableSeriesId, Q as tickerModifierIds, U as unregisterChartType, X as unregisterRendererDefaults, Y as unregisterRendererLayer } from './plugin-D94muTV-.cjs';
+export { B as BarsChangeReason, C as ContextSelect, E as EngineAlert, d as EngineCapabilities, e as EngineContextSnapshot, f as EngineFactory, g as EngineWarning, h as ExecutionHandlers, i as ExecutionMarket, j as ExecutionRequest, k as ExecutionSession, F as FetchSeries, L as LegendActionDescriptor, n as LegendIndicatorInfo, N as NativeIndicator, o as NativeIndicatorContext, p as NativeIndicatorDescriptor, q as NativeIndicatorInfo, r as NativeIndicatorOutput, s as PreparedScript, a as ScriptRun, w as ScriptRunCause, x as ScriptRunResult, S as ScriptingEngine, y as SidePanelButton, z as SidePanelDescriptor, A as SidePanelHandle, G as SidePanelHeader, H as StrategyFill, J as StrategyState, K as StrategyTrade, Q as VisibleBarRange, U as WidgetActionDescriptor, X as WidgetActionTarget, Y as WidgetAttachment, W as WidgetContext, Z as getNativeIndicator, _ as legendActions, a0 as nativeIndicatorTypes, a1 as registerDefaultEngine, a2 as registerLegendAction, a3 as registerNativeIndicator, a4 as registerSidePanel, a5 as registerWidgetAction, a6 as registerWidgetAttachment, a7 as resolveEngines, a8 as sidePanels, a9 as unregisterDefaultEngine, aa as unregisterLegendAction, ab as unregisterNativeIndicator, ac as unregisterSidePanel, ad as unregisterWidgetAction, ae as unregisterWidgetAttachment, af as widgetActions, ag as widgetAttachments } from './contributions-o1GRKPI_.cjs';
+export { D as DEFAULT_PANEL_MAX_WIDTH, a as DEFAULT_PANEL_MIN_WIDTH, b as DEFAULT_PANEL_WIDTH, S as SidePanelOptions, c as clampPanelWidth } from './side-panel-CT9ZwIGz.cjs';
+export { B as Background, w as BoxFontFamily, x as BoxHAlign, y as BoxTextSize, z as BoxVAlign, E as CandleBarColor, F as CandleSeries, G as CandleStyle, Q as DirtyRange, W as DrawingBox, X as DrawingExtend, Z as DrawingLabel, _ as DrawingLine, $ as DrawingLinefill, a2 as DrawingPolyline, a4 as DrawingTable, u as DrawingTypeKey, a6 as DrawingXLoc, a8 as Fill, a9 as FillGradientStop, aa as IndicatorMeta, j as IndicatorModel, ab as InputSchema, ac as InputType, l as InputValue, ad as LabelStyle, ae as LabelYLoc, af as LineLikeKind, ag as LineLikeSeries, ah as LineLikeStyle, L as LineStyle, ai as MarkerPoint, aj as MarkerSeries, s as Millis, O as OHLCV, g as Pane, am as PaneHint, an as PaneKind, ao as PolylinePoint, ap as PriceLine, P as PriceStyle, at as Scene, k as ScenePatch, au as SchemaPatch, av as SeriesKind, aw as SeriesPoint, ax as SeriesSpec, ay as SeriesValueDelta, aB as TableCell, aC as TableMerge, aD as TablePosition, aF as TradeExecution, aG as ValuePatch } from './options-Q-576hIi.cjs';
+export { i as iconMarkup, r as registerIcon } from './icons-BZYbJXSV.cjs';
+export { a as KeyBindingDescriptor, R as ResolvedBinding } from './keymap-CGOz5F5f.cjs';
+export { B as BarRange, D as DataProvider, M as MarketDataFeed, b as ProviderCapabilities, P as ProviderInfo, a as SymbolDescriptor, S as SymbolInfo } from './DataProvider-DKNDHpNv.cjs';

package/dist/plugin.d.ts

@@ -0,0 +1,7 @@
+export { A as ACCENT, a as ACCENT_BRIGHT, B as BEARISH, b as BULLISH, c as BarTransform, C as CATEGORICAL, d as CROSSHAIR, e as ChartTypeDefinition, f as ChartTypeSettingsSection, D as DrawingTypeMeta, H as HIGHLIGHT, I as INFO, g as INVALID, h as IdentifiableKind, M as MARKER, N as NEUTRAL, R as RendererLayerArgs, i as RendererLayerDefinition, j as RendererLayerInstance, S as SERIES_LINE, k as SESSION_OFF, l as SESSION_POST, m as SESSION_PRE, n as SLATE, o as SLATE_DEEP, p as SeriesDataEngine, q as SeriesDataEngineHost, r as SettingsRowDescriptor, T as TRADE_EXIT, s as TRADE_LONG, t as TRADE_SHORT, V as VALID, W as WARNING, u as categoricalColor, v as chartType, w as chartTypes, z as drawingTypes, E as getDrawingType, F as registerChartType, J as registerRendererDefaults, K as registerRendererLayer, L as rendererDefaults, O as rendererLayers, P as stableSeriesId, Q as tickerModifierIds, U as unregisterChartType, X as unregisterRendererDefaults, Y as unregisterRendererLayer } from './plugin-aGUD1epn.js';
+export { B as BarsChangeReason, C as ContextSelect, E as EngineAlert, d as EngineCapabilities, e as EngineContextSnapshot, f as EngineFactory, g as EngineWarning, h as ExecutionHandlers, i as ExecutionMarket, j as ExecutionRequest, k as ExecutionSession, F as FetchSeries, L as LegendActionDescriptor, n as LegendIndicatorInfo, N as NativeIndicator, o as NativeIndicatorContext, p as NativeIndicatorDescriptor, q as NativeIndicatorInfo, r as NativeIndicatorOutput, s as PreparedScript, a as ScriptRun, w as ScriptRunCause, x as ScriptRunResult, S as ScriptingEngine, y as SidePanelButton, z as SidePanelDescriptor, A as SidePanelHandle, G as SidePanelHeader, H as StrategyFill, J as StrategyState, K as StrategyTrade, Q as VisibleBarRange, U as WidgetActionDescriptor, X as WidgetActionTarget, Y as WidgetAttachment, W as WidgetContext, Z as getNativeIndicator, _ as legendActions, a0 as nativeIndicatorTypes, a1 as registerDefaultEngine, a2 as registerLegendAction, a3 as registerNativeIndicator, a4 as registerSidePanel, a5 as registerWidgetAction, a6 as registerWidgetAttachment, a7 as resolveEngines, a8 as sidePanels, a9 as unregisterDefaultEngine, aa as unregisterLegendAction, ab as unregisterNativeIndicator, ac as unregisterSidePanel, ad as unregisterWidgetAction, ae as unregisterWidgetAttachment, af as widgetActions, ag as widgetAttachments } from './contributions-hX3EUyjG.js';
+export { D as DEFAULT_PANEL_MAX_WIDTH, a as DEFAULT_PANEL_MIN_WIDTH, b as DEFAULT_PANEL_WIDTH, S as SidePanelOptions, c as clampPanelWidth } from './side-panel-CT9ZwIGz.js';
+export { B as Background, w as BoxFontFamily, x as BoxHAlign, y as BoxTextSize, z as BoxVAlign, E as CandleBarColor, F as CandleSeries, G as CandleStyle, Q as DirtyRange, W as DrawingBox, X as DrawingExtend, Z as DrawingLabel, _ as DrawingLine, $ as DrawingLinefill, a2 as DrawingPolyline, a4 as DrawingTable, u as DrawingTypeKey, a6 as DrawingXLoc, a8 as Fill, a9 as FillGradientStop, aa as IndicatorMeta, j as IndicatorModel, ab as InputSchema, ac as InputType, l as InputValue, ad as LabelStyle, ae as LabelYLoc, af as LineLikeKind, ag as LineLikeSeries, ah as LineLikeStyle, L as LineStyle, ai as MarkerPoint, aj as MarkerSeries, s as Millis, O as OHLCV, g as Pane, am as PaneHint, an as PaneKind, ao as PolylinePoint, ap as PriceLine, P as PriceStyle, at as Scene, k as ScenePatch, au as SchemaPatch, av as SeriesKind, aw as SeriesPoint, ax as SeriesSpec, ay as SeriesValueDelta, aB as TableCell, aC as TableMerge, aD as TablePosition, aF as TradeExecution, aG as ValuePatch } from './options-Q-576hIi.js';
+export { i as iconMarkup, r as registerIcon } from './icons-BZYbJXSV.js';
+export { a as KeyBindingDescriptor, R as ResolvedBinding } from './keymap-CGOz5F5f.js';
+export { B as BarRange, D as DataProvider, M as MarketDataFeed, b as ProviderCapabilities, P as ProviderInfo, a as SymbolDescriptor, S as SymbolInfo } from './DataProvider-Dzd-Erlk.js';

package/dist/plugin.js

@@ -0,0 +1,3 @@
+export { stableSeriesId } from './chunk-Q3XQHLIH.js';
+export { DEFAULT_PANEL_MAX_WIDTH, DEFAULT_PANEL_MIN_WIDTH, DEFAULT_PANEL_WIDTH, chartType, chartTypes, clampPanelWidth, drawingTypes, getDrawingType, getNativeIndicator, legendActions, nativeIndicatorTypes, registerChartType, registerDefaultEngine, registerLegendAction, registerNativeIndicator, registerRendererDefaults, registerRendererLayer, registerSidePanel, registerWidgetAction, registerWidgetAttachment, rendererDefaults, rendererLayers, resolveEngines, sidePanels, tickerModifierIds, unregisterChartType, unregisterDefaultEngine, unregisterLegendAction, unregisterNativeIndicator, unregisterRendererDefaults, unregisterRendererLayer, unregisterSidePanel, unregisterWidgetAction, unregisterWidgetAttachment, widgetActions, widgetAttachments } from './chunk-7UFX5ZIG.js';
+export { ACCENT, ACCENT_BRIGHT, BEARISH, BULLISH, CATEGORICAL, CROSSHAIR, HIGHLIGHT, INFO, INVALID, MARKER, NEUTRAL, SERIES_LINE, SESSION_OFF, SESSION_POST, SESSION_PRE, SLATE, SLATE_DEEP, TRADE_EXIT, TRADE_LONG, TRADE_SHORT, VALID, WARNING, categoricalColor, iconMarkup, registerIcon } from './chunk-GYD2THPV.js';

package/dist/providers/binance.cjs

@@ -0,0 +1,390 @@
+'use strict';
+
+// src/data/providers/binance/BinanceProvider.ts
+var SPOT_BASE = "https://api.binance.com/api/v3";
+var SPOT_BASE_US = "https://api.binance.us/api/v3";
+var FUTURES_BASE = "https://fapi.binance.com/fapi/v1";
+var SPOT_WS = "wss://stream.binance.com:9443";
+var SPOT_WS_US = "wss://stream.binance.us:9443";
+var FUTURES_WS = "wss://fstream.binance.com";
+var STREAM_STALL_MS = 15e3;
+var STREAM_RECONNECT_MS = 2e3;
+var TF_TO_INTERVAL = {
+  "1": "1m",
+  "3": "3m",
+  "5": "5m",
+  "15": "15m",
+  "30": "30m",
+  "60": "1h",
+  "120": "2h",
+  "240": "4h",
+  "360": "6h",
+  "480": "8h",
+  "720": "12h",
+  D: "1d",
+  W: "1w",
+  M: "1M"
+};
+var TF_NORMALIZE = {
+  "1m": "1",
+  "3m": "3",
+  "5m": "5",
+  "15m": "15",
+  "30m": "30",
+  "45m": "45",
+  "1h": "60",
+  "2h": "120",
+  "3h": "180",
+  "4h": "240",
+  "6h": "360",
+  "8h": "480",
+  "12h": "720",
+  "1d": "D",
+  "1w": "W",
+  "1mo": "M",
+  "1D": "D",
+  "1W": "W",
+  "4H": "240",
+  D: "D",
+  W: "W",
+  M: "M"
+};
+var NATIVE_MINUTES = [1, 3, 5, 15, 30, 60, 120, 240, 360, 480, 720];
+var MIN_TO_INTERVAL = {
+  1: "1m",
+  3: "3m",
+  5: "5m",
+  15: "15m",
+  30: "30m",
+  60: "1h",
+  120: "2h",
+  240: "4h",
+  360: "6h",
+  480: "8h",
+  720: "12h"
+};
+var SUPPORTED_TIMEFRAMES = ["1", "3", "5", "15", "30", "45", "60", "120", "180", "240", "D", "W", "M"];
+function normalizeTf(tf) {
+  return TF_NORMALIZE[tf] ?? TF_NORMALIZE[tf.toLowerCase()] ?? tf;
+}
+function parseTicker(ticker) {
+  const t = ticker.trim().toUpperCase();
+  if (t.endsWith(".P")) return { apiSymbol: t.slice(0, -2), isFutures: true };
+  return { apiSymbol: t, isFutures: false };
+}
+function klinesToOHLCV(raw) {
+  return raw.map((k) => ({
+    time: Number(k[0]),
+    open: Number(k[1]),
+    high: Number(k[2]),
+    low: Number(k[3]),
+    close: Number(k[4]),
+    volume: Number(k[5])
+  }));
+}
+function klineEventToOHLCV(k) {
+  return { time: Number(k.t), open: Number(k.o), high: Number(k.h), low: Number(k.l), close: Number(k.c), volume: Number(k.v) };
+}
+function dedupeSorted(bars) {
+  const byTime = /* @__PURE__ */ new Map();
+  for (const b of bars) byTime.set(b.time, b);
+  return [...byTime.values()].sort((a, b) => a.time - b.time);
+}
+function aggregate(sub, bucketMs) {
+  const buckets = /* @__PURE__ */ new Map();
+  for (const b of sub) {
+    const key = Math.floor(b.time / bucketMs) * bucketMs;
+    const cur = buckets.get(key);
+    if (!cur) {
+      buckets.set(key, { time: key, open: b.open, high: b.high, low: b.low, close: b.close, volume: b.volume ?? 0 });
+    } else {
+      cur.high = Math.max(cur.high, b.high);
+      cur.low = Math.min(cur.low, b.low);
+      cur.close = b.close;
+      cur.volume = (cur.volume ?? 0) + (b.volume ?? 0);
+    }
+  }
+  return [...buckets.values()].sort((a, b) => a.time - b.time);
+}
+function selectSubTf(targetMin) {
+  return NATIVE_MINUTES.filter((m) => m < targetMin && targetMin % m === 0).sort((a, b) => b - a)[0] ?? null;
+}
+var BinanceProvider = class {
+  constructor() {
+    /** The spot endpoint confirmed reachable (cached after the first probe). */
+    this.spotBaseUrl = null;
+    /** The in-flight endpoint probe, shared so concurrent first calls don't each ping. */
+    this.spotBaseProbe = null;
+    /** Cached symbol enumeration (exchangeInfo is large; fetch once). */
+    this.symbolsPromise = null;
+  }
+  info() {
+    return {
+      name: "binance",
+      displayName: "Binance",
+      requiresApiKey: false,
+      supportedTimeframes: SUPPORTED_TIMEFRAMES,
+      capabilities: { enumerate: true, stream: true, symbolInfo: true }
+    };
+  }
+  async getBars(ticker, timeframe, range) {
+    try {
+      const { apiSymbol, isFutures } = parseTicker(ticker);
+      const base = isFutures ? FUTURES_BASE : await this.spotBase();
+      const tf = normalizeTf(timeframe);
+      const nativeInterval = TF_TO_INTERVAL[tf];
+      if (nativeInterval) {
+        return dedupeSorted(klinesToOHLCV(await this.fetchKlines(base, apiSymbol, nativeInterval, range)));
+      }
+      const targetMin = /^\d+$/.test(tf) ? parseInt(tf, 10) : null;
+      const subMin = targetMin != null ? selectSubTf(targetMin) : null;
+      if (targetMin == null || subMin == null) {
+        console.warn(`[vela] Binance: timeframe "${timeframe}" is not supported and cannot be aggregated.`);
+        return [];
+      }
+      const ratio = targetMin / subMin;
+      const subRange = { ...range, limit: range.limit != null ? range.limit * ratio + ratio : void 0 };
+      const sub = klinesToOHLCV(await this.fetchKlines(base, apiSymbol, MIN_TO_INTERVAL[subMin], subRange));
+      const agg = aggregate(sub, targetMin * 6e4);
+      return range.limit != null && agg.length > range.limit ? agg.slice(-range.limit) : agg;
+    } catch (e) {
+      console.warn(`[vela] Binance: failed to fetch ${ticker} ${timeframe} \u2014 ${e instanceof Error ? e.message : String(e)}`);
+      return [];
+    }
+  }
+  async getSymbolInfo(ticker) {
+    const { apiSymbol, isFutures } = parseTicker(ticker);
+    const base = isFutures ? FUTURES_BASE : await this.spotBase();
+    const url = isFutures ? `${base}/exchangeInfo` : `${base}/exchangeInfo?symbol=${apiSymbol}`;
+    const data = await this.json(url).catch(() => null);
+    const symbols = data?.symbols ?? [];
+    const s = isFutures ? symbols.find((x) => x.symbol === apiSymbol) : symbols[0];
+    if (!s) return void 0;
+    const priceFilter = s.filters?.find((f) => f.filterType === "PRICE_FILTER");
+    const tickSize = priceFilter ? parseFloat(priceFilter.tickSize ?? "0.01") : 0.01;
+    return {
+      ticker,
+      // keep the original, incl. any .P (as Pine Script expects)
+      tickerid: `BINANCE:${ticker}`,
+      prefix: "BINANCE",
+      description: `${s.baseAsset} / ${s.quoteAsset}${isFutures ? " Perpetual" : ""}`,
+      type: isFutures ? "futures" : "crypto",
+      basecurrency: s.baseAsset,
+      currency: s.quoteAsset,
+      mintick: tickSize,
+      pricescale: Math.round(1 / tickSize),
+      timezone: "Etc/UTC",
+      session: "24x7"
+    };
+  }
+  listSymbols() {
+    if (!this.symbolsPromise) {
+      this.symbolsPromise = Promise.all([
+        this.listSpot().catch(() => []),
+        this.listFutures().catch(() => [])
+      ]).then(([spot, futures]) => [...spot, ...futures]);
+    }
+    return this.symbolsPromise;
+  }
+  subscribe(ticker, timeframe, onBar) {
+    const { apiSymbol, isFutures } = parseTicker(ticker);
+    const interval = TF_TO_INTERVAL[normalizeTf(timeframe)];
+    if (interval && typeof WebSocket !== "undefined") return this.streamKlines(ticker, timeframe, apiSymbol, isFutures, interval, onBar);
+    return this.pollBars(ticker, timeframe, onBar);
+  }
+  // ── internals ────────────────────────────────────────────────────────
+  /**
+   * Open a Binance kline WebSocket (single-stream URL form — the stream is in the
+   * path, so no subscribe frame is sent). Perpetuals use `fstream`; spot uses the
+   * host matching the resolved REST endpoint (`.com`/`.us`). Reconnects on an
+   * unexpected close until unsubscribed; the browser auto-answers Binance's
+   * protocol-level pings, so no manual keepalive is needed.
+   *
+   * A stall watchdog falls the subscription back to polling if the socket opens but
+   * never delivers a candle — so a blocked/silent stream (e.g. geo-restricted
+   * futures) still yields live updates instead of a silently-dead feed.
+   */
+  streamKlines(ticker, timeframe, apiSymbol, isFutures, interval, onBar) {
+    let closed = false;
+    let ws = null;
+    let reconnect = null;
+    let stall = null;
+    let polling = null;
+    const stream = `${apiSymbol.toLowerCase()}@kline_${interval}`;
+    const clearStall = () => {
+      if (stall) {
+        clearTimeout(stall);
+        stall = null;
+      }
+    };
+    const fallToPolling = () => {
+      if (closed || polling) return;
+      clearStall();
+      if (reconnect) {
+        clearTimeout(reconnect);
+        reconnect = null;
+      }
+      try {
+        ws?.close();
+      } catch {
+      }
+      ws = null;
+      console.warn(`[vela] Binance: ${ticker} ${timeframe} stream delivered no data; falling back to polling.`);
+      polling = this.pollBars(ticker, timeframe, onBar);
+    };
+    const open = async () => {
+      if (closed) return;
+      const base = isFutures ? FUTURES_WS : await this.spotWsBase();
+      if (closed) return;
+      ws = new WebSocket(`${base}/ws/${stream}`);
+      stall = setTimeout(fallToPolling, STREAM_STALL_MS);
+      ws.onmessage = (ev) => {
+        if (closed || polling) return;
+        try {
+          const msg = JSON.parse(typeof ev.data === "string" ? ev.data : "");
+          if (msg.k) {
+            clearStall();
+            onBar(klineEventToOHLCV(msg.k));
+          }
+        } catch {
+        }
+      };
+      ws.onclose = () => {
+        if (!closed && !polling) reconnect = setTimeout(() => void open(), STREAM_RECONNECT_MS);
+      };
+      ws.onerror = () => {
+        try {
+          ws?.close();
+        } catch {
+        }
+      };
+    };
+    void open();
+    return () => {
+      closed = true;
+      clearStall();
+      if (reconnect) clearTimeout(reconnect);
+      polling?.();
+      try {
+        ws?.close();
+      } catch {
+      }
+    };
+  }
+  /** WebSocket host matching the resolved REST spot endpoint (`.com` default, else `.us`). */
+  async spotWsBase() {
+    const base = await this.spotBase();
+    return base.includes("binance.us") ? SPOT_WS_US : SPOT_WS;
+  }
+  /** Poll the forming candle (for aggregated timeframes Binance has no native kline stream for). */
+  pollBars(ticker, timeframe, onBar) {
+    let stopped = false;
+    let timer = null;
+    const poll = async () => {
+      if (stopped) return;
+      try {
+        const bars = await this.getBars(ticker, timeframe, { limit: 2 });
+        for (const b of bars) onBar(b);
+      } catch {
+      }
+      if (!stopped) timer = setTimeout(() => void poll(), 3e3);
+    };
+    timer = setTimeout(() => void poll(), 3e3);
+    return () => {
+      stopped = true;
+      if (timer) clearTimeout(timer);
+    };
+  }
+  async listSpot() {
+    const base = await this.spotBase();
+    const data = await this.json(`${base}/exchangeInfo`);
+    return (data.symbols ?? []).filter((s) => s.status === "TRADING").map((s) => ({ ticker: s.symbol, description: `${s.baseAsset} / ${s.quoteAsset}`, type: "crypto" }));
+  }
+  async listFutures() {
+    const data = await this.json(`${FUTURES_BASE}/exchangeInfo`);
+    return (data.symbols ?? []).filter((s) => s.contractType === "PERPETUAL" && s.status === "TRADING").map((s) => ({ ticker: `${s.symbol}.P`, description: `${s.baseAsset} / ${s.quoteAsset} Perpetual`, type: "futures" }));
+  }
+  /** Fetch klines, paginating past Binance's 1000-row cap. */
+  async fetchKlines(base, symbol, interval, range) {
+    if (range.from != null) return this.paginateForward(base, symbol, interval, range.from, range.to ?? Date.now(), range.limit);
+    const limit = range.limit ?? 500;
+    if (limit > 1e3) return this.paginateBackward(base, symbol, interval, limit, range.to);
+    return this.klinesChunk(base, { symbol, interval, limit, endTime: range.to });
+  }
+  /** Forward pagination from `from` to `to` (used by ranged/tail fetches). */
+  async paginateForward(base, symbol, interval, from, to, limit) {
+    const out = [];
+    let cursor = from;
+    while (cursor < to) {
+      const chunk = await this.klinesChunk(base, { symbol, interval, limit: 1e3, startTime: cursor, endTime: to });
+      if (chunk.length === 0) break;
+      out.push(...chunk);
+      cursor = Number(chunk[chunk.length - 1][6]) + 1;
+      if (chunk.length < 1e3) break;
+      if (limit && out.length >= limit) break;
+    }
+    return limit ? out.slice(0, limit) : out;
+  }
+  /** Backward pagination to assemble the most-recent `limit` bars. */
+  async paginateBackward(base, symbol, interval, limit, endTime) {
+    let out = [];
+    let remaining = limit;
+    let cursor = endTime;
+    let guard = Math.ceil(limit / 1e3) + 5;
+    while (remaining > 0 && guard-- > 0) {
+      const size = Math.min(remaining, 1e3);
+      const chunk = await this.klinesChunk(base, { symbol, interval, limit: size, endTime: cursor });
+      if (chunk.length === 0) break;
+      out = chunk.concat(out);
+      remaining -= chunk.length;
+      cursor = Number(chunk[0][0]) - 1;
+      if (chunk.length < size) break;
+    }
+    return out;
+  }
+  async klinesChunk(base, params) {
+    const url = new URL(`${base}/klines`);
+    url.searchParams.set("symbol", params.symbol);
+    url.searchParams.set("interval", params.interval);
+    if (params.limit) url.searchParams.set("limit", String(Math.min(params.limit, 1e3)));
+    if (params.startTime != null) url.searchParams.set("startTime", String(params.startTime));
+    if (params.endTime != null) url.searchParams.set("endTime", String(params.endTime));
+    const data = await this.json(url.toString());
+    if (!Array.isArray(data)) return [];
+    if (data.length > 0 && !Array.isArray(data[0])) return [];
+    return data;
+  }
+  /**
+   * Resolve the reachable spot endpoint (default, else the US mirror). The in-flight
+   * probe is shared, so a burst of concurrent first calls issues ONE ping pair, not one
+   * per call. A confirmed endpoint is cached permanently; a total failure clears the
+   * probe so a later call can retry.
+   */
+  spotBase() {
+    if (this.spotBaseUrl) return Promise.resolve(this.spotBaseUrl);
+    if (!this.spotBaseProbe) {
+      this.spotBaseProbe = (async () => {
+        try {
+          for (const url of [SPOT_BASE, SPOT_BASE_US]) {
+            try {
+              const res = await fetch(`${url}/ping`, { signal: AbortSignal.timeout(5e3) });
+              if (res.ok) return this.spotBaseUrl = url;
+            } catch {
+            }
+          }
+          return SPOT_BASE;
+        } finally {
+          this.spotBaseProbe = null;
+        }
+      })();
+    }
+    return this.spotBaseProbe;
+  }
+  async json(url) {
+    const res = await fetch(url);
+    if (!res.ok) throw new Error(`Binance HTTP ${res.status} for ${url}`);
+    return res.json();
+  }
+};
+
+exports.BinanceProvider = BinanceProvider;

package/dist/providers/binance.d.cts

@@ -0,0 +1,62 @@
+import { O as OHLCV, U as Unsubscribe } from '../options-Q-576hIi.cjs';
+import { D as DataProvider, P as ProviderInfo, B as BarRange, S as SymbolInfo, a as SymbolDescriptor } from '../DataProvider-DKNDHpNv.cjs';
+
+/**
+ * Binance market-data provider, built from scratch on the public REST + WebSocket
+ * APIs — no third-party market-data SDK. Serves spot and USDT-margined perpetual futures (`SYMBOL.P`),
+ * paginates past the 1000-kline cap, falls back `api.binance.com → api.binance.us`,
+ * and aggregates timeframes Binance doesn't serve natively (e.g. `45`, `180`). No API
+ * key; live ticks stream from a native kline WebSocket (`subscribe`), with a poll
+ * fallback for aggregated timeframes.
+ *
+ *   import { BinanceProvider } from 'vela/providers/binance';
+ *   chart.data.registerProvider('binance', new BinanceProvider());
+ */
+declare class BinanceProvider implements DataProvider {
+    /** The spot endpoint confirmed reachable (cached after the first probe). */
+    private spotBaseUrl;
+    /** The in-flight endpoint probe, shared so concurrent first calls don't each ping. */
+    private spotBaseProbe;
+    /** Cached symbol enumeration (exchangeInfo is large; fetch once). */
+    private symbolsPromise;
+    info(): ProviderInfo;
+    getBars(ticker: string, timeframe: string, range: BarRange): Promise<OHLCV[]>;
+    getSymbolInfo(ticker: string): Promise<SymbolInfo | undefined>;
+    listSymbols(): Promise<SymbolDescriptor[]>;
+    subscribe(ticker: string, timeframe: string, onBar: (bar: OHLCV) => void): Unsubscribe;
+    /**
+     * Open a Binance kline WebSocket (single-stream URL form — the stream is in the
+     * path, so no subscribe frame is sent). Perpetuals use `fstream`; spot uses the
+     * host matching the resolved REST endpoint (`.com`/`.us`). Reconnects on an
+     * unexpected close until unsubscribed; the browser auto-answers Binance's
+     * protocol-level pings, so no manual keepalive is needed.
+     *
+     * A stall watchdog falls the subscription back to polling if the socket opens but
+     * never delivers a candle — so a blocked/silent stream (e.g. geo-restricted
+     * futures) still yields live updates instead of a silently-dead feed.
+     */
+    private streamKlines;
+    /** WebSocket host matching the resolved REST spot endpoint (`.com` default, else `.us`). */
+    private spotWsBase;
+    /** Poll the forming candle (for aggregated timeframes Binance has no native kline stream for). */
+    private pollBars;
+    private listSpot;
+    private listFutures;
+    /** Fetch klines, paginating past Binance's 1000-row cap. */
+    private fetchKlines;
+    /** Forward pagination from `from` to `to` (used by ranged/tail fetches). */
+    private paginateForward;
+    /** Backward pagination to assemble the most-recent `limit` bars. */
+    private paginateBackward;
+    private klinesChunk;
+    /**
+     * Resolve the reachable spot endpoint (default, else the US mirror). The in-flight
+     * probe is shared, so a burst of concurrent first calls issues ONE ping pair, not one
+     * per call. A confirmed endpoint is cached permanently; a total failure clears the
+     * probe so a later call can retry.
+     */
+    private spotBase;
+    private json;
+}
+
+export { BinanceProvider, DataProvider, ProviderInfo, SymbolDescriptor };

package/dist/providers/binance.d.ts

@@ -0,0 +1,62 @@
+import { O as OHLCV, U as Unsubscribe } from '../options-Q-576hIi.js';
+import { D as DataProvider, P as ProviderInfo, B as BarRange, S as SymbolInfo, a as SymbolDescriptor } from '../DataProvider-Dzd-Erlk.js';
+
+/**
+ * Binance market-data provider, built from scratch on the public REST + WebSocket
+ * APIs — no third-party market-data SDK. Serves spot and USDT-margined perpetual futures (`SYMBOL.P`),
+ * paginates past the 1000-kline cap, falls back `api.binance.com → api.binance.us`,
+ * and aggregates timeframes Binance doesn't serve natively (e.g. `45`, `180`). No API
+ * key; live ticks stream from a native kline WebSocket (`subscribe`), with a poll
+ * fallback for aggregated timeframes.
+ *
+ *   import { BinanceProvider } from 'vela/providers/binance';
+ *   chart.data.registerProvider('binance', new BinanceProvider());
+ */
+declare class BinanceProvider implements DataProvider {
+    /** The spot endpoint confirmed reachable (cached after the first probe). */
+    private spotBaseUrl;
+    /** The in-flight endpoint probe, shared so concurrent first calls don't each ping. */
+    private spotBaseProbe;
+    /** Cached symbol enumeration (exchangeInfo is large; fetch once). */
+    private symbolsPromise;
+    info(): ProviderInfo;
+    getBars(ticker: string, timeframe: string, range: BarRange): Promise<OHLCV[]>;
+    getSymbolInfo(ticker: string): Promise<SymbolInfo | undefined>;
+    listSymbols(): Promise<SymbolDescriptor[]>;
+    subscribe(ticker: string, timeframe: string, onBar: (bar: OHLCV) => void): Unsubscribe;
+    /**
+     * Open a Binance kline WebSocket (single-stream URL form — the stream is in the
+     * path, so no subscribe frame is sent). Perpetuals use `fstream`; spot uses the
+     * host matching the resolved REST endpoint (`.com`/`.us`). Reconnects on an
+     * unexpected close until unsubscribed; the browser auto-answers Binance's
+     * protocol-level pings, so no manual keepalive is needed.
+     *
+     * A stall watchdog falls the subscription back to polling if the socket opens but
+     * never delivers a candle — so a blocked/silent stream (e.g. geo-restricted
+     * futures) still yields live updates instead of a silently-dead feed.
+     */
+    private streamKlines;
+    /** WebSocket host matching the resolved REST spot endpoint (`.com` default, else `.us`). */
+    private spotWsBase;
+    /** Poll the forming candle (for aggregated timeframes Binance has no native kline stream for). */
+    private pollBars;
+    private listSpot;
+    private listFutures;
+    /** Fetch klines, paginating past Binance's 1000-row cap. */
+    private fetchKlines;
+    /** Forward pagination from `from` to `to` (used by ranged/tail fetches). */
+    private paginateForward;
+    /** Backward pagination to assemble the most-recent `limit` bars. */
+    private paginateBackward;
+    private klinesChunk;
+    /**
+     * Resolve the reachable spot endpoint (default, else the US mirror). The in-flight
+     * probe is shared, so a burst of concurrent first calls issues ONE ping pair, not one
+     * per call. A confirmed endpoint is cached permanently; a total failure clears the
+     * probe so a later call can retry.
+     */
+    private spotBase;
+    private json;
+}
+
+export { BinanceProvider, DataProvider, ProviderInfo, SymbolDescriptor };