@tradejs/infra 1.0.0

package/dist/ml.mjs

@@ -0,0 +1,1512 @@
+import {
+  logger
+} from "./chunk-LNFUOXDW.mjs";
+
+// src/mlDatasetFile.ts
+import { once } from "events";
+import { createReadStream, createWriteStream } from "fs";
+import fs from "fs/promises";
+import path from "path";
+var DEFAULT_DIR = "data/ml/export";
+var ML_DATASET_WRITE_BATCH_SIZE = 200;
+var writerByPath = /* @__PURE__ */ new Map();
+var toFileToken = (value) => value.trim().toLowerCase().replace(/[^a-z0-9_-]+/g, "_").replace(/^_+|_+$/g, "") || "any";
+var getMlChunkFilePath = (strategyName, chunkId, outDir = DEFAULT_DIR) => path.join(
+  outDir,
+  `ml-dataset-${toFileToken(strategyName)}-chunk-${toFileToken(chunkId)}.jsonl`
+);
+var appendMlDatasetRow = async (params) => {
+  const { strategyName, chunkId, row, outDir = DEFAULT_DIR } = params;
+  const filePath = getMlChunkFilePath(strategyName, chunkId, outDir);
+  let state = writerByPath.get(filePath);
+  if (!state) {
+    await fs.mkdir(outDir, { recursive: true });
+    const stream = createWriteStream(filePath, {
+      encoding: "utf8",
+      flags: "a"
+    });
+    state = {
+      filePath,
+      stream,
+      buffer: [],
+      writeQueue: Promise.resolve(),
+      closed: false
+    };
+    writerByPath.set(filePath, state);
+  }
+  if (state.closed) {
+    throw new Error(`ML dataset writer is closed: ${filePath}`);
+  }
+  state.buffer.push(`${JSON.stringify(row)}
+`);
+  if (state.buffer.length >= ML_DATASET_WRITE_BATCH_SIZE) {
+    await flushMlDatasetWriter(filePath);
+  }
+  return filePath;
+};
+var flushState = async (state) => {
+  if (state.closed || state.buffer.length === 0) {
+    return;
+  }
+  const chunk = state.buffer.join("");
+  state.buffer = [];
+  if (!state.stream.write(chunk)) {
+    await once(state.stream, "drain");
+  }
+};
+var flushMlDatasetWriter = async (filePath) => {
+  const state = writerByPath.get(filePath);
+  if (!state || state.closed) {
+    return;
+  }
+  state.writeQueue = state.writeQueue.then(() => flushState(state));
+  await state.writeQueue;
+};
+var closeState = async (state) => {
+  if (state.closed) {
+    return;
+  }
+  await flushState(state);
+  state.closed = true;
+  state.stream.end();
+  await Promise.all([
+    once(state.stream, "finish"),
+    once(state.stream, "close")
+  ]);
+};
+var closeMlDatasetWriter = async (filePath) => {
+  const state = writerByPath.get(filePath);
+  if (!state) return;
+  state.writeQueue = state.writeQueue.then(() => closeState(state));
+  await state.writeQueue;
+  writerByPath.delete(filePath);
+};
+var closeAllMlDatasetWriters = async () => {
+  const filePaths = [...writerByPath.keys()];
+  for (const filePath of filePaths) {
+    await closeMlDatasetWriter(filePath);
+  }
+};
+var listMlChunkFiles = async (params) => {
+  const { strategyName, outDir = DEFAULT_DIR } = params;
+  const prefix = `ml-dataset-${toFileToken(strategyName)}-chunk-`;
+  let entries = [];
+  try {
+    entries = await fs.readdir(outDir);
+  } catch (error) {
+    return [];
+  }
+  return entries.filter((name) => name.startsWith(prefix) && name.endsWith(".jsonl")).map((name) => path.join(outDir, name)).sort();
+};
+var mergeJsonlFiles = async (params) => {
+  const { filePaths, outPath } = params;
+  await fs.mkdir(path.dirname(outPath), { recursive: true });
+  const stream = createWriteStream(outPath, { encoding: "utf8" });
+  const done = Promise.all([once(stream, "finish"), once(stream, "close")]);
+  try {
+    for (const filePath of filePaths) {
+      const reader = createReadStream(filePath, { encoding: "utf8" });
+      for await (const chunk of reader) {
+        if (!stream.write(chunk)) {
+          await once(stream, "drain");
+        }
+      }
+    }
+  } finally {
+    stream.end();
+    await done;
+  }
+};
+
+// src/mlGrpc.ts
+import path2 from "path";
+import * as grpc from "@grpc/grpc-js";
+import * as protoLoader from "@grpc/proto-loader";
+import fs2 from "fs";
+var clientCache = /* @__PURE__ */ new Map();
+var resolveProtoPath = () => {
+  const candidates = [
+    path2.resolve(__dirname, "../proto/ml_infer.proto"),
+    path2.resolve(__dirname, "../../proto/ml_infer.proto"),
+    path2.resolve(process.cwd(), "proto/ml_infer.proto")
+  ];
+  for (const candidate of candidates) {
+    if (fs2.existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  return candidates[candidates.length - 1];
+};
+var getClient = (address) => {
+  const cached = clientCache.get(address);
+  if (cached) return cached;
+  const protoPath = resolveProtoPath();
+  const packageDefinition = protoLoader.loadSync(protoPath, {
+    keepCase: true,
+    longs: String,
+    enums: String,
+    defaults: true,
+    oneofs: true
+  });
+  const proto = grpc.loadPackageDefinition(packageDefinition);
+  const client = new proto.ml_infer.MlInfer(
+    address,
+    grpc.credentials.createInsecure()
+  );
+  clientCache.set(address, client);
+  return client;
+};
+var toFiniteNumber = (value) => {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : null;
+};
+var buildMlFeatures = (row) => {
+  const features = {};
+  for (const [key, value] of Object.entries(row)) {
+    if (key === "label" || key === "profit" || key === "entryTimestamp" || key === "strategy") {
+      continue;
+    }
+    const num = toFiniteNumber(value);
+    if (num != null) {
+      features[key] = num;
+    }
+  }
+  return features;
+};
+var fetchMlThreshold = async ({
+  strategy,
+  features,
+  threshold,
+  grpcAddress
+}) => {
+  try {
+    const address = grpcAddress || process.env.ML_GRPC_ADDRESS || "localhost:50051";
+    const client = getClient(address);
+    return await new Promise((resolve, reject) => {
+      client.Predict(
+        {
+          strategy,
+          features,
+          threshold
+        },
+        (err, response) => {
+          if (err) {
+            reject(err);
+            return;
+          }
+          resolve(response);
+        }
+      );
+    });
+  } catch (err) {
+    logger.error("ml grpc error: %s", err);
+    return null;
+  }
+};
+
+// src/mlSeriesAnalysis.ts
+var toFinite = (value, fallback = 0) => Number.isFinite(value) ? value : fallback;
+var safeDiv = (num, denom) => {
+  if (!Number.isFinite(num) || !Number.isFinite(denom) || denom === 0) return 0;
+  return num / denom;
+};
+var clamp = (value, min, max) => {
+  if (!Number.isFinite(value)) return 0;
+  if (value < min) return min;
+  if (value > max) return max;
+  return value;
+};
+var mean = (values) => {
+  if (!values.length) return 0;
+  return values.reduce((acc, value) => acc + value, 0) / values.length;
+};
+var std = (values) => {
+  if (!values.length) return 0;
+  const valuesMean = mean(values);
+  const variance = values.reduce((acc, value) => acc + (value - valuesMean) ** 2, 0) / values.length;
+  return Math.sqrt(variance);
+};
+var median = (values) => {
+  if (!values.length) return 0;
+  const sorted = [...values].sort((a, b) => a - b);
+  const mid = Math.floor(sorted.length / 2);
+  if (sorted.length % 2 === 0) {
+    return (sorted[mid - 1] + sorted[mid]) / 2;
+  }
+  return sorted[mid];
+};
+var percentileRank = (values, target) => {
+  if (!values.length || !Number.isFinite(target)) return 0.5;
+  let less = 0;
+  let equal = 0;
+  for (const value of values) {
+    if (!Number.isFinite(value)) continue;
+    if (value < target) less += 1;
+    else if (value === target) equal += 1;
+  }
+  return clamp((less + equal * 0.5) / values.length, 0, 1);
+};
+var linearSlope = (values) => {
+  const n = values.length;
+  if (n < 2) return 0;
+  const xMean = (n - 1) / 2;
+  const yMean = mean(values);
+  let cov = 0;
+  let varX = 0;
+  for (let i = 0; i < n; i += 1) {
+    const dx = i - xMean;
+    cov += dx * (values[i] - yMean);
+    varX += dx * dx;
+  }
+  return varX === 0 ? 0 : cov / varX;
+};
+var simpleReturns = (values) => {
+  if (values.length < 2) return [];
+  const result = [];
+  for (let i = 1; i < values.length; i += 1) {
+    result.push(clamp(safeDiv(values[i], values[i - 1]) - 1, -5, 5));
+  }
+  return result;
+};
+var sign = (value) => {
+  if (value > 0) return 1;
+  if (value < 0) return -1;
+  return 0;
+};
+var normalizeCandle = (candle) => ({
+  open: toFinite(Number(candle?.open ?? 0), 0),
+  high: toFinite(Number(candle?.high ?? 0), 0),
+  low: toFinite(Number(candle?.low ?? 0), 0),
+  close: toFinite(Number(candle?.close ?? 0), 0),
+  volume: toFinite(Number(candle?.volume ?? 0), 0),
+  timestamp: toFinite(Number(candle?.timestamp ?? 0), 0)
+});
+var analyzeNumericSeries = (values) => {
+  const clean = values.map((value) => toFinite(value, 0));
+  const last = clean[clean.length - 1] ?? 0;
+  const valuesMean = mean(clean);
+  const valuesStd = std(clean);
+  const slope = linearSlope(clean);
+  const zLast = valuesStd > 0 ? (last - valuesMean) / valuesStd : 0;
+  return {
+    LAST: last,
+    MEAN: valuesMean,
+    STD: valuesStd,
+    SLOPE: slope,
+    SLOPE_NORM: Math.tanh(safeDiv(slope, Math.abs(valuesMean) + 1e-9)),
+    Z_LAST: clamp(zLast, -8, 8),
+    RANK_LAST: percentileRank(clean.length ? clean : [0], last)
+  };
+};
+var candleCoreSummary = (rawCandles) => {
+  const candles = rawCandles.map((candle) => normalizeCandle(candle));
+  if (!candles.length) {
+    return {
+      CLOSE_NET_RET: 0,
+      CLOSE_SLOPE_NORM: 0,
+      CLOSE_VOL: 0,
+      TREND_EFFICIENCY: 0,
+      UP_MOVE_RATIO: 0,
+      AVG_RANGE_PCT: 0,
+      AVG_BODY_PCT: 0,
+      WICK_IMBALANCE: 0,
+      RANGE_POSITION: 0.5,
+      DRAWDOWN_FROM_HIGH: 0,
+      REBOUND_FROM_LOW: 0,
+      VOLUME_SLOPE_NORM: 0,
+      VOLUME_SPIKE: 0,
+      BREAKOUT_ABOVE_PREV_HIGH: 0,
+      BREAKOUT_BELOW_PREV_LOW: 0
+    };
+  }
+  const closes = candles.map((candle) => toFinite(candle.close, 0));
+  const opens = candles.map((candle) => toFinite(candle.open, 0));
+  const highs = candles.map((candle) => toFinite(candle.high, 0));
+  const lows = candles.map((candle) => toFinite(candle.low, 0));
+  const volumes = candles.map(
+    (candle) => Math.log1p(Math.max(0, candle.volume))
+  );
+  const rangesPct = candles.map(
+    (candle) => safeDiv(
+      Math.max(0, candle.high - candle.low),
+      Math.abs(candle.close) + 1e-9
+    )
+  );
+  const bodyPct = candles.map(
+    (candle) => safeDiv(
+      Math.abs(candle.close - candle.open),
+      Math.abs(candle.close) + 1e-9
+    )
+  );
+  const wickImbalance = candles.map((candle) => {
+    const range = Math.max(0, candle.high - candle.low);
+    if (range === 0) return 0;
+    const upper = candle.high - Math.max(candle.open, candle.close);
+    const lower = Math.min(candle.open, candle.close) - candle.low;
+    return clamp(safeDiv(upper - lower, range), -1, 1);
+  });
+  const closeReturns = simpleReturns(closes);
+  let upMoves = 0;
+  let absMoveSum = 0;
+  for (let i = 1; i < closes.length; i += 1) {
+    const diff = closes[i] - closes[i - 1];
+    if (diff > 0) upMoves += 1;
+    absMoveSum += Math.abs(diff);
+  }
+  const firstClose = closes[0] ?? 0;
+  const lastClose = closes[closes.length - 1] ?? 0;
+  const netMove = lastClose - firstClose;
+  const closeSlope = linearSlope(closes);
+  const highMax = highs.length ? Math.max(...highs) : 0;
+  const lowMin = lows.length ? Math.min(...lows) : 0;
+  const windowRange = Math.max(0, highMax - lowMin);
+  const prevHigh = highs.length > 1 ? Math.max(...highs.slice(0, highs.length - 1)) : highMax;
+  const prevLow = lows.length > 1 ? Math.min(...lows.slice(0, lows.length - 1)) : lowMin;
+  return {
+    CLOSE_NET_RET: clamp(safeDiv(lastClose, firstClose) - 1, -5, 5),
+    CLOSE_SLOPE_NORM: Math.tanh(
+      safeDiv(closeSlope, Math.abs(firstClose) + 1e-9)
+    ),
+    CLOSE_VOL: std(closeReturns),
+    TREND_EFFICIENCY: clamp(safeDiv(Math.abs(netMove), absMoveSum), 0, 1),
+    UP_MOVE_RATIO: clamp(
+      safeDiv(upMoves, Math.max(1, closes.length - 1)),
+      0,
+      1
+    ),
+    AVG_RANGE_PCT: clamp(mean(rangesPct), 0, 5),
+    AVG_BODY_PCT: clamp(mean(bodyPct), 0, 5),
+    WICK_IMBALANCE: mean(wickImbalance),
+    RANGE_POSITION: clamp(safeDiv(lastClose - lowMin, windowRange || 1), 0, 1),
+    DRAWDOWN_FROM_HIGH: clamp(
+      safeDiv(highMax - lastClose, Math.abs(lastClose) + 1e-9),
+      0,
+      5
+    ),
+    REBOUND_FROM_LOW: clamp(
+      safeDiv(lastClose - lowMin, Math.abs(lastClose) + 1e-9),
+      -5,
+      5
+    ),
+    VOLUME_SLOPE_NORM: Math.tanh(linearSlope(volumes)),
+    VOLUME_SPIKE: clamp(
+      safeDiv(volumes[volumes.length - 1] ?? 0, median(volumes) || 1),
+      0,
+      10
+    ),
+    BREAKOUT_ABOVE_PREV_HIGH: clamp(
+      safeDiv(lastClose - prevHigh, Math.abs(lastClose) + 1e-9),
+      -5,
+      5
+    ),
+    BREAKOUT_BELOW_PREV_LOW: clamp(
+      safeDiv(prevLow - lastClose, Math.abs(lastClose) + 1e-9),
+      -5,
+      5
+    )
+  };
+};
+var analyzeMlSeriesWindow = (input) => {
+  const summary = {
+    ...candleCoreSummary(input.candles)
+  };
+  const benchmark = input.benchmarkCandles;
+  if (benchmark?.length) {
+    const benchSummary = candleCoreSummary(benchmark);
+    const closeNetRet = summary.CLOSE_NET_RET ?? 0;
+    const benchNetRet = benchSummary.CLOSE_NET_RET ?? 0;
+    const closeSlopeNorm = summary.CLOSE_SLOPE_NORM ?? 0;
+    const benchSlopeNorm = benchSummary.CLOSE_SLOPE_NORM ?? 0;
+    summary.REL_BENCH_NET_RET = clamp(closeNetRet - benchNetRet, -5, 5);
+    summary.REL_BENCH_SLOPE_GAP = clamp(closeSlopeNorm - benchSlopeNorm, -2, 2);
+    summary.REL_BENCH_TREND_ALIGN = clamp(
+      sign(closeSlopeNorm) * sign(benchSlopeNorm),
+      -1,
+      1
+    );
+    summary.REL_BENCH_VOL_RATIO = clamp(
+      safeDiv(summary.CLOSE_VOL ?? 0, benchSummary.CLOSE_VOL ?? 0),
+      0,
+      10
+    );
+  }
+  const indicatorMap = input.indicators;
+  if (indicatorMap) {
+    const indicatorEntries = [
+      ["ATR_PCT", indicatorMap.atrPct],
+      ["PRICE1H_PCNT", indicatorMap.price1hPcnt],
+      ["PRICE24H_PCNT", indicatorMap.price24hPcnt],
+      ["MACD_HIST", indicatorMap.macdHistogram]
+    ];
+    for (const [prefix, maybeSeries] of indicatorEntries) {
+      const series = (maybeSeries ?? []).filter(
+        (value) => Number.isFinite(value)
+      );
+      if (!series.length) continue;
+      const stats = analyzeNumericSeries(series);
+      summary[`${prefix}_LAST`] = stats.LAST ?? 0;
+      summary[`${prefix}_MEAN`] = stats.MEAN ?? 0;
+      summary[`${prefix}_STD`] = stats.STD ?? 0;
+      summary[`${prefix}_SLOPE_NORM`] = stats.SLOPE_NORM ?? 0;
+      summary[`${prefix}_Z_LAST`] = stats.Z_LAST ?? 0;
+      summary[`${prefix}_RANK_LAST`] = stats.RANK_LAST ?? 0;
+    }
+    const maFast = (indicatorMap.maFast ?? []).filter(
+      (v) => Number.isFinite(v)
+    );
+    const maSlow = (indicatorMap.maSlow ?? []).filter(
+      (v) => Number.isFinite(v)
+    );
+    if (maFast.length && maSlow.length) {
+      const length = Math.min(maFast.length, maSlow.length);
+      const spread = Array.from(
+        { length },
+        (_, i) => clamp(
+          safeDiv(
+            maFast[maFast.length - length + i] - maSlow[maSlow.length - length + i],
+            maSlow[maSlow.length - length + i] || 1
+          ),
+          -5,
+          5
+        )
+      );
+      const spreadStats = analyzeNumericSeries(spread);
+      summary.MA_FAST_SLOW_SPREAD_LAST = spreadStats.LAST ?? 0;
+      summary.MA_FAST_SLOW_SPREAD_SLOPE_NORM = spreadStats.SLOPE_NORM ?? 0;
+      summary.MA_FAST_SLOW_SPREAD_Z_LAST = spreadStats.Z_LAST ?? 0;
+    }
+  }
+  return summary;
+};
+var buildMlSeriesAlignment = (left, right) => {
+  const leftSlope = left?.CLOSE_SLOPE_NORM ?? 0;
+  const rightSlope = right?.CLOSE_SLOPE_NORM ?? 0;
+  const leftRet = left?.CLOSE_NET_RET ?? 0;
+  const rightRet = right?.CLOSE_NET_RET ?? 0;
+  const leftEfficiency = left?.TREND_EFFICIENCY ?? 0;
+  const rightEfficiency = right?.TREND_EFFICIENCY ?? 0;
+  return {
+    TREND_ALIGN_SIGN: clamp(sign(leftSlope) * sign(rightSlope), -1, 1),
+    TREND_SLOPE_GAP: clamp(leftSlope - rightSlope, -2, 2),
+    NET_RET_GAP: clamp(leftRet - rightRet, -5, 5),
+    EFFICIENCY_GAP: clamp(leftEfficiency - rightEfficiency, -1, 1),
+    CONFLUENCE_SCORE: clamp(
+      leftSlope * rightSlope * (0.5 + 0.5 * Math.min(leftEfficiency, rightEfficiency)),
+      -1,
+      1
+    )
+  };
+};
+
+// src/mlTrainingTransform.ts
+var ML_BASE_CANDLES_WINDOW = 50;
+var ML_CANDLE_FEATURE_WINDOW = 50;
+var ML_WINDOW_POLICY = {
+  indicatorWindow: Math.max(1, ML_BASE_CANDLES_WINDOW - 1),
+  candleWindow: Math.max(1, ML_CANDLE_FEATURE_WINDOW - 1),
+  outputWindow: 5,
+  dropLastIndicatorElement: true
+};
+var CANDLE_WINDOW = ML_WINDOW_POLICY.candleWindow;
+var INDICATOR_WINDOW = ML_WINDOW_POLICY.indicatorWindow;
+var CANDLE_TIMEFRAMES = [
+  { label: "TF15M", key: "candles15m", btcKey: "btcCandles15m" },
+  { label: "TF1H", key: "candles1h", btcKey: "btcCandles1h" },
+  { label: "TF4H", key: "candles4h", btcKey: "btcCandles4h" },
+  { label: "TF1D", key: "candles1d", btcKey: "btcCandles1d" }
+];
+var INDICATOR_TIMEFRAMES = [
+  { label: "TF15M", suffix: "" },
+  { label: "TF1H", suffix: "1h" },
+  { label: "TF4H", suffix: "4h" },
+  { label: "TF1D", suffix: "1d" }
+];
+var toNumber = (value, fallback = 0) => {
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? value : fallback;
+  }
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : fallback;
+};
+var safeDiv2 = (num, denom) => {
+  if (!Number.isFinite(num) || !Number.isFinite(denom) || denom === 0) {
+    return 0;
+  }
+  return num / denom;
+};
+var safeLog1p = (value) => {
+  if (!Number.isFinite(value)) {
+    return 0;
+  }
+  if (value === 0) {
+    return 0;
+  }
+  return Math.sign(value) * Math.log1p(Math.abs(value));
+};
+var clamp2 = (value, min, max) => {
+  if (!Number.isFinite(value)) return 0;
+  if (value < min) return min;
+  if (value > max) return max;
+  return value;
+};
+var safeLog1pPositive = (value) => {
+  if (!Number.isFinite(value) || value <= 0) return 0;
+  return Math.log1p(value);
+};
+var squash = (value, scale) => {
+  if (!Number.isFinite(value) || !Number.isFinite(scale) || scale <= 0) {
+    return 0;
+  }
+  return Math.tanh(value / scale);
+};
+var normalizeSymbol = (value) => {
+  if (typeof value !== "string") return "";
+  return value.trim().toUpperCase();
+};
+var computeMedian = (values) => {
+  if (values.length === 0) return 0;
+  const sorted = [...values].sort((a, b) => a - b);
+  const mid = Math.floor(sorted.length / 2);
+  if (sorted.length % 2 === 0) {
+    return (sorted[mid - 1] + sorted[mid]) / 2;
+  }
+  return sorted[mid];
+};
+var computeMean = (values) => {
+  if (values.length === 0) return 0;
+  const sum = values.reduce((acc, value) => acc + value, 0);
+  return sum / values.length;
+};
+var computeStd = (values) => {
+  if (values.length === 0) return 0;
+  const mean2 = computeMean(values);
+  const variance = values.reduce((acc, value) => acc + (value - mean2) ** 2, 0) / values.length;
+  return Math.sqrt(variance);
+};
+var computeSkew = (values) => {
+  if (values.length === 0) return 0;
+  const mean2 = computeMean(values);
+  const std2 = computeStd(values);
+  if (std2 === 0) return 0;
+  const m3 = values.reduce((acc, value) => acc + (value - mean2) ** 3, 0) / values.length;
+  return m3 / std2 ** 3;
+};
+var computeKurtosis = (values) => {
+  if (values.length === 0) return 0;
+  const mean2 = computeMean(values);
+  const std2 = computeStd(values);
+  if (std2 === 0) return 0;
+  const m4 = values.reduce((acc, value) => acc + (value - mean2) ** 4, 0) / values.length;
+  return m4 / std2 ** 4;
+};
+var percentileRank2 = (values, target) => {
+  if (!values.length || !Number.isFinite(target)) return 0.5;
+  let less = 0;
+  let equal = 0;
+  for (const value of values) {
+    if (!Number.isFinite(value)) continue;
+    if (value < target) less += 1;
+    else if (value === target) equal += 1;
+  }
+  const n = values.length;
+  if (n === 0) return 0.5;
+  return clamp2((less + equal * 0.5) / n, 0, 1);
+};
+var standardizeSeries = (values) => {
+  if (!values.length) return [];
+  const valuesMean = computeMean(values);
+  const valuesStd = computeStd(values);
+  if (valuesStd === 0) {
+    return values.map(() => 0);
+  }
+  return values.map((value) => (value - valuesMean) / valuesStd);
+};
+var backwardReturns = (values) => {
+  if (values.length < 2) return [];
+  const result = [];
+  for (let i = values.length - 1; i >= 1; i -= 1) {
+    result.push(clamp2(safeDiv2(values[i], values[i - 1]) - 1, -5, 5));
+  }
+  return result;
+};
+var assignBackwardReturns = (row, prefix, returnsNewestFirst) => {
+  const returnsOldestFirst = [...returnsNewestFirst].reverse();
+  for (let i = 0; i < returnsOldestFirst.length; i += 1) {
+    row[`${prefix}_${i + 2}`] = clamp2(returnsOldestFirst[i], -5, 5);
+  }
+};
+var sliceWindow = (values, endIndex, windowSize) => {
+  if (values.length === 0) return [];
+  const start = Math.max(0, endIndex - windowSize + 1);
+  return values.slice(start, endIndex + 1);
+};
+var asArray = (value) => Array.isArray(value) ? value : [];
+var dropLastFromIndicatorSeries = (indicators) => {
+  if (!ML_WINDOW_POLICY.dropLastIndicatorElement) {
+    return indicators;
+  }
+  const next = {};
+  for (const [key, value] of Object.entries(indicators)) {
+    if (Array.isArray(value)) {
+      next[key] = value.slice(0, Math.max(0, value.length - 1));
+    } else {
+      next[key] = value;
+    }
+  }
+  return next;
+};
+var normalizeSeries = (value) => {
+  if (Array.isArray(value)) {
+    return value.map((item) => toNumber(item, 0));
+  }
+  if (typeof value === "number") {
+    return [toNumber(value, 0)];
+  }
+  return [];
+};
+var padSeries = (values) => {
+  if (values.length >= INDICATOR_WINDOW) {
+    return values.slice(-INDICATOR_WINDOW);
+  }
+  const fill = values.length ? values[0] : 0;
+  const missing = INDICATOR_WINDOW - values.length;
+  return Array.from({ length: missing }, () => fill).concat(values);
+};
+var normalizeCandles = (value) => {
+  if (!Array.isArray(value)) return [];
+  const normalized = value.map((item) => ({
+    open: toNumber(item?.open, 0),
+    high: toNumber(item?.high, 0),
+    low: toNumber(item?.low, 0),
+    close: toNumber(item?.close, 0),
+    volume: toNumber(item?.volume, 0),
+    timestamp: toNumber(item?.timestamp, 0)
+  })).filter((candle) => candle.timestamp > 0);
+  normalized.sort((a, b) => a.timestamp - b.timestamp);
+  return normalized;
+};
+var padCandles = (candles) => {
+  if (candles.length >= CANDLE_WINDOW) {
+    return candles.slice(-CANDLE_WINDOW);
+  }
+  const fill = candles[0] ?? {
+    open: 0,
+    high: 0,
+    low: 0,
+    close: 0,
+    volume: 0,
+    timestamp: 0
+  };
+  const missing = CANDLE_WINDOW - candles.length;
+  return Array.from({ length: missing }, () => ({ ...fill })).concat(candles);
+};
+var padNumberWindow = (values, fallback) => {
+  if (values.length >= CANDLE_WINDOW) {
+    return values.slice(-CANDLE_WINDOW);
+  }
+  const fill = values.length ? values[0] : fallback;
+  const missing = CANDLE_WINDOW - values.length;
+  return Array.from({ length: missing }, () => fill).concat(values);
+};
+var addCandleFeatures = (row, params) => {
+  const {
+    featurePrefix = "",
+    candles: rawCandles,
+    btcCandles: rawBtcCandles,
+    currentPrice,
+    priceScaleSeries: rawPriceScaleSeries
+  } = params;
+  const candles = padCandles(rawCandles);
+  const btcCandles = padCandles(rawBtcCandles);
+  const priceScaleSeries = padNumberWindow(rawPriceScaleSeries, currentPrice);
+  const key = (name) => featurePrefix ? `${featurePrefix}_${name}` : name;
+  const altKey = (name) => key(`ALT_${name}`);
+  const btcKey = (name) => key(`BTC_${name}`);
+  const candleVolumes = candles.map((candle) => candle.volume);
+  const btcVolumes = btcCandles.map((candle) => candle.volume);
+  const altReturns = [];
+  const btcReturns = [];
+  const relReturns = [];
+  const candleBodyRaw = [];
+  const altToBtcOpenRaw = [];
+  const altToBtcCloseRaw = [];
+  const altToBtcHighRaw = [];
+  const altToBtcLowRaw = [];
+  const lastBtcClose = toNumber(btcCandles[btcCandles.length - 1]?.close, 0);
+  const btcPrice = lastBtcClose;
+  for (let i = 0; i < CANDLE_WINDOW; i += 1) {
+    const candle = candles[i] ?? {};
+    const btcCandle = btcCandles[i] ?? {};
+    const altOpenRaw = toNumber(candle?.open, 0);
+    const altCloseRaw = toNumber(candle?.close, 0);
+    const altHighRaw = toNumber(candle?.high, 0);
+    const altLowRaw = toNumber(candle?.low, 0);
+    const btcOpenRaw = toNumber(btcCandle?.open, 0);
+    const btcCloseRaw = toNumber(btcCandle?.close, 0);
+    const btcHighRaw = toNumber(btcCandle?.high, 0);
+    const btcLowRaw = toNumber(btcCandle?.low, 0);
+    const altRet = safeDiv2(altCloseRaw, altOpenRaw);
+    const btcRet = safeDiv2(btcCloseRaw, btcOpenRaw);
+    row[altKey(`Ret_${i + 1}`)] = altRet;
+    row[btcKey(`Ret_${i + 1}`)] = btcRet;
+    row[key(`RelRet_${i + 1}`)] = altRet - btcRet;
+    altReturns.push(altRet);
+    btcReturns.push(btcRet);
+    relReturns.push(altRet - btcRet);
+    const altToBtcOpen = safeDiv2(altOpenRaw, btcOpenRaw);
+    const altToBtcClose = safeDiv2(altCloseRaw, btcCloseRaw);
+    const altToBtcHigh = safeDiv2(altHighRaw, btcHighRaw);
+    const altToBtcLow = safeDiv2(altLowRaw, btcLowRaw);
+    altToBtcOpenRaw.push(altToBtcOpen);
+    altToBtcCloseRaw.push(altToBtcClose);
+    altToBtcHighRaw.push(altToBtcHigh);
+    altToBtcLowRaw.push(altToBtcLow);
+    const priceScale = toNumber(priceScaleSeries[i], currentPrice);
+    const candleMax = Math.max(altOpenRaw, altCloseRaw);
+    const candleMin = Math.min(altOpenRaw, altCloseRaw);
+    candleBodyRaw.push(safeDiv2(altCloseRaw - altOpenRaw, priceScale));
+    row[altKey(`Candle_Range_${i + 1}`)] = safeDiv2(
+      altHighRaw - altLowRaw,
+      priceScale
+    );
+    row[altKey(`Candle_UpperWick_${i + 1}`)] = safeDiv2(
+      altHighRaw - candleMax,
+      priceScale
+    );
+    row[altKey(`Candle_LowerWick_${i + 1}`)] = safeDiv2(
+      candleMin - altLowRaw,
+      priceScale
+    );
+    row[altKey(`Candle_Direction_${i + 1}`)] = altCloseRaw >= altOpenRaw ? 1 : 0;
+    const btcCandleMax = Math.max(btcOpenRaw, btcCloseRaw);
+    const btcCandleMin = Math.min(btcOpenRaw, btcCloseRaw);
+    row[btcKey(`Candle_Body_${i + 1}`)] = safeDiv2(
+      btcCloseRaw - btcOpenRaw,
+      btcPrice
+    );
+    row[btcKey(`Candle_Range_${i + 1}`)] = safeDiv2(
+      btcHighRaw - btcLowRaw,
+      btcPrice
+    );
+    row[btcKey(`Candle_UpperWick_${i + 1}`)] = safeDiv2(
+      btcHighRaw - btcCandleMax,
+      btcPrice
+    );
+    row[btcKey(`Candle_LowerWick_${i + 1}`)] = safeDiv2(
+      btcCandleMin - btcLowRaw,
+      btcPrice
+    );
+    row[btcKey(`Candle_Direction_${i + 1}`)] = btcCloseRaw >= btcOpenRaw ? 1 : 0;
+    const candleVol = toNumber(candle?.volume, 0);
+    const btcVol = toNumber(btcCandle?.volume, 0);
+    const candleWindow = sliceWindow(
+      candleVolumes,
+      i,
+      Math.min(20, candleVolumes.length)
+    );
+    const btcWindow = sliceWindow(
+      btcVolumes,
+      i,
+      Math.min(20, btcVolumes.length)
+    );
+    const candleMedian = computeMedian(candleWindow);
+    const btcMedian = computeMedian(btcWindow);
+    row[altKey(`Candle_Volume_${i + 1}`)] = safeLog1p(candleVol);
+    if (i > 0) {
+      row[altKey(`Candle_Volume_${i + 1}_MedianNorm`)] = safeDiv2(
+        candleVol,
+        candleMedian
+      );
+    }
+    row[btcKey(`Candle_Volume_${i + 1}`)] = safeLog1p(btcVol);
+    if (i > 0) {
+      row[btcKey(`Candle_Volume_${i + 1}_MedianNorm`)] = safeDiv2(
+        btcVol,
+        btcMedian
+      );
+    }
+  }
+  const candleBodyStd = standardizeSeries(candleBodyRaw);
+  const altToBtcOpenRet = backwardReturns(altToBtcOpenRaw);
+  const altToBtcCloseRet = backwardReturns(altToBtcCloseRaw);
+  const altToBtcHighRet = backwardReturns(altToBtcHighRaw);
+  const altToBtcLowRet = backwardReturns(altToBtcLowRaw);
+  for (let i = 0; i < CANDLE_WINDOW; i += 1) {
+    row[altKey(`Candle_Body_${i + 1}`)] = candleBodyStd[i] ?? 0;
+  }
+  assignBackwardReturns(row, key("AltToBtc_Open"), altToBtcOpenRet);
+  assignBackwardReturns(row, key("AltToBtc_Close"), altToBtcCloseRet);
+  assignBackwardReturns(row, key("AltToBtc_High"), altToBtcHighRet);
+  assignBackwardReturns(row, key("AltToBtc_Low"), altToBtcLowRet);
+  const windowAlt = sliceWindow(
+    altReturns,
+    altReturns.length - 1,
+    CANDLE_WINDOW
+  );
+  const windowBtc = sliceWindow(
+    btcReturns,
+    btcReturns.length - 1,
+    CANDLE_WINDOW
+  );
+  const windowRel = sliceWindow(
+    relReturns,
+    relReturns.length - 1,
+    CANDLE_WINDOW
+  );
+  row[altKey("Ret_Mean")] = computeMean(windowAlt);
+  row[altKey("Ret_Std")] = computeStd(windowAlt);
+  row[altKey("Ret_Skew")] = computeSkew(windowAlt);
+  row[altKey("Ret_Kurt")] = computeKurtosis(windowAlt);
+  row[btcKey("Ret_Mean")] = computeMean(windowBtc);
+  row[btcKey("Ret_Std")] = computeStd(windowBtc);
+  row[btcKey("Ret_Skew")] = computeSkew(windowBtc);
+  row[btcKey("Ret_Kurt")] = computeKurtosis(windowBtc);
+  row[key("RelRet_Mean")] = computeMean(windowRel);
+  row[key("RelRet_Std")] = computeStd(windowRel);
+  row[key("RelRet_Skew")] = computeSkew(windowRel);
+  row[key("RelRet_Kurt")] = computeKurtosis(windowRel);
+};
+var buildMlTrainingRow = (signalRecord, resultRecord) => {
+  const { signal, context } = signalRecord;
+  const indicators = dropLastFromIndicatorSeries(
+    signal?.indicators ?? {}
+  );
+  const currentPrice = toNumber(signal?.prices?.currentPrice, 0);
+  const candleList = normalizeCandles(indicators.candles15m);
+  const btcList = normalizeCandles(indicators.btcCandles15m);
+  const entryTimestamp = toNumber(signal?.timestamp, 0);
+  const intervalMinutes = toNumber(signal?.interval, 0);
+  const entryDate = entryTimestamp > 0 ? new Date(entryTimestamp) : null;
+  const entryHour = entryDate ? entryDate.getUTCHours() : 0;
+  const entryDayOfWeek = entryDate ? entryDate.getUTCDay() : 0;
+  const row = {
+    symbol: normalizeSymbol(
+      signal?.symbol ?? context?.symbol ?? resultRecord?.symbol ?? ""
+    ),
+    strategy: normalizeSymbol(signal?.strategy ?? context?.strategyName ?? ""),
+    direction: signal?.direction === "LONG" ? 1 : 0,
+    entryTimestamp,
+    takeProfitPrice: safeDiv2(
+      currentPrice,
+      toNumber(signal?.prices?.takeProfitPrice, 0)
+    ),
+    stopLossPrice: safeDiv2(
+      currentPrice,
+      toNumber(signal?.prices?.stopLossPrice, 0)
+    ),
+    riskRatio: toNumber(signal?.prices?.riskRatio, 0),
+    Correlation: toNumber(signal?.indicators?.correlation, 0),
+    Touches: toNumber(
+      signal?.additionalIndicators?.touches ?? signal?.indicators?.touches,
+      0
+    ),
+    Distance: toNumber(
+      signal?.additionalIndicators?.distance ?? signal?.indicators?.distance,
+      0
+    ),
+    Ctx_EntryHour: entryHour,
+    Ctx_EntryDayOfWeek: entryDayOfWeek,
+    Ctx_EntryHourSin: Math.sin(2 * Math.PI * entryHour / 24),
+    Ctx_EntryHourCos: Math.cos(2 * Math.PI * entryHour / 24),
+    Ctx_StopDistance: clamp2(
+      1 - safeDiv2(currentPrice, toNumber(signal?.prices?.stopLossPrice, 0)),
+      -5,
+      5
+    ),
+    Ctx_TakeDistance: clamp2(
+      safeDiv2(currentPrice, toNumber(signal?.prices?.takeProfitPrice, 0)) - 1,
+      -5,
+      5
+    )
+  };
+  row.Ctx_RiskAsymmetry = clamp2(
+    safeDiv2(
+      toNumber(row.Ctx_TakeDistance, 0),
+      Math.abs(toNumber(row.Ctx_StopDistance, 0))
+    ),
+    -10,
+    10
+  );
+  const addSeries = (prefix, values, priceBase = currentPrice) => {
+    const series = padSeries(normalizeSeries(values));
+    for (let i = 0; i < INDICATOR_WINDOW; i += 1) {
+      const value = series[i];
+      row[`${prefix}_${i + 1}`] = safeDiv2(value, priceBase);
+    }
+  };
+  const addSeriesBackwardReturns = (prefix, values) => {
+    const series = padSeries(normalizeSeries(values));
+    const returns = backwardReturns(series);
+    assignBackwardReturns(row, prefix, returns);
+  };
+  const addSeriesRaw = (prefix, values) => {
+    const series = padSeries(normalizeSeries(values));
+    for (let i = 0; i < INDICATOR_WINDOW; i += 1) {
+      row[`${prefix}_${i + 1}`] = series[i];
+    }
+  };
+  const addSeriesPct = (prefix, values) => {
+    const series = padSeries(normalizeSeries(values));
+    for (let i = 0; i < INDICATOR_WINDOW; i += 1) {
+      row[`${prefix}_${i + 1}`] = squash(series[i], 10);
+    }
+  };
+  const addSeriesMoments = (prefix, values) => {
+    const series = padSeries(normalizeSeries(values));
+    row[`${prefix}_Mean`] = computeMean(series);
+    row[`${prefix}_Std`] = computeStd(series);
+    row[`${prefix}_Skew`] = computeSkew(series);
+    row[`${prefix}_Kurt`] = computeKurtosis(series);
+  };
+  const addSeriesStd = (prefix, values) => {
+    const series = padSeries(normalizeSeries(values));
+    const standardized = standardizeSeries(series);
+    for (let i = 0; i < INDICATOR_WINDOW; i += 1) {
+      row[`${prefix}_${i + 1}`] = standardized[i] ?? 0;
+    }
+  };
+  const addSeriesRelTo = (prefix, values, denomSeries) => {
+    const series = padSeries(normalizeSeries(values));
+    const denomSeriesSafe = padSeries(normalizeSeries(denomSeries));
+    for (let i = 0; i < INDICATOR_WINDOW; i += 1) {
+      const value = series[i];
+      const denom = denomSeriesSafe[i];
+      row[`${prefix}_${i + 1}`] = safeDiv2(value, denom);
+    }
+  };
+  const addSeriesLogVolume = (prefix, values) => {
+    const series = padSeries(normalizeSeries(values));
+    for (let i = 0; i < INDICATOR_WINDOW; i += 1) {
+      const value = series[i];
+      row[`${prefix}_${i + 1}`] = clamp2(safeLog1p(value), -20, 20);
+    }
+  };
+  const addSeriesLogVolumeBackwardReturns = (prefix, values) => {
+    const series = padSeries(normalizeSeries(values));
+    const loggedSeries = series.map((value) => safeLog1p(value));
+    const returns = backwardReturns(loggedSeries);
+    assignBackwardReturns(row, prefix, returns);
+  };
+  const addSeriesVolumeMedianNormalized = (prefix, values) => {
+    const numericValues = padSeries(normalizeSeries(values));
+    const windowSize = Math.min(20, numericValues.length);
+    for (let i = 1; i < INDICATOR_WINDOW; i += 1) {
+      const value = numericValues[i];
+      const window = sliceWindow(numericValues, i, windowSize);
+      const median2 = computeMedian(window);
+      row[`${prefix}_${i + 1}_MedianNorm`] = clamp2(
+        safeDiv2(value, median2),
+        0,
+        20
+      );
+    }
+  };
+  const keyWithSourceSuffix = (key, sourceSuffix, sourcePrefix) => {
+    const baseKey = sourcePrefix ? `${sourcePrefix}${key[0].toUpperCase()}${key.slice(1)}` : key;
+    return sourceSuffix ? `${baseKey}${sourceSuffix}` : baseKey;
+  };
+  const keyWithFeaturePrefix = (key, featurePrefix) => featurePrefix ? `${featurePrefix}_${key}` : key;
+  const addIndicatorFeatures = (featurePrefix, sourceSuffix, sourcePrefix, priceBase, assetPrefix = "ALT") => {
+    const indicatorSeries = (key) => asArray(indicators[keyWithSourceSuffix(key, sourceSuffix, sourcePrefix)]);
+    const featureKey = (key) => keyWithFeaturePrefix(`${assetPrefix}_${key}`, featurePrefix);
+    const backwardReturnSeries = [
+      ["MA_Fast", "maFast"],
+      ["MA_Medium", "maMedium"],
+      ["MA_Slow", "maSlow"],
+      ["BB_Upper", "bbUpper"],
+      ["BB_Middle", "bbMiddle"],
+      ["BB_Lower", "bbLower"]
+    ];
+    const logVolumeBackwardReturnSeries = [
+      ["OBV_LogRet", "obv"],
+      ["SMA_OBV_LogRet", "smaObv"]
+    ];
+    const momentsSeries = [
+      ["ATR_PCT", "atrPct"],
+      ["BB_Upper", "bbUpper"],
+      ["BB_Middle", "bbMiddle"],
+      ["BB_Lower", "bbLower"],
+      ["MACD_Histogram", "macdHistogram"],
+      ["Price24hPcnt", "price24hPcnt"],
+      ["Price1hPcnt", "price1hPcnt"]
+    ];
+    const stdSeries = [
+      ["MACD", "macd"],
+      ["MACD_Signal", "macdSignal"],
+      ["MACD_Histogram", "macdHistogram"]
+    ];
+    const pctSeries = [
+      ["Price24hPcnt", "price24hPcnt"],
+      ["Price1hPcnt", "price1hPcnt"]
+    ];
+    const volumeSeries = [
+      ["Volume1h", "volume1h"],
+      ["Volume24h", "volume24h"]
+    ];
+    const relToSeries = [
+      ["HighPrice1h", "highPrice1h", "maMedium"],
+      ["LowPrice1h", "lowPrice1h", "maMedium"],
+      ["HighPrice24h", "highPrice24h", "maMedium"],
+      ["LowPrice24h", "lowPrice24h", "maMedium"],
+      ["HighLevel", "highLevel", "maMedium"],
+      ["LowLevel", "lowLevel", "maMedium"],
+      ["PrevClose", "prevClose", "maMedium"]
+    ];
+    addSeries(featureKey("ATR"), indicatorSeries("atr"), priceBase);
+    for (const [featureName, sourceName] of backwardReturnSeries) {
+      addSeriesBackwardReturns(
+        featureKey(featureName),
+        indicatorSeries(sourceName)
+      );
+    }
+    for (const [featureName, sourceName] of logVolumeBackwardReturnSeries) {
+      addSeriesLogVolumeBackwardReturns(
+        featureKey(featureName),
+        indicatorSeries(sourceName)
+      );
+    }
+    addSeriesRaw(featureKey("ATR_PCT"), indicatorSeries("atrPct"));
+    if (!sourcePrefix && !sourceSuffix && assetPrefix === "ALT") {
+      addSeriesRaw(featureKey("Spread"), indicatorSeries("spread"));
+    }
+    for (const [featureName, sourceName] of momentsSeries) {
+      addSeriesMoments(featureKey(featureName), indicatorSeries(sourceName));
+    }
+    for (const [featureName, sourceName] of stdSeries) {
+      addSeriesStd(featureKey(featureName), indicatorSeries(sourceName));
+    }
+    for (const [featureName, sourceName] of pctSeries) {
+      addSeriesPct(featureKey(featureName), indicatorSeries(sourceName));
+    }
+    for (const [featureName, sourceName, denomName] of relToSeries) {
+      addSeriesRelTo(
+        featureKey(featureName),
+        indicatorSeries(sourceName),
+        indicatorSeries(denomName)
+      );
+    }
+    for (const [featureName, sourceName] of volumeSeries) {
+      const series = indicatorSeries(sourceName);
+      addSeriesLogVolume(featureKey(featureName), series);
+      addSeriesVolumeMedianNormalized(featureKey(featureName), series);
+    }
+  };
+  const applyIndicatorAndCandlePhases = () => {
+    const maMediumSeries = asArray(indicators.maMedium);
+    const btcCandlesByTimeframe = {
+      TF15M: btcList,
+      TF1H: normalizeCandles(indicators.btcCandles1h),
+      TF4H: normalizeCandles(indicators.btcCandles4h),
+      TF1D: normalizeCandles(indicators.btcCandles1d)
+    };
+    const btcPriceByTimeframe = {
+      TF15M: toNumber(
+        btcCandlesByTimeframe.TF15M[btcCandlesByTimeframe.TF15M.length - 1]?.close,
+        currentPrice
+      ),
+      TF1H: toNumber(
+        btcCandlesByTimeframe.TF1H[btcCandlesByTimeframe.TF1H.length - 1]?.close,
+        currentPrice
+      ),
+      TF4H: toNumber(
+        btcCandlesByTimeframe.TF4H[btcCandlesByTimeframe.TF4H.length - 1]?.close,
+        currentPrice
+      ),
+      TF1D: toNumber(
+        btcCandlesByTimeframe.TF1D[btcCandlesByTimeframe.TF1D.length - 1]?.close,
+        currentPrice
+      )
+    };
+    for (const timeframe of INDICATOR_TIMEFRAMES) {
+      addIndicatorFeatures(
+        timeframe.label,
+        timeframe.suffix,
+        void 0,
+        void 0,
+        "ALT"
+      );
+      addIndicatorFeatures(
+        timeframe.label,
+        timeframe.suffix,
+        "btc",
+        btcPriceByTimeframe[timeframe.label],
+        "BTC"
+      );
+    }
+    const basePriceScale = padSeries(normalizeSeries(maMediumSeries));
+    for (const timeframe of CANDLE_TIMEFRAMES) {
+      const tfCandlesFromIndicators = timeframe.key === "candles15m" ? candleList : normalizeCandles(indicators[timeframe.key]);
+      const tfBtcCandlesFromIndicators = timeframe.btcKey === "btcCandles15m" ? btcList : normalizeCandles(indicators[timeframe.btcKey]);
+      const tfCandles = tfCandlesFromIndicators.slice(-CANDLE_WINDOW);
+      const tfBtcCandles = tfBtcCandlesFromIndicators.slice(-CANDLE_WINDOW);
+      const priceScaleSeries = timeframe.label === "TF15M" ? basePriceScale : tfCandles.map((candle) => candle.close);
+      addCandleFeatures(row, {
+        featurePrefix: timeframe.label,
+        candles: tfCandles,
+        btcCandles: tfBtcCandles,
+        currentPrice,
+        priceScaleSeries
+      });
+    }
+  };
+  const applySeriesAnalysisPhase = () => {
+    const tfConfigByLabel = {
+      TF15M: {
+        indicatorSuffix: "",
+        candleKey: "candles15m",
+        btcCandleKey: "btcCandles15m"
+      },
+      TF1H: {
+        indicatorSuffix: "1h",
+        candleKey: "candles1h",
+        btcCandleKey: "btcCandles1h"
+      },
+      TF4H: {
+        indicatorSuffix: "4h",
+        candleKey: "candles4h",
+        btcCandleKey: "btcCandles4h"
+      },
+      TF1D: {
+        indicatorSuffix: "1d",
+        candleKey: "candles1d",
+        btcCandleKey: "btcCandles1d"
+      }
+    };
+    const keyWithSuffix = (baseKey, suffix) => suffix ? `${baseKey}${suffix}` : baseKey;
+    const keyWithBtcPrefix = (baseKey, suffix) => {
+      const withSuffix = keyWithSuffix(baseKey, suffix);
+      return `btc${withSuffix[0].toUpperCase()}${withSuffix.slice(1)}`;
+    };
+    const altSummaries = {};
+    for (const tf of INDICATOR_TIMEFRAMES) {
+      const cfg = tfConfigByLabel[tf.label];
+      const altCandles = cfg.candleKey === "candles15m" ? candleList : normalizeCandles(indicators[cfg.candleKey]);
+      const btcCandles = cfg.btcCandleKey === "btcCandles15m" ? btcList : normalizeCandles(indicators[cfg.btcCandleKey]);
+      const altSummary = analyzeMlSeriesWindow({
+        candles: altCandles.slice(-CANDLE_WINDOW),
+        benchmarkCandles: btcCandles.slice(-CANDLE_WINDOW),
+        indicators: {
+          atrPct: normalizeSeries(
+            indicators[keyWithSuffix("atrPct", cfg.indicatorSuffix)]
+          ),
+          price1hPcnt: normalizeSeries(
+            indicators[keyWithSuffix("price1hPcnt", cfg.indicatorSuffix)]
+          ),
+          price24hPcnt: normalizeSeries(
+            indicators[keyWithSuffix("price24hPcnt", cfg.indicatorSuffix)]
+          ),
+          macdHistogram: normalizeSeries(
+            indicators[keyWithSuffix("macdHistogram", cfg.indicatorSuffix)]
+          ),
+          maFast: normalizeSeries(
+            indicators[keyWithSuffix("maFast", cfg.indicatorSuffix)]
+          ),
+          maSlow: normalizeSeries(
+            indicators[keyWithSuffix("maSlow", cfg.indicatorSuffix)]
+          )
+        }
+      });
+      altSummaries[tf.label] = altSummary;
+      for (const [featureName, value] of Object.entries(altSummary)) {
+        row[`${tf.label}_ALT_ANALYSIS_${featureName}`] = value;
+      }
+      const btcSummary = analyzeMlSeriesWindow({
+        candles: btcCandles.slice(-CANDLE_WINDOW),
+        indicators: {
+          atrPct: normalizeSeries(
+            indicators[keyWithBtcPrefix("atrPct", cfg.indicatorSuffix)]
+          ),
+          price1hPcnt: normalizeSeries(
+            indicators[keyWithBtcPrefix("price1hPcnt", cfg.indicatorSuffix)]
+          ),
+          price24hPcnt: normalizeSeries(
+            indicators[keyWithBtcPrefix("price24hPcnt", cfg.indicatorSuffix)]
+          ),
+          macdHistogram: normalizeSeries(
+            indicators[keyWithBtcPrefix("macdHistogram", cfg.indicatorSuffix)]
+          ),
+          maFast: normalizeSeries(
+            indicators[keyWithBtcPrefix("maFast", cfg.indicatorSuffix)]
+          ),
+          maSlow: normalizeSeries(
+            indicators[keyWithBtcPrefix("maSlow", cfg.indicatorSuffix)]
+          )
+        }
+      });
+      for (const [featureName, value] of Object.entries(btcSummary)) {
+        row[`${tf.label}_BTC_ANALYSIS_${featureName}`] = value;
+      }
+    }
+    const alignmentPairs = [
+      ["TF15M", "TF1H"],
+      ["TF1H", "TF4H"],
+      ["TF4H", "TF1D"],
+      ["TF15M", "TF4H"]
+    ];
+    for (const [leftTf, rightTf] of alignmentPairs) {
+      const alignment = buildMlSeriesAlignment(
+        altSummaries[leftTf],
+        altSummaries[rightTf]
+      );
+      for (const [featureName, value] of Object.entries(alignment)) {
+        row[`MTF_ALT_${leftTf}_${rightTf}_ANALYSIS_${featureName}`] = value;
+      }
+    }
+  };
+  const applyRegimePhase = () => {
+    const atrPctSeries = padSeries(normalizeSeries(indicators.atrPct));
+    const price1hPctSeries = padSeries(normalizeSeries(indicators.price1hPcnt));
+    const tf15mReturns = backwardReturns(
+      candleList.slice(-INDICATOR_WINDOW).map((candle) => toNumber(candle.close, 0))
+    );
+    const atrPctLast = atrPctSeries[atrPctSeries.length - 1] ?? 0;
+    const atrPctMean = computeMean(atrPctSeries);
+    const atrPctStd = computeStd(atrPctSeries);
+    const atrPctZ = atrPctStd > 0 ? (atrPctLast - atrPctMean) / atrPctStd : 0;
+    const atrPctRank = percentileRank2(atrPctSeries, atrPctLast);
+    const realizedVol = computeStd(tf15mReturns);
+    const realizedVolRank = percentileRank2(
+      tf15mReturns.length ? tf15mReturns : [0],
+      tf15mReturns.length ? tf15mReturns[tf15mReturns.length - 1] : 0
+    );
+    const trendStrength = Math.abs(computeMean(price1hPctSeries));
+    row.Regime_ATR_PCT_Last = atrPctLast;
+    row.Regime_ATR_PCT_Z = clamp2(atrPctZ, -8, 8);
+    row.Regime_ATR_PCT_Rank = atrPctRank;
+    row.Regime_RealizedVol = realizedVol;
+    row.Regime_RealizedVol_Rank = realizedVolRank;
+    row.Regime_TrendStrength = trendStrength;
+    row.Regime_IsHighVol = atrPctRank >= 0.7 || realizedVolRank >= 0.7 ? 1 : 0;
+    const latestIdx = INDICATOR_WINDOW;
+    row.Ctx_DistanceTo24hRange = clamp2(
+      toNumber(row[`TF15M_ALT_HighPrice24h_${latestIdx}`], 0) - toNumber(row[`TF15M_ALT_LowPrice24h_${latestIdx}`], 0),
+      -10,
+      10
+    );
+  };
+  const applyTrendlinePhase = () => {
+    const trendLine = signal?.figures?.trendLine ?? signal?.additionalIndicators?.trendLine ?? {};
+    row.TrendLine_Mode = trendLine?.mode === "highs" ? 1 : 0;
+    row.TrendLine_Distance = toNumber(trendLine?.distance, 0);
+    const trendAlpha = padSeries(normalizeSeries(trendLine?.alpha));
+    for (let i = 0; i < INDICATOR_WINDOW; i += 1) {
+      row[`TrendLine_Alpha_${i + 1}`] = trendAlpha[i];
+    }
+    const points = asArray(
+      trendLine?.points
+    );
+    const maxPoints = 2;
+    for (let i = 0; i < maxPoints; i += 1) {
+      const point = points[i] ?? {};
+      row[`POINTS_VALUE_${i + 1}`] = safeDiv2(
+        toNumber(point?.value, 0),
+        currentPrice
+      );
+      const pointDeltaMs = entryTimestamp - toNumber(point?.timestamp, 0);
+      const pointDeltaMin = safeDiv2(pointDeltaMs, 6e4);
+      if (i === 0) {
+        const pointDeltaBars = intervalMinutes > 0 ? safeDiv2(pointDeltaMin, intervalMinutes) : pointDeltaMin;
+        row[`POINTS_TS_${i + 1}`] = safeLog1pPositive(pointDeltaBars);
+      }
+    }
+    const touches = asArray(
+      trendLine?.touches
+    ).map((touch) => ({
+      value: toNumber(touch?.value, NaN),
+      timestamp: toNumber(touch?.timestamp, NaN)
+    })).filter(
+      (touch) => Number.isFinite(touch.value) && Number.isFinite(touch.timestamp)
+    ).sort((a, b) => a.timestamp - b.timestamp).slice(-3);
+    const maxTouches = 3;
+    for (let i = 0; i < maxTouches; i += 1) {
+      const touch = touches[i];
+      if (!touch) {
+        row[`TOUCHES_VALUE_${i + 1}`] = 0;
+        row[`TOUCHES_TS_${i + 1}`] = 0;
+        continue;
+      }
+      row[`TOUCHES_VALUE_${i + 1}`] = safeDiv2(
+        toNumber(touch?.value, 0),
+        currentPrice
+      );
+      const touchDeltaMs = entryTimestamp - toNumber(touch?.timestamp, 0);
+      const touchDeltaMin = safeDiv2(touchDeltaMs, 6e4);
+      const touchDeltaBars = intervalMinutes > 0 ? safeDiv2(touchDeltaMin, intervalMinutes) : touchDeltaMin;
+      row[`TOUCHES_TS_${i + 1}`] = safeLog1pPositive(touchDeltaBars);
+    }
+    const normalizedPoints = points.map((point) => ({
+      value: toNumber(point?.value, NaN),
+      timestamp: toNumber(point?.timestamp, NaN)
+    })).filter(
+      (point) => Number.isFinite(point.value) && Number.isFinite(point.timestamp)
+    ).sort((a, b) => a.timestamp - b.timestamp);
+    if (normalizedPoints.length >= 2) {
+      const p1 = normalizedPoints[normalizedPoints.length - 2];
+      const p2 = normalizedPoints[normalizedPoints.length - 1];
+      const dtMs = p2.timestamp - p1.timestamp;
+      if (dtMs !== 0) {
+        const slopePerMs = (p2.value - p1.value) / dtMs;
+        const tlAtEntry = p1.value + slopePerMs * (entryTimestamp - p1.timestamp);
+        const slopePerBar = intervalMinutes > 0 ? slopePerMs * intervalMinutes * 6e4 : null;
+        row.TrendLine_Delta_To_Price = safeDiv2(
+          currentPrice - tlAtEntry,
+          currentPrice
+        );
+        row.TrendLine_Slope = slopePerBar == null ? null : safeLog1p(slopePerBar);
+      } else {
+        row.TrendLine_Delta_To_Price = null;
+        row.TrendLine_Slope = null;
+      }
+    } else {
+      row.TrendLine_Delta_To_Price = null;
+      row.TrendLine_Slope = null;
+    }
+  };
+  const applyLabelPhase = () => {
+    const profit = toNumber(resultRecord?.profit, NaN);
+    row.label = Number.isFinite(profit) ? profit > 0 ? 1 : 0 : null;
+    row.profit = Number.isFinite(profit) ? profit : null;
+  };
+  applyIndicatorAndCandlePhases();
+  applyRegimePhase();
+  applySeriesAnalysisPhase();
+  applyTrendlinePhase();
+  applyLabelPhase();
+  return row;
+};
+var trimMlTrainingRowWindows = (row, keep = ML_WINDOW_POLICY.outputWindow) => {
+  const indexedKeyPattern = /^(.*_)(\d+)(?:(_.*))?$/;
+  const groupMaxIndex = /* @__PURE__ */ new Map();
+  const groupKeyCount = /* @__PURE__ */ new Map();
+  for (const key of Object.keys(row)) {
+    const match = key.match(indexedKeyPattern);
+    if (!match) continue;
+    const index = Number(match[2]);
+    if (!Number.isFinite(index)) continue;
+    const signature = `${match[1]}|${match[3] ?? ""}`;
+    const prev = groupMaxIndex.get(signature) ?? 0;
+    if (index > prev) {
+      groupMaxIndex.set(signature, index);
+    }
+    groupKeyCount.set(signature, (groupKeyCount.get(signature) ?? 0) + 1);
+  }
+  const next = {};
+  for (const [key, value] of Object.entries(row)) {
+    const match = key.match(indexedKeyPattern);
+    if (!match) {
+      next[key] = value;
+      continue;
+    }
+    const prefix = match[1];
+    const suffix = match[3] ?? "";
+    const signature = `${prefix}|${suffix}`;
+    const maxIndex = groupMaxIndex.get(signature) ?? 0;
+    const keyCount = groupKeyCount.get(signature) ?? 0;
+    if (maxIndex <= keep || keyCount <= keep) {
+      next[key] = value;
+      continue;
+    }
+    const index = Number(match[2]);
+    const firstKeptIndex = maxIndex - keep + 1;
+    if (index < firstKeptIndex || index > maxIndex) {
+      continue;
+    }
+    const newIndex = index - firstKeptIndex + 1;
+    next[`${prefix}${newIndex}${suffix}`] = value;
+  }
+  return next;
+};
+
+// src/mlWindowing.ts
+var DAY_MS = 24 * 60 * 60 * 1e3;
+var toIsoUtcOrNull = (value) => {
+  if (!Number.isFinite(value) || !value || value <= 0) return null;
+  return new Date(Number(value)).toISOString();
+};
+var isDerivedDatasetFileName = (name) => [
+  ".holdout-train.",
+  ".holdout-test.",
+  ".walk-forward.",
+  ".walk-forward-",
+  ".prod."
+].some((token) => name.includes(token));
+var computeWindowBoundaries = ({
+  maxLabeledTs,
+  maxTrainTs,
+  testDays,
+  trainRecentDays,
+  walkForwardFolds
+}) => {
+  const holdoutCutoffMs = maxLabeledTs - testDays * DAY_MS;
+  const holdoutTrainStartMs = trainRecentDays > 0 ? maxTrainTs - trainRecentDays * DAY_MS : Number.NEGATIVE_INFINITY;
+  const wfStartMs = trainRecentDays > 0 ? maxTrainTs - (trainRecentDays + Math.max(walkForwardFolds, 0) * testDays) * DAY_MS : Number.NEGATIVE_INFINITY;
+  const prodStartMs = trainRecentDays > 0 ? maxLabeledTs - trainRecentDays * DAY_MS : Number.NEGATIVE_INFINITY;
+  const folds = Array.from(
+    { length: Math.max(walkForwardFolds, 0) },
+    (_, i) => {
+      const fold = i + 1;
+      const endTs = maxTrainTs - (fold - 1) * testDays * DAY_MS;
+      const startTs = endTs - testDays * DAY_MS;
+      return { fold, startTs, endTs };
+    }
+  );
+  return {
+    holdoutCutoffMs,
+    holdoutTrainStartMs,
+    wfStartMs,
+    prodStartMs,
+    folds
+  };
+};
+
+// src/mlCausalityGuard.ts
+var parseTimestampMs = (value) => {
+  const numeric = Number(value);
+  if (!Number.isFinite(numeric) || numeric <= 0) return null;
+  return numeric < 1e12 ? Math.trunc(numeric * 1e3) : Math.trunc(numeric);
+};
+var LOOKAHEAD_TS_KEY_RE = /(Timestamp|Ts|AtMs)$/;
+var isTimestampFeatureKey = (key) => {
+  if (!key || key === "entryTimestamp") return false;
+  return LOOKAHEAD_TS_KEY_RE.test(key);
+};
+var findLookaheadViolations = (row) => {
+  const entryTimestampMs = parseTimestampMs(row.entryTimestamp);
+  if (!entryTimestampMs) return [];
+  const violations = [];
+  for (const [key, value] of Object.entries(row)) {
+    if (!isTimestampFeatureKey(key)) continue;
+    const featureTimestampMs = parseTimestampMs(value);
+    if (!featureTimestampMs) continue;
+    if (featureTimestampMs > entryTimestampMs) {
+      violations.push({
+        key,
+        entryTimestampMs,
+        featureTimestampMs
+      });
+    }
+  }
+  return violations;
+};
+export {
+  analyzeMlSeriesWindow,
+  appendMlDatasetRow,
+  buildMlFeatures,
+  buildMlSeriesAlignment,
+  buildMlTrainingRow,
+  closeAllMlDatasetWriters,
+  closeMlDatasetWriter,
+  computeWindowBoundaries,
+  fetchMlThreshold,
+  findLookaheadViolations,
+  flushMlDatasetWriter,
+  getMlChunkFilePath,
+  isDerivedDatasetFileName,
+  isTimestampFeatureKey,
+  listMlChunkFiles,
+  mergeJsonlFiles,
+  toFileToken,
+  toIsoUtcOrNull,
+  trimMlTrainingRowWindows
+};