@tradejs/core 1.0.0

package/dist/chunk-LIGD3WWX.mjs

@@ -0,0 +1,1545 @@
+import {
+  round
+} from "./chunk-AYC2QVKI.mjs";
+import {
+  toMs
+} from "./chunk-PXLXXXLA.mjs";
+import {
+  CORRELATION_WINDOW,
+  ML_BASE_CANDLES_WINDOW,
+  TRENDLINE_DEFAULTS
+} from "./chunk-JG2QPVAV.mjs";
+import {
+  cloneArrayValues
+} from "./chunk-M7QGVZ3J.mjs";
+
+// src/utils/correlation.ts
+var alignSortedCandlesByTimestamp = (coinCandles, btcCandles) => {
+  const alignedCoinCandles = [];
+  const alignedBtcCandles = [];
+  let coinIndex = 0;
+  let btcIndex = 0;
+  while (coinIndex < coinCandles.length && btcIndex < btcCandles.length) {
+    const coinTimestampMs = coinCandles[coinIndex].timestamp;
+    const btcTimestampMs = btcCandles[btcIndex].timestamp;
+    if (coinTimestampMs === btcTimestampMs) {
+      alignedCoinCandles.push(coinCandles[coinIndex]);
+      alignedBtcCandles.push(btcCandles[btcIndex]);
+      coinIndex += 1;
+      btcIndex += 1;
+    } else if (coinTimestampMs < btcTimestampMs) {
+      coinIndex += 1;
+    } else {
+      btcIndex += 1;
+    }
+  }
+  return {
+    alignedCoinCandles,
+    alignedBtcCandles
+  };
+};
+var buildReturnsFromCandles = (candles) => {
+  const returns = [];
+  for (let candleIndex = 1; candleIndex < candles.length; candleIndex += 1) {
+    const previousClose = candles[candleIndex - 1].close;
+    const currentClose = candles[candleIndex].close;
+    if (!Number.isFinite(previousClose) || !Number.isFinite(currentClose)) {
+      continue;
+    }
+    const change = (currentClose - previousClose) / previousClose;
+    returns.push(change);
+  }
+  return returns;
+};
+var calculatePearsonCorrelation = (firstSeries, secondSeries) => {
+  if (firstSeries.length !== secondSeries.length) {
+    throw new Error(
+      "calculatePearsonCorrelation: series lengths are different"
+    );
+  }
+  const length = firstSeries.length;
+  if (length === 0) return null;
+  if (length === 1) return null;
+  const sumFirst = firstSeries.reduce((sum, value) => sum + value, 0);
+  const sumSecond = secondSeries.reduce((sum, value) => sum + value, 0);
+  const meanFirst = sumFirst / length;
+  const meanSecond = sumSecond / length;
+  let covariance = 0;
+  let varianceFirst = 0;
+  let varianceSecond = 0;
+  for (let index = 0; index < length; index += 1) {
+    const deltaFirst = firstSeries[index] - meanFirst;
+    const deltaSecond = secondSeries[index] - meanSecond;
+    covariance += deltaFirst * deltaSecond;
+    varianceFirst += deltaFirst * deltaFirst;
+    varianceSecond += deltaSecond * deltaSecond;
+  }
+  if (varianceFirst === 0 || varianceSecond === 0) {
+    return null;
+  }
+  const correlation = covariance / Math.sqrt(varianceFirst * varianceSecond);
+  return correlation;
+};
+var calculateCoinBtcCorrelation = (coinCandles, btcCandles) => {
+  const { alignedCoinCandles, alignedBtcCandles } = alignSortedCandlesByTimestamp(coinCandles, btcCandles);
+  const MIN_LENGTH_FOR_CORRELATION = 10;
+  if (alignedCoinCandles.length <= MIN_LENGTH_FOR_CORRELATION) {
+    return {
+      correlation: null,
+      alignedCoinCandles,
+      alignedBtcCandles,
+      coinReturns: [],
+      btcReturns: []
+    };
+  }
+  const coinReturns = buildReturnsFromCandles(alignedCoinCandles);
+  const btcReturns = buildReturnsFromCandles(alignedBtcCandles);
+  const minReturnsLength = Math.min(coinReturns.length, btcReturns.length);
+  const slicedCoinReturns = coinReturns.slice(-minReturnsLength);
+  const slicedBtcReturns = btcReturns.slice(-minReturnsLength);
+  const correlation = calculatePearsonCorrelation(
+    slicedCoinReturns,
+    slicedBtcReturns
+  );
+  return {
+    correlation: correlation ? round(correlation) : correlation,
+    alignedCoinCandles,
+    alignedBtcCandles,
+    coinReturns: slicedCoinReturns,
+    btcReturns: slicedBtcReturns
+  };
+};
+
+// src/utils/derivativesFeatureUtils.ts
+var SUPPORTED_DERIVATIVE_INTERVALS = [
+  "15m",
+  "1h"
+];
+var parseDerivativesIntervals = (value) => {
+  const supported = new Set(
+    SUPPORTED_DERIVATIVE_INTERVALS
+  );
+  const values = String(value ?? "").split(",").map((item) => item.trim().toLowerCase()).filter(Boolean);
+  return values.filter(
+    (item) => supported.has(item)
+  );
+};
+var toFiniteNumber = (value, fallback = 0) => {
+  const num = Number(value);
+  return Number.isFinite(num) ? num : fallback;
+};
+
+// src/utils/derivativesCoinalyze.ts
+var normalizeCoinalyzeSymbols = (input) => String(input ?? "").split(",").map((item) => item.trim().toUpperCase()).filter(Boolean);
+var normalizeDerivativesIntervals = (input) => parseDerivativesIntervals(input);
+var toCoinalyzeTimestampMs = (value) => {
+  const num = Number(value);
+  if (!Number.isFinite(num)) return null;
+  if (num > 1e13) return Math.floor(num / 1e3);
+  if (num > 1e10) return Math.floor(num);
+  return Math.floor(num * 1e3);
+};
+var toFiniteNumber2 = (value) => Number.isFinite(Number(value)) ? toFiniteNumber(value) : null;
+var toArrayData = (value) => {
+  if (Array.isArray(value)) return value;
+  if (value && typeof value === "object") {
+    const maybeData = value.data;
+    if (Array.isArray(maybeData)) return maybeData;
+    const maybeResult = value.result;
+    if (Array.isArray(maybeResult)) return maybeResult;
+  }
+  return [];
+};
+var mergeCoinalyzeMetrics = (params) => {
+  const { symbol, oiRaw, fundingRaw, liqRaw } = params;
+  const points = /* @__PURE__ */ new Map();
+  const upsertPoint = (ts) => {
+    let point = points.get(ts);
+    if (!point) {
+      point = { symbol, ts };
+      points.set(ts, point);
+    }
+    return point;
+  };
+  for (const item of toArrayData(oiRaw)) {
+    const ts = toCoinalyzeTimestampMs(
+      item.t ?? item.ts ?? item.time ?? item.timestamp
+    );
+    if (!ts) continue;
+    const point = upsertPoint(ts);
+    point.openInterest = toFiniteNumber2(
+      item.open_interest ?? item.openInterest ?? item.oi ?? item.value
+    );
+  }
+  for (const item of toArrayData(fundingRaw)) {
+    const ts = toCoinalyzeTimestampMs(
+      item.t ?? item.ts ?? item.time ?? item.timestamp
+    );
+    if (!ts) continue;
+    const point = upsertPoint(ts);
+    point.fundingRate = toFiniteNumber2(
+      item.funding_rate ?? item.fundingRate ?? item.rate ?? item.value
+    );
+  }
+  for (const item of toArrayData(liqRaw)) {
+    const ts = toCoinalyzeTimestampMs(
+      item.t ?? item.ts ?? item.time ?? item.timestamp
+    );
+    if (!ts) continue;
+    const point = upsertPoint(ts);
+    point.liqLong = toFiniteNumber2(
+      item.liq_long ?? item.long_liq ?? item.longLiquidations ?? item.long
+    );
+    point.liqShort = toFiniteNumber2(
+      item.liq_short ?? item.short_liq ?? item.shortLiquidations ?? item.short
+    );
+    point.liqTotal = toFiniteNumber2(
+      item.liq_total ?? item.total_liq ?? item.totalLiquidations
+    ) ?? (point.liqLong ?? 0) + (point.liqShort ?? 0);
+  }
+  return [...points.values()].sort((a, b) => a.ts - b.ts);
+};
+var coinalyzePointsToRows = (points, interval, source) => points.map((point) => ({
+  symbol: point.symbol,
+  interval,
+  ts: new Date(point.ts),
+  openInterest: point.openInterest ?? null,
+  fundingRate: point.fundingRate ?? null,
+  liqLong: point.liqLong ?? null,
+  liqShort: point.liqShort ?? null,
+  liqTotal: point.liqTotal ?? null,
+  source
+}));
+
+// src/utils/indicators.ts
+import { SMA, ATR, BollingerBands, OBV, MACD } from "technicalindicators";
+
+// src/utils/indicatorPlugins.ts
+var warn = (message, ...args) => {
+  console.warn(`[core:indicators] ${message}`, ...args);
+};
+var pluginIndicatorEntries = /* @__PURE__ */ new Map();
+var registerIndicatorEntries = (entries, source) => {
+  for (const entry of entries) {
+    const indicatorId = entry.indicator?.id;
+    if (!indicatorId) {
+      warn("Skip indicator entry without id from %s", source);
+      continue;
+    }
+    if (pluginIndicatorEntries.has(indicatorId)) {
+      warn(
+        'Skip duplicate indicator "%s" from %s: already registered',
+        indicatorId,
+        source
+      );
+      continue;
+    }
+    pluginIndicatorEntries.set(indicatorId, entry);
+  }
+};
+var getRegisteredIndicatorEntries = () => [
+  ...pluginIndicatorEntries.values()
+];
+var getPluginIndicatorCatalog = () => getRegisteredIndicatorEntries().map((entry) => ({
+  id: entry.indicator.id,
+  label: entry.indicator.label,
+  enabled: entry.indicator.enabled,
+  periods: entry.indicator.periods
+}));
+var getPluginIndicatorRenderers = () => getRegisteredIndicatorEntries().filter(
+  (entry) => Boolean(entry.renderer)
+).map((entry) => ({
+  indicatorId: entry.indicator.id,
+  renderer: entry.renderer
+}));
+var resetIndicatorRegistryCache = () => {
+  pluginIndicatorEntries.clear();
+};
+
+// src/utils/spread.ts
+var DEFAULT_SPREAD_WINDOW = 50;
+var toFinitePrice = (value) => {
+  if (value == null) return null;
+  const num = Number(value);
+  return Number.isFinite(num) ? num : null;
+};
+var toFiniteSpread = (value) => {
+  if (value == null) return null;
+  const num = Number(value);
+  return Number.isFinite(num) ? num : null;
+};
+var createSpreadSmoother = (window = DEFAULT_SPREAD_WINDOW) => {
+  const binanceWindow = [];
+  const coinbaseWindow = [];
+  let binanceSum = 0;
+  let coinbaseSum = 0;
+  const next = (params) => {
+    const binance = toFinitePrice(params.binancePrice);
+    const coinbase = toFinitePrice(params.coinbasePrice);
+    if (binance != null && coinbase != null) {
+      binanceWindow.push(binance);
+      coinbaseWindow.push(coinbase);
+      binanceSum += binance;
+      coinbaseSum += coinbase;
+      if (binanceWindow.length > window) {
+        binanceSum -= binanceWindow.shift() ?? 0;
+        coinbaseSum -= coinbaseWindow.shift() ?? 0;
+      }
+    }
+    let spread = toFiniteSpread(params.fallbackSpread);
+    if (binanceWindow.length > 0 && coinbaseWindow.length > 0) {
+      const avgBinance = binanceSum / binanceWindow.length;
+      const avgCoinbase = coinbaseSum / coinbaseWindow.length;
+      if (Number.isFinite(avgBinance) && avgBinance > 0) {
+        spread = (avgCoinbase - avgBinance) / avgBinance;
+      }
+    }
+    return toFiniteSpread(spread);
+  };
+  return { next };
+};
+var smoothSpreadSeries = (points, window = DEFAULT_SPREAD_WINDOW) => {
+  const smoother = createSpreadSmoother(window);
+  return points.map((point) => ({
+    timestamp: point.timestamp,
+    spread: smoother.next({
+      binancePrice: point.binancePrice,
+      coinbasePrice: point.coinbasePrice,
+      fallbackSpread: point.spread
+    })
+  }));
+};
+var intervalToMs = (interval) => interval === "1h" ? 60 * 60 * 1e3 : 15 * 60 * 1e3;
+var coinbaseProductFromSymbol = (symbol) => {
+  const upper = symbol.trim().toUpperCase();
+  const quoteSuffixes = ["USDT", "USDC", "BUSD", "USD"];
+  for (const suffix of quoteSuffixes) {
+    if (upper.endsWith(suffix)) {
+      const base = upper.slice(0, -suffix.length);
+      if (!base) return null;
+      return `${base}-USD`;
+    }
+  }
+  return null;
+};
+var alignSpreadRows = (params) => {
+  const { symbol, interval, binance, coinbase, source } = params;
+  if (!binance.length || !coinbase.length) return [];
+  const coinbaseByTs = /* @__PURE__ */ new Map();
+  for (const row of coinbase) {
+    if (!Number.isFinite(row.ts) || !Number.isFinite(row.close)) continue;
+    coinbaseByTs.set(row.ts, row.close);
+  }
+  const rows = [];
+  for (const row of binance) {
+    if (!Number.isFinite(row.ts) || !Number.isFinite(row.close) || row.close <= 0) {
+      continue;
+    }
+    const cb = coinbaseByTs.get(row.ts);
+    if (cb == null || !Number.isFinite(cb)) continue;
+    const spread = (cb - row.close) / row.close;
+    rows.push({
+      symbol,
+      interval,
+      ts: new Date(row.ts),
+      binancePrice: row.close,
+      coinbasePrice: cb,
+      spread,
+      source
+    });
+  }
+  return rows;
+};
+var rollingMeanStd = (values, endIndex, window) => {
+  const start = Math.max(0, endIndex - window + 1);
+  const slice = values.slice(start, endIndex + 1).map((x) => toFiniteNumber(x, Number.NaN)).filter((x) => Number.isFinite(x));
+  if (!slice.length) return { mean: 0, std: 0 };
+  const mean = slice.reduce((acc, x) => acc + x, 0) / slice.length;
+  if (slice.length < 2) return { mean, std: 0 };
+  const variance = slice.reduce((acc, x) => acc + (x - mean) * (x - mean), 0) / slice.length;
+  return { mean, std: Math.sqrt(Math.max(variance, 0)) };
+};
+
+// src/utils/indicators.ts
+var CANDLE_WINDOW = ML_BASE_CANDLES_WINDOW;
+var BASE_INTERVAL_MINUTES = 15;
+var INDICATOR_TIMEFRAMES = [
+  { minutes: 60, suffix: "1h" },
+  { minutes: 240, suffix: "4h" },
+  { minutes: 1440, suffix: "1d" }
+];
+var DEFAULT_INDICATOR_PERIODS = {
+  maFast: 14,
+  maMedium: 49,
+  maSlow: 50,
+  obvSma: 10,
+  atr: 14,
+  atrPctShort: 7,
+  atrPctLong: 30,
+  bb: 20,
+  bbStd: 2,
+  macdFast: 12,
+  macdSlow: 26,
+  macdSignal: 9,
+  levelLookback: 20,
+  levelDelay: 2
+};
+var ONE_HOUR_MS = 36e5;
+var ONE_DAY_MS = 864e5;
+var toMlCandle = (candle) => ({
+  open: Number(candle.open) || 0,
+  high: Number(candle.high) || 0,
+  low: Number(candle.low) || 0,
+  close: Number(candle.close) || 0,
+  volume: Number(candle.volume) || 0,
+  turnover: Number(candle.turnover) || 0,
+  timestamp: Number(candle.timestamp) || 0
+});
+var resampleCandles = (candles, targetMinutes) => {
+  if (targetMinutes <= BASE_INTERVAL_MINUTES) return candles.map(toMlCandle);
+  const bucketMs = targetMinutes * 6e4;
+  const buckets = /* @__PURE__ */ new Map();
+  for (const raw of candles) {
+    const candle = toMlCandle(raw);
+    const ts = candle.timestamp;
+    if (!Number.isFinite(ts) || ts <= 0) continue;
+    const bucket = Math.floor(ts / bucketMs) * bucketMs;
+    const current = buckets.get(bucket);
+    if (!current) {
+      buckets.set(bucket, { ...candle, timestamp: bucket });
+      continue;
+    }
+    current.high = Math.max(current.high, candle.high);
+    current.low = Math.min(current.low, candle.low);
+    current.close = candle.close;
+    current.volume += candle.volume;
+    current.turnover += candle.turnover;
+  }
+  return [...buckets.entries()].sort((a, b) => a[0] - b[0]).map(([, candle]) => candle);
+};
+var buildMlCandleIndicators = (candles, btcCandles) => ({
+  candles15m: candles.slice(-CANDLE_WINDOW).map(toMlCandle),
+  candles1h: resampleCandles(candles, 60).slice(-CANDLE_WINDOW),
+  candles4h: resampleCandles(candles, 240).slice(-CANDLE_WINDOW),
+  candles1d: resampleCandles(candles, 1440).slice(-CANDLE_WINDOW),
+  btcCandles15m: btcCandles.slice(-CANDLE_WINDOW).map(toMlCandle),
+  btcCandles1h: resampleCandles(btcCandles, 60).slice(-CANDLE_WINDOW),
+  btcCandles4h: resampleCandles(btcCandles, 240).slice(-CANDLE_WINDOW),
+  btcCandles1d: resampleCandles(btcCandles, 1440).slice(-CANDLE_WINDOW)
+});
+var percentChange = (current, previous) => {
+  if (!Number.isFinite(current) || !Number.isFinite(previous) || previous === 0) {
+    return null;
+  }
+  return (current - previous) / previous * 100;
+};
+var applyIndicatorsToHistory = (indicators, pushIndicator) => {
+  pushIndicator("maFast", indicators.maFast);
+  pushIndicator("maMedium", indicators.maMedium);
+  pushIndicator("maSlow", indicators.maSlow);
+  pushIndicator("atr", indicators.atr);
+  pushIndicator("atrPct", indicators.atrPct);
+  pushIndicator("bbUpper", indicators.bbUpper);
+  pushIndicator("bbMiddle", indicators.bbMiddle);
+  pushIndicator("bbLower", indicators.bbLower);
+  pushIndicator("obv", indicators.obv);
+  pushIndicator("smaObv", indicators.smaObv);
+  pushIndicator("macd", indicators.macd);
+  pushIndicator("macdSignal", indicators.macdSignal);
+  pushIndicator("macdHistogram", indicators.macdHistogram);
+  pushIndicator("price24hPcnt", indicators.price24hPcnt ?? void 0);
+  pushIndicator("price1hPcnt", indicators.price1hPcnt ?? void 0);
+  pushIndicator("highPrice1h", indicators.highPrice1h ?? void 0);
+  pushIndicator("lowPrice1h", indicators.lowPrice1h ?? void 0);
+  pushIndicator("volume1h", indicators.volume1h ?? void 0);
+  pushIndicator("highPrice24h", indicators.highPrice24h ?? void 0);
+  pushIndicator("lowPrice24h", indicators.lowPrice24h ?? void 0);
+  pushIndicator("volume24h", indicators.volume24h ?? void 0);
+  pushIndicator("highLevel", indicators.highLevel ?? void 0);
+  pushIndicator("lowLevel", indicators.lowLevel ?? void 0);
+  pushIndicator("prevClose", indicators.prevClose ?? void 0);
+  pushIndicator("correlation", indicators.correlation ?? void 0);
+  pushIndicator("spread", indicators.spread ?? void 0);
+};
+var createIndicators = (data, btcData = [], options = {}) => {
+  const indicatorPluginEntries = getRegisteredIndicatorEntries();
+  const includeMlPayload = options.includeMlPayload !== false;
+  const indicatorPeriods = {
+    ...DEFAULT_INDICATOR_PERIODS,
+    ...options.periods || {}
+  };
+  const closes = [];
+  const highs = [];
+  const lows = [];
+  const volumes = [];
+  const timestamps = [];
+  const candlesHistory = [];
+  const btcCandlesHistory = [];
+  const btcBinanceCandles = (options.btcBinanceData ?? []).map(toMlCandle);
+  const btcCoinbaseCandles = (options.btcCoinbaseData ?? []).map(toMlCandle);
+  const spreadSmoother = createSpreadSmoother();
+  let btcBinanceCursor = 0;
+  let btcCoinbaseCursor = 0;
+  const obv = new OBV({ close: [], volume: [] });
+  const smaObv = new SMA({ period: indicatorPeriods.obvSma, values: [] });
+  const ma14 = new SMA({ period: indicatorPeriods.maFast, values: [] });
+  const ma49 = new SMA({ period: indicatorPeriods.maMedium, values: [] });
+  const ma50 = new SMA({ period: indicatorPeriods.maSlow, values: [] });
+  const atr = new ATR({
+    period: indicatorPeriods.atr,
+    high: [],
+    low: [],
+    close: []
+  });
+  const atrPctShort = new SMA({
+    period: indicatorPeriods.atrPctShort,
+    values: []
+  });
+  const atrPctLong = new SMA({
+    period: indicatorPeriods.atrPctLong,
+    values: []
+  });
+  const bb = new BollingerBands({
+    period: indicatorPeriods.bb,
+    values: [],
+    stdDev: indicatorPeriods.bbStd
+  });
+  const macd = new MACD({
+    fastPeriod: indicatorPeriods.macdFast,
+    slowPeriod: indicatorPeriods.macdSlow,
+    signalPeriod: indicatorPeriods.macdSignal,
+    values: [],
+    SimpleMAOscillator: false,
+    SimpleMASignal: false
+  });
+  const indicatorHistory = {};
+  const indicatorPluginErrorShown = /* @__PURE__ */ new Set();
+  const pushIndicator = (key, value) => {
+    if (value == null) {
+      return;
+    }
+    if (!indicatorHistory[key]) {
+      indicatorHistory[key] = [];
+    }
+    indicatorHistory[key].push(value);
+    if (indicatorHistory[key].length > ML_BASE_CANDLES_WINDOW) {
+      indicatorHistory[key].splice(
+        0,
+        indicatorHistory[key].length - ML_BASE_CANDLES_WINDOW
+      );
+    }
+  };
+  const resolveCloseAtOrBefore = (candles, cursor, targetTs) => {
+    let idx = cursor;
+    while (idx + 1 < candles.length && candles[idx + 1].timestamp <= targetTs) {
+      idx += 1;
+    }
+    const close = idx < candles.length && candles[idx].timestamp <= targetTs ? candles[idx].close : null;
+    return { close, cursor: idx };
+  };
+  let window1hStart = 0;
+  let window24hStart = 0;
+  const computeWindow = (currentTimestamp, windowMs, startIdx) => {
+    const windowStart = currentTimestamp - windowMs;
+    if (timestamps.length === 0 || timestamps[0] > windowStart) {
+      return {
+        startIdx,
+        high: null,
+        low: null,
+        volume: null,
+        startClose: null,
+        hasFullWindow: false
+      };
+    }
+    let idx = startIdx;
+    while (idx < timestamps.length && timestamps[idx] < windowStart) {
+      idx += 1;
+    }
+    let high = -Infinity;
+    let low = Infinity;
+    let volume = 0;
+    for (let i = idx; i < highs.length; i += 1) {
+      const highValue = highs[i];
+      const lowValue = lows[i];
+      const volumeValue = volumes[i];
+      if (highValue > high) high = highValue;
+      if (lowValue < low) low = lowValue;
+      volume += volumeValue;
+    }
+    return {
+      startIdx: idx,
+      high,
+      low,
+      volume,
+      startClose: closes[idx],
+      hasFullWindow: true
+    };
+  };
+  const findNearestStartClose = (currentTimestamp, windowMs) => {
+    if (timestamps.length === 0) {
+      return { startClose: null, startIdx: 0 };
+    }
+    const windowStart = currentTimestamp - windowMs;
+    let idx = 0;
+    while (idx < timestamps.length && timestamps[idx] < windowStart) {
+      idx += 1;
+    }
+    if (idx <= 0) {
+      return { startClose: closes[0], startIdx: 0 };
+    }
+    if (idx >= timestamps.length) {
+      const lastIdx = timestamps.length - 1;
+      return { startClose: closes[lastIdx], startIdx: lastIdx };
+    }
+    const prevIdx = idx - 1;
+    const currentIdx = timestamps.length - 1;
+    if (idx === currentIdx && timestamps[idx] > windowStart) {
+      return { startClose: closes[prevIdx], startIdx: prevIdx };
+    }
+    const prevDiff = windowStart - timestamps[prevIdx];
+    const nextDiff = timestamps[idx] - windowStart;
+    const chosenIdx = prevDiff <= nextDiff ? prevIdx : idx;
+    return { startClose: closes[chosenIdx], startIdx: chosenIdx };
+  };
+  const next = (candle, btcCandle) => {
+    candlesHistory.push(candle);
+    if (btcCandle) {
+      btcCandlesHistory.push(btcCandle);
+    }
+    closes.push(candle.close);
+    highs.push(candle.high);
+    lows.push(candle.low);
+    volumes.push(candle.volume);
+    timestamps.push(candle.timestamp);
+    const ma14Value = ma14.nextValue(candle.close);
+    const ma49Value = ma49.nextValue(candle.close);
+    const ma50Value = ma50.nextValue(candle.close);
+    const atrValue = atr.nextValue(candle);
+    const atrPctValue = atrValue != null && Number.isFinite(atrValue) && candle.close ? atrValue / candle.close * 100 : null;
+    const atrPctShortValue = atrPctValue == null ? null : atrPctShort.nextValue(atrPctValue);
+    const atrPctLongValue = atrPctValue == null ? null : atrPctLong.nextValue(atrPctValue);
+    const atrPctRatio = typeof atrPctShortValue === "number" && Number.isFinite(atrPctShortValue) && typeof atrPctLongValue === "number" && Number.isFinite(atrPctLongValue) && atrPctLongValue !== 0 ? atrPctShortValue / atrPctLongValue : null;
+    const bbValue = bb.nextValue(candle.close);
+    const obvValue = obv.nextValue(candle);
+    const smaObvValue = obvValue == null ? null : smaObv.nextValue(obvValue);
+    const macdValue = macd.nextValue(candle.close);
+    const currentTimestamp = candle.timestamp;
+    const len = candlesHistory.length;
+    const prevCandle = len > 1 ? candlesHistory[len - 2] : null;
+    const correlation = btcCandlesHistory.length > 0 ? calculateCoinBtcCorrelation(
+      candlesHistory.slice(-CORRELATION_WINDOW),
+      btcCandlesHistory.slice(-CORRELATION_WINDOW)
+    ).correlation ?? 0 : 0;
+    let spread = null;
+    if (btcBinanceCandles.length > 0 && btcCoinbaseCandles.length > 0) {
+      const binanceResolved = resolveCloseAtOrBefore(
+        btcBinanceCandles,
+        btcBinanceCursor,
+        currentTimestamp
+      );
+      const coinbaseResolved = resolveCloseAtOrBefore(
+        btcCoinbaseCandles,
+        btcCoinbaseCursor,
+        currentTimestamp
+      );
+      btcBinanceCursor = binanceResolved.cursor;
+      btcCoinbaseCursor = coinbaseResolved.cursor;
+      if (binanceResolved.close != null && coinbaseResolved.close != null && Number.isFinite(binanceResolved.close) && Number.isFinite(coinbaseResolved.close) && binanceResolved.close > 0) {
+        spread = spreadSmoother.next({
+          binancePrice: binanceResolved.close,
+          coinbasePrice: coinbaseResolved.close
+        });
+      }
+    }
+    const computePluginSeries = (baseResult2) => {
+      const pluginSeries2 = {};
+      for (const pluginEntry of indicatorPluginEntries) {
+        if (!pluginEntry.compute) continue;
+        const historyKey = pluginEntry.historyKey || pluginEntry.indicator.id;
+        try {
+          const pluginValue = pluginEntry.compute({
+            candle,
+            btcCandle,
+            data: candlesHistory,
+            btcData: btcCandlesHistory,
+            baseResult: baseResult2
+          });
+          if (pluginValue == null || typeof pluginValue !== "number" || !Number.isFinite(pluginValue)) {
+            continue;
+          }
+          pluginSeries2[historyKey] = pluginValue;
+          pushIndicator(historyKey, pluginValue);
+        } catch (error) {
+          if (indicatorPluginErrorShown.has(historyKey)) {
+            continue;
+          }
+          indicatorPluginErrorShown.add(historyKey);
+          console.warn(
+            `Indicator plugin "${historyKey}" compute failed: ${String(error)}`
+          );
+        }
+      }
+      return pluginSeries2;
+    };
+    if (ma14Value == null || ma49Value == null || ma50Value == null || atrValue == null || !bbValue || obvValue == null || smaObvValue == null || !macdValue) {
+      computePluginSeries({
+        prevCandle,
+        correlation,
+        spread,
+        candle
+      });
+      return null;
+    }
+    const window1h = computeWindow(
+      currentTimestamp,
+      ONE_HOUR_MS,
+      window1hStart
+    );
+    window1hStart = window1h.startIdx;
+    const window24h = computeWindow(
+      currentTimestamp,
+      ONE_DAY_MS,
+      window24hStart
+    );
+    window24hStart = window24h.startIdx;
+    const price1hStart = findNearestStartClose(currentTimestamp, ONE_HOUR_MS);
+    const price24hStart = findNearestStartClose(currentTimestamp, ONE_DAY_MS);
+    const price1hPcntRaw = price1hStart.startClose != null ? percentChange(candle.close, price1hStart.startClose) : null;
+    const price24hPcntRaw = price24hStart.startClose != null ? percentChange(candle.close, price24hStart.startClose) : null;
+    const price1hPcnt = price1hPcntRaw ?? 0;
+    const price24hPcnt = price24hPcntRaw ?? 0;
+    const highPrice1h = window1h.hasFullWindow ? window1h.high : null;
+    const lowPrice1h = window1h.hasFullWindow ? window1h.low : null;
+    const volume1h = window1h.hasFullWindow ? window1h.volume : null;
+    const highPrice24h = window24h.hasFullWindow ? window24h.high : null;
+    const lowPrice24h = window24h.hasFullWindow ? window24h.low : null;
+    const volume24h = window24h.hasFullWindow ? window24h.volume : null;
+    let highLevel = null;
+    let lowLevel = null;
+    if (len >= indicatorPeriods.levelLookback + indicatorPeriods.levelDelay) {
+      const window = candlesHistory.slice(
+        len - indicatorPeriods.levelLookback - indicatorPeriods.levelDelay,
+        len - indicatorPeriods.levelDelay
+      );
+      highLevel = Math.max(...window.map((item) => item.high));
+      lowLevel = Math.min(...window.map((item) => item.low));
+    }
+    const baseResult = {
+      maFast: ma14Value,
+      maMedium: ma49Value,
+      maSlow: ma50Value,
+      atr: atrValue,
+      atrPct: atrPctRatio,
+      bbUpper: bbValue.upper,
+      bbMiddle: bbValue.middle,
+      bbLower: bbValue.lower,
+      obv: obvValue,
+      smaObv: smaObvValue,
+      macd: macdValue.MACD,
+      macdSignal: macdValue.signal,
+      macdHistogram: macdValue.histogram,
+      price24hPcnt,
+      price1hPcnt,
+      highPrice1h,
+      lowPrice1h,
+      volume1h,
+      highPrice24h,
+      lowPrice24h,
+      volume24h,
+      highLevel,
+      lowLevel,
+      prevClose: prevCandle?.close ?? null,
+      correlation,
+      spread
+    };
+    applyIndicatorsToHistory(baseResult, pushIndicator);
+    const pluginSeries = computePluginSeries({
+      ...baseResult,
+      candle,
+      prevCandle,
+      correlation
+    });
+    const result = {
+      ...baseResult,
+      ...pluginSeries,
+      candle,
+      prevCandle,
+      highLevel,
+      lowLevel,
+      correlation
+    };
+    return result;
+  };
+  data.forEach((candle, index) => {
+    next(candle, btcData[index]);
+  });
+  return {
+    next,
+    result: () => {
+      const baseHistory = cloneArrayValues(indicatorHistory);
+      if (!includeMlPayload) {
+        return baseHistory;
+      }
+      const fullHistory = {
+        ...baseHistory,
+        ...buildMlTimeframeIndicators(candlesHistory, indicatorPeriods),
+        ...buildMlCandleIndicators(candlesHistory, btcCandlesHistory),
+        ...buildIndicatorSeriesByTimeframes(
+          btcCandlesHistory,
+          indicatorPeriods,
+          "btc"
+        )
+      };
+      return fullHistory;
+    }
+  };
+};
+var buildMlTimeframeIndicators = (candles, periods = {}) => {
+  const result = {};
+  const indicatorPeriods = {
+    ...DEFAULT_INDICATOR_PERIODS,
+    ...periods
+  };
+  for (const timeframe of INDICATOR_TIMEFRAMES) {
+    const tfCandles = resampleCandles(candles, timeframe.minutes);
+    if (tfCandles.length === 0) continue;
+    const history = createIndicators(tfCandles, [], {
+      includeMlPayload: false,
+      periods: indicatorPeriods
+    }).result();
+    for (const [key, values] of Object.entries(history)) {
+      result[`${key}${timeframe.suffix}`] = values;
+    }
+  }
+  return cloneArrayValues(result);
+};
+var withSourcePrefix = (key, sourcePrefix = "") => {
+  if (!sourcePrefix) return key;
+  return `${sourcePrefix}${key[0].toUpperCase()}${key.slice(1)}`;
+};
+var buildIndicatorSeriesByTimeframes = (candles, periods, sourcePrefix = "") => {
+  const result = {};
+  if (candles.length === 0) return result;
+  const baseHistory = createIndicators(candles, [], {
+    includeMlPayload: false,
+    periods
+  }).result();
+  for (const [key, values] of Object.entries(baseHistory)) {
+    result[withSourcePrefix(key, sourcePrefix)] = values;
+  }
+  const timeframeHistory = buildMlTimeframeIndicators(candles, periods);
+  for (const [key, values] of Object.entries(timeframeHistory)) {
+    result[withSourcePrefix(key, sourcePrefix)] = values;
+  }
+  return cloneArrayValues(result);
+};
+
+// src/utils/supportResistance.ts
+var MERGE_THRESHOLD_PCT = 0.01;
+var detectRawSupportResistance = (data, lookAround = 2) => {
+  const supports = [];
+  const resistances = [];
+  for (let i = lookAround; i < data.length - lookAround; i++) {
+    const cur = data[i];
+    const curLow = cur.low;
+    const curHigh = cur.high;
+    let isSupport = true;
+    let isResistance = true;
+    for (let j = i - lookAround; j <= i + lookAround; j++) {
+      if (j === i) continue;
+      if (data[j].low < curLow) isSupport = false;
+      if (data[j].high > curHigh) isResistance = false;
+    }
+    if (isSupport) supports.push(curLow);
+    if (isResistance) resistances.push(curHigh);
+  }
+  return { supports, resistances };
+};
+var mergeCloseLevels = (levels) => {
+  if (!levels.length) return [];
+  const sorted = [...levels].sort((a, b) => a - b);
+  const merged = [];
+  let bucket = [sorted[0]];
+  for (let i = 1; i < sorted.length; i++) {
+    const prev = bucket[bucket.length - 1];
+    const cur = sorted[i];
+    const diffPct = Math.abs(cur - prev) / prev;
+    if (diffPct <= MERGE_THRESHOLD_PCT) {
+      bucket.push(cur);
+    } else {
+      merged.push(bucket);
+      bucket = [cur];
+    }
+  }
+  merged.push(bucket);
+  const averaged = merged.map((group) => {
+    const sum = group.reduce((acc, v) => acc + v, 0);
+    return sum / group.length;
+  });
+  return averaged;
+};
+var getSupportResistanceLevels = (data) => {
+  if (!data || data.length === 0) {
+    return { supportLevels: [], resistanceLevels: [] };
+  }
+  const { supports, resistances } = detectRawSupportResistance(data, 2);
+  const uniqSupports = mergeCloseLevels(supports);
+  const uniqResistances = mergeCloseLevels(resistances);
+  const supportLevels = uniqSupports.slice(0, 5).map((price, idx) => ({
+    id: `support-${idx}`,
+    price
+  }));
+  const resistanceLevels = uniqResistances.slice(0, 5).map((price, idx) => ({
+    id: `resistance-${idx}`,
+    price
+  }));
+  return { supportLevels, resistanceLevels };
+};
+
+// src/utils/trendLine/engine.ts
+var DEFAULTS = TRENDLINE_DEFAULTS;
+var toleranceAt = (lineY, epsilonPct) => Math.max(0, Math.abs(lineY) * epsilonPct);
+var buildLineEvaluator = (params) => {
+  const { t1, y1, t2, y2 } = params;
+  const deltaTime = t2 - t1;
+  if (deltaTime === 0) return (_timeMs) => y1;
+  const slope = (y2 - y1) / deltaTime;
+  return (timeMs) => y1 + slope * (timeMs - t1);
+};
+var buildAlphaSeries = (params) => {
+  const { timestampsMs, closeSeries, evaluateY, window } = params;
+  if (!timestampsMs.length || !closeSeries.length) return [];
+  const startIndex = Math.max(0, timestampsMs.length - window);
+  const result = [];
+  for (let i = startIndex; i < timestampsMs.length; i++) {
+    const close = closeSeries[i];
+    if (!Number.isFinite(close) || close == 0) {
+      result.push(0);
+      continue;
+    }
+    const lineY = evaluateY(timestampsMs[i]);
+    result.push(lineY / close);
+  }
+  return result;
+};
+var hasTooLargeTouchGaps = (touchIndices, maxTouchGap) => {
+  if (!Number.isFinite(maxTouchGap) || maxTouchGap <= 0) return false;
+  if (touchIndices.length < 2) return true;
+  for (let index = 1; index < touchIndices.length; index++) {
+    if (touchIndices[index] - touchIndices[index - 1] > maxTouchGap)
+      return true;
+  }
+  return false;
+};
+var collectTouchIndices = (params) => {
+  const {
+    bodySeriesForTouches,
+    timestampsMs,
+    startIndex,
+    endIndex,
+    evaluateY,
+    epsilon,
+    minTouchGap
+  } = params;
+  const touchIndices = [];
+  let lastTouchIndex = -Infinity;
+  for (let barIndex = startIndex; barIndex <= endIndex; barIndex++) {
+    const lineY = evaluateY(timestampsMs[barIndex]);
+    const tolerance = toleranceAt(lineY, epsilon);
+    const bodyValue = bodySeriesForTouches[barIndex];
+    if (Math.abs(bodyValue - lineY) <= tolerance) {
+      if (touchIndices.length === 0 || barIndex - lastTouchIndex >= minTouchGap) {
+        touchIndices.push(barIndex);
+        lastTouchIndex = barIndex;
+      }
+    }
+  }
+  return touchIndices;
+};
+var hasCloseBreachInRange = (params) => {
+  const {
+    mode,
+    closeSeries,
+    timestampsMs,
+    startIndex,
+    endIndex,
+    evaluateY,
+    epsilon
+  } = params;
+  if (startIndex > endIndex) return false;
+  for (let barIndex = startIndex; barIndex <= endIndex; barIndex++) {
+    const lineY = evaluateY(timestampsMs[barIndex]);
+    const tolerance = toleranceAt(lineY, epsilon);
+    const closePrice = closeSeries[barIndex];
+    if (mode === "lows") {
+      if (closePrice < lineY - tolerance) return true;
+    } else {
+      if (closePrice > lineY + tolerance) return true;
+    }
+  }
+  return false;
+};
+var BLOCK_SIZE = 64;
+var getBlockIndex = (barIndex) => Math.floor(barIndex / BLOCK_SIZE);
+var ensureBlockValue = (arr, blockIndex, initial) => {
+  while (arr.length <= blockIndex) arr.push(initial);
+};
+var updateBlockStats = (stats, barIndex, lowValue, highValue) => {
+  const blockIndex = getBlockIndex(barIndex);
+  ensureBlockValue(stats.lowBlockMins, blockIndex, Number.POSITIVE_INFINITY);
+  ensureBlockValue(stats.highBlockMaxs, blockIndex, Number.NEGATIVE_INFINITY);
+  stats.lowBlockMins[blockIndex] = Math.min(
+    stats.lowBlockMins[blockIndex],
+    lowValue
+  );
+  stats.highBlockMaxs[blockIndex] = Math.max(
+    stats.highBlockMaxs[blockIndex],
+    highValue
+  );
+};
+var hasWickBreachOnSegmentFast = (params) => {
+  const {
+    mode,
+    lowSeries,
+    highSeries,
+    timestampsMs,
+    startIndex,
+    endIndex,
+    evaluateY,
+    epsilon,
+    blockStats
+  } = params;
+  if (startIndex > endIndex) return false;
+  const scanBarsPrecisely = (fromIndex, toIndex) => {
+    for (let barIndex = fromIndex; barIndex <= toIndex; barIndex++) {
+      const lineY = evaluateY(timestampsMs[barIndex]);
+      const tolerance = toleranceAt(lineY, epsilon);
+      if (mode === "lows") {
+        if (lowSeries[barIndex] < lineY - tolerance) return true;
+      } else {
+        if (highSeries[barIndex] > lineY + tolerance) return true;
+      }
+    }
+    return false;
+  };
+  const startBlockIndex = getBlockIndex(startIndex);
+  const endBlockIndex = getBlockIndex(endIndex);
+  if (startBlockIndex === endBlockIndex)
+    return scanBarsPrecisely(startIndex, endIndex);
+  const firstBlockEndIndex = (startBlockIndex + 1) * BLOCK_SIZE - 1;
+  if (scanBarsPrecisely(startIndex, Math.min(firstBlockEndIndex, endIndex)))
+    return true;
+  const lastBlockStartIndex = endBlockIndex * BLOCK_SIZE;
+  if (scanBarsPrecisely(Math.max(lastBlockStartIndex, startIndex), endIndex))
+    return true;
+  for (let blockIndex = startBlockIndex + 1; blockIndex <= endBlockIndex - 1; blockIndex++) {
+    const blockStartIndex = blockIndex * BLOCK_SIZE;
+    const blockEndIndex = blockStartIndex + BLOCK_SIZE - 1;
+    const startTimestamp = timestampsMs[blockStartIndex];
+    const endTimestamp = timestampsMs[blockEndIndex];
+    const startLineY = evaluateY(startTimestamp);
+    const endLineY = evaluateY(endTimestamp);
+    if (mode === "lows") {
+      const startThreshold = startLineY - toleranceAt(startLineY, epsilon);
+      const endThreshold = endLineY - toleranceAt(endLineY, epsilon);
+      const maxThresholdInBlock = Math.max(startThreshold, endThreshold);
+      const blockLowMin = blockStats.lowBlockMins[blockIndex];
+      if (blockLowMin >= maxThresholdInBlock) continue;
+      if (scanBarsPrecisely(blockStartIndex, blockEndIndex)) return true;
+    } else {
+      const startThreshold = startLineY + toleranceAt(startLineY, epsilon);
+      const endThreshold = endLineY + toleranceAt(endLineY, epsilon);
+      const minThresholdInBlock = Math.min(startThreshold, endThreshold);
+      const blockHighMax = blockStats.highBlockMaxs[blockIndex];
+      if (blockHighMax <= minThresholdInBlock) continue;
+      if (scanBarsPrecisely(blockStartIndex, blockEndIndex)) return true;
+    }
+  }
+  return false;
+};
+var createTrendlineEngine = (initialCandles, options) => {
+  const opts = {
+    mode: options.mode,
+    maxLines: options.maxLines ?? DEFAULTS.maxLines,
+    range: options.range ?? DEFAULTS.range,
+    firstRange: options.firstRange ?? DEFAULTS.firstRange,
+    epsilon: options.epsilon ?? DEFAULTS.epsilon,
+    epsilonOffset: options.epsilonOffset ?? DEFAULTS.epsilonOffset,
+    minTouches: options.minTouches ?? DEFAULTS.minTouches,
+    minDistance: options.minDistance ?? DEFAULTS.minDistance,
+    minTouchGap: options.minTouchGap ?? DEFAULTS.minTouchGap,
+    maxTouchGap: options.maxTouchGap ?? DEFAULTS.maxTouchGap,
+    offset: options.offset ?? DEFAULTS.offset,
+    capture: options.capture ?? DEFAULTS.capture,
+    bestLines: options.bestLines ?? DEFAULTS.bestLines,
+    maxDistance: options.maxDistance ?? DEFAULTS.maxDistance
+  };
+  let timestampsMs = [];
+  let closeSeries = [];
+  let lowSeries = [];
+  let highSeries = [];
+  let shadowSeries = [];
+  const firstRangeWindowSize = 2 * opts.firstRange + 1;
+  let lowFirstDeque = [];
+  let highFirstDeque = [];
+  let lowFirstCenter = [];
+  let highFirstCenter = [];
+  const blockStats = { lowBlockMins: [], highBlockMaxs: [] };
+  let extremaDeque = [];
+  let rawExtremaPoints = [];
+  let clusteredAnchors = [];
+  let currentClusterBest = null;
+  let lastRawExtremum = null;
+  let activeLines = [];
+  let pairCache = /* @__PURE__ */ new Map();
+  const MAX_PAIR_CACHE = 5e3;
+  const resetState = () => {
+    timestampsMs = [];
+    closeSeries = [];
+    lowSeries = [];
+    highSeries = [];
+    shadowSeries = [];
+    blockStats.lowBlockMins = [];
+    blockStats.highBlockMaxs = [];
+    extremaDeque = [];
+    rawExtremaPoints = [];
+    lowFirstDeque = [];
+    highFirstDeque = [];
+    lowFirstCenter = [];
+    highFirstCenter = [];
+    clusteredAnchors = [];
+    currentClusterBest = null;
+    lastRawExtremum = null;
+    activeLines = [];
+    pairCache.clear();
+  };
+  const updateExtremaDeque = (barIndex) => {
+    const windowSize = 2 * opts.range + 1;
+    const findMin = opts.mode === "lows";
+    const isBetter = findMin ? (leftValue, rightValue) => leftValue <= rightValue : (leftValue, rightValue) => leftValue >= rightValue;
+    while (extremaDeque.length > 0 && !isBetter(
+      shadowSeries[extremaDeque[extremaDeque.length - 1]],
+      shadowSeries[barIndex]
+    )) {
+      extremaDeque.pop();
+    }
+    extremaDeque.push(barIndex);
+    const startIndex = barIndex - windowSize + 1;
+    while (extremaDeque.length > 0 && extremaDeque[0] < startIndex) {
+      extremaDeque.shift();
+    }
+  };
+  const isStrongFirstAnchorFast = (anchorIndex) => {
+    const lastBarIndex = lowSeries.length - 1;
+    const startIndex = Math.max(0, anchorIndex - opts.firstRange);
+    const endIndex = Math.min(lastBarIndex, anchorIndex + opts.firstRange);
+    const canUseCenter = anchorIndex - opts.firstRange >= 0 && anchorIndex + opts.firstRange <= lastBarIndex;
+    if (opts.mode === "lows") {
+      if (canUseCenter && Number.isFinite(lowFirstCenter[anchorIndex])) {
+        return lowSeries[anchorIndex] === lowFirstCenter[anchorIndex];
+      }
+      let windowMin = Number.POSITIVE_INFINITY;
+      for (let i = startIndex; i <= endIndex; i++) {
+        if (lowSeries[i] < windowMin) windowMin = lowSeries[i];
+      }
+      return lowSeries[anchorIndex] === windowMin;
+    }
+    if (canUseCenter && Number.isFinite(highFirstCenter[anchorIndex])) {
+      return highSeries[anchorIndex] === highFirstCenter[anchorIndex];
+    }
+    let windowMax = Number.NEGATIVE_INFINITY;
+    for (let i = startIndex; i <= endIndex; i++) {
+      if (highSeries[i] > windowMax) windowMax = highSeries[i];
+    }
+    return highSeries[anchorIndex] === windowMax;
+  };
+  const updateFirstRangeExtrema = (barIndex) => {
+    if (firstRangeWindowSize <= 1) return;
+    while (lowFirstDeque.length > 0 && lowSeries[lowFirstDeque[lowFirstDeque.length - 1]] >= lowSeries[barIndex]) {
+      lowFirstDeque.pop();
+    }
+    lowFirstDeque.push(barIndex);
+    while (highFirstDeque.length > 0 && highSeries[highFirstDeque[highFirstDeque.length - 1]] <= highSeries[barIndex]) {
+      highFirstDeque.pop();
+    }
+    highFirstDeque.push(barIndex);
+    const startIndex = barIndex - firstRangeWindowSize + 1;
+    while (lowFirstDeque.length > 0 && lowFirstDeque[0] < startIndex) {
+      lowFirstDeque.shift();
+    }
+    while (highFirstDeque.length > 0 && highFirstDeque[0] < startIndex) {
+      highFirstDeque.shift();
+    }
+    if (startIndex >= 0) {
+      const centerIndex = barIndex - opts.firstRange;
+      lowFirstCenter[centerIndex] = lowSeries[lowFirstDeque[0]];
+      highFirstCenter[centerIndex] = highSeries[highFirstDeque[0]];
+    }
+  };
+  const getPairCache = (leftAnchor, rightAnchor) => {
+    const key = `${leftAnchor.x}|${rightAnchor.x}`;
+    const cached = pairCache.get(key);
+    if (cached) return cached;
+    const evaluateY = buildLineEvaluator({
+      t1: leftAnchor.t,
+      y1: leftAnchor.y,
+      t2: rightAnchor.t,
+      y2: rightAnchor.y
+    });
+    const touchIndices = collectTouchIndices({
+      bodySeriesForTouches: shadowSeries,
+      timestampsMs,
+      startIndex: leftAnchor.x,
+      endIndex: rightAnchor.x,
+      evaluateY,
+      epsilon: opts.epsilon,
+      minTouchGap: opts.minTouchGap
+    });
+    const touchCount = touchIndices.length;
+    const touchSpan = touchCount > 1 ? touchIndices[touchCount - 1] - touchIndices[0] : 0;
+    const lastTouches = touchCount > 2 ? touchIndices.slice(-2) : touchIndices;
+    const hasTouchGap = hasTooLargeTouchGaps(
+      [...lastTouches, rightAnchor.x],
+      opts.maxTouchGap
+    );
+    const wickBreached = hasWickBreachOnSegmentFast({
+      mode: opts.mode,
+      lowSeries,
+      highSeries,
+      timestampsMs,
+      startIndex: leftAnchor.x,
+      endIndex: rightAnchor.x,
+      evaluateY,
+      epsilon: opts.epsilon,
+      blockStats
+    });
+    const entry = {
+      distance: rightAnchor.x - leftAnchor.x,
+      evaluateY,
+      touchIndices,
+      touchCount,
+      touchSpan,
+      hasTouchGap,
+      wickBreached
+    };
+    if (pairCache.size > MAX_PAIR_CACHE) {
+      pairCache.clear();
+    }
+    pairCache.set(key, entry);
+    return entry;
+  };
+  const rebuildCandidatesLikeBatch = () => {
+    const anchors = currentClusterBest != null ? [...clusteredAnchors, currentClusterBest] : clusteredAnchors;
+    const anchorsLength = anchors.length;
+    const lastBarIndex = timestampsMs.length - 1;
+    if (lastBarIndex < 0) {
+      activeLines = [];
+      return;
+    }
+    if (rawExtremaPoints.length < opts.minTouches || anchorsLength < opts.minTouches) {
+      activeLines = [];
+      return;
+    }
+    const candidates = [];
+    const anchorXs = anchors.map((pt) => pt.x);
+    const lowerBound = (arr, value) => {
+      let left = 0;
+      let right = arr.length;
+      while (left < right) {
+        const mid = left + right >> 1;
+        if (arr[mid] < value) left = mid + 1;
+        else right = mid;
+      }
+      return left;
+    };
+    const upperBound = (arr, value) => {
+      let left = 0;
+      let right = arr.length;
+      while (left < right) {
+        const mid = left + right >> 1;
+        if (arr[mid] <= value) left = mid + 1;
+        else right = mid;
+      }
+      return left - 1;
+    };
+    for (let rightAnchorIndex = anchorsLength - 1; rightAnchorIndex >= 0; rightAnchorIndex--) {
+      const rightAnchor = anchors[rightAnchorIndex];
+      const rightX = rightAnchor.x;
+      const leftMinX = rightX - opts.maxDistance;
+      const leftMaxX = rightX - opts.minDistance;
+      let leftStart = lowerBound(anchorXs, leftMinX);
+      let leftEnd = upperBound(anchorXs, leftMaxX);
+      if (leftEnd >= rightAnchorIndex) leftEnd = rightAnchorIndex - 1;
+      if (leftStart > leftEnd) continue;
+      for (let leftAnchorIndex = leftEnd; leftAnchorIndex >= leftStart; leftAnchorIndex--) {
+        if (candidates.length >= opts.maxLines) break;
+        const leftAnchor = anchors[leftAnchorIndex];
+        const distance = rightAnchor.x - leftAnchor.x;
+        if (distance < opts.minDistance) continue;
+        if (distance > opts.maxDistance) break;
+        if (!isStrongFirstAnchorFast(leftAnchor.x)) continue;
+        const slope = (rightAnchor.y - leftAnchor.y) / (rightAnchor.x - leftAnchor.x);
+        if (opts.mode === "lows" && slope <= 0) continue;
+        if (opts.mode === "highs" && slope >= 0) continue;
+        const cached = getPairCache(leftAnchor, rightAnchor);
+        if (cached.touchCount < opts.minTouches) continue;
+        if (cached.hasTouchGap) continue;
+        if (cached.touchSpan < opts.minDistance) continue;
+        if (cached.wickBreached) continue;
+        const closeBreachEndIndex = lastBarIndex - Math.max(0, opts.offset);
+        const closeBreachStartIndex = rightAnchor.x + 1;
+        if (closeBreachStartIndex <= closeBreachEndIndex) {
+          const closeBreached = hasCloseBreachInRange({
+            mode: opts.mode,
+            closeSeries,
+            timestampsMs,
+            startIndex: closeBreachStartIndex,
+            endIndex: closeBreachEndIndex,
+            evaluateY: cached.evaluateY,
+            epsilon: opts.epsilon
+          });
+          if (closeBreached) continue;
+        }
+        const captureHitIndices = [];
+        if (opts.capture) {
+          const captureStartIndex = Math.max(
+            rightAnchor.x + 1,
+            lastBarIndex - opts.offset + 1
+          );
+          const captureEndIndex = lastBarIndex;
+          for (let barIndex = captureStartIndex; barIndex <= captureEndIndex; barIndex++) {
+            const lineY = cached.evaluateY(timestampsMs[barIndex]);
+            const offsetTolerance = toleranceAt(lineY, opts.epsilonOffset);
+            const hit = opts.mode === "lows" ? lowSeries[barIndex] <= lineY - offsetTolerance : highSeries[barIndex] >= lineY + offsetTolerance;
+            if (hit) captureHitIndices.push(barIndex);
+          }
+        }
+        const runtime = {
+          leftAnchor,
+          rightAnchor,
+          distance: cached.distance,
+          evaluateY: cached.evaluateY,
+          touchIndices: cached.touchIndices,
+          captureHitIndices,
+          invalid: false
+        };
+        candidates.push(runtime);
+      }
+      if (candidates.length >= opts.maxLines) break;
+    }
+    activeLines = candidates;
+  };
+  const maybeFinalizeClusterAndRebuild = (rawPoint) => {
+    if (!currentClusterBest) {
+      currentClusterBest = rawPoint;
+      lastRawExtremum = rawPoint;
+      rebuildCandidatesLikeBatch();
+      return;
+    }
+    if (rawPoint.x - lastRawExtremum.x < opts.minDistance) {
+      const better = opts.mode === "lows" ? rawPoint.y < currentClusterBest.y : rawPoint.y > currentClusterBest.y;
+      if (better) {
+        currentClusterBest = rawPoint;
+        rebuildCandidatesLikeBatch();
+      }
+      lastRawExtremum = rawPoint;
+      return;
+    }
+    clusteredAnchors.push(currentClusterBest);
+    currentClusterBest = rawPoint;
+    lastRawExtremum = rawPoint;
+    rebuildCandidatesLikeBatch();
+  };
+  const maybeAddRawExtremum = (endIndex) => {
+    const range = opts.range;
+    if (endIndex < 2 * range) return;
+    const centerIndex = endIndex - range;
+    const extremaValue = shadowSeries[extremaDeque[0]];
+    if (shadowSeries[centerIndex] !== extremaValue) return;
+    const rawPoint = {
+      x: centerIndex,
+      y: shadowSeries[centerIndex],
+      t: timestampsMs[centerIndex]
+    };
+    rawExtremaPoints.push(rawPoint);
+    maybeFinalizeClusterAndRebuild(rawPoint);
+  };
+  const updateCloseBreachDeferred = (line, lastBarIndex) => {
+    if (line.invalid) return;
+    if (opts.offset <= 0) return;
+    const checkIndex = lastBarIndex - opts.offset;
+    if (checkIndex <= line.rightAnchor.x) return;
+    if (checkIndex < 0 || checkIndex >= timestampsMs.length) return;
+    const timestamp = timestampsMs[checkIndex];
+    const lineY = line.evaluateY(timestamp);
+    const tolerance = toleranceAt(lineY, opts.epsilon);
+    const closePrice = closeSeries[checkIndex];
+    if (opts.mode === "lows") {
+      if (closePrice < lineY - tolerance) line.invalid = true;
+    } else {
+      if (closePrice > lineY + tolerance) line.invalid = true;
+    }
+  };
+  const updateCaptureSlidingWindow = (line, lastBarIndex) => {
+    if (line.invalid) return;
+    if (!opts.capture) return;
+    if (opts.offset <= 0) return;
+    const windowStartIndex = Math.max(
+      line.rightAnchor.x + 1,
+      lastBarIndex - opts.offset + 1
+    );
+    if (lastBarIndex >= windowStartIndex) {
+      const timestamp = timestampsMs[lastBarIndex];
+      const lineY = line.evaluateY(timestamp);
+      const offsetTolerance = toleranceAt(lineY, opts.epsilonOffset);
+      const hit = opts.mode === "lows" ? lowSeries[lastBarIndex] <= lineY - offsetTolerance : highSeries[lastBarIndex] >= lineY + offsetTolerance;
+      if (hit) line.captureHitIndices.push(lastBarIndex);
+    }
+    while (line.captureHitIndices.length > 0 && line.captureHitIndices[0] < windowStartIndex) {
+      line.captureHitIndices.shift();
+    }
+    if (line.captureHitIndices.length === 0) {
+      return;
+    }
+  };
+  const gcInvalidLines = () => {
+    activeLines = activeLines.filter((line) => !line.invalid);
+  };
+  const buildResult = () => {
+    if (!timestampsMs.length) return [];
+    const lastBarIndex = timestampsMs.length - 1;
+    const lastTimestamp = timestampsMs[lastBarIndex];
+    const filtered = activeLines.filter((line) => {
+      if (line.invalid) return false;
+      if (line.touchIndices.length < opts.minTouches) return false;
+      const touchSpan = line.touchIndices[line.touchIndices.length - 1] - line.touchIndices[0];
+      if (touchSpan < opts.minDistance) return false;
+      const lastTouches = line.touchIndices.length > 2 ? line.touchIndices.slice(-2) : line.touchIndices;
+      if (hasTooLargeTouchGaps(
+        [...lastTouches, line.rightAnchor.x],
+        opts.maxTouchGap
+      ))
+        return false;
+      if (opts.capture) {
+        const windowStartIndex = Math.max(
+          line.rightAnchor.x + 1,
+          lastBarIndex - opts.offset + 1
+        );
+        while (line.captureHitIndices.length > 0 && line.captureHitIndices[0] < windowStartIndex) {
+          line.captureHitIndices.shift();
+        }
+        if (line.captureHitIndices.length === 0) return false;
+      }
+      return true;
+    });
+    filtered.sort((a, b) => b.leftAnchor.x - a.leftAnchor.x);
+    const takeCount = Math.max(
+      1,
+      Math.min(opts.bestLines, opts.maxLines, filtered.length)
+    );
+    const best = filtered.slice(0, takeCount);
+    return best.map((line, index) => ({
+      id: `${opts.mode}TrendLine-${index + 1}`,
+      mode: opts.mode,
+      distance: line.distance,
+      points: [
+        {
+          timestamp: line.leftAnchor.t,
+          value: line.evaluateY(line.leftAnchor.t)
+        },
+        { timestamp: lastTimestamp, value: line.evaluateY(lastTimestamp) }
+      ],
+      touches: line.touchIndices.filter(
+        (barIndex) => barIndex !== line.leftAnchor.x && barIndex !== line.rightAnchor.x
+      ).map((barIndex) => {
+        const timestamp = timestampsMs[barIndex];
+        return { timestamp, value: line.evaluateY(timestamp) };
+      }),
+      alpha: buildAlphaSeries({
+        timestampsMs,
+        closeSeries,
+        evaluateY: line.evaluateY,
+        window: 10
+      })
+    }));
+  };
+  const appendCandle = (candle) => {
+    const barIndex = timestampsMs.length;
+    const timestampMs = toMs(candle.timestamp);
+    timestampsMs.push(timestampMs);
+    closeSeries.push(candle.close);
+    lowSeries.push(candle.low);
+    highSeries.push(candle.high);
+    const shadowValue = opts.mode === "lows" ? candle.low : candle.high;
+    shadowSeries.push(shadowValue);
+    updateBlockStats(blockStats, barIndex, candle.low, candle.high);
+    updateFirstRangeExtrema(barIndex);
+    updateExtremaDeque(barIndex);
+    maybeAddRawExtremum(barIndex);
+    let invalidatedByOffsetLogic = false;
+    for (const line of activeLines) {
+      const wasInvalid = line.invalid;
+      updateCloseBreachDeferred(line, barIndex);
+      updateCaptureSlidingWindow(line, barIndex);
+      if (!wasInvalid && line.invalid) invalidatedByOffsetLogic = true;
+    }
+    gcInvalidLines();
+    if (invalidatedByOffsetLogic) {
+      rebuildCandidatesLikeBatch();
+    }
+  };
+  const next = (candle) => {
+    appendCandle(candle);
+    let result = buildResult();
+    if (opts.capture && result.length === 0 && rawExtremaPoints.length) {
+      rebuildCandidatesLikeBatch();
+      result = buildResult();
+    }
+    return result;
+  };
+  const nextMany = (candles) => {
+    let result = [];
+    for (const candle of candles) result = next(candle);
+    return result;
+  };
+  const getLines = () => buildResult();
+  const reset = () => {
+    resetState();
+    if (initialCandles?.length) nextMany(initialCandles);
+  };
+  resetState();
+  if (initialCandles?.length) nextMany(initialCandles);
+  return { next, nextMany, reset, getLines };
+};
+
+export {
+  alignSortedCandlesByTimestamp,
+  buildReturnsFromCandles,
+  calculatePearsonCorrelation,
+  calculateCoinBtcCorrelation,
+  normalizeCoinalyzeSymbols,
+  normalizeDerivativesIntervals,
+  toCoinalyzeTimestampMs,
+  toFiniteNumber2 as toFiniteNumber,
+  toArrayData,
+  mergeCoinalyzeMetrics,
+  coinalyzePointsToRows,
+  registerIndicatorEntries,
+  getRegisteredIndicatorEntries,
+  getPluginIndicatorCatalog,
+  getPluginIndicatorRenderers,
+  resetIndicatorRegistryCache,
+  createSpreadSmoother,
+  smoothSpreadSeries,
+  intervalToMs,
+  coinbaseProductFromSymbol,
+  alignSpreadRows,
+  rollingMeanStd,
+  buildMlCandleIndicators,
+  applyIndicatorsToHistory,
+  createIndicators,
+  buildMlTimeframeIndicators,
+  detectRawSupportResistance,
+  getSupportResistanceLevels,
+  createTrendlineEngine
+};