@adrienhobbs/candlekit 0.1.0

package/dist/index.js

@@ -0,0 +1,3903 @@
+import { useRef, useState, useEffect, useMemo, useCallback } from 'react';
+import { createChart, ColorType, CandlestickSeries, HistogramSeries, createSeriesMarkers, LineSeries, AreaSeries, LineStyle } from 'lightweight-charts';
+import { jsxs, jsx } from 'react/jsx-runtime';
+import { X, Search, Plus } from 'lucide-react';
+import { z } from 'zod';
+import { stochastic, obv, mfi, forceindex, atr, adx, macd, psar, cci, williamsr, keltnerchannel, supertrend, ichimokucloud, donchianchannels, roc, stochasticrsi, wma } from 'fast-technical-indicators';
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/indicators/core/registry.ts
+var IndicatorRegistry = class {
+  constructor() {
+    __publicField(this, "indicators", /* @__PURE__ */ new Map());
+    __publicField(this, "instanceCounters", /* @__PURE__ */ new Map());
+  }
+  register(definition) {
+    if (this.indicators.has(definition.metadata.id)) {
+      console.warn(
+        `Indicator with id "${definition.metadata.id}" is already registered. Overwriting.`
+      );
+    }
+    this.indicators.set(definition.metadata.id, definition);
+  }
+  unregister(id) {
+    return this.indicators.delete(id);
+  }
+  get(id) {
+    return this.indicators.get(id);
+  }
+  getAll() {
+    return Array.from(this.indicators.values());
+  }
+  getByCategory(category) {
+    return this.getAll().filter(
+      (indicator) => indicator.metadata.category === category
+    );
+  }
+  search(query) {
+    const lowerQuery = query.toLowerCase();
+    return this.getAll().filter(
+      (indicator) => indicator.metadata.name.toLowerCase().includes(lowerQuery) || indicator.metadata.description.toLowerCase().includes(lowerQuery)
+    );
+  }
+  createInstance(definitionId, customSettings) {
+    const definition = this.get(definitionId);
+    if (!definition) {
+      throw new Error(`Indicator definition "${definitionId}" not found`);
+    }
+    const currentCount = this.instanceCounters.get(definitionId) || 0;
+    const newCount = currentCount + 1;
+    this.instanceCounters.set(definitionId, newCount);
+    const instanceId = `${definitionId}-${newCount}`;
+    const defaultSettings = {};
+    Object.entries(definition.settings).forEach(([key, field]) => {
+      defaultSettings[key] = field.defaultValue;
+    });
+    const settings = { ...defaultSettings, ...customSettings };
+    return {
+      id: instanceId,
+      definitionId,
+      name: `${definition.metadata.name}(${newCount})`,
+      settings
+    };
+  }
+  validateSettings(definitionId, settings) {
+    const definition = this.get(definitionId);
+    if (!definition) {
+      return false;
+    }
+    for (const [key, field] of Object.entries(definition.settings)) {
+      const value = settings[key];
+      if (value === void 0) {
+        return false;
+      }
+      if (field.type === "number") {
+        if (typeof value !== "number") return false;
+        if (field.min !== void 0 && value < field.min) return false;
+        if (field.max !== void 0 && value > field.max) return false;
+      } else if (field.type === "boolean") {
+        if (typeof value !== "boolean") return false;
+      } else if (field.type === "color" || field.type === "lineStyle") {
+        if (typeof value !== "string") return false;
+      } else if (field.type === "select") {
+        if (typeof value !== "string") return false;
+        if (field.options && !field.options.some((opt) => opt.value === value)) {
+          return false;
+        }
+      }
+    }
+    return true;
+  }
+  getMetadataList() {
+    return this.getAll().map((indicator) => indicator.metadata);
+  }
+  clear() {
+    this.indicators.clear();
+    this.instanceCounters.clear();
+  }
+};
+var indicatorRegistry = new IndicatorRegistry();
+
+// src/indicators/core/calculator.ts
+var IndicatorCalculator = class {
+  constructor() {
+    __publicField(this, "cache", /* @__PURE__ */ new Map());
+  }
+  hashSettings(settings) {
+    return JSON.stringify(settings);
+  }
+  calculate(instance, bars) {
+    const definition = indicatorRegistry.get(instance.definitionId);
+    if (!definition) {
+      console.error(
+        `Indicator definition "${instance.definitionId}" not found`
+      );
+      return [];
+    }
+    const settingsHash = this.hashSettings(instance.settings);
+    const cacheKey = instance.id;
+    const cached = this.cache.get(cacheKey);
+    if (cached && cached.settingsHash === settingsHash && cached.dataLength === bars.length) {
+      return cached.data;
+    }
+    try {
+      const data = definition.calculate(bars, instance.settings);
+      this.cache.set(cacheKey, {
+        data,
+        settingsHash,
+        dataLength: bars.length
+      });
+      return data;
+    } catch (error) {
+      console.error(
+        `Error calculating indicator "${instance.definitionId}":`,
+        error
+      );
+      return [];
+    }
+  }
+  invalidateCache(instanceId) {
+    if (instanceId) {
+      this.cache.delete(instanceId);
+    } else {
+      this.cache.clear();
+    }
+  }
+  getCacheSize() {
+    return this.cache.size;
+  }
+};
+var indicatorCalculator = new IndicatorCalculator();
+
+// src/indicators/primitives/BandsPrimitive.ts
+var AreaBetweenLinesPaneView = class {
+  constructor(source) {
+    __publicField(this, "_source");
+    __publicField(this, "_data", null);
+    this._source = source;
+  }
+  update() {
+    const series1 = this._source._upperSeries;
+    const series2 = this._source._lowerSeries;
+    const chart = this._source._chart;
+    if (!series1 || !series2 || !chart) return;
+    const timeScale = chart.timeScale();
+    const data1 = series1.data();
+    const data2 = series2.data();
+    const points = [];
+    let i = 0;
+    let j = 0;
+    while (i < data1.length && j < data2.length) {
+      const d1 = data1[i];
+      const d2 = data2[j];
+      if (d1.time < d2.time) {
+        i++;
+      } else if (d1.time > d2.time) {
+        j++;
+      } else {
+        const x = timeScale.timeToCoordinate(d1.time);
+        const y1 = series1.priceToCoordinate(d1.value);
+        const y2 = series2.priceToCoordinate(d2.value);
+        if (x !== null && y1 !== null && y2 !== null) {
+          points.push({ x, y1, y2 });
+        }
+        i++;
+        j++;
+      }
+    }
+    this._data = {
+      points,
+      color: this._source._options.fillColor || "rgba(59, 130, 246, 0.1)"
+    };
+  }
+  renderer() {
+    return new AreaBetweenLinesRenderer(this._data);
+  }
+};
+var AreaBetweenLinesRenderer = class {
+  constructor(data) {
+    __publicField(this, "_data");
+    this._data = data;
+  }
+  draw(target) {
+    target.useBitmapCoordinateSpace((scope) => {
+      if (!this._data || this._data.points.length === 0) return;
+      const ctx = scope.context;
+      ctx.save();
+      ctx.scale(scope.horizontalPixelRatio, scope.verticalPixelRatio);
+      const points = this._data.points;
+      ctx.beginPath();
+      ctx.moveTo(points[0].x, points[0].y1);
+      for (let i = 1; i < points.length; i++) {
+        ctx.lineTo(points[i].x, points[i].y1);
+      }
+      for (let i = points.length - 1; i >= 0; i--) {
+        ctx.lineTo(points[i].x, points[i].y2);
+      }
+      ctx.closePath();
+      ctx.fillStyle = this._data.color;
+      ctx.fill();
+      ctx.restore();
+    });
+  }
+  drawBackground(target) {
+    this.draw(target);
+  }
+};
+var BandsPrimitive = class {
+  constructor(options) {
+    __publicField(this, "_options");
+    __publicField(this, "_upperSeries");
+    __publicField(this, "_lowerSeries");
+    __publicField(this, "_chart", null);
+    __publicField(this, "_series", null);
+    __publicField(this, "_paneViews");
+    this._options = options;
+    this._upperSeries = options.upperSeries;
+    this._lowerSeries = options.lowerSeries;
+    this._paneViews = [new AreaBetweenLinesPaneView(this)];
+  }
+  attached(param) {
+    this._chart = param.chart;
+    this._series = param.series;
+  }
+  detached() {
+    this._chart = null;
+    this._series = null;
+  }
+  paneViews() {
+    return this._paneViews;
+  }
+  updateAllViews() {
+    this._paneViews.forEach((pw) => pw.update());
+  }
+};
+function ChartComponent({
+  bars,
+  onLoadMoreData,
+  indicators = [],
+  lines = [],
+  onBarUpdate,
+  onNewBar,
+  onDeleteLine,
+  onAddLine,
+  onClearAllLines,
+  enableBarSelection = true,
+  onBarClick
+}) {
+  const chartContainerRef = useRef(null);
+  const chartRef = useRef(null);
+  const candlestickSeriesRef = useRef(null);
+  const volumeSeriesRef = useRef(null);
+  const indicatorSeriesRef = useRef(/* @__PURE__ */ new Map());
+  const indicatorPaneIndexRef = useRef(/* @__PURE__ */ new Map());
+  const nextPaneIndexRef = useRef(2);
+  const priceLineRefs = useRef(/* @__PURE__ */ new Map());
+  const seriesMarkersRef = useRef(null);
+  const [isLoadingMore, setIsLoadingMore] = useState(false);
+  const [contextMenu, setContextMenu] = useState(null);
+  const [linePositions, setLinePositions] = useState(/* @__PURE__ */ new Map());
+  const [selectedBar, setSelectedBar] = useState(null);
+  const selectedBarRef = useRef(null);
+  const [spotlightPosition, setSpotlightPosition] = useState(null);
+  const previousBarsRef = useRef([]);
+  const previousBarsLengthRef = useRef(0);
+  const isLoadingRef = useRef(false);
+  const barsRef = useRef(bars);
+  const isDraggingRef = useRef(false);
+  const mouseDownPosRef = useRef(null);
+  useEffect(() => {
+    if (!chartContainerRef.current) return;
+    const chart = createChart(chartContainerRef.current, {
+      layout: {
+        background: { type: ColorType.Solid, color: "#0f172a" },
+        textColor: "#94a3b8",
+        panes: {
+          enableResize: true,
+          separatorColor: "#1e293b",
+          separatorHoverColor: "rgba(148,163,184,0.5)"
+        }
+      },
+      grid: {
+        vertLines: { color: "#1e293b" },
+        horzLines: { color: "#1e293b" }
+      },
+      width: chartContainerRef.current.clientWidth,
+      height: 600,
+      timeScale: {
+        timeVisible: true,
+        secondsVisible: true,
+        borderColor: "#334155"
+      },
+      rightPriceScale: {
+        borderColor: "#334155"
+      },
+      crosshair: {
+        mode: 0,
+        vertLine: {
+          width: 1,
+          color: "#475569",
+          style: 3
+        },
+        horzLine: {
+          width: 1,
+          color: "#475569",
+          style: 3
+        }
+      }
+    });
+    const candlestickSeries = chart.addSeries(CandlestickSeries, {
+      upColor: "#10b981",
+      downColor: "#ef4444",
+      borderVisible: false,
+      wickUpColor: "#10b981",
+      wickDownColor: "#ef4444"
+    }, 0);
+    const volumeSeries = chart.addSeries(HistogramSeries, {
+      color: "#64748b",
+      priceFormat: {
+        type: "volume"
+      },
+      priceScaleId: ""
+    }, 1);
+    chartRef.current = chart;
+    candlestickSeriesRef.current = candlestickSeries;
+    volumeSeriesRef.current = volumeSeries;
+    seriesMarkersRef.current = createSeriesMarkers(candlestickSeries, []);
+    chart.timeScale().subscribeVisibleLogicalRangeChange((logicalRange) => {
+      if (logicalRange && logicalRange.from < 5 && !isLoadingRef.current && onLoadMoreData) {
+        console.log("Triggering load more, logicalRange.from:", logicalRange.from);
+        isLoadingRef.current = true;
+        setIsLoadingMore(true);
+        previousBarsLengthRef.current = barsRef.current.length;
+        console.log("Set previousBarsLengthRef to:", previousBarsLengthRef.current);
+        const sortedBars = [...barsRef.current].sort((a, b) => a.timestamp - b.timestamp);
+        const oldestTimestamp = sortedBars[0]?.timestamp;
+        if (oldestTimestamp) {
+          onLoadMoreData(oldestTimestamp);
+        }
+      }
+    });
+    const handleResize = () => {
+      if (chartContainerRef.current && chart) {
+        chart.applyOptions({ width: chartContainerRef.current.clientWidth });
+      }
+    };
+    const handleContextMenu = (e) => {
+      console.log("Context menu event triggered!", e);
+      e.preventDefault();
+      e.stopPropagation();
+      if (!candlestickSeriesRef.current) {
+        console.log("No candlestick series yet");
+        return;
+      }
+      const rect = chartContainerRef.current.getBoundingClientRect();
+      const y = e.clientY - rect.top;
+      console.log("Y position:", y, "Rect:", rect);
+      const price = candlestickSeriesRef.current.coordinateToPrice(y);
+      console.log("Calculated price:", price);
+      if (price !== null) {
+        setContextMenu({
+          x: e.clientX - rect.left,
+          y,
+          price
+        });
+        console.log("Context menu set:", { x: e.clientX - rect.left, y, price });
+      }
+    };
+    const handleMouseDown = (e) => {
+      mouseDownPosRef.current = { x: e.clientX, y: e.clientY };
+      isDraggingRef.current = false;
+    };
+    const handleMouseMove = (e) => {
+      if (mouseDownPosRef.current) {
+        const dx = Math.abs(e.clientX - mouseDownPosRef.current.x);
+        const dy = Math.abs(e.clientY - mouseDownPosRef.current.y);
+        if (dx > 5 || dy > 5) {
+          isDraggingRef.current = true;
+        }
+      }
+    };
+    const handleMouseUp = () => {
+      mouseDownPosRef.current = null;
+    };
+    const handleClick = (e) => {
+      console.log("=== CLICK DEBUG START ===");
+      console.log("Click event - closing context menu");
+      setContextMenu(null);
+      if (isDraggingRef.current) {
+        console.log("Ignoring click - user was dragging");
+        isDraggingRef.current = false;
+        return;
+      }
+      console.log("enableBarSelection prop:", enableBarSelection);
+      console.log("chartRef.current:", !!chartRef.current);
+      console.log("candlestickSeriesRef.current:", !!candlestickSeriesRef.current);
+      console.log("bars.length:", bars.length);
+      if (!enableBarSelection) {
+        console.log("Bar selection is DISABLED - exiting");
+        return;
+      }
+      if (!chartRef.current) {
+        console.log("Chart ref is NULL - exiting");
+        return;
+      }
+      if (!candlestickSeriesRef.current) {
+        console.log("Candlestick series ref is NULL - exiting");
+        return;
+      }
+      console.log("All checks passed - proceeding with bar selection");
+      const rect = chartContainerRef.current.getBoundingClientRect();
+      const x = e.clientX - rect.left;
+      console.log("Click X coordinate:", x);
+      const timeScale = chartRef.current.timeScale();
+      const coordinate = timeScale.coordinateToTime(x);
+      console.log("Coordinate from timeScale:", coordinate);
+      if (!coordinate) {
+        console.log("No coordinate from timeScale - exiting");
+        return;
+      }
+      const clickedTime = coordinate;
+      console.log("Clicked time:", clickedTime);
+      console.log("Sample bar timestamps (first 3):", barsRef.current.slice(0, 3).map((b) => b.timestamp / 1e3));
+      const clickedBar = barsRef.current.find((bar) => {
+        const diff = Math.abs(bar.timestamp / 1e3 - clickedTime);
+        return diff < 300;
+      });
+      console.log("Clicked bar found:", !!clickedBar);
+      if (clickedBar) {
+        console.log("Clicked bar details:", clickedBar);
+        console.log("Current selectedBarRef.current:", selectedBarRef.current);
+        if (selectedBarRef.current && selectedBarRef.current.timestamp === clickedBar.timestamp) {
+          console.log("Deselecting bar (same bar clicked)");
+          selectedBarRef.current = null;
+          setSelectedBar(null);
+          setSpotlightPosition(null);
+          if (onBarClick) {
+            onBarClick(null);
+          }
+        } else {
+          console.log("Selecting new bar");
+          selectedBarRef.current = clickedBar;
+          setSelectedBar(clickedBar);
+          const barX = timeScale.timeToCoordinate(clickedBar.timestamp / 1e3);
+          console.log("Bar X position:", barX);
+          if (barX !== null) {
+            const barWidth = Math.max(8, rect.width / barsRef.current.length);
+            console.log("Bar width:", barWidth);
+            setSpotlightPosition({ x: barX - barWidth / 2, width: barWidth });
+          }
+          if (onBarClick) {
+            onBarClick(clickedBar);
+          }
+        }
+      } else {
+        console.log("No bar found at clicked position");
+      }
+      console.log("=== CLICK DEBUG END ===");
+    };
+    window.addEventListener("resize", handleResize);
+    chartContainerRef.current.addEventListener("contextmenu", handleContextMenu, true);
+    chartContainerRef.current.addEventListener("mousedown", handleMouseDown, true);
+    chartContainerRef.current.addEventListener("mousemove", handleMouseMove, true);
+    chartContainerRef.current.addEventListener("mouseup", handleMouseUp, true);
+    chartContainerRef.current.addEventListener("click", handleClick, true);
+    const container = chartContainerRef.current;
+    return () => {
+      window.removeEventListener("resize", handleResize);
+      container.removeEventListener("contextmenu", handleContextMenu, true);
+      container.removeEventListener("mousedown", handleMouseDown, true);
+      container.removeEventListener("mousemove", handleMouseMove, true);
+      container.removeEventListener("mouseup", handleMouseUp, true);
+      container.removeEventListener("click", handleClick, true);
+      chart.remove();
+    };
+  }, []);
+  useEffect(() => {
+    barsRef.current = bars;
+  }, [bars]);
+  useEffect(() => {
+    if (!candlestickSeriesRef.current || !volumeSeriesRef.current) return;
+    const sortedBars = [...bars].sort((a, b) => a.timestamp - b.timestamp);
+    const uniqueBars = sortedBars.reduce((acc, bar) => {
+      const exists = acc.find((b) => b.timestamp === bar.timestamp);
+      if (!exists) {
+        acc.push(bar);
+      }
+      return acc;
+    }, []);
+    console.log("Debug - bars.length:", bars.length, "uniqueBars.length:", uniqueBars.length, "isLoadingRef:", isLoadingRef.current, "previousBarsLength:", previousBarsLengthRef.current);
+    const previousBars = previousBarsRef.current;
+    const isInitialLoad = previousBars.length === 0;
+    const hasNewBars = uniqueBars.length > previousBars.length;
+    const lastBarChanged = uniqueBars.length > 0 && previousBars.length > 0 && uniqueBars[uniqueBars.length - 1].timestamp === previousBars[previousBars.length - 1].timestamp;
+    console.log("isInitialLoad:", isInitialLoad, "hasNewBars:", hasNewBars, "lastBarChanged:", lastBarChanged);
+    console.log("previousBars.length:", previousBars.length, "uniqueBars.length:", uniqueBars.length);
+    if (isLoadingRef.current && uniqueBars.length > previousBarsLengthRef.current) {
+      console.log("Hiding loading indicator");
+      isLoadingRef.current = false;
+      setIsLoadingMore(false);
+    }
+    const firstBarChanged = uniqueBars.length > 0 && previousBars.length > 0 && uniqueBars[0].timestamp !== previousBars[0].timestamp;
+    if (isInitialLoad || hasNewBars) {
+      console.log("Setting data with", uniqueBars.length, "bars", "firstBarChanged:", firstBarChanged);
+      const candleData = uniqueBars.map((bar) => ({
+        time: bar.timestamp / 1e3,
+        open: bar.open,
+        high: bar.high,
+        low: bar.low,
+        close: bar.close
+      }));
+      const volumeData = uniqueBars.map((bar) => ({
+        time: bar.timestamp / 1e3,
+        value: bar.volume,
+        color: bar.close >= bar.open ? "#10b98180" : "#ef444480"
+      }));
+      console.log("candleData sample (first 3):", candleData.slice(0, 3));
+      console.log("candleData sample (last 3):", candleData.slice(-3));
+      candlestickSeriesRef.current.setData(candleData);
+      volumeSeriesRef.current.setData(volumeData);
+    } else if (lastBarChanged && uniqueBars.length > 0 && !hasNewBars) {
+      const lastBar = uniqueBars[uniqueBars.length - 1];
+      const candleUpdate = {
+        time: lastBar.timestamp / 1e3,
+        open: lastBar.open,
+        high: lastBar.high,
+        low: lastBar.low,
+        close: lastBar.close
+      };
+      const volumeUpdate = {
+        time: lastBar.timestamp / 1e3,
+        value: lastBar.volume,
+        color: lastBar.close >= lastBar.open ? "#10b98180" : "#ef444480"
+      };
+      candlestickSeriesRef.current.update(candleUpdate);
+      volumeSeriesRef.current.update(volumeUpdate);
+    }
+    previousBarsRef.current = uniqueBars;
+  }, [bars]);
+  useEffect(() => {
+    if (!chartRef.current || !candlestickSeriesRef.current) return;
+    priceLineRefs.current.forEach((priceLine) => {
+      candlestickSeriesRef.current?.removePriceLine(priceLine);
+    });
+    priceLineRefs.current.clear();
+    const newPositions = /* @__PURE__ */ new Map();
+    lines.forEach((line) => {
+      const priceLine = candlestickSeriesRef.current?.createPriceLine({
+        price: line.price,
+        color: line.color,
+        lineWidth: line.lineWidth || 2,
+        lineStyle: getLineStyle(line.lineStyle),
+        axisLabelVisible: true,
+        title: line.title || ""
+      });
+      if (priceLine) {
+        priceLineRefs.current.set(line.id, priceLine);
+      }
+      const y = candlestickSeriesRef.current?.priceToCoordinate(line.price);
+      if (y !== null && y !== void 0) {
+        newPositions.set(line.id, y);
+      }
+    });
+    setLinePositions(newPositions);
+  }, [lines]);
+  useEffect(() => {
+    if (!chartRef.current || !candlestickSeriesRef.current) return;
+    const updatePositions = () => {
+      const newPositions = /* @__PURE__ */ new Map();
+      lines.forEach((line) => {
+        const y = candlestickSeriesRef.current?.priceToCoordinate(line.price);
+        if (y !== null && y !== void 0) {
+          newPositions.set(line.id, y);
+        }
+      });
+      setLinePositions(newPositions);
+    };
+    chartRef.current.timeScale().subscribeVisibleLogicalRangeChange(updatePositions);
+    return () => {
+      chartRef.current?.timeScale().unsubscribeVisibleLogicalRangeChange(updatePositions);
+    };
+  }, [lines]);
+  useEffect(() => {
+    if (!chartRef.current) return;
+    indicatorSeriesRef.current.forEach((series) => {
+      chartRef.current?.removeSeries(series);
+    });
+    indicatorSeriesRef.current.clear();
+    indicatorPaneIndexRef.current.clear();
+    nextPaneIndexRef.current = 2;
+    indicators.forEach((indicator) => {
+      const definition = indicatorRegistry.get(indicator.definitionId);
+      if (!definition) return;
+      const data = indicatorCalculator.calculate(indicator, barsRef.current);
+      if (!data || data.length === 0) return;
+      const seriesType = definition.renderConfig.seriesType;
+      const isOverlay = definition.renderConfig.overlay !== false;
+      const paneIndex = isOverlay ? 0 : nextPaneIndexRef.current;
+      if (!isOverlay) {
+        indicatorPaneIndexRef.current.set(indicator.id, paneIndex);
+        nextPaneIndexRef.current++;
+      }
+      if (seriesType === "line") {
+        if (definition.renderConfig.outputCount === 1) {
+          const series = chartRef.current.addSeries(LineSeries, {
+            color: indicator.settings.color || "#3b82f6",
+            lineWidth: indicator.settings.lineWidth || 2,
+            title: indicator.name
+          }, paneIndex);
+          const lineData = data.map((d) => ({ time: d.time, value: d.value }));
+          series.setData(lineData);
+          indicatorSeriesRef.current.set(indicator.id, series);
+        } else if (definition.renderConfig.hasBandFill && definition.renderConfig.fillBands) {
+          const { upper: upperField, lower: lowerField } = definition.renderConfig.fillBands;
+          const upperSeries = chartRef.current.addSeries(LineSeries, {
+            color: indicator.settings.upperColor || "#ef4444",
+            lineWidth: indicator.settings.lineWidth || 2,
+            title: `${indicator.name} Upper`
+          }, paneIndex);
+          const middleSeries = chartRef.current.addSeries(LineSeries, {
+            color: indicator.settings.middleColor || indicator.settings.vwapColor || "#3b82f6",
+            lineWidth: indicator.settings.lineWidth || 2,
+            title: `${indicator.name} Middle`
+          }, paneIndex);
+          const lowerSeries = chartRef.current.addSeries(LineSeries, {
+            color: indicator.settings.lowerColor || "#10b981",
+            lineWidth: indicator.settings.lineWidth || 2,
+            title: `${indicator.name} Lower`
+          }, paneIndex);
+          const upperData = data.map((d) => ({ time: d.time, value: d[upperField] })).filter((d) => !isNaN(d.value));
+          const middleData = data.map((d) => ({ time: d.time, value: d.value })).filter((d) => !isNaN(d.value));
+          const lowerData = data.map((d) => ({ time: d.time, value: d[lowerField] })).filter((d) => !isNaN(d.value));
+          upperSeries.setData(upperData);
+          middleSeries.setData(middleData);
+          lowerSeries.setData(lowerData);
+          if (indicator.settings.showFill !== false) {
+            const bandsPrimitive = new BandsPrimitive({
+              upperSeries,
+              lowerSeries,
+              fillColor: indicator.settings.fillColor || "rgba(59, 130, 246, 0.1)"
+            });
+            upperSeries.attachPrimitive(bandsPrimitive);
+          }
+          indicatorSeriesRef.current.set(`${indicator.id}-upper`, upperSeries);
+          indicatorSeriesRef.current.set(`${indicator.id}-middle`, middleSeries);
+          indicatorSeriesRef.current.set(`${indicator.id}-lower`, lowerSeries);
+        }
+      } else if (seriesType === "histogram") {
+        const series = chartRef.current.addSeries(HistogramSeries, {
+          color: indicator.settings.color || "#8b5cf6",
+          title: indicator.name
+        }, paneIndex);
+        const histData = data.map((d) => ({ time: d.time, value: d.value }));
+        series.setData(histData);
+        indicatorSeriesRef.current.set(indicator.id, series);
+      } else if (seriesType === "area") {
+        const series = chartRef.current.addSeries(AreaSeries, {
+          topColor: indicator.settings.topColor || "#3b82f680",
+          bottomColor: indicator.settings.bottomColor || "#3b82f600",
+          lineColor: indicator.settings.lineColor || "#3b82f6",
+          lineWidth: indicator.settings.lineWidth || 2,
+          title: indicator.name
+        }, paneIndex);
+        const areaData = data.map((d) => ({ time: d.time, value: d.value }));
+        series.setData(areaData);
+        indicatorSeriesRef.current.set(indicator.id, series);
+      }
+    });
+  }, [indicators]);
+  useEffect(() => {
+    if (!chartRef.current || indicators.length === 0) return;
+    indicators.forEach((indicator) => {
+      const definition = indicatorRegistry.get(indicator.definitionId);
+      if (!definition) return;
+      const data = indicatorCalculator.calculate(indicator, barsRef.current);
+      if (!data || data.length === 0) return;
+      if (definition.renderConfig.outputCount === 1) {
+        const series = indicatorSeriesRef.current.get(indicator.id);
+        if (series) {
+          const lineData = data.map((d) => ({ time: d.time, value: d.value }));
+          series.setData(lineData);
+        }
+      } else if (definition.renderConfig.hasBandFill && definition.renderConfig.fillBands) {
+        const { upper: upperField, lower: lowerField } = definition.renderConfig.fillBands;
+        const upperSeries = indicatorSeriesRef.current.get(`${indicator.id}-upper`);
+        const middleSeries = indicatorSeriesRef.current.get(`${indicator.id}-middle`);
+        const lowerSeries = indicatorSeriesRef.current.get(`${indicator.id}-lower`);
+        if (upperSeries && middleSeries && lowerSeries) {
+          const upperData = data.map((d) => ({ time: d.time, value: d[upperField] })).filter((d) => !isNaN(d.value));
+          const middleData = data.map((d) => ({ time: d.time, value: d.value })).filter((d) => !isNaN(d.value));
+          const lowerData = data.map((d) => ({ time: d.time, value: d[lowerField] })).filter((d) => !isNaN(d.value));
+          upperSeries.setData(upperData);
+          middleSeries.setData(middleData);
+          lowerSeries.setData(lowerData);
+        }
+      }
+    });
+  }, [bars, indicators]);
+  useEffect(() => {
+    console.log("Marker effect running, selectedBar:", selectedBar);
+    if (!seriesMarkersRef.current) {
+      console.log("Marker API not initialized yet.");
+      return;
+    }
+    if (!enableBarSelection) {
+      console.log("Marker effect: clearing markers, selection disabled");
+      seriesMarkersRef.current.setMarkers([]);
+      return;
+    }
+    if (!selectedBar) {
+      console.log("Marker effect: clearing markers, no bar selected");
+      seriesMarkersRef.current.setMarkers([]);
+      return;
+    }
+    console.log("Marker effect: setting marker for bar:", selectedBar.timestamp);
+    const marker = {
+      time: selectedBar.timestamp / 1e3,
+      position: "aboveBar",
+      color: "#3b82f6",
+      shape: "circle",
+      text: "Selected"
+    };
+    seriesMarkersRef.current.setMarkers([marker]);
+  }, [selectedBar, enableBarSelection]);
+  useEffect(() => {
+    if (!chartRef.current || !selectedBar || !enableBarSelection) {
+      setSpotlightPosition(null);
+      return;
+    }
+    const updateSpotlightPosition = () => {
+      if (!chartRef.current || !selectedBar || !chartContainerRef.current) return;
+      const timeScale2 = chartRef.current.timeScale();
+      const barX = timeScale2.timeToCoordinate(selectedBar.timestamp / 1e3);
+      if (barX !== null) {
+        const rect = chartContainerRef.current.getBoundingClientRect();
+        const barWidth = Math.max(8, rect.width / bars.length);
+        setSpotlightPosition({ x: barX - barWidth / 2, width: barWidth });
+      }
+    };
+    updateSpotlightPosition();
+    const timeScale = chartRef.current.timeScale();
+    timeScale.subscribeVisibleLogicalRangeChange(updateSpotlightPosition);
+    return () => {
+      if (chartRef.current) {
+        chartRef.current.timeScale().unsubscribeVisibleLogicalRangeChange(updateSpotlightPosition);
+      }
+    };
+  }, [selectedBar, enableBarSelection, bars.length]);
+  const handleDeleteLine = (lineId) => {
+    if (onDeleteLine) {
+      onDeleteLine(lineId);
+    }
+  };
+  const handleAddLineFromContext = (type) => {
+    if (onAddLine && contextMenu) {
+      onAddLine(type, contextMenu.price);
+      setContextMenu(null);
+    }
+  };
+  const handleClearAllLines = () => {
+    if (onClearAllLines) {
+      onClearAllLines();
+      setContextMenu(null);
+    }
+  };
+  return /* @__PURE__ */ jsxs("div", { className: "relative space-y-4", children: [
+    isLoadingMore && /* @__PURE__ */ jsx("div", { className: "absolute top-4 left-1/2 transform -translate-x-1/2 bg-slate-800 text-slate-200 px-4 py-2 rounded-lg shadow-lg z-10", children: "Loading more data..." }),
+    /* @__PURE__ */ jsxs("div", { className: "relative", children: [
+      /* @__PURE__ */ jsx("div", { ref: chartContainerRef, className: "w-full" }),
+      enableBarSelection && spotlightPosition && /* @__PURE__ */ jsx(
+        "div",
+        {
+          className: "absolute top-0 bottom-0 pointer-events-none z-5",
+          style: {
+            left: `${spotlightPosition.x}px`,
+            width: `${spotlightPosition.width}px`,
+            background: "rgba(59, 130, 246, 0.15)",
+            borderLeft: "1px solid rgba(59, 130, 246, 0.4)",
+            borderRight: "1px solid rgba(59, 130, 246, 0.4)"
+          }
+        }
+      ),
+      lines.map((line) => {
+        const y = linePositions.get(line.id);
+        if (y === null || y === void 0) return null;
+        return /* @__PURE__ */ jsx(
+          "button",
+          {
+            onClick: () => handleDeleteLine(line.id),
+            className: "absolute bg-red-500/70 hover:bg-red-500 text-white rounded-full w-4 h-4 flex items-center justify-center text-xs font-bold transition-colors z-20 shadow-md",
+            style: {
+              right: "68px",
+              top: `${y - 8}px`
+            },
+            title: "Delete line",
+            children: "\xD7"
+          },
+          line.id
+        );
+      })
+    ] }),
+    contextMenu && /* @__PURE__ */ jsxs(
+      "div",
+      {
+        className: "absolute bg-slate-800 border border-slate-600 rounded-lg shadow-xl z-30 py-1 min-w-[180px]",
+        style: {
+          left: `${contextMenu.x}px`,
+          top: `${contextMenu.y}px`
+        },
+        children: [
+          /* @__PURE__ */ jsxs("div", { className: "px-3 py-1 text-xs text-slate-400 border-b border-slate-600", children: [
+            "Price: ",
+            contextMenu.price.toFixed(3)
+          ] }),
+          /* @__PURE__ */ jsx(
+            "button",
+            {
+              onClick: () => handleAddLineFromContext("entry"),
+              className: "w-full px-3 py-2 text-left text-sm text-slate-200 hover:bg-slate-700 transition-colors",
+              children: "Add Entry Line"
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            "button",
+            {
+              onClick: () => handleAddLineFromContext("stopLoss"),
+              className: "w-full px-3 py-2 text-left text-sm text-slate-200 hover:bg-slate-700 transition-colors",
+              children: "Add Stop Loss"
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            "button",
+            {
+              onClick: () => handleAddLineFromContext("takeProfit"),
+              className: "w-full px-3 py-2 text-left text-sm text-slate-200 hover:bg-slate-700 transition-colors",
+              children: "Add Take Profit"
+            }
+          ),
+          /* @__PURE__ */ jsx("div", { className: "border-t border-slate-600 my-1" }),
+          /* @__PURE__ */ jsx(
+            "button",
+            {
+              onClick: () => handleAddLineFromContext("support"),
+              className: "w-full px-3 py-2 text-left text-sm text-slate-200 hover:bg-slate-700 transition-colors",
+              children: "Add Support Line"
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            "button",
+            {
+              onClick: () => handleAddLineFromContext("resistance"),
+              className: "w-full px-3 py-2 text-left text-sm text-slate-200 hover:bg-slate-700 transition-colors",
+              children: "Add Resistance Line"
+            }
+          ),
+          /* @__PURE__ */ jsx("div", { className: "border-t border-slate-600 my-1" }),
+          /* @__PURE__ */ jsx(
+            "button",
+            {
+              onClick: handleClearAllLines,
+              className: "w-full px-3 py-2 text-left text-sm text-red-400 hover:bg-slate-700 transition-colors",
+              children: "Clear All Lines"
+            }
+          )
+        ]
+      }
+    )
+  ] });
+}
+function getLineStyle(style) {
+  switch (style) {
+    case "dashed":
+      return LineStyle.Dashed;
+    case "dotted":
+      return LineStyle.Dotted;
+    default:
+      return LineStyle.Solid;
+  }
+}
+var IndicatorCategory = /* @__PURE__ */ ((IndicatorCategory2) => {
+  IndicatorCategory2["TREND"] = "Trend";
+  IndicatorCategory2["MOMENTUM"] = "Momentum";
+  IndicatorCategory2["VOLATILITY"] = "Volatility";
+  IndicatorCategory2["VOLUME"] = "Volume";
+  IndicatorCategory2["OSCILLATORS"] = "Oscillators";
+  return IndicatorCategory2;
+})(IndicatorCategory || {});
+var ChartSeriesType = /* @__PURE__ */ ((ChartSeriesType2) => {
+  ChartSeriesType2["LINE"] = "line";
+  ChartSeriesType2["HISTOGRAM"] = "histogram";
+  ChartSeriesType2["AREA"] = "area";
+  return ChartSeriesType2;
+})(ChartSeriesType || {});
+var SettingFieldTypeSchema = z.enum([
+  "number",
+  "color",
+  "boolean",
+  "select",
+  "lineStyle"
+]);
+var LineStyleSchema = z.enum(["solid", "dashed", "dotted"]);
+var SettingFieldSchema = z.object({
+  type: SettingFieldTypeSchema,
+  label: z.string(),
+  defaultValue: z.union([z.string(), z.number(), z.boolean()]),
+  description: z.string().optional(),
+  min: z.number().optional(),
+  max: z.number().optional(),
+  step: z.number().optional(),
+  options: z.array(z.object({ label: z.string(), value: z.string() })).optional()
+});
+var IndicatorSettingsSchema = z.record(z.string(), SettingFieldSchema);
+var IndicatorMetadataSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  description: z.string(),
+  category: z.nativeEnum(IndicatorCategory),
+  version: z.string().default("1.0.0")
+});
+var RenderConfigSchema = z.object({
+  seriesType: z.nativeEnum(ChartSeriesType),
+  outputCount: z.number().default(1),
+  overlay: z.boolean().default(true),
+  hasBandFill: z.boolean().optional(),
+  fillBands: z.object({
+    upper: z.string(),
+    lower: z.string()
+  }).optional()
+});
+var IndicatorInstanceSchema = z.object({
+  id: z.string(),
+  definitionId: z.string(),
+  name: z.string(),
+  settings: z.record(z.string(), z.any())
+});
+function IndicatorBrowser({
+  isOpen,
+  onClose,
+  onAddIndicator
+}) {
+  const [searchQuery, setSearchQuery] = useState("");
+  const [selectedCategory, setSelectedCategory] = useState("All");
+  const categories = useMemo(() => {
+    return ["All", ...Object.values(IndicatorCategory)];
+  }, []);
+  const filteredIndicators = useMemo(() => {
+    let indicators = indicatorRegistry.getAll();
+    if (selectedCategory !== "All") {
+      indicators = indicators.filter(
+        (ind) => ind.metadata.category === selectedCategory
+      );
+    }
+    if (searchQuery.trim()) {
+      indicators = indicatorRegistry.search(searchQuery);
+      if (selectedCategory !== "All") {
+        indicators = indicators.filter(
+          (ind) => ind.metadata.category === selectedCategory
+        );
+      }
+    }
+    return indicators;
+  }, [searchQuery, selectedCategory]);
+  if (!isOpen) return null;
+  const handleAddIndicator = (definitionId) => {
+    onAddIndicator(definitionId);
+    onClose();
+  };
+  return /* @__PURE__ */ jsx("div", { className: "fixed inset-0 bg-black/50 flex items-center justify-center z-50", children: /* @__PURE__ */ jsxs("div", { className: "bg-slate-800 rounded-lg shadow-xl w-full max-w-3xl max-h-[80vh] flex flex-col", children: [
+    /* @__PURE__ */ jsxs("div", { className: "flex items-center justify-between p-4 border-b border-slate-700", children: [
+      /* @__PURE__ */ jsx("h2", { className: "text-lg font-semibold text-slate-100", children: "Add Indicator" }),
+      /* @__PURE__ */ jsx(
+        "button",
+        {
+          onClick: onClose,
+          className: "text-slate-400 hover:text-slate-200 transition",
+          children: /* @__PURE__ */ jsx(X, { size: 20 })
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsxs("div", { className: "p-4 border-b border-slate-700", children: [
+      /* @__PURE__ */ jsxs("div", { className: "relative", children: [
+        /* @__PURE__ */ jsx(
+          Search,
+          {
+            className: "absolute left-3 top-1/2 -translate-y-1/2 text-slate-400",
+            size: 20
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          "input",
+          {
+            type: "text",
+            placeholder: "Search indicators...",
+            value: searchQuery,
+            onChange: (e) => setSearchQuery(e.target.value),
+            className: "w-full pl-10 pr-4 py-2 bg-slate-700 border border-slate-600 rounded-lg text-slate-100 placeholder-slate-400 focus:outline-none focus:ring-2 focus:ring-blue-500"
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsx("div", { className: "flex gap-2 mt-3 overflow-x-auto pb-2", children: categories.map((category) => /* @__PURE__ */ jsx(
+        "button",
+        {
+          onClick: () => setSelectedCategory(category),
+          className: `px-3 py-1.5 rounded-lg text-sm font-medium whitespace-nowrap transition ${selectedCategory === category ? "bg-blue-600 text-white" : "bg-slate-700 text-slate-300 hover:bg-slate-600"}`,
+          children: category
+        },
+        category
+      )) })
+    ] }),
+    /* @__PURE__ */ jsx("div", { className: "flex-1 overflow-y-auto p-4", children: filteredIndicators.length === 0 ? /* @__PURE__ */ jsxs("div", { className: "text-center py-12 text-slate-400", children: [
+      /* @__PURE__ */ jsx("p", { children: "No indicators found" }),
+      searchQuery && /* @__PURE__ */ jsx("p", { className: "text-sm mt-2", children: "Try adjusting your search or category filter" })
+    ] }) : /* @__PURE__ */ jsx("div", { className: "grid gap-3", children: filteredIndicators.map((indicator) => /* @__PURE__ */ jsx(
+      IndicatorCard,
+      {
+        indicator,
+        onAdd: () => handleAddIndicator(indicator.metadata.id)
+      },
+      indicator.metadata.id
+    )) }) })
+  ] }) });
+}
+function IndicatorCard({ indicator, onAdd }) {
+  const getCategoryColor = (category) => {
+    switch (category) {
+      case "Trend" /* TREND */:
+        return "bg-blue-500/20 text-blue-400";
+      case "Momentum" /* MOMENTUM */:
+        return "bg-purple-500/20 text-purple-400";
+      case "Volatility" /* VOLATILITY */:
+        return "bg-orange-500/20 text-orange-400";
+      case "Volume" /* VOLUME */:
+        return "bg-green-500/20 text-green-400";
+      case "Oscillators" /* OSCILLATORS */:
+        return "bg-pink-500/20 text-pink-400";
+      default:
+        return "bg-slate-500/20 text-slate-400";
+    }
+  };
+  return /* @__PURE__ */ jsx("div", { className: "bg-slate-700/50 rounded-lg p-4 hover:bg-slate-700 transition group", children: /* @__PURE__ */ jsxs("div", { className: "flex items-start justify-between gap-3", children: [
+    /* @__PURE__ */ jsxs("div", { className: "flex-1", children: [
+      /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-2 mb-2", children: [
+        /* @__PURE__ */ jsx("h3", { className: "text-slate-100 font-medium", children: indicator.metadata.name }),
+        /* @__PURE__ */ jsx(
+          "span",
+          {
+            className: `px-2 py-0.5 rounded text-xs font-medium ${getCategoryColor(
+              indicator.metadata.category
+            )}`,
+            children: indicator.metadata.category
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsx("p", { className: "text-sm text-slate-400", children: indicator.metadata.description })
+    ] }),
+    /* @__PURE__ */ jsxs(
+      "button",
+      {
+        onClick: onAdd,
+        className: "flex items-center gap-1.5 px-3 py-1.5 bg-blue-600 hover:bg-blue-700 text-white rounded-lg transition text-sm font-medium opacity-0 group-hover:opacity-100",
+        children: [
+          /* @__PURE__ */ jsx(Plus, { size: 16 }),
+          "Add"
+        ]
+      }
+    )
+  ] }) });
+}
+function IndicatorSettingsForm({
+  settings,
+  currentValues,
+  onChange
+}) {
+  return /* @__PURE__ */ jsx("div", { className: "space-y-4", children: Object.entries(settings).map(([key, field]) => /* @__PURE__ */ jsxs("div", { children: [
+    /* @__PURE__ */ jsx("label", { className: "block text-sm font-medium text-slate-300 mb-1", children: field.label }),
+    field.description && /* @__PURE__ */ jsx("p", { className: "text-xs text-slate-400 mb-2", children: field.description }),
+    renderField(key, field, currentValues[key], onChange)
+  ] }, key)) });
+}
+function parseColor(colorValue) {
+  const rgbaMatch = colorValue.match(/^rgba?\((\d+),\s*(\d+),\s*(\d+)(?:,\s*([\d.]+))?\)$/);
+  if (rgbaMatch) {
+    const r = parseInt(rgbaMatch[1]);
+    const g = parseInt(rgbaMatch[2]);
+    const b = parseInt(rgbaMatch[3]);
+    const a = rgbaMatch[4] ? parseFloat(rgbaMatch[4]) : 1;
+    const hex = `#${r.toString(16).padStart(2, "0")}${g.toString(16).padStart(2, "0")}${b.toString(16).padStart(2, "0")}`;
+    return { hex, opacity: Math.round(a * 100) };
+  }
+  return { hex: colorValue, opacity: 100 };
+}
+function hexToRgba(hex, opacity) {
+  const r = parseInt(hex.slice(1, 3), 16);
+  const g = parseInt(hex.slice(3, 5), 16);
+  const b = parseInt(hex.slice(5, 7), 16);
+  const a = opacity / 100;
+  return `rgba(${r}, ${g}, ${b}, ${a})`;
+}
+function ColorPicker({ value, defaultValue, onChange }) {
+  const colorValue = value ?? defaultValue;
+  const { hex, opacity } = parseColor(colorValue);
+  const [localHex, setLocalHex] = useState(hex);
+  const [localOpacity, setLocalOpacity] = useState(opacity);
+  const handleColorChange = (newHex) => {
+    setLocalHex(newHex);
+    onChange(hexToRgba(newHex, localOpacity));
+  };
+  const handleOpacityChange = (newOpacity) => {
+    setLocalOpacity(newOpacity);
+    onChange(hexToRgba(localHex, newOpacity));
+  };
+  const handleTextChange = (newValue) => {
+    const parsed = parseColor(newValue);
+    setLocalHex(parsed.hex);
+    setLocalOpacity(parsed.opacity);
+    onChange(newValue);
+  };
+  return /* @__PURE__ */ jsxs("div", { className: "space-y-2", children: [
+    /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-2", children: [
+      /* @__PURE__ */ jsx(
+        "input",
+        {
+          type: "color",
+          value: localHex,
+          onChange: (e) => handleColorChange(e.target.value),
+          className: "w-12 h-10 rounded cursor-pointer"
+        }
+      ),
+      /* @__PURE__ */ jsx(
+        "input",
+        {
+          type: "text",
+          value: colorValue,
+          onChange: (e) => handleTextChange(e.target.value),
+          className: "flex-1 px-3 py-2 bg-slate-700 border border-slate-600 rounded-lg text-slate-100 focus:outline-none focus:ring-2 focus:ring-blue-500 font-mono text-sm"
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-2", children: [
+      /* @__PURE__ */ jsx(
+        "input",
+        {
+          type: "range",
+          min: "0",
+          max: "100",
+          value: localOpacity,
+          onChange: (e) => handleOpacityChange(parseInt(e.target.value)),
+          className: "flex-1 h-2 bg-slate-600 rounded-lg appearance-none cursor-pointer"
+        }
+      ),
+      /* @__PURE__ */ jsxs("span", { className: "text-sm text-slate-400 w-12 text-right", children: [
+        localOpacity,
+        "%"
+      ] })
+    ] })
+  ] });
+}
+function renderField(key, field, value, onChange) {
+  switch (field.type) {
+    case "number":
+      return /* @__PURE__ */ jsx(
+        "input",
+        {
+          type: "number",
+          value: value ?? field.defaultValue,
+          onChange: (e) => onChange(key, parseFloat(e.target.value)),
+          min: field.min,
+          max: field.max,
+          step: field.step,
+          className: "w-full px-3 py-2 bg-slate-700 border border-slate-600 rounded-lg text-slate-100 focus:outline-none focus:ring-2 focus:ring-blue-500"
+        }
+      );
+    case "color":
+      return /* @__PURE__ */ jsx(
+        ColorPicker,
+        {
+          value,
+          defaultValue: field.defaultValue,
+          onChange: (newValue) => onChange(key, newValue)
+        }
+      );
+    case "boolean":
+      return /* @__PURE__ */ jsxs("label", { className: "flex items-center gap-2 cursor-pointer", children: [
+        /* @__PURE__ */ jsx(
+          "input",
+          {
+            type: "checkbox",
+            checked: value ?? field.defaultValue,
+            onChange: (e) => onChange(key, e.target.checked),
+            className: "w-4 h-4 text-blue-600 bg-slate-700 border-slate-600 rounded focus:ring-blue-500"
+          }
+        ),
+        /* @__PURE__ */ jsx("span", { className: "text-sm text-slate-300", children: value ?? field.defaultValue ? "Enabled" : "Disabled" })
+      ] });
+    case "select":
+      return /* @__PURE__ */ jsx(
+        "select",
+        {
+          value: value ?? field.defaultValue,
+          onChange: (e) => onChange(key, e.target.value),
+          className: "w-full px-3 py-2 bg-slate-700 border border-slate-600 rounded-lg text-slate-100 focus:outline-none focus:ring-2 focus:ring-blue-500",
+          children: field.options?.map((option) => /* @__PURE__ */ jsx("option", { value: option.value, children: option.label }, option.value))
+        }
+      );
+    case "lineStyle":
+      return /* @__PURE__ */ jsxs(
+        "select",
+        {
+          value: value ?? field.defaultValue,
+          onChange: (e) => onChange(key, e.target.value),
+          className: "w-full px-3 py-2 bg-slate-700 border border-slate-600 rounded-lg text-slate-100 focus:outline-none focus:ring-2 focus:ring-blue-500",
+          children: [
+            /* @__PURE__ */ jsx("option", { value: "solid", children: "Solid" }),
+            /* @__PURE__ */ jsx("option", { value: "dashed", children: "Dashed" }),
+            /* @__PURE__ */ jsx("option", { value: "dotted", children: "Dotted" })
+          ]
+        }
+      );
+    default:
+      return /* @__PURE__ */ jsx(
+        "input",
+        {
+          type: "text",
+          value: value ?? field.defaultValue,
+          onChange: (e) => onChange(key, e.target.value),
+          className: "w-full px-3 py-2 bg-slate-700 border border-slate-600 rounded-lg text-slate-100 focus:outline-none focus:ring-2 focus:ring-blue-500"
+        }
+      );
+  }
+}
+function SettingsDialog({
+  isOpen,
+  onClose,
+  indicator,
+  onSave
+}) {
+  const [settings, setSettings] = useState({});
+  useEffect(() => {
+    if (indicator) {
+      setSettings({ ...indicator.settings });
+    }
+  }, [indicator]);
+  if (!isOpen || !indicator) return null;
+  const definition = indicatorRegistry.get(indicator.definitionId);
+  if (!definition) return null;
+  const handleSave = () => {
+    onSave(indicator.id, settings);
+    onClose();
+  };
+  const handleChange = (key, value) => {
+    setSettings((prev) => ({
+      ...prev,
+      [key]: value
+    }));
+  };
+  return /* @__PURE__ */ jsx("div", { className: "fixed inset-0 bg-black/50 flex items-center justify-center z-50", children: /* @__PURE__ */ jsxs("div", { className: "bg-slate-800 rounded-lg shadow-xl w-full max-w-md", children: [
+    /* @__PURE__ */ jsxs("div", { className: "flex items-center justify-between p-4 border-b border-slate-700", children: [
+      /* @__PURE__ */ jsxs("h2", { className: "text-lg font-semibold text-slate-100", children: [
+        indicator.name,
+        " Settings"
+      ] }),
+      /* @__PURE__ */ jsx(
+        "button",
+        {
+          onClick: onClose,
+          className: "text-slate-400 hover:text-slate-200 transition",
+          children: /* @__PURE__ */ jsx(X, { size: 20 })
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsx("div", { className: "p-4", children: /* @__PURE__ */ jsx(
+      IndicatorSettingsForm,
+      {
+        settings: definition.settings,
+        currentValues: settings,
+        onChange: handleChange
+      }
+    ) }),
+    /* @__PURE__ */ jsxs("div", { className: "flex items-center justify-end gap-2 p-4 border-t border-slate-700", children: [
+      /* @__PURE__ */ jsx(
+        "button",
+        {
+          onClick: onClose,
+          className: "px-4 py-2 text-slate-300 hover:text-slate-100 transition",
+          children: "Cancel"
+        }
+      ),
+      /* @__PURE__ */ jsx(
+        "button",
+        {
+          onClick: handleSave,
+          className: "px-4 py-2 bg-blue-600 hover:bg-blue-700 text-white rounded-lg transition",
+          children: "Save Changes"
+        }
+      )
+    ] })
+  ] }) });
+}
+function useChartAPI(options) {
+  const [lines, setLines] = useState([]);
+  const [indicators, setIndicators] = useState([]);
+  const [isLoading, setIsLoading] = useState(true);
+  useEffect(() => {
+    if (options?.persistenceAdapter) {
+      options.persistenceAdapter.loadIndicators().then((loaded) => {
+        setIndicators(loaded);
+        setIsLoading(false);
+      });
+    } else {
+      setIsLoading(false);
+    }
+  }, [options?.persistenceAdapter]);
+  useEffect(() => {
+    if (!isLoading && options?.persistenceAdapter) {
+      options.persistenceAdapter.saveIndicators(indicators);
+    }
+  }, [indicators, isLoading, options?.persistenceAdapter]);
+  const addLine = useCallback(
+    (id, price, options2) => {
+      const newLine = {
+        id,
+        price,
+        color: options2?.color || "#3b82f6",
+        lineWidth: options2?.lineWidth || 2,
+        lineStyle: options2?.lineStyle || "solid",
+        title: options2?.title
+      };
+      setLines((prev) => [...prev, newLine]);
+    },
+    []
+  );
+  const removeLine = useCallback((id) => {
+    setLines((prev) => prev.filter((line) => line.id !== id));
+  }, []);
+  const updateLine = useCallback((id, price) => {
+    setLines(
+      (prev) => prev.map((line) => line.id === id ? { ...line, price } : line)
+    );
+  }, []);
+  const addEntryLine = useCallback(
+    (price) => {
+      const id = `entry-${Date.now()}`;
+      addLine(id, price, {
+        color: "#3b82f6",
+        title: "Entry",
+        lineStyle: "solid"
+      });
+    },
+    [addLine]
+  );
+  const addStopLoss = useCallback(
+    (price) => {
+      const id = `stop-loss-${Date.now()}`;
+      addLine(id, price, {
+        color: "#ef4444",
+        title: "Stop Loss",
+        lineStyle: "dashed"
+      });
+    },
+    [addLine]
+  );
+  const addTakeProfit = useCallback(
+    (price) => {
+      const id = `take-profit-${Date.now()}`;
+      addLine(id, price, {
+        color: "#10b981",
+        title: "Take Profit",
+        lineStyle: "dashed"
+      });
+    },
+    [addLine]
+  );
+  const addSupportLine = useCallback(
+    (price) => {
+      const id = `support-${Date.now()}`;
+      addLine(id, price, {
+        color: "#10b981",
+        title: "Support",
+        lineStyle: "dotted"
+      });
+    },
+    [addLine]
+  );
+  const addResistanceLine = useCallback(
+    (price) => {
+      const id = `resistance-${Date.now()}`;
+      addLine(id, price, {
+        color: "#f97316",
+        title: "Resistance",
+        lineStyle: "dotted"
+      });
+    },
+    [addLine]
+  );
+  const clearAllLines = useCallback(() => {
+    setLines([]);
+  }, []);
+  const addLineByType = useCallback(
+    (type, price) => {
+      if (type === "entry") {
+        addEntryLine(price);
+      } else if (type === "stopLoss") {
+        addStopLoss(price);
+      } else if (type === "takeProfit") {
+        addTakeProfit(price);
+      } else if (type === "support") {
+        addSupportLine(price);
+      } else if (type === "resistance") {
+        addResistanceLine(price);
+      }
+    },
+    [addEntryLine, addStopLoss, addTakeProfit, addSupportLine, addResistanceLine]
+  );
+  const addIndicator = useCallback((definitionId, customSettings) => {
+    const instance = indicatorRegistry.createInstance(definitionId, customSettings);
+    setIndicators((prev) => [...prev, instance]);
+    return instance;
+  }, []);
+  const removeIndicator = useCallback((id) => {
+    setIndicators((prev) => prev.filter((indicator) => indicator.id !== id));
+    indicatorCalculator.invalidateCache(id);
+  }, []);
+  const updateIndicatorSettings = useCallback(
+    (id, settings) => {
+      setIndicators(
+        (prev) => prev.map(
+          (indicator) => indicator.id === id ? { ...indicator, settings } : indicator
+        )
+      );
+      indicatorCalculator.invalidateCache(id);
+    },
+    []
+  );
+  return {
+    lines,
+    indicators,
+    isLoadingIndicators: isLoading,
+    addLine,
+    removeLine,
+    updateLine,
+    addEntryLine,
+    addStopLoss,
+    addTakeProfit,
+    addSupportLine,
+    addResistanceLine,
+    clearAllLines,
+    addLineByType,
+    addIndicator,
+    removeIndicator,
+    updateIndicatorSettings
+  };
+}
+
+// src/utils/barUtils.ts
+function validateBar(bar) {
+  if (!bar || typeof bar !== "object") return false;
+  const required = ["timestamp", "open", "high", "low", "close", "volume"];
+  for (const field of required) {
+    if (!(field in bar)) return false;
+    if (typeof bar[field] !== "number") return false;
+  }
+  if (bar.timestamp <= 0) return false;
+  if (bar.open <= 0 || bar.high <= 0 || bar.low <= 0 || bar.close <= 0) return false;
+  if (bar.volume < 0) return false;
+  if (bar.high < bar.low) return false;
+  if (bar.high < bar.open || bar.high < bar.close) return false;
+  if (bar.low > bar.open || bar.low > bar.close) return false;
+  return true;
+}
+function isValidBar(bar) {
+  return validateBar(bar);
+}
+function normalizeTimestamp(timestamp) {
+  if (timestamp < 1e10) {
+    return timestamp * 1e3;
+  }
+  return timestamp;
+}
+function sortBars(bars) {
+  return [...bars].sort((a, b) => a.timestamp - b.timestamp);
+}
+function deduplicateBars(bars) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const bar of bars) {
+    const existing = seen.get(bar.timestamp);
+    if (!existing) {
+      seen.set(bar.timestamp, bar);
+    }
+  }
+  return Array.from(seen.values()).sort((a, b) => a.timestamp - b.timestamp);
+}
+function mergeBars(existingBars, newBars) {
+  const allBars = [...existingBars, ...newBars];
+  return deduplicateBars(allBars);
+}
+function validateAndNormalizeBars(bars) {
+  console.log(`validateAndNormalizeBars: received ${bars.length} bars`);
+  const validated = bars.filter((bar) => {
+    if (!validateBar(bar)) {
+      console.warn("Invalid bar data:", bar);
+      return false;
+    }
+    return true;
+  }).map((bar) => ({
+    ...bar,
+    timestamp: normalizeTimestamp(bar.timestamp)
+  }));
+  console.log(`validateAndNormalizeBars: returning ${validated.length} valid bars`);
+  return validated;
+}
+function updateBarInArray(bars, updatedBar) {
+  const index = bars.findIndex((b) => b.timestamp === updatedBar.timestamp);
+  if (index === -1) {
+    return [...bars, updatedBar].sort((a, b) => a.timestamp - b.timestamp);
+  }
+  const updated = [...bars];
+  updated[index] = updatedBar;
+  return updated;
+}
+function appendBar(bars, newBar) {
+  const exists = bars.find((b) => b.timestamp === newBar.timestamp);
+  if (exists) {
+    return bars;
+  }
+  return [...bars, newBar];
+}
+function prependBars(bars, newBars) {
+  const existingTimestamps = new Set(bars.map((b) => b.timestamp));
+  const uniqueNewBars = newBars.filter((b) => !existingTimestamps.has(b.timestamp));
+  return [...uniqueNewBars, ...bars];
+}
+function getOldestBar(bars) {
+  if (bars.length === 0) return null;
+  return bars[0];
+}
+function getNewestBar(bars) {
+  if (bars.length === 0) return null;
+  return bars[bars.length - 1];
+}
+function updateCurrentBar(bars, tradePrice, tradeVolume) {
+  if (bars.length === 0) return bars;
+  const updated = [...bars];
+  const lastBar = { ...updated[updated.length - 1] };
+  lastBar.close = tradePrice;
+  lastBar.high = Math.max(lastBar.high, tradePrice);
+  lastBar.low = Math.min(lastBar.low, tradePrice);
+  lastBar.volume += tradeVolume;
+  updated[updated.length - 1] = lastBar;
+  return updated;
+}
+
+// src/hooks/useBarsData.ts
+function useBarsData(options = {}) {
+  const {
+    adapter,
+    symbol = "AAPL",
+    timeframe = "5Min",
+    autoFetch = false,
+    autoSubscribe = false,
+    limit = 500
+  } = options;
+  const [bars, setBarsState] = useState([]);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const [connected, setConnected] = useState(false);
+  const subscriptionRef = useRef(null);
+  const isMountedRef = useRef(true);
+  const hasInitialFetchRef = useRef(false);
+  const isFetchingRef = useRef(false);
+  const setBars = useCallback((newBars) => {
+    const validated = validateAndNormalizeBars(newBars);
+    const sorted = sortBars(validated);
+    setBarsState(sorted);
+  }, []);
+  const appendBar2 = useCallback((bar) => {
+    setBarsState((prev) => appendBar(prev, bar));
+  }, []);
+  const updateLastBar = useCallback((bar) => {
+    setBarsState((prev) => {
+      if (prev.length === 0) return [bar];
+      const updated = [...prev];
+      updated[updated.length - 1] = bar;
+      return updated;
+    });
+  }, []);
+  const updateCurrentBar2 = useCallback((tradePrice, tradeVolume) => {
+    setBarsState((prev) => updateCurrentBar(prev, tradePrice, tradeVolume));
+  }, []);
+  const prependBars2 = useCallback((newBars) => {
+    const validated = validateAndNormalizeBars(newBars);
+    setBarsState((prev) => prependBars(prev, validated));
+  }, []);
+  const clearBars = useCallback(() => {
+    setBarsState([]);
+  }, []);
+  const fetchHistorical = useCallback(
+    async (params = {}) => {
+      if (!adapter) {
+        setError(new Error("No adapter provided"));
+        return;
+      }
+      if (isFetchingRef.current) {
+        console.log("fetchHistorical: already fetching, skipping");
+        return;
+      }
+      console.log("fetchHistorical called, params:", params);
+      console.log("isMountedRef.current:", isMountedRef.current);
+      isFetchingRef.current = true;
+      setLoading(true);
+      setError(null);
+      try {
+        const fetchParams = {
+          symbol: params.symbol || symbol,
+          timeframe: params.timeframe || timeframe,
+          limit: params.limit || limit,
+          before: params.before,
+          after: params.after
+        };
+        console.log("Calling adapter.fetchHistoricalBars with:", fetchParams);
+        const data = await adapter.fetchHistoricalBars(fetchParams);
+        console.log("adapter.fetchHistoricalBars returned, data.length:", data.length);
+        if (isMountedRef.current) {
+          console.log("Component still mounted, processing data");
+          const validated = validateAndNormalizeBars(data);
+          if (params.before) {
+            console.log("Prepending bars (before param present)");
+            setBarsState((prev) => prependBars(prev, validated));
+          } else {
+            console.log("Setting initial bars (no before param)");
+            const sorted = sortBars(validated);
+            setBarsState(sorted);
+          }
+        } else {
+          console.log("Component unmounted, skipping data update");
+        }
+      } catch (err) {
+        console.log("Error caught:", err);
+        if (isMountedRef.current) {
+          const error2 = err instanceof Error ? err : new Error("Failed to fetch historical data");
+          setError(error2);
+          console.error("Failed to fetch historical data:", error2);
+        }
+      } finally {
+        console.log("Finally block executing, isMountedRef.current:", isMountedRef.current);
+        isFetchingRef.current = false;
+        if (isMountedRef.current) {
+          console.log("Setting loading to false");
+          setLoading(false);
+        } else {
+          console.log("Skipping setLoading(false) - component unmounted");
+        }
+      }
+    },
+    [adapter, symbol, timeframe, limit]
+  );
+  const subscribe = useCallback(() => {
+    if (!adapter?.subscribeRealtime) {
+      console.warn("Adapter does not support real-time subscriptions");
+      return;
+    }
+    if (subscriptionRef.current) {
+      console.warn("Already subscribed");
+      return;
+    }
+    subscriptionRef.current = adapter.subscribeRealtime(symbol, {
+      onBar: (bar) => {
+        if (isMountedRef.current) {
+          appendBar2(bar);
+        }
+      },
+      onTrade: (price, volume) => {
+        if (isMountedRef.current) {
+          updateCurrentBar2(price, volume);
+        }
+      },
+      onError: (err) => {
+        if (isMountedRef.current) {
+          setError(err);
+          setConnected(false);
+        }
+      },
+      onConnect: () => {
+        if (isMountedRef.current) {
+          setConnected(true);
+        }
+      },
+      onDisconnect: () => {
+        if (isMountedRef.current) {
+          setConnected(false);
+        }
+      }
+    });
+  }, [adapter, symbol, appendBar2, updateCurrentBar2]);
+  const unsubscribe = useCallback(() => {
+    if (subscriptionRef.current) {
+      subscriptionRef.current.unsubscribe();
+      subscriptionRef.current = null;
+      setConnected(false);
+    }
+  }, []);
+  const refetch = useCallback(async () => {
+    await fetchHistorical();
+  }, [fetchHistorical]);
+  useEffect(() => {
+    console.log("useEffect[autoFetch] running, autoFetch:", autoFetch, "adapter:", !!adapter, "hasInitialFetch:", hasInitialFetchRef.current);
+    if (autoFetch && adapter && !hasInitialFetchRef.current) {
+      console.log("Calling fetchHistorical from useEffect (initial fetch)");
+      hasInitialFetchRef.current = true;
+      fetchHistorical();
+    }
+  }, [autoFetch, adapter, fetchHistorical]);
+  useEffect(() => {
+    if (autoSubscribe && adapter?.subscribeRealtime) {
+      subscribe();
+    }
+    return () => {
+      unsubscribe();
+    };
+  }, [autoSubscribe, adapter, subscribe, unsubscribe]);
+  useEffect(() => {
+    isMountedRef.current = true;
+    return () => {
+      isMountedRef.current = false;
+      if (subscriptionRef.current) {
+        subscriptionRef.current.unsubscribe();
+        subscriptionRef.current = null;
+      }
+    };
+  }, []);
+  return {
+    bars,
+    loading,
+    error,
+    connected,
+    setBars,
+    appendBar: appendBar2,
+    updateLastBar,
+    updateCurrentBar: updateCurrentBar2,
+    prependBars: prependBars2,
+    clearBars,
+    fetchHistorical,
+    subscribe,
+    unsubscribe,
+    refetch
+  };
+}
+function useRealtimeUpdates(initialBars, config) {
+  const [bars, setBars] = useState([]);
+  const updateIntervalRef = useRef();
+  const newBarIntervalRef = useRef();
+  const lastBarTimeRef = useRef(0);
+  const initializedRef = useRef(false);
+  const updateCurrentBar2 = useCallback((tradePrice, tradeVolume) => {
+    setBars((prev) => {
+      if (prev.length === 0) return prev;
+      const updated = [...prev];
+      const lastBar = { ...updated[updated.length - 1] };
+      lastBar.close = tradePrice;
+      lastBar.high = Math.max(lastBar.high, tradePrice);
+      lastBar.low = Math.min(lastBar.low, tradePrice);
+      lastBar.volume += tradeVolume;
+      updated[updated.length - 1] = lastBar;
+      return updated;
+    });
+  }, []);
+  const addNewBar = useCallback((newBar) => {
+    setBars((prev) => {
+      const exists = prev.find((b) => b.timestamp === newBar.timestamp);
+      if (exists) return prev;
+      return [...prev, newBar];
+    });
+  }, []);
+  const prependBars2 = useCallback((newBars) => {
+    setBars((prev) => {
+      const existingTimestamps = new Set(prev.map((b) => b.timestamp));
+      const uniqueNewBars = newBars.filter((b) => !existingTimestamps.has(b.timestamp));
+      return [...uniqueNewBars, ...prev];
+    });
+  }, []);
+  useCallback((currentPrice) => {
+    const volatility = 5e-4;
+    const drift = 0;
+    const change = currentPrice * (drift + volatility * (Math.random() * 2 - 1));
+    return currentPrice + change;
+  }, []);
+  useEffect(() => {
+    if (!initializedRef.current && initialBars.length > 0) {
+      setBars(initialBars);
+      initializedRef.current = true;
+    }
+  }, [initialBars]);
+  useEffect(() => {
+    if (!config.enabled || bars.length === 0) return;
+    const lastBar = bars[bars.length - 1];
+    lastBarTimeRef.current = lastBar.timestamp;
+    updateIntervalRef.current = window.setInterval(() => {
+      setBars((prev) => {
+        if (prev.length === 0) return prev;
+        const updated = [...prev];
+        const currentBar = { ...updated[updated.length - 1] };
+        const newPrice = currentBar.close * (1 + (Math.random() - 0.5) * 1e-3);
+        const newVolume = Math.floor(Math.random() * 100) + 10;
+        currentBar.close = newPrice;
+        currentBar.high = Math.max(currentBar.high, newPrice);
+        currentBar.low = Math.min(currentBar.low, newPrice);
+        currentBar.volume += newVolume;
+        updated[updated.length - 1] = currentBar;
+        return updated;
+      });
+    }, config.updateIntervalMs);
+    newBarIntervalRef.current = window.setInterval(() => {
+      setBars((prev) => {
+        if (prev.length === 0) return prev;
+        const lastBar2 = prev[prev.length - 1];
+        const newTimestamp = lastBar2.timestamp + config.newBarIntervalMs;
+        const newPrice = lastBar2.close * (1 + (Math.random() - 0.5) * 2e-3);
+        const newBar = {
+          timestamp: newTimestamp,
+          open: lastBar2.close,
+          high: newPrice,
+          low: Math.min(lastBar2.close, newPrice),
+          close: newPrice,
+          volume: Math.floor(Math.random() * 1e3) + 100
+        };
+        lastBarTimeRef.current = newTimestamp;
+        return [...prev, newBar];
+      });
+    }, config.newBarIntervalMs);
+    return () => {
+      if (updateIntervalRef.current) {
+        clearInterval(updateIntervalRef.current);
+      }
+      if (newBarIntervalRef.current) {
+        clearInterval(newBarIntervalRef.current);
+      }
+    };
+  }, [config.enabled, config.updateIntervalMs, config.newBarIntervalMs, bars.length]);
+  return {
+    bars,
+    updateCurrentBar: updateCurrentBar2,
+    addNewBar,
+    prependBars: prependBars2
+  };
+}
+
+// src/indicators/core/persistence.ts
+var LocalStoragePersistenceAdapter = class {
+  constructor() {
+    __publicField(this, "storageKey", "chart_indicators");
+  }
+  async saveIndicators(indicators) {
+    try {
+      const serialized = JSON.stringify(indicators);
+      localStorage.setItem(this.storageKey, serialized);
+    } catch (error) {
+      console.error("Error saving indicators to localStorage:", error);
+    }
+  }
+  async loadIndicators() {
+    try {
+      const serialized = localStorage.getItem(this.storageKey);
+      if (!serialized) {
+        return [];
+      }
+      const parsed = JSON.parse(serialized);
+      return Array.isArray(parsed) ? parsed : [];
+    } catch (error) {
+      console.error("Error loading indicators from localStorage:", error);
+      return [];
+    }
+  }
+  async deleteIndicator(id) {
+    try {
+      const indicators = await this.loadIndicators();
+      const filtered = indicators.filter((ind) => ind.id !== id);
+      await this.saveIndicators(filtered);
+    } catch (error) {
+      console.error("Error deleting indicator from localStorage:", error);
+    }
+  }
+};
+var NoOpPersistenceAdapter = class {
+  async saveIndicators(indicators) {
+  }
+  async loadIndicators() {
+    return [];
+  }
+  async deleteIndicator(id) {
+  }
+};
+function createPersistenceAdapter(kind) {
+  switch (kind) {
+    case "localStorage":
+      return new LocalStoragePersistenceAdapter();
+    case "noop":
+      return new NoOpPersistenceAdapter();
+    default:
+      throw new Error("Unknown persistence kind: " + kind);
+  }
+}
+
+// src/indicators/utils/calculations.ts
+function padIndicatorArray(result, barsLength) {
+  const missing = barsLength - result.length;
+  if (missing <= 0) return result;
+  return [...Array(missing).fill(NaN), ...result];
+}
+function displaceArray(arr, offset) {
+  if (offset <= 0) return arr;
+  return [...arr.slice(offset), ...Array(offset).fill(NaN)];
+}
+function calculateSMA(bars, period) {
+  const result = [];
+  for (let i = 0; i < bars.length; i++) {
+    if (i < period - 1) {
+      result.push(NaN);
+    } else {
+      let sum = 0;
+      for (let j = 0; j < period; j++) {
+        sum += bars[i - j].close;
+      }
+      result.push(sum / period);
+    }
+  }
+  return result;
+}
+function calculateEMA(bars, period) {
+  const result = [];
+  const multiplier = 2 / (period + 1);
+  let ema = 0;
+  for (let i = 0; i < bars.length; i++) {
+    if (i < period - 1) {
+      result.push(NaN);
+    } else if (i === period - 1) {
+      let sum = 0;
+      for (let j = 0; j < period; j++) {
+        sum += bars[i - j].close;
+      }
+      ema = sum / period;
+      result.push(ema);
+    } else {
+      ema = (bars[i].close - ema) * multiplier + ema;
+      result.push(ema);
+    }
+  }
+  return result;
+}
+function calculateRSI(bars, period) {
+  const result = [];
+  const changes = [];
+  for (let i = 1; i < bars.length; i++) {
+    changes.push(bars[i].close - bars[i - 1].close);
+  }
+  for (let i = 0; i < bars.length; i++) {
+    if (i < period) {
+      result.push(NaN);
+    } else {
+      let gains = 0;
+      let losses = 0;
+      for (let j = i - period; j < i; j++) {
+        const change = changes[j - 1];
+        if (change > 0) {
+          gains += change;
+        } else {
+          losses += Math.abs(change);
+        }
+      }
+      const avgGain = gains / period;
+      const avgLoss = losses / period;
+      if (avgLoss === 0) {
+        result.push(100);
+      } else {
+        const rs = avgGain / avgLoss;
+        const rsi = 100 - 100 / (1 + rs);
+        result.push(rsi);
+      }
+    }
+  }
+  return result;
+}
+function calculateStandardDeviation(values, period) {
+  const result = [];
+  for (let i = 0; i < values.length; i++) {
+    if (i < period - 1 || isNaN(values[i])) {
+      result.push(NaN);
+    } else {
+      let sum = 0;
+      let count = 0;
+      for (let j = 0; j < period; j++) {
+        const val = values[i - j];
+        if (!isNaN(val)) {
+          sum += val;
+          count++;
+        }
+      }
+      const mean = sum / count;
+      let squaredDiffSum = 0;
+      for (let j = 0; j < period; j++) {
+        const val = values[i - j];
+        if (!isNaN(val)) {
+          squaredDiffSum += Math.pow(val - mean, 2);
+        }
+      }
+      const variance = squaredDiffSum / count;
+      result.push(Math.sqrt(variance));
+    }
+  }
+  return result;
+}
+function calculateBollingerBands(bars, period, stdDev) {
+  const middle = calculateSMA(bars, period);
+  const closes = bars.map((b) => b.close);
+  const std = calculateStandardDeviation(closes, period);
+  const upper = [];
+  const lower = [];
+  for (let i = 0; i < middle.length; i++) {
+    if (isNaN(middle[i]) || isNaN(std[i])) {
+      upper.push(NaN);
+      lower.push(NaN);
+    } else {
+      upper.push(middle[i] + std[i] * stdDev);
+      lower.push(middle[i] - std[i] * stdDev);
+    }
+  }
+  return { upper, middle, lower };
+}
+
+// src/indicators/registry/sma.ts
+var SMAIndicator = {
+  metadata: {
+    id: "sma",
+    name: "SMA",
+    description: "Simple Moving Average - smooths price data by averaging over a period",
+    category: "Trend" /* TREND */,
+    version: "1.0.0"
+  },
+  settings: {
+    period: {
+      type: "number",
+      label: "Period",
+      defaultValue: 20,
+      description: "Number of bars to average",
+      min: 1,
+      max: 500,
+      step: 1
+    },
+    color: {
+      type: "color",
+      label: "Line Color",
+      defaultValue: "#3b82f6",
+      description: "Color of the SMA line"
+    },
+    lineWidth: {
+      type: "number",
+      label: "Line Width",
+      defaultValue: 2,
+      description: "Width of the SMA line",
+      min: 1,
+      max: 5,
+      step: 1
+    }
+  },
+  renderConfig: {
+    seriesType: "line" /* LINE */,
+    outputCount: 1,
+    overlay: true
+  },
+  calculate: (bars, settings) => {
+    const smaValues = calculateSMA(bars, settings.period);
+    return bars.map((bar, i) => ({
+      time: bar.timestamp / 1e3,
+      value: smaValues[i]
+    }));
+  }
+};
+
+// src/indicators/registry/ema.ts
+var EMAIndicator = {
+  metadata: {
+    id: "ema",
+    name: "EMA",
+    description: "Exponential Moving Average - gives more weight to recent prices",
+    category: "Trend" /* TREND */,
+    version: "1.0.0"
+  },
+  settings: {
+    period: {
+      type: "number",
+      label: "Period",
+      defaultValue: 12,
+      description: "Number of bars for EMA calculation",
+      min: 1,
+      max: 500,
+      step: 1
+    },
+    color: {
+      type: "color",
+      label: "Line Color",
+      defaultValue: "#10b981",
+      description: "Color of the EMA line"
+    },
+    lineWidth: {
+      type: "number",
+      label: "Line Width",
+      defaultValue: 2,
+      description: "Width of the EMA line",
+      min: 1,
+      max: 5,
+      step: 1
+    }
+  },
+  renderConfig: {
+    seriesType: "line" /* LINE */,
+    outputCount: 1,
+    overlay: true
+  },
+  calculate: (bars, settings) => {
+    const emaValues = calculateEMA(bars, settings.period);
+    return bars.map((bar, i) => ({
+      time: bar.timestamp / 1e3,
+      value: emaValues[i]
+    }));
+  }
+};
+
+// src/indicators/registry/rsi.ts
+var RSIIndicator = {
+  metadata: {
+    id: "rsi",
+    name: "RSI",
+    description: "Relative Strength Index - momentum oscillator measuring speed and magnitude of price changes",
+    category: "Momentum" /* MOMENTUM */,
+    version: "1.0.0"
+  },
+  settings: {
+    period: {
+      type: "number",
+      label: "Period",
+      defaultValue: 14,
+      description: "Number of bars for RSI calculation",
+      min: 2,
+      max: 100,
+      step: 1
+    },
+    color: {
+      type: "color",
+      label: "Line Color",
+      defaultValue: "#8b5cf6",
+      description: "Color of the RSI line"
+    },
+    lineWidth: {
+      type: "number",
+      label: "Line Width",
+      defaultValue: 2,
+      description: "Width of the RSI line",
+      min: 1,
+      max: 5,
+      step: 1
+    }
+  },
+  renderConfig: {
+    seriesType: "line" /* LINE */,
+    outputCount: 1,
+    overlay: false
+  },
+  calculate: (bars, settings) => {
+    const rsiValues = calculateRSI(bars, settings.period);
+    return bars.map((bar, i) => ({
+      time: bar.timestamp / 1e3,
+      value: rsiValues[i]
+    }));
+  }
+};
+
+// src/indicators/registry/bollinger.ts
+var BollingerBandsIndicator = {
+  metadata: {
+    id: "bollinger",
+    name: "Bollinger Bands",
+    description: "Bollinger Bands - volatility bands placed above and below a moving average",
+    category: "Volatility" /* VOLATILITY */,
+    version: "1.0.0"
+  },
+  settings: {
+    period: {
+      type: "number",
+      label: "Period",
+      defaultValue: 20,
+      description: "Number of bars for moving average",
+      min: 2,
+      max: 200,
+      step: 1
+    },
+    stdDev: {
+      type: "number",
+      label: "Standard Deviation",
+      defaultValue: 2,
+      description: "Number of standard deviations for bands",
+      min: 0.5,
+      max: 5,
+      step: 0.1
+    },
+    upperColor: {
+      type: "color",
+      label: "Upper Band Color",
+      defaultValue: "#ef4444",
+      description: "Color of the upper band"
+    },
+    middleColor: {
+      type: "color",
+      label: "Middle Band Color",
+      defaultValue: "#3b82f6",
+      description: "Color of the middle band"
+    },
+    lowerColor: {
+      type: "color",
+      label: "Lower Band Color",
+      defaultValue: "#10b981",
+      description: "Color of the lower band"
+    },
+    lineWidth: {
+      type: "number",
+      label: "Line Width",
+      defaultValue: 2,
+      description: "Width of the band lines",
+      min: 1,
+      max: 5,
+      step: 1
+    },
+    showFill: {
+      type: "boolean",
+      label: "Show Fill",
+      defaultValue: true,
+      description: "Show shaded area between bands"
+    },
+    fillColor: {
+      type: "color",
+      label: "Fill Color",
+      defaultValue: "rgba(59, 130, 246, 0.1)",
+      description: "Color of the shaded area between bands"
+    }
+  },
+  renderConfig: {
+    seriesType: "line" /* LINE */,
+    outputCount: 3,
+    overlay: true,
+    hasBandFill: true,
+    fillBands: {
+      upper: "upper",
+      lower: "lower"
+    }
+  },
+  calculate: (bars, settings) => {
+    const { upper, middle, lower } = calculateBollingerBands(
+      bars,
+      settings.period,
+      settings.stdDev
+    );
+    return bars.map((bar, i) => ({
+      time: bar.timestamp / 1e3,
+      value: middle[i],
+      upper: upper[i],
+      lower: lower[i]
+    }));
+  }
+};
+
+// src/indicators/registry/vwap.ts
+function calculateVWAPWithBands(bars, {
+  reset = "none",
+  bandMultiplier = 1,
+  includeBands = true
+}) {
+  if (!bars.length) return { vwap: [], upper: [], lower: [] };
+  let cumulativeVolume = 0;
+  let cumulativeTPV = 0;
+  let sessionPrices = [];
+  const vwap = [];
+  const upper = [];
+  const lower = [];
+  const getWeek = (d) => {
+    const day = new Date(Date.UTC(d.getFullYear(), d.getMonth(), d.getDate()));
+    const dayNum = day.getUTCDay() || 7;
+    day.setUTCDate(day.getUTCDate() + 4 - dayNum);
+    const yearStart = new Date(Date.UTC(day.getUTCFullYear(), 0, 1));
+    return Math.ceil(
+      ((day.getTime() - yearStart.getTime()) / 864e5 + 1) / 7
+    );
+  };
+  const std = (arr) => {
+    const mean = arr.reduce((a, b) => a + b, 0) / arr.length;
+    return Math.sqrt(arr.reduce((a, b) => a + (b - mean) ** 2, 0) / arr.length);
+  };
+  for (let i = 0; i < bars.length; i++) {
+    const bar = bars[i];
+    const typical = (bar.high + bar.low + bar.close) / 3;
+    if (i > 0 && reset !== "none") {
+      const prev = new Date(bars[i - 1].timestamp);
+      const curr = new Date(bar.timestamp);
+      let resetFlag = false;
+      if (reset === "daily") {
+        resetFlag = curr.getDate() !== prev.getDate() || curr.getMonth() !== prev.getMonth() || curr.getFullYear() !== prev.getFullYear();
+      } else if (reset === "weekly") {
+        resetFlag = getWeek(curr) !== getWeek(prev) || curr.getFullYear() !== prev.getFullYear();
+      } else if (reset === "monthly") {
+        resetFlag = curr.getMonth() !== prev.getMonth() || curr.getFullYear() !== prev.getFullYear();
+      }
+      if (resetFlag) {
+        cumulativeVolume = 0;
+        cumulativeTPV = 0;
+        sessionPrices = [];
+      }
+    }
+    cumulativeTPV += typical * bar.volume;
+    cumulativeVolume += bar.volume;
+    sessionPrices.push(typical);
+    const vwapValue = cumulativeTPV / cumulativeVolume;
+    vwap.push(vwapValue);
+    if (includeBands && sessionPrices.length > 1) {
+      const sigma = std(sessionPrices);
+      upper.push(vwapValue + sigma * bandMultiplier);
+      lower.push(vwapValue - sigma * bandMultiplier);
+    } else {
+      upper.push(NaN);
+      lower.push(NaN);
+    }
+  }
+  return { vwap, upper, lower };
+}
+var VWAPIndicator = {
+  metadata: {
+    id: "vwap",
+    name: "VWAP",
+    description: "Volume Weighted Average Price with standard deviation bands",
+    category: "Volume" /* VOLUME */,
+    version: "1.0.0"
+  },
+  settings: {
+    reset: {
+      type: "select",
+      label: "Reset Period",
+      defaultValue: "daily",
+      description: "When to reset VWAP calculation",
+      options: [
+        { label: "None", value: "none" },
+        { label: "Daily", value: "daily" },
+        { label: "Weekly", value: "weekly" },
+        { label: "Monthly", value: "monthly" }
+      ]
+    },
+    bandMultiplier: {
+      type: "number",
+      label: "Band Multiplier",
+      defaultValue: 1,
+      description: "Standard deviation multiplier for bands",
+      min: 0.5,
+      max: 5,
+      step: 0.1
+    },
+    showBands: {
+      type: "boolean",
+      label: "Show Bands",
+      defaultValue: true,
+      description: "Show standard deviation bands"
+    },
+    vwapColor: {
+      type: "color",
+      label: "VWAP Color",
+      defaultValue: "#f59e0b",
+      description: "Color of the VWAP line"
+    },
+    upperColor: {
+      type: "color",
+      label: "Upper Band Color",
+      defaultValue: "#ef4444",
+      description: "Color of the upper band"
+    },
+    lowerColor: {
+      type: "color",
+      label: "Lower Band Color",
+      defaultValue: "#10b981",
+      description: "Color of the lower band"
+    },
+    lineWidth: {
+      type: "number",
+      label: "Line Width",
+      defaultValue: 2,
+      description: "Width of the lines",
+      min: 1,
+      max: 5,
+      step: 1
+    },
+    showFill: {
+      type: "boolean",
+      label: "Show Fill",
+      defaultValue: true,
+      description: "Show shaded area between bands"
+    },
+    fillColor: {
+      type: "color",
+      label: "Fill Color",
+      defaultValue: "rgba(245, 158, 11, 0.1)",
+      description: "Color of the shaded area between bands"
+    }
+  },
+  renderConfig: {
+    seriesType: "line" /* LINE */,
+    outputCount: 3,
+    overlay: true,
+    hasBandFill: true,
+    fillBands: {
+      upper: "upper",
+      lower: "lower"
+    }
+  },
+  calculate: (bars, settings) => {
+    const { vwap, upper, lower } = calculateVWAPWithBands(bars, {
+      reset: settings.reset,
+      bandMultiplier: settings.bandMultiplier,
+      includeBands: settings.showBands
+    });
+    return bars.map((bar, i) => ({
+      time: bar.timestamp / 1e3,
+      value: vwap[i],
+      upper: upper[i],
+      lower: lower[i]
+    }));
+  }
+};
+var StochasticIndicator = {
+  metadata: {
+    id: "stochastic",
+    name: "Stochastic Oscillator",
+    description: "Compares closing price to price range over time - momentum indicator",
+    category: "Momentum" /* MOMENTUM */,
+    version: "1.0.0"
+  },
+  settings: {
+    period: {
+      type: "number",
+      label: "Period (K)",
+      defaultValue: 14,
+      description: "Number of bars for %K calculation",
+      min: 2,
+      max: 100,
+      step: 1
+    },
+    signalPeriod: {
+      type: "number",
+      label: "Signal Period (D)",
+      defaultValue: 3,
+      description: "Number of bars for %D signal line",
+      min: 1,
+      max: 50,
+      step: 1
+    },
+    kColor: {
+      type: "color",
+      label: "%K Line Color",
+      defaultValue: "#3b82f6",
+      description: "Color of the %K line"
+    },
+    dColor: {
+      type: "color",
+      label: "%D Line Color",
+      defaultValue: "#ef4444",
+      description: "Color of the %D signal line"
+    },
+    lineWidth: {
+      type: "number",
+      label: "Line Width",
+      defaultValue: 2,
+      description: "Width of the indicator lines",
+      min: 1,
+      max: 5,
+      step: 1
+    }
+  },
+  renderConfig: {
+    seriesType: "line" /* LINE */,
+    outputCount: 2,
+    overlay: false
+  },
+  calculate: (bars, settings) => {
+    const high = bars.map((bar) => bar.high);
+    const low = bars.map((bar) => bar.low);
+    const close = bars.map((bar) => bar.close);
+    const stochValues = stochastic({
+      high,
+      low,
+      close,
+      period: settings.period,
+      signalPeriod: settings.signalPeriod
+    });
+    return bars.map((bar, i) => ({
+      time: bar.timestamp / 1e3,
+      value: stochValues[i]?.k ?? NaN,
+      signal: stochValues[i]?.d ?? NaN
+    }));
+  }
+};
+var OBVIndicator = {
+  metadata: {
+    id: "obv",
+    name: "OBV",
+    description: "On-Balance Volume - cumulative volume indicator showing buying/selling pressure",
+    category: "Volume" /* VOLUME */,
+    version: "1.0.0"
+  },
+  settings: {
+    color: {
+      type: "color",
+      label: "Line Color",
+      defaultValue: "#10b981",
+      description: "Color of the OBV line"
+    },
+    lineWidth: {
+      type: "number",
+      label: "Line Width",
+      defaultValue: 2,
+      description: "Width of the OBV line",
+      min: 1,
+      max: 5,
+      step: 1
+    }
+  },
+  renderConfig: {
+    seriesType: "line" /* LINE */,
+    outputCount: 1,
+    overlay: false
+  },
+  calculate: (bars) => {
+    const close = bars.map((bar) => bar.close);
+    const volume = bars.map((bar) => bar.volume || 0);
+    const obvValues = obv({ close, volume });
+    return bars.map((bar, i) => ({
+      time: bar.timestamp / 1e3,
+      value: obvValues[i] ?? NaN
+    }));
+  }
+};
+var MFIIndicator = {
+  metadata: {
+    id: "mfi",
+    name: "MFI",
+    description: "Money Flow Index - volume-weighted momentum indicator (RSI with volume)",
+    category: "Volume" /* VOLUME */,
+    version: "1.0.0"
+  },
+  settings: {
+    period: {
+      type: "number",
+      label: "Period",
+      defaultValue: 14,
+      description: "Number of bars for MFI calculation",
+      min: 2,
+      max: 100,
+      step: 1
+    },
+    color: {
+      type: "color",
+      label: "Line Color",
+      defaultValue: "#f59e0b",
+      description: "Color of the MFI line"
+    },
+    lineWidth: {
+      type: "number",
+      label: "Line Width",
+      defaultValue: 2,
+      description: "Width of the MFI line",
+      min: 1,
+      max: 5,
+      step: 1
+    }
+  },
+  renderConfig: {
+    seriesType: "line" /* LINE */,
+    outputCount: 1,
+    overlay: false
+  },
+  calculate: (bars, settings) => {
+    const high = bars.map((bar) => bar.high);
+    const low = bars.map((bar) => bar.low);
+    const close = bars.map((bar) => bar.close);
+    const volume = bars.map((bar) => bar.volume || 0);
+    const mfiValues = mfi({
+      high,
+      low,
+      close,
+      volume,
+      period: settings.period
+    });
+    return bars.map((bar, i) => ({
+      time: bar.timestamp / 1e3,
+      value: mfiValues[i] ?? NaN
+    }));
+  }
+};
+var ForceIndexIndicator = {
+  metadata: {
+    id: "forceindex",
+    name: "Force Index",
+    description: "Measures buying/selling pressure using price and volume",
+    category: "Volume" /* VOLUME */,
+    version: "1.0.0"
+  },
+  settings: {
+    period: {
+      type: "number",
+      label: "Period",
+      defaultValue: 13,
+      description: "Smoothing period for force index",
+      min: 1,
+      max: 100,
+      step: 1
+    },
+    color: {
+      type: "color",
+      label: "Line Color",
+      defaultValue: "#8b5cf6",
+      description: "Color of the Force Index line"
+    },
+    lineWidth: {
+      type: "number",
+      label: "Line Width",
+      defaultValue: 2,
+      description: "Width of the Force Index line",
+      min: 1,
+      max: 5,
+      step: 1
+    }
+  },
+  renderConfig: {
+    seriesType: "line" /* LINE */,
+    outputCount: 1,
+    overlay: false
+  },
+  calculate: (bars, settings) => {
+    const close = bars.map((bar) => bar.close);
+    const volume = bars.map((bar) => bar.volume || 0);
+    const forceValues = forceindex({
+      close,
+      volume,
+      period: settings.period
+    });
+    return bars.map((bar, i) => ({
+      time: bar.timestamp / 1e3,
+      value: forceValues[i] ?? NaN
+    }));
+  }
+};
+var ATRIndicator = {
+  metadata: {
+    id: "atr",
+    name: "ATR",
+    description: "Average True Range - measures market volatility",
+    category: "Volatility" /* VOLATILITY */,
+    version: "1.0.0"
+  },
+  settings: {
+    period: {
+      type: "number",
+      label: "Period",
+      defaultValue: 14,
+      description: "Number of bars for ATR calculation",
+      min: 1,
+      max: 100,
+      step: 1
+    },
+    color: {
+      type: "color",
+      label: "Line Color",
+      defaultValue: "#14b8a6",
+      description: "Color of the ATR line"
+    },
+    lineWidth: {
+      type: "number",
+      label: "Line Width",
+      defaultValue: 2,
+      description: "Width of the ATR line",
+      min: 1,
+      max: 5,
+      step: 1
+    }
+  },
+  renderConfig: {
+    seriesType: "line" /* LINE */,
+    outputCount: 1,
+    overlay: false
+  },
+  calculate: (bars, settings) => {
+    const high = bars.map((bar) => bar.high);
+    const low = bars.map((bar) => bar.low);
+    const close = bars.map((bar) => bar.close);
+    const atrValues = atr({
+      high,
+      low,
+      close,
+      period: settings.period
+    });
+    return bars.map((bar, i) => ({
+      time: bar.timestamp / 1e3,
+      value: atrValues[i] ?? NaN
+    }));
+  }
+};
+var ADXIndicator = {
+  metadata: {
+    id: "adx",
+    name: "ADX",
+    description: "Average Directional Index - measures trend strength (not direction)",
+    category: "Trend" /* TREND */,
+    version: "1.0.0"
+  },
+  settings: {
+    period: {
+      type: "number",
+      label: "Period",
+      defaultValue: 14,
+      description: "Number of bars for ADX calculation",
+      min: 2,
+      max: 100,
+      step: 1
+    },
+    color: {
+      type: "color",
+      label: "Line Color",
+      defaultValue: "#06b6d4",
+      description: "Color of the ADX line"
+    },
+    lineWidth: {
+      type: "number",
+      label: "Line Width",
+      defaultValue: 2,
+      description: "Width of the ADX line",
+      min: 1,
+      max: 5,
+      step: 1
+    }
+  },
+  renderConfig: {
+    seriesType: "line" /* LINE */,
+    outputCount: 1,
+    overlay: false
+  },
+  calculate: (bars, settings) => {
+    const high = bars.map((bar) => bar.high);
+    const low = bars.map((bar) => bar.low);
+    const close = bars.map((bar) => bar.close);
+    const adxValues = adx({
+      high,
+      low,
+      close,
+      period: settings.period
+    });
+    return bars.map((bar, i) => ({
+      time: bar.timestamp / 1e3,
+      value: adxValues[i]?.adx ?? NaN
+    }));
+  }
+};
+var MACDIndicator = {
+  metadata: {
+    id: "macd",
+    name: "MACD",
+    description: "Moving Average Convergence Divergence - trend-following momentum indicator",
+    category: "Momentum" /* MOMENTUM */,
+    version: "1.0.0"
+  },
+  settings: {
+    fastPeriod: {
+      type: "number",
+      label: "Fast Period",
+      defaultValue: 12,
+      description: "Period for fast EMA",
+      min: 2,
+      max: 100,
+      step: 1
+    },
+    slowPeriod: {
+      type: "number",
+      label: "Slow Period",
+      defaultValue: 26,
+      description: "Period for slow EMA",
+      min: 2,
+      max: 100,
+      step: 1
+    },
+    signalPeriod: {
+      type: "number",
+      label: "Signal Period",
+      defaultValue: 9,
+      description: "Period for signal line",
+      min: 1,
+      max: 50,
+      step: 1
+    },
+    macdColor: {
+      type: "color",
+      label: "MACD Line Color",
+      defaultValue: "#3b82f6",
+      description: "Color of the MACD line"
+    },
+    signalColor: {
+      type: "color",
+      label: "Signal Line Color",
+      defaultValue: "#ef4444",
+      description: "Color of the signal line"
+    },
+    histogramColor: {
+      type: "color",
+      label: "Histogram Color",
+      defaultValue: "#10b981",
+      description: "Color of the histogram"
+    },
+    lineWidth: {
+      type: "number",
+      label: "Line Width",
+      defaultValue: 2,
+      description: "Width of the MACD and signal lines",
+      min: 1,
+      max: 5,
+      step: 1
+    }
+  },
+  renderConfig: {
+    seriesType: "line" /* LINE */,
+    outputCount: 3,
+    overlay: false
+  },
+  calculate: (bars, settings) => {
+    const values = bars.map((bar) => bar.close);
+    const macdValues = macd({
+      values,
+      fastPeriod: settings.fastPeriod,
+      slowPeriod: settings.slowPeriod,
+      signalPeriod: settings.signalPeriod,
+      SimpleMAOscillator: false,
+      SimpleMASignal: false
+    });
+    return bars.map((bar, i) => ({
+      time: bar.timestamp / 1e3,
+      value: macdValues[i]?.MACD ?? NaN,
+      signal: macdValues[i]?.signal ?? NaN,
+      histogram: macdValues[i]?.histogram ?? NaN
+    }));
+  }
+};
+var PSARIndicator = {
+  metadata: {
+    id: "psar",
+    name: "Parabolic SAR",
+    description: "Parabolic Stop and Reverse - shows potential reversal points as dots",
+    category: "Trend" /* TREND */,
+    version: "1.0.0"
+  },
+  settings: {
+    step: {
+      type: "number",
+      label: "Step (AF)",
+      defaultValue: 0.02,
+      description: "Acceleration Factor step",
+      min: 1e-3,
+      max: 1,
+      step: 1e-3
+    },
+    max: {
+      type: "number",
+      label: "Max AF",
+      defaultValue: 0.2,
+      description: "Maximum Acceleration Factor",
+      min: 0.01,
+      max: 1,
+      step: 0.01
+    },
+    color: {
+      type: "color",
+      label: "Color",
+      defaultValue: "#f59e0b",
+      description: "Color of the SAR dots"
+    }
+  },
+  renderConfig: {
+    seriesType: "line" /* LINE */,
+    outputCount: 1,
+    overlay: true
+  },
+  calculate: (bars, settings) => {
+    const high = bars.map((bar) => bar.high);
+    const low = bars.map((bar) => bar.low);
+    const psarValues = psar({
+      high,
+      low,
+      step: settings.step,
+      max: settings.max
+    });
+    return bars.map((bar, i) => ({
+      time: bar.timestamp / 1e3,
+      value: psarValues[i] ?? NaN
+    }));
+  }
+};
+var CCIIndicator = {
+  metadata: {
+    id: "cci",
+    name: "CCI",
+    description: "Commodity Channel Index - identifies cyclical trends and overbought/oversold levels",
+    category: "Oscillators" /* OSCILLATORS */,
+    version: "1.0.0"
+  },
+  settings: {
+    period: {
+      type: "number",
+      label: "Period",
+      defaultValue: 20,
+      description: "Number of bars for CCI calculation",
+      min: 2,
+      max: 100,
+      step: 1
+    },
+    color: {
+      type: "color",
+      label: "Line Color",
+      defaultValue: "#ec4899",
+      description: "Color of the CCI line"
+    },
+    lineWidth: {
+      type: "number",
+      label: "Line Width",
+      defaultValue: 2,
+      description: "Width of the CCI line",
+      min: 1,
+      max: 5,
+      step: 1
+    }
+  },
+  renderConfig: {
+    seriesType: "line" /* LINE */,
+    outputCount: 1,
+    overlay: false
+  },
+  calculate: (bars, settings) => {
+    const high = bars.map((bar) => bar.high);
+    const low = bars.map((bar) => bar.low);
+    const close = bars.map((bar) => bar.close);
+    const cciValues = cci({
+      high,
+      low,
+      close,
+      period: settings.period
+    });
+    return bars.map((bar, i) => ({
+      time: bar.timestamp / 1e3,
+      value: cciValues[i] ?? NaN
+    }));
+  }
+};
+var WilliamsRIndicator = {
+  metadata: {
+    id: "williamsr",
+    name: "Williams %R",
+    description: "Williams Percent Range - momentum indicator showing overbought/oversold levels",
+    category: "Momentum" /* MOMENTUM */,
+    version: "1.0.0"
+  },
+  settings: {
+    period: {
+      type: "number",
+      label: "Period",
+      defaultValue: 14,
+      description: "Number of bars for Williams %R calculation",
+      min: 2,
+      max: 100,
+      step: 1
+    },
+    color: {
+      type: "color",
+      label: "Line Color",
+      defaultValue: "#a855f7",
+      description: "Color of the Williams %R line"
+    },
+    lineWidth: {
+      type: "number",
+      label: "Line Width",
+      defaultValue: 2,
+      description: "Width of the Williams %R line",
+      min: 1,
+      max: 5,
+      step: 1
+    }
+  },
+  renderConfig: {
+    seriesType: "line" /* LINE */,
+    outputCount: 1,
+    overlay: false
+  },
+  calculate: (bars, settings) => {
+    const high = bars.map((bar) => bar.high);
+    const low = bars.map((bar) => bar.low);
+    const close = bars.map((bar) => bar.close);
+    const williamsValues = williamsr({
+      high,
+      low,
+      close,
+      period: settings.period
+    });
+    return bars.map((bar, i) => ({
+      time: bar.timestamp / 1e3,
+      value: williamsValues[i] ?? NaN
+    }));
+  }
+};
+var KeltnerChannelsIndicator = {
+  metadata: {
+    id: "keltner",
+    name: "Keltner Channels",
+    description: "Volatility-based channels using ATR - similar to Bollinger Bands",
+    category: "Volatility" /* VOLATILITY */,
+    version: "1.0.0"
+  },
+  settings: {
+    period: {
+      type: "number",
+      label: "Period",
+      defaultValue: 20,
+      description: "Period for middle line (EMA)",
+      min: 2,
+      max: 200,
+      step: 1
+    },
+    atrPeriod: {
+      type: "number",
+      label: "ATR Period",
+      defaultValue: 10,
+      description: "Period for ATR calculation",
+      min: 1,
+      max: 100,
+      step: 1
+    },
+    atrMultiplier: {
+      type: "number",
+      label: "ATR Multiplier",
+      defaultValue: 2,
+      description: "Multiplier for channel width",
+      min: 0.1,
+      max: 10,
+      step: 0.1
+    },
+    upperColor: {
+      type: "color",
+      label: "Upper Band Color",
+      defaultValue: "#ef4444",
+      description: "Color of the upper band"
+    },
+    middleColor: {
+      type: "color",
+      label: "Middle Line Color",
+      defaultValue: "#3b82f6",
+      description: "Color of the middle line"
+    },
+    lowerColor: {
+      type: "color",
+      label: "Lower Band Color",
+      defaultValue: "#10b981",
+      description: "Color of the lower band"
+    },
+    lineWidth: {
+      type: "number",
+      label: "Line Width",
+      defaultValue: 2,
+      description: "Width of the channel lines",
+      min: 1,
+      max: 5,
+      step: 1
+    },
+    showFill: {
+      type: "boolean",
+      label: "Show Fill",
+      defaultValue: true,
+      description: "Fill area between bands"
+    },
+    fillColor: {
+      type: "color",
+      label: "Fill Color",
+      defaultValue: "rgba(59, 130, 246, 0.1)",
+      description: "Color of the channel fill"
+    }
+  },
+  renderConfig: {
+    seriesType: "line" /* LINE */,
+    outputCount: 3,
+    overlay: true,
+    hasBandFill: true
+  },
+  calculate: (bars, settings) => {
+    const high = bars.map((bar) => bar.high);
+    const low = bars.map((bar) => bar.low);
+    const close = bars.map((bar) => bar.close);
+    const keltnerValues = keltnerchannel({
+      high,
+      low,
+      close,
+      period: settings.period,
+      atrPeriod: settings.atrPeriod,
+      multiplier: settings.atrMultiplier
+    });
+    return bars.map((bar, i) => ({
+      time: bar.timestamp / 1e3,
+      value: keltnerValues[i]?.middle ?? NaN,
+      upper: keltnerValues[i]?.upper ?? NaN,
+      lower: keltnerValues[i]?.lower ?? NaN
+    }));
+  }
+};
+var SuperTrendIndicator = {
+  metadata: {
+    id: "supertrend",
+    name: "SuperTrend",
+    description: "Modern trend-following indicator with clear buy/sell signals",
+    category: "Trend" /* TREND */,
+    version: "1.0.0"
+  },
+  settings: {
+    period: {
+      type: "number",
+      label: "Period",
+      defaultValue: 10,
+      description: "Period for ATR calculation",
+      min: 1,
+      max: 100,
+      step: 1
+    },
+    multiplier: {
+      type: "number",
+      label: "Multiplier",
+      defaultValue: 3,
+      description: "ATR multiplier for bands",
+      min: 0.1,
+      max: 10,
+      step: 0.1
+    },
+    color: {
+      type: "color",
+      label: "Line Color",
+      defaultValue: "#06b6d4",
+      description: "Color of the SuperTrend line"
+    },
+    lineWidth: {
+      type: "number",
+      label: "Line Width",
+      defaultValue: 2,
+      description: "Width of the SuperTrend line",
+      min: 1,
+      max: 5,
+      step: 1
+    }
+  },
+  renderConfig: {
+    seriesType: "line" /* LINE */,
+    outputCount: 1,
+    overlay: true
+  },
+  calculate: (bars, settings) => {
+    const high = bars.map((bar) => bar.high);
+    const low = bars.map((bar) => bar.low);
+    const close = bars.map((bar) => bar.close);
+    const supertrendValues = supertrend({
+      high,
+      low,
+      close,
+      period: settings.period,
+      multiplier: settings.multiplier
+    });
+    return bars.map((bar, i) => ({
+      time: bar.timestamp / 1e3,
+      value: supertrendValues[i]?.supertrend ?? NaN
+    }));
+  }
+};
+var IchimokuIndicator = {
+  metadata: {
+    id: "ichimoku",
+    name: "Ichimoku Cloud",
+    description: "Comprehensive trend system with conversion, base, and span lines forming a cloud",
+    category: "Trend" /* TREND */,
+    version: "1.0.0"
+  },
+  settings: {
+    conversionPeriod: {
+      type: "number",
+      label: "Conversion Period (Tenkan)",
+      defaultValue: 9,
+      description: "Period for conversion line",
+      min: 1,
+      max: 100,
+      step: 1
+    },
+    basePeriod: {
+      type: "number",
+      label: "Base Period (Kijun)",
+      defaultValue: 26,
+      description: "Period for base line",
+      min: 1,
+      max: 100,
+      step: 1
+    },
+    spanPeriod: {
+      type: "number",
+      label: "Span Period (Senkou)",
+      defaultValue: 52,
+      description: "Period for span B",
+      min: 1,
+      max: 200,
+      step: 1
+    },
+    displacement: {
+      type: "number",
+      label: "Displacement",
+      defaultValue: 26,
+      description: "Forward displacement for span lines",
+      min: 0,
+      max: 100,
+      step: 1
+    },
+    conversionColor: {
+      type: "color",
+      label: "Conversion Line Color",
+      defaultValue: "#3b82f6",
+      description: "Color of the conversion line"
+    },
+    baseColor: {
+      type: "color",
+      label: "Base Line Color",
+      defaultValue: "#ef4444",
+      description: "Color of the base line"
+    },
+    spanAColor: {
+      type: "color",
+      label: "Span A Color",
+      defaultValue: "#10b981",
+      description: "Color of span A (cloud edge)"
+    },
+    spanBColor: {
+      type: "color",
+      label: "Span B Color",
+      defaultValue: "#f59e0b",
+      description: "Color of span B (cloud edge)"
+    },
+    lineWidth: {
+      type: "number",
+      label: "Line Width",
+      defaultValue: 2,
+      description: "Width of the indicator lines",
+      min: 1,
+      max: 5,
+      step: 1
+    },
+    showCloud: {
+      type: "boolean",
+      label: "Show Cloud",
+      defaultValue: true,
+      description: "Fill area between span A and span B"
+    },
+    cloudColor: {
+      type: "color",
+      label: "Cloud Color",
+      defaultValue: "rgba(59, 130, 246, 0.1)",
+      description: "Color of the cloud fill"
+    }
+  },
+  renderConfig: {
+    seriesType: "line" /* LINE */,
+    outputCount: 5,
+    overlay: true,
+    hasBandFill: true,
+    fillBands: {
+      upper: "spanA",
+      lower: "spanB"
+    }
+  },
+  calculate: (bars, settings) => {
+    const high = bars.map((bar) => bar.high);
+    const low = bars.map((bar) => bar.low);
+    const ichimokuValues = ichimokucloud({
+      high,
+      low,
+      conversionPeriod: settings.conversionPeriod,
+      basePeriod: settings.basePeriod,
+      spanPeriod: settings.spanPeriod,
+      displacement: 0
+    });
+    const conversion = bars.map((_, i) => ichimokuValues[i]?.conversion ?? NaN);
+    const base = bars.map((_, i) => ichimokuValues[i]?.base ?? NaN);
+    const spanA = bars.map((_, i) => ichimokuValues[i]?.spanA ?? NaN);
+    const spanB = bars.map((_, i) => ichimokuValues[i]?.spanB ?? NaN);
+    const displacedSpanA = displaceArray(spanA, settings.displacement);
+    const displacedSpanB = displaceArray(spanB, settings.displacement);
+    return bars.map((bar, i) => ({
+      time: bar.timestamp / 1e3,
+      value: conversion[i],
+      base: base[i],
+      spanA: displacedSpanA[i],
+      spanB: displacedSpanB[i]
+    }));
+  }
+};
+var DonchianChannelsIndicator = {
+  metadata: {
+    id: "donchian",
+    name: "Donchian Channels",
+    description: "Highest high and lowest low over a period - classic breakout indicator",
+    category: "Volatility" /* VOLATILITY */,
+    version: "1.0.0"
+  },
+  settings: {
+    period: {
+      type: "number",
+      label: "Period",
+      defaultValue: 20,
+      description: "Number of bars to look back",
+      min: 2,
+      max: 200,
+      step: 1
+    },
+    upperColor: {
+      type: "color",
+      label: "Upper Band Color",
+      defaultValue: "#ef4444",
+      description: "Color of the upper band"
+    },
+    middleColor: {
+      type: "color",
+      label: "Middle Line Color",
+      defaultValue: "#3b82f6",
+      description: "Color of the middle line"
+    },
+    lowerColor: {
+      type: "color",
+      label: "Lower Band Color",
+      defaultValue: "#10b981",
+      description: "Color of the lower band"
+    },
+    lineWidth: {
+      type: "number",
+      label: "Line Width",
+      defaultValue: 2,
+      description: "Width of the channel lines",
+      min: 1,
+      max: 5,
+      step: 1
+    },
+    showFill: {
+      type: "boolean",
+      label: "Show Fill",
+      defaultValue: true,
+      description: "Fill area between bands"
+    },
+    fillColor: {
+      type: "color",
+      label: "Fill Color",
+      defaultValue: "rgba(59, 130, 246, 0.1)",
+      description: "Color of the channel fill"
+    }
+  },
+  renderConfig: {
+    seriesType: "line" /* LINE */,
+    outputCount: 3,
+    overlay: true,
+    hasBandFill: true,
+    fillBands: {
+      upper: "upper",
+      lower: "lower"
+    }
+  },
+  calculate: (bars, settings) => {
+    const high = bars.map((bar) => bar.high);
+    const low = bars.map((bar) => bar.low);
+    const donchianValues = donchianchannels({
+      high,
+      low,
+      period: settings.period
+    });
+    return bars.map((bar, i) => ({
+      time: bar.timestamp / 1e3,
+      value: donchianValues[i]?.middle ?? NaN,
+      upper: donchianValues[i]?.upper ?? NaN,
+      lower: donchianValues[i]?.lower ?? NaN
+    }));
+  }
+};
+var ROCIndicator = {
+  metadata: {
+    id: "roc",
+    name: "ROC",
+    description: "Rate of Change - measures percentage change in price over a period",
+    category: "Momentum" /* MOMENTUM */,
+    version: "1.0.0"
+  },
+  settings: {
+    period: {
+      type: "number",
+      label: "Period",
+      defaultValue: 12,
+      description: "Number of bars for ROC calculation",
+      min: 1,
+      max: 100,
+      step: 1
+    },
+    color: {
+      type: "color",
+      label: "Line Color",
+      defaultValue: "#06b6d4",
+      description: "Color of the ROC line"
+    },
+    lineWidth: {
+      type: "number",
+      label: "Line Width",
+      defaultValue: 2,
+      description: "Width of the ROC line",
+      min: 1,
+      max: 5,
+      step: 1
+    }
+  },
+  renderConfig: {
+    seriesType: "line" /* LINE */,
+    outputCount: 1,
+    overlay: false
+  },
+  calculate: (bars, settings) => {
+    const values = bars.map((bar) => bar.close);
+    const rocValues = roc({
+      values,
+      period: settings.period
+    });
+    return bars.map((bar, i) => ({
+      time: bar.timestamp / 1e3,
+      value: rocValues[i] ?? NaN
+    }));
+  }
+};
+var StochRSIIndicator = {
+  metadata: {
+    id: "stochrsi",
+    name: "Stochastic RSI",
+    description: "Stochastic RSI - applies Stochastic oscillator to RSI values",
+    category: "Momentum" /* MOMENTUM */,
+    version: "1.0.0"
+  },
+  settings: {
+    rsiPeriod: {
+      type: "number",
+      label: "RSI Period",
+      defaultValue: 14,
+      description: "Period for RSI calculation",
+      min: 2,
+      max: 100,
+      step: 1
+    },
+    stochPeriod: {
+      type: "number",
+      label: "Stochastic Period",
+      defaultValue: 14,
+      description: "Period for Stochastic calculation",
+      min: 2,
+      max: 100,
+      step: 1
+    },
+    kPeriod: {
+      type: "number",
+      label: "%K Period",
+      defaultValue: 3,
+      description: "Smoothing period for %K",
+      min: 1,
+      max: 50,
+      step: 1
+    },
+    dPeriod: {
+      type: "number",
+      label: "%D Period",
+      defaultValue: 3,
+      description: "Smoothing period for %D signal line",
+      min: 1,
+      max: 50,
+      step: 1
+    },
+    kColor: {
+      type: "color",
+      label: "%K Line Color",
+      defaultValue: "#3b82f6",
+      description: "Color of the %K line"
+    },
+    dColor: {
+      type: "color",
+      label: "%D Line Color",
+      defaultValue: "#ef4444",
+      description: "Color of the %D signal line"
+    },
+    lineWidth: {
+      type: "number",
+      label: "Line Width",
+      defaultValue: 2,
+      description: "Width of the indicator lines",
+      min: 1,
+      max: 5,
+      step: 1
+    }
+  },
+  renderConfig: {
+    seriesType: "line" /* LINE */,
+    outputCount: 2,
+    overlay: false
+  },
+  calculate: (bars, settings) => {
+    const values = bars.map((bar) => bar.close);
+    const stochRSIValues = stochasticrsi({
+      values,
+      rsiPeriod: settings.rsiPeriod,
+      stochasticPeriod: settings.stochPeriod,
+      kPeriod: settings.kPeriod,
+      dPeriod: settings.dPeriod
+    });
+    return bars.map((bar, i) => ({
+      time: bar.timestamp / 1e3,
+      value: stochRSIValues[i]?.k ?? NaN,
+      signal: stochRSIValues[i]?.d ?? NaN
+    }));
+  }
+};
+var WMAIndicator = {
+  metadata: {
+    id: "wma",
+    name: "WMA",
+    description: "Weighted Moving Average - gives more weight to recent prices",
+    category: "Trend" /* TREND */,
+    version: "1.0.0"
+  },
+  settings: {
+    period: {
+      type: "number",
+      label: "Period",
+      defaultValue: 20,
+      description: "Number of bars to average",
+      min: 1,
+      max: 500,
+      step: 1
+    },
+    color: {
+      type: "color",
+      label: "Line Color",
+      defaultValue: "#f59e0b",
+      description: "Color of the WMA line"
+    },
+    lineWidth: {
+      type: "number",
+      label: "Line Width",
+      defaultValue: 2,
+      description: "Width of the WMA line",
+      min: 1,
+      max: 5,
+      step: 1
+    }
+  },
+  renderConfig: {
+    seriesType: "line" /* LINE */,
+    outputCount: 1,
+    overlay: true
+  },
+  calculate: (bars, settings) => {
+    const values = bars.map((bar) => bar.close);
+    const wmaValues = wma({
+      values,
+      period: settings.period
+    });
+    return bars.map((bar, i) => ({
+      time: bar.timestamp / 1e3,
+      value: wmaValues[i] ?? NaN
+    }));
+  }
+};
+
+// src/indicators/registry/index.ts
+function registerBuiltInIndicators() {
+  indicatorRegistry.register(SMAIndicator);
+  indicatorRegistry.register(EMAIndicator);
+  indicatorRegistry.register(RSIIndicator);
+  indicatorRegistry.register(BollingerBandsIndicator);
+  indicatorRegistry.register(VWAPIndicator);
+  indicatorRegistry.register(StochasticIndicator);
+  indicatorRegistry.register(OBVIndicator);
+  indicatorRegistry.register(MFIIndicator);
+  indicatorRegistry.register(ForceIndexIndicator);
+  indicatorRegistry.register(ATRIndicator);
+  indicatorRegistry.register(ADXIndicator);
+  indicatorRegistry.register(MACDIndicator);
+  indicatorRegistry.register(PSARIndicator);
+  indicatorRegistry.register(CCIIndicator);
+  indicatorRegistry.register(WilliamsRIndicator);
+  indicatorRegistry.register(KeltnerChannelsIndicator);
+  indicatorRegistry.register(SuperTrendIndicator);
+  indicatorRegistry.register(IchimokuIndicator);
+  indicatorRegistry.register(DonchianChannelsIndicator);
+  indicatorRegistry.register(ROCIndicator);
+  indicatorRegistry.register(StochRSIIndicator);
+  indicatorRegistry.register(WMAIndicator);
+}
+
+// src/adapters/alpaca.ts
+var AlpacaBarAdapter = class {
+  constructor(options) {
+    __publicField(this, "apiKey");
+    __publicField(this, "secretKey");
+    __publicField(this, "baseUrl");
+    __publicField(this, "wsUrl");
+    __publicField(this, "ws", null);
+    __publicField(this, "reconnectAttempts", 0);
+    __publicField(this, "maxReconnectAttempts", 5);
+    __publicField(this, "reconnectDelay", 1e3);
+    __publicField(this, "currentHandlers", null);
+    __publicField(this, "currentSymbol", null);
+    __publicField(this, "authenticated", false);
+    if (!options.apiKey || !options.secretKey) {
+      throw new Error("Alpaca API key and secret key are required");
+    }
+    this.apiKey = options.apiKey;
+    this.secretKey = options.secretKey;
+    this.baseUrl = options.baseUrl || "https://data.alpaca.markets";
+    this.wsUrl = options.wsUrl || "wss://stream.data.alpaca.markets/v2/iex";
+  }
+  async fetchHistoricalBars(params) {
+    const { symbol, timeframe, before, after, limit = 500 } = params;
+    const url = new URL(`${this.baseUrl}/v2/stocks/${symbol}/bars`);
+    url.searchParams.set("timeframe", timeframe);
+    url.searchParams.set("limit", limit.toString());
+    if (before) {
+      const beforeDate = new Date(before).toISOString();
+      url.searchParams.set("end", beforeDate);
+    }
+    if (after) {
+      const afterDate = new Date(after).toISOString();
+      url.searchParams.set("start", afterDate);
+    }
+    url.searchParams.set("feed", "iex");
+    const headers = {
+      "APCA-API-KEY-ID": this.apiKey,
+      "APCA-API-SECRET-KEY": this.secretKey
+    };
+    try {
+      const response = await fetch(url.toString(), { headers });
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Alpaca API error: ${response.status} ${errorText}`);
+      }
+      const data = await response.json();
+      const bars = data.bars[symbol] || [];
+      return this.convertAlpacaBars(bars);
+    } catch (error) {
+      console.error("Failed to fetch Alpaca bars:", error);
+      throw error;
+    }
+  }
+  subscribeRealtime(symbol, handlers) {
+    this.currentSymbol = symbol;
+    this.currentHandlers = handlers;
+    this.connectWebSocket();
+    return {
+      unsubscribe: () => this.disconnect()
+    };
+  }
+  unsubscribeAll() {
+    this.disconnect();
+  }
+  connectWebSocket() {
+    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+      console.log("WebSocket already connected");
+      return;
+    }
+    try {
+      this.ws = new WebSocket(this.wsUrl);
+      this.ws.onopen = () => {
+        console.log("Alpaca WebSocket connected");
+        this.authenticated = false;
+        this.authenticate();
+      };
+      this.ws.onmessage = (event) => {
+        this.handleMessage(event.data);
+      };
+      this.ws.onerror = (event) => {
+        console.error("Alpaca WebSocket error:", event);
+        this.currentHandlers?.onError?.(new Error("WebSocket error"));
+      };
+      this.ws.onclose = () => {
+        console.log("Alpaca WebSocket closed");
+        this.authenticated = false;
+        this.currentHandlers?.onDisconnect?.();
+        this.attemptReconnect();
+      };
+    } catch (error) {
+      console.error("Failed to create WebSocket:", error);
+      this.currentHandlers?.onError?.(
+        error instanceof Error ? error : new Error("Failed to create WebSocket")
+      );
+    }
+  }
+  authenticate() {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) return;
+    const authMessage = {
+      action: "auth",
+      key: this.apiKey,
+      secret: this.secretKey
+    };
+    this.ws.send(JSON.stringify(authMessage));
+  }
+  subscribe() {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN || !this.currentSymbol) return;
+    const subscribeMessage = {
+      action: "subscribe",
+      trades: [this.currentSymbol],
+      bars: [this.currentSymbol]
+    };
+    this.ws.send(JSON.stringify(subscribeMessage));
+    console.log(`Subscribed to ${this.currentSymbol}`);
+  }
+  handleMessage(data) {
+    try {
+      const messages = JSON.parse(data);
+      if (!Array.isArray(messages)) {
+        console.warn("Unexpected message format:", messages);
+        return;
+      }
+      for (const message of messages) {
+        if (message.T === "success" && message.msg === "authenticated") {
+          console.log("Alpaca WebSocket authenticated");
+          this.authenticated = true;
+          this.reconnectAttempts = 0;
+          this.currentHandlers?.onConnect?.();
+          this.subscribe();
+        } else if (message.T === "error") {
+          console.error("Alpaca error:", message.msg);
+          this.currentHandlers?.onError?.(new Error(message.msg));
+        } else if (message.T === "t") {
+          this.handleTrade(message);
+        } else if (message.T === "b") {
+          this.handleBar(message);
+        } else if (message.T === "subscription") {
+          console.log("Subscription confirmed:", message);
+        }
+      }
+    } catch (error) {
+      console.error("Failed to parse WebSocket message:", error);
+    }
+  }
+  handleTrade(trade) {
+    if (trade.S !== this.currentSymbol) return;
+    this.currentHandlers?.onTrade?.(trade.p, trade.s);
+  }
+  handleBar(bar) {
+    if (bar.S !== this.currentSymbol) return;
+    const ohlcvBar = {
+      timestamp: new Date(bar.t).getTime(),
+      open: bar.o,
+      high: bar.h,
+      low: bar.l,
+      close: bar.c,
+      volume: bar.v,
+      trade_count: bar.n,
+      vwap: bar.vw
+    };
+    this.currentHandlers?.onBar?.(ohlcvBar);
+  }
+  attemptReconnect() {
+    if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+      console.error("Max reconnection attempts reached");
+      this.currentHandlers?.onError?.(new Error("Max reconnection attempts reached"));
+      return;
+    }
+    this.reconnectAttempts++;
+    const delay = this.reconnectDelay * Math.pow(2, this.reconnectAttempts - 1);
+    console.log(`Attempting to reconnect in ${delay}ms (attempt ${this.reconnectAttempts})`);
+    setTimeout(() => {
+      if (this.currentSymbol && this.currentHandlers) {
+        this.connectWebSocket();
+      }
+    }, delay);
+  }
+  disconnect() {
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+    this.authenticated = false;
+    this.currentSymbol = null;
+    this.currentHandlers = null;
+    this.reconnectAttempts = 0;
+  }
+  convertAlpacaBars(bars) {
+    return bars.map((bar) => ({
+      timestamp: new Date(bar.t).getTime(),
+      open: bar.o,
+      high: bar.h,
+      low: bar.l,
+      close: bar.c,
+      volume: bar.v,
+      trade_count: bar.n,
+      vwap: bar.vw
+    }));
+  }
+};
+
+// src/adapters/mock.ts
+var MockAdapter = class {
+  constructor() {
+    __publicField(this, "intervalId", null);
+  }
+  async fetchHistoricalBars(params) {
+    const { limit = 100, before } = params;
+    await new Promise((resolve) => setTimeout(resolve, 800));
+    const bars = [];
+    const now = before || Date.now();
+    let price = 100;
+    for (let i = limit - 1; i >= 0; i--) {
+      const timestamp = now - i * 3e5;
+      const change = (Math.random() - 0.5) * 2;
+      price = Math.max(price + change, 1);
+      const open = price;
+      const close = price + (Math.random() - 0.5) * 1.5;
+      const high = Math.max(open, close) + Math.random() * 0.5;
+      const low = Math.min(open, close) - Math.random() * 0.5;
+      bars.push({
+        timestamp,
+        open: Math.max(open, 0.01),
+        high: Math.max(high, 0.01),
+        low: Math.max(low, 0.01),
+        close: Math.max(close, 0.01),
+        volume: Math.floor(Math.random() * 1e4) + 1e3
+      });
+      price = Math.max(close, 1);
+    }
+    console.log(`MockAdapter: Generated ${bars.length} bars (before: ${before})`);
+    console.log("First bar:", bars[0]);
+    console.log("Last bar:", bars[bars.length - 1]);
+    return bars;
+  }
+  subscribeRealtime(symbol, handlers) {
+    handlers.onConnect?.();
+    let lastPrice = 100;
+    this.intervalId = window.setInterval(() => {
+      const now = Date.now();
+      const timestamp = Math.floor(now / 3e5) * 3e5;
+      const change = (Math.random() - 0.5) * 2;
+      lastPrice = Math.max(lastPrice + change, 1);
+      const open = lastPrice;
+      const close = lastPrice + (Math.random() - 0.5) * 1.5;
+      const high = Math.max(open, close) + Math.random() * 0.5;
+      const low = Math.min(open, close) - Math.random() * 0.5;
+      const bar = {
+        timestamp,
+        open,
+        high,
+        low,
+        close,
+        volume: Math.floor(Math.random() * 1e4) + 1e3
+      };
+      handlers.onBar?.(bar);
+      lastPrice = close;
+    }, 5e3);
+    return {
+      unsubscribe: () => this.unsubscribeAll()
+    };
+  }
+  unsubscribeAll() {
+    if (this.intervalId !== null) {
+      clearInterval(this.intervalId);
+      this.intervalId = null;
+    }
+  }
+};
+
+export { ADXIndicator, ATRIndicator, AlpacaBarAdapter, BollingerBandsIndicator, CCIIndicator, ChartComponent, ChartSeriesType, DonchianChannelsIndicator, EMAIndicator, ForceIndexIndicator, IchimokuIndicator, IndicatorBrowser, IndicatorCategory, IndicatorInstanceSchema, IndicatorMetadataSchema, IndicatorSettingsForm, IndicatorSettingsSchema, KeltnerChannelsIndicator, LineStyleSchema, LocalStoragePersistenceAdapter, MACDIndicator, MFIIndicator, MockAdapter, NoOpPersistenceAdapter, OBVIndicator, PSARIndicator, ROCIndicator, RSIIndicator, RenderConfigSchema, SMAIndicator, SettingFieldSchema, SettingFieldTypeSchema, SettingsDialog, StochRSIIndicator, StochasticIndicator, SuperTrendIndicator, VWAPIndicator, WMAIndicator, WilliamsRIndicator, appendBar, calculateBollingerBands, calculateEMA, calculateRSI, calculateSMA, calculateStandardDeviation, createPersistenceAdapter, deduplicateBars, displaceArray, getNewestBar, getOldestBar, indicatorCalculator, indicatorRegistry, isValidBar, mergeBars, normalizeTimestamp, padIndicatorArray, prependBars, registerBuiltInIndicators, sortBars, updateBarInArray, updateCurrentBar, useBarsData, useChartAPI, useRealtimeUpdates, validateAndNormalizeBars, validateBar };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map