@tradejs/core 3.0.0 → 3.1.0

package/dist/runtimeTrades.js

@@ -0,0 +1,577 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/runtimeTrades.ts
+var runtimeTrades_exports = {};
+__export(runtimeTrades_exports, {
+  assignLegacyRuntimeTradeAccountScopes: () => assignLegacyRuntimeTradeAccountScopes,
+  buildRuntimeStrategyAiGateChanges: () => buildRuntimeStrategyAiGateChanges,
+  buildRuntimeStrategyAnalytics: () => buildRuntimeStrategyAnalytics,
+  buildRuntimeStrategyIdentityKey: () => buildRuntimeStrategyIdentityKey,
+  buildRuntimeStrategyMaxLossValueTimeline: () => buildRuntimeStrategyMaxLossValueTimeline,
+  getRuntimeStrategyAiGateObservedFrom: () => getRuntimeStrategyAiGateObservedFrom,
+  isRuntimeStrategyLineageScope: () => isRuntimeStrategyLineageScope,
+  isRuntimeTradeRecord: () => isRuntimeTradeRecord,
+  resolveStrategyNameByOrderLinkId: () => resolveStrategyNameByOrderLinkId,
+  selectTradesForWindow: () => selectTradesForWindow,
+  toRuntimeTradeView: () => toRuntimeTradeView
+});
+module.exports = __toCommonJS(runtimeTrades_exports);
+
+// src/utils/runtimeTradeAnalytics.ts
+var import_date_fns = require("date-fns");
+
+// src/constants/index.ts
+var BACKTEST_EXECUTION_DELAY_MS = 5 * 6e4;
+var INITIAL_BACKTEST_AMOUNT = 100;
+var DERIVATIVES_CONTEXT_BASE_REFERENCE_SYMBOLS = [
+  "BTCUSDT",
+  "ETHUSDT"
+];
+var DERIVATIVES_CONTEXT_DEFAULT_EXTRA_REFERENCE_SYMBOLS = [
+  "BNBUSDT",
+  "SOLUSDT",
+  "TRXUSDT",
+  "XRPUSDT"
+];
+var DERIVATIVES_CONTEXT_REFERENCE_SYMBOLS = [
+  ...DERIVATIVES_CONTEXT_BASE_REFERENCE_SYMBOLS,
+  ...DERIVATIVES_CONTEXT_DEFAULT_EXTRA_REFERENCE_SYMBOLS
+];
+
+// src/utils/array.ts
+var import_lodash = __toESM(require("lodash"));
+
+// src/trade.ts
+var ORDER_LINK_PREFIX = "tjs-";
+var ORDER_LINK_SEPARATOR = "--";
+var STRATEGY_SLUG_LENGTH = 10;
+var STRATEGY_HASH_LENGTH = 5;
+var toBase36Hash = (value) => {
+  let hash = 0;
+  for (let index = 0; index < value.length; index += 1) {
+    hash = hash * 31 + value.charCodeAt(index) >>> 0;
+  }
+  return hash.toString(36).padStart(STRATEGY_HASH_LENGTH, "0");
+};
+var normalizeStrategyOrderLinkKey = (strategyName) => {
+  const normalized = String(strategyName ?? "").trim().toLowerCase();
+  if (!normalized) {
+    return null;
+  }
+  const slug = normalized.replace(/[^a-z0-9]+/g, "").slice(0, STRATEGY_SLUG_LENGTH) || "strategy";
+  const hash = toBase36Hash(normalized).slice(0, STRATEGY_HASH_LENGTH);
+  return `${slug}-${hash}`;
+};
+var parseStrategyOrderLinkKey = (orderLinkId) => {
+  const normalized = String(orderLinkId ?? "").trim().toLowerCase();
+  if (!normalized.startsWith(ORDER_LINK_PREFIX)) {
+    return null;
+  }
+  const remainder = normalized.slice(ORDER_LINK_PREFIX.length);
+  const separatorIndex = remainder.indexOf(ORDER_LINK_SEPARATOR);
+  if (separatorIndex <= 0) {
+    return null;
+  }
+  const strategyPart = remainder.slice(0, separatorIndex).trim();
+  if (!strategyPart) {
+    return null;
+  }
+  return strategyPart;
+};
+
+// src/utils/runtimeTradeAnalytics.ts
+var MS_IN_DAY = 24 * 60 * 60 * 1e3;
+var AVG_DAYS_IN_MONTH = 30.4375;
+var roundValue = (value, digits = 2) => {
+  if (!Number.isFinite(value)) return 0;
+  const factor = 10 ** digits;
+  return Math.round(value * factor) / factor;
+};
+var toFiniteNumberOrNull = (value) => typeof value === "number" && Number.isFinite(value) ? value : null;
+var getTradePnl = (trade) => trade.status === "closed" ? trade.closedPnl ?? trade.currentPnl ?? null : trade.currentPnl ?? null;
+var getTradeResolvedTimestamp = (trade, endTime) => typeof trade.exitTimestamp === "number" && Number.isFinite(trade.exitTimestamp) ? trade.exitTimestamp : endTime;
+var resolveTradesWithKnownPnl = (trades, endTime) => trades.map((trade) => {
+  const resolvedPnl = getTradePnl(trade);
+  const resolvedTimestamp = getTradeResolvedTimestamp(trade, endTime);
+  if (typeof resolvedPnl !== "number" || !Number.isFinite(resolvedPnl) || !Number.isFinite(resolvedTimestamp)) {
+    return null;
+  }
+  return {
+    ...trade,
+    resolvedPnl,
+    resolvedTimestamp: Math.max(trade.entryTimestamp, resolvedTimestamp)
+  };
+}).filter((trade) => trade != null).sort(
+  (left, right) => left.resolvedTimestamp - right.resolvedTimestamp || left.entryTimestamp - right.entryTimestamp
+);
+var calculateMaxDrawdown = (amounts) => {
+  let peak = amounts[0] ?? 0;
+  let maxDrawdown = 0;
+  for (const amount of amounts) {
+    peak = Math.max(peak, amount);
+    if (peak > 0) {
+      maxDrawdown = Math.max(maxDrawdown, (peak - amount) / peak * 100);
+    }
+  }
+  return roundValue(maxDrawdown);
+};
+var calculateSharpeRatio = (orderLog, startTime, endTime) => {
+  if (!orderLog.length || endTime <= startTime) return null;
+  const points = [...orderLog].map(([ts, amount]) => ({ ts, amount })).sort((left, right) => left.ts - right.ts);
+  const eomSeries = [];
+  let pointIndex = 0;
+  let monthCursor = (0, import_date_fns.startOfMonth)(new Date(startTime));
+  const lastMonth = (0, import_date_fns.endOfMonth)(new Date(endTime));
+  let lastAmount = points[0]?.amount ?? INITIAL_BACKTEST_AMOUNT;
+  while (monthCursor <= lastMonth) {
+    const eomTs = (0, import_date_fns.endOfMonth)(monthCursor).getTime();
+    while (pointIndex < points.length && points[pointIndex].ts <= eomTs) {
+      lastAmount = points[pointIndex].amount;
+      pointIndex += 1;
+    }
+    eomSeries.push(lastAmount);
+    monthCursor = (0, import_date_fns.addMonths)(monthCursor, 1);
+  }
+  if (eomSeries.length < 2) return null;
+  const monthlyReturns = eomSeries.slice(1).map((amount, index) => {
+    const previous = eomSeries[index];
+    return previous > 0 ? amount / previous - 1 : 0;
+  });
+  const mean = monthlyReturns.reduce((sum, value) => sum + value, 0) / monthlyReturns.length;
+  const variance = monthlyReturns.reduce((sum, value) => sum + (value - mean) ** 2, 0) / monthlyReturns.length;
+  const standardDeviation = Math.sqrt(variance);
+  return standardDeviation > 0 && Number.isFinite(standardDeviation) ? roundValue(mean / standardDeviation * Math.sqrt(12)) : null;
+};
+var calculateExposurePercent = (trades, startTime, endTime) => {
+  if (endTime <= startTime) return 0;
+  const intervals = trades.map((trade) => ({
+    start: Math.max(startTime, trade.entryTimestamp),
+    end: Math.min(endTime, getTradeResolvedTimestamp(trade, endTime))
+  })).filter(({ start, end }) => end > start).sort((left, right) => left.start - right.start);
+  const merged = [];
+  for (const interval of intervals) {
+    const last = merged[merged.length - 1];
+    if (!last || interval.start > last.end) {
+      merged.push({ ...interval });
+    } else {
+      last.end = Math.max(last.end, interval.end);
+    }
+  }
+  const coveredMs = merged.reduce(
+    (sum, interval) => sum + interval.end - interval.start,
+    0
+  );
+  return roundValue(coveredMs / (endTime - startTime) * 100);
+};
+var calculateStreaks = (pnls) => {
+  let currentWins = 0;
+  let currentLosses = 0;
+  let maxConsecutiveWins = 0;
+  let maxConsecutiveLosses = 0;
+  for (const pnl of pnls) {
+    if (pnl > 0) {
+      currentWins += 1;
+      currentLosses = 0;
+    } else if (pnl < 0) {
+      currentLosses += 1;
+      currentWins = 0;
+    } else {
+      currentWins = 0;
+      currentLosses = 0;
+    }
+    maxConsecutiveWins = Math.max(maxConsecutiveWins, currentWins);
+    maxConsecutiveLosses = Math.max(maxConsecutiveLosses, currentLosses);
+  }
+  return { maxConsecutiveWins, maxConsecutiveLosses };
+};
+var calculateSymbolConcentration = (trades, limit) => {
+  const pnlBySymbol = /* @__PURE__ */ new Map();
+  for (const trade of trades) {
+    pnlBySymbol.set(
+      trade.symbol,
+      (pnlBySymbol.get(trade.symbol) ?? 0) + Math.abs(trade.resolvedPnl)
+    );
+  }
+  const values = [...pnlBySymbol.values()].sort((left, right) => right - left);
+  const total = values.reduce((sum, value) => sum + value, 0);
+  return total > 0 ? roundValue(
+    values.slice(0, limit).reduce((sum, value) => sum + value, 0) / total * 100
+  ) : null;
+};
+var createEmptyStat = (startTime, endTime) => {
+  const periodDays = Math.max(0, (endTime - startTime) / MS_IN_DAY);
+  return {
+    periodDays: roundValue(periodDays),
+    periodMonths: roundValue(periodDays / AVG_DAYS_IN_MONTH),
+    orders: 0,
+    wins: 0,
+    losses: 0,
+    ordersPerMonth: 0,
+    exposure: 0,
+    amount: INITIAL_BACKTEST_AMOUNT,
+    maxAmount: INITIAL_BACKTEST_AMOUNT,
+    minAmount: INITIAL_BACKTEST_AMOUNT,
+    netProfit: 0,
+    totalReturn: 0,
+    cagr: 0,
+    maxDrawdown: 0,
+    calmar: null,
+    winRate: 0,
+    riskRewardRatio: null,
+    expectancy: 0,
+    maxConsecutiveWins: 0,
+    maxConsecutiveLosses: 0,
+    sharpeRatio: null,
+    score: 0
+  };
+};
+var resolveStrategyNameByOrderLinkId = ({
+  orderLinkId,
+  strategyNames
+}) => {
+  const strategyKey = parseStrategyOrderLinkKey(orderLinkId);
+  if (!strategyKey) return null;
+  const strategyByKey = /* @__PURE__ */ new Map();
+  for (const strategyName of strategyNames) {
+    const key = normalizeStrategyOrderLinkKey(strategyName);
+    if (key && !strategyByKey.has(key)) strategyByKey.set(key, strategyName);
+  }
+  return strategyByKey.get(strategyKey) ?? null;
+};
+var isRuntimeTradeRecord = (value) => {
+  if (!value || typeof value !== "object") return false;
+  const record = value;
+  return typeof record.orderId === "string" && typeof record.strategy === "string" && typeof record.symbol === "string" && typeof record.entryTimestamp === "number" && typeof record.entryPrice === "number" && typeof record.qty === "number";
+};
+var selectTradesForWindow = (trades, startTime, activeOrderIds = /* @__PURE__ */ new Set()) => trades.filter((trade) => {
+  if (trade.status === "active") {
+    return activeOrderIds.has(trade.orderId) || trade.entryTimestamp >= startTime;
+  }
+  return trade.entryTimestamp >= startTime || typeof trade.exitTimestamp === "number" && trade.exitTimestamp >= startTime;
+});
+var buildRuntimeStrategyAnalytics = ({
+  trades,
+  startTime,
+  endTime
+}) => {
+  const resolvedTrades = resolveTradesWithKnownPnl(trades, endTime);
+  const orderLog = [[startTime, INITIAL_BACKTEST_AMOUNT]];
+  let runningAmount = INITIAL_BACKTEST_AMOUNT;
+  for (const trade of resolvedTrades) {
+    runningAmount = roundValue(runningAmount + trade.resolvedPnl);
+    orderLog.push([trade.resolvedTimestamp, runningAmount]);
+  }
+  if (orderLog[orderLog.length - 1]?.[0] !== endTime) {
+    orderLog.push([endTime, runningAmount]);
+  }
+  const pnls = resolvedTrades.map(({ resolvedPnl }) => resolvedPnl);
+  const wins = pnls.filter((pnl) => pnl > 0).length;
+  const losses = pnls.filter((pnl) => pnl < 0).length;
+  const averageWin = wins ? pnls.filter((pnl) => pnl > 0).reduce((sum, pnl) => sum + pnl, 0) / wins : 0;
+  const averageLoss = losses ? Math.abs(
+    pnls.filter((pnl) => pnl < 0).reduce((sum, pnl) => sum + pnl, 0) / losses
+  ) : 0;
+  let amountBeforeTrade = INITIAL_BACKTEST_AMOUNT;
+  const returnSeries = resolvedTrades.map((trade) => {
+    const value = amountBeforeTrade > 0 ? trade.resolvedPnl / amountBeforeTrade : 0;
+    amountBeforeTrade += trade.resolvedPnl;
+    return value;
+  });
+  const periodDays = Math.max(0, (endTime - startTime) / MS_IN_DAY);
+  const periodMonths = periodDays / AVG_DAYS_IN_MONTH;
+  const amount = orderLog[orderLog.length - 1]?.[1] ?? INITIAL_BACKTEST_AMOUNT;
+  const netProfit = amount - INITIAL_BACKTEST_AMOUNT;
+  const totalReturn = netProfit / INITIAL_BACKTEST_AMOUNT * 100;
+  const cagr = periodMonths > 0 ? (Math.pow(amount / INITIAL_BACKTEST_AMOUNT, 12 / periodMonths) - 1) * 100 : 0;
+  const amounts = orderLog.map(([, value]) => value);
+  const maxDrawdown = calculateMaxDrawdown(amounts);
+  const streaks = calculateStreaks(pnls);
+  const stat = trades.length ? {
+    periodDays: roundValue(periodDays),
+    periodMonths: roundValue(periodMonths),
+    orders: trades.length,
+    wins,
+    losses,
+    ordersPerMonth: periodMonths ? roundValue(trades.length / periodMonths) : 0,
+    exposure: calculateExposurePercent(trades, startTime, endTime),
+    amount: roundValue(amount),
+    maxAmount: roundValue(Math.max(...amounts)),
+    minAmount: roundValue(Math.min(...amounts)),
+    netProfit: roundValue(netProfit),
+    totalReturn: roundValue(totalReturn),
+    cagr: roundValue(cagr),
+    maxDrawdown,
+    calmar: maxDrawdown > 0 ? roundValue(cagr / maxDrawdown) : null,
+    winRate: roundValue(wins / trades.length * 100),
+    riskRewardRatio: averageLoss > 0 ? roundValue(averageWin / averageLoss) : null,
+    expectancy: returnSeries.length ? roundValue(
+      returnSeries.reduce((sum, value) => sum + value, 0) / returnSeries.length * 100
+    ) : 0,
+    ...streaks,
+    sharpeRatio: calculateSharpeRatio(orderLog, startTime, endTime),
+    score: 0
+  } : createEmptyStat(startTime, endTime);
+  const activeTrades = trades.filter(({ status }) => status === "active");
+  const closedTrades = trades.filter(({ status }) => status === "closed");
+  const sumPnl = (rows, primary) => roundValue(
+    rows.reduce((sum, trade) => {
+      const value = trade[primary] ?? trade.currentPnl;
+      return sum + (typeof value === "number" && Number.isFinite(value) ? value : 0);
+    }, 0)
+  );
+  const activePnl = sumPnl(activeTrades, "currentPnl");
+  const closedPnl = sumPnl(closedTrades, "closedPnl");
+  const summary = {
+    totalTrades: trades.length,
+    activeTrades: activeTrades.length,
+    closedTrades: closedTrades.length,
+    wins,
+    losses,
+    activePnl,
+    closedPnl,
+    totalPnl: roundValue(activePnl + closedPnl),
+    symbolConcentrationTop1: calculateSymbolConcentration(resolvedTrades, 1),
+    symbolConcentrationTop5: calculateSymbolConcentration(resolvedTrades, 5)
+  };
+  return { orderLog, stat, summary };
+};
+var getLevelPercent = (trade, levelPrice, kind) => {
+  if (typeof levelPrice !== "number" || !Number.isFinite(levelPrice) || !Number.isFinite(trade.entryPrice) || trade.entryPrice <= 0) {
+    return null;
+  }
+  const raw = trade.direction === "LONG" ? (levelPrice - trade.entryPrice) / trade.entryPrice * 100 : (trade.entryPrice - levelPrice) / trade.entryPrice * 100;
+  return roundValue(kind === "stopLoss" ? Math.abs(raw) : raw);
+};
+var getSlippagePercent = (expectedPrice, actualPrice) => typeof expectedPrice === "number" && Number.isFinite(expectedPrice) && expectedPrice > 0 && typeof actualPrice === "number" && Number.isFinite(actualPrice) ? roundValue((actualPrice - expectedPrice) / expectedPrice * 100, 4) : null;
+var getTotalFee = (trade) => {
+  const explicit = toFiniteNumberOrNull(trade.totalFee);
+  if (explicit != null) return explicit;
+  const fees = [trade.openFee, trade.closeFee, trade.fundingFee].map(toFiniteNumberOrNull).filter((value) => value != null);
+  return fees.length ? Number(fees.reduce((sum, value) => sum + value, 0).toFixed(12)) : null;
+};
+var toRuntimeTradeView = (trade, endTime = Date.now()) => {
+  const resolvedTimestamp = getTradeResolvedTimestamp(trade, endTime);
+  const durationHours = Number.isFinite(resolvedTimestamp) && resolvedTimestamp >= trade.entryTimestamp ? roundValue((resolvedTimestamp - trade.entryTimestamp) / 36e5) : null;
+  const expectedExitPrice = trade.exitType === "tp" ? trade.aiAnalysis?.takeProfitPrice : trade.exitType === "sl" ? trade.aiAnalysis?.stopLossPrice : null;
+  return {
+    orderId: trade.orderId,
+    symbol: trade.symbol,
+    direction: trade.direction,
+    status: trade.status,
+    qty: trade.qty,
+    entryTimestamp: trade.entryTimestamp,
+    entryPrice: trade.entryPrice,
+    actualEntryPrice: toFiniteNumberOrNull(trade.actualEntryPrice),
+    exitTimestamp: toFiniteNumberOrNull(trade.exitTimestamp),
+    exitPrice: toFiniteNumberOrNull(trade.exitPrice),
+    actualExitPrice: toFiniteNumberOrNull(trade.actualExitPrice),
+    currentPrice: toFiniteNumberOrNull(trade.currentPrice),
+    pnl: getTradePnl(trade),
+    durationHours,
+    entrySlippagePercent: getSlippagePercent(
+      trade.entryPrice,
+      trade.actualEntryPrice
+    ),
+    exitSlippagePercent: getSlippagePercent(
+      expectedExitPrice,
+      trade.actualExitPrice ?? trade.exitPrice
+    ),
+    exitType: trade.exitType ?? null,
+    takeProfitPrice: toFiniteNumberOrNull(trade.aiAnalysis?.takeProfitPrice),
+    stopLossPrice: toFiniteNumberOrNull(trade.aiAnalysis?.stopLossPrice),
+    takeProfitPercent: getLevelPercent(
+      trade,
+      trade.aiAnalysis?.takeProfitPrice,
+      "takeProfit"
+    ),
+    stopLossPercent: getLevelPercent(
+      trade,
+      trade.aiAnalysis?.stopLossPrice,
+      "stopLoss"
+    ),
+    openFee: toFiniteNumberOrNull(trade.openFee),
+    closeFee: toFiniteNumberOrNull(trade.closeFee),
+    fundingFee: toFiniteNumberOrNull(trade.fundingFee),
+    totalFee: getTotalFee(trade),
+    lastSyncedAt: toFiniteNumberOrNull(trade.lastSyncedAt)
+  };
+};
+
+// src/utils/runtimeTradeLineage.ts
+var buildRuntimeStrategyIdentityKey = ({
+  strategyName,
+  configId,
+  universe,
+  accountId,
+  deploymentId,
+  policyProfileId
+}) => [
+  strategyName,
+  configId ?? "config",
+  universe ?? "crypto",
+  accountId ?? "default",
+  deploymentId ?? "default",
+  policyProfileId ?? "default"
+].join(":");
+var assignLegacyRuntimeTradeAccountScopes = (trades, scopes) => trades.map((trade) => {
+  if (trade.accountId || trade.deploymentId) return trade;
+  const matchingAccountIds = new Set(
+    scopes.filter(
+      (scope) => scope.strategyName === trade.strategy && scope.configId === (trade.runtimeConfigId ?? "config") && scope.universe === (trade.universe ?? "crypto")
+    ).map((scope) => scope.accountId).filter((accountId) => Boolean(accountId))
+  );
+  return matchingAccountIds.size === 1 ? { ...trade, accountId: [...matchingAccountIds][0] } : trade;
+});
+var getRuntimeStrategyAiGateObservedFrom = ({
+  scopes,
+  strategyName,
+  configId,
+  endTime
+}) => {
+  const normalizedConfigId = configId ?? "config";
+  let observedFrom = null;
+  for (const scope of scopes) {
+    if (scope.strategy !== strategyName || (scope.runtimeConfigId ?? "config") !== normalizedConfigId || scope.firstTimestamp > endTime) {
+      continue;
+    }
+    observedFrom = observedFrom == null ? scope.firstTimestamp : Math.min(observedFrom, scope.firstTimestamp);
+  }
+  return observedFrom;
+};
+var buildRuntimeStrategyMaxLossValueTimeline = ({
+  scopes,
+  strategyName,
+  configId,
+  startTime,
+  endTime
+}) => {
+  const normalizedConfigId = configId ?? "config";
+  const observationsByTimestamp = /* @__PURE__ */ new Map();
+  for (const scope of scopes) {
+    const value = scope.lineage.maxLossValue;
+    if (scope.strategy !== strategyName || (scope.runtimeConfigId ?? "config") !== normalizedConfigId || scope.firstTimestamp > endTime || typeof value !== "number" || !Number.isFinite(value)) {
+      continue;
+    }
+    const existing = observationsByTimestamp.get(scope.firstTimestamp);
+    if (!existing || scope.lastTimestamp > existing.lastTimestamp || scope.lastTimestamp === existing.lastTimestamp && value > existing.value) {
+      observationsByTimestamp.set(scope.firstTimestamp, {
+        value,
+        lastTimestamp: scope.lastTimestamp
+      });
+    }
+  }
+  const changes = [];
+  let observedFrom = null;
+  let initialValue = null;
+  let currentValue = null;
+  for (const [timestamp, observation] of [
+    ...observationsByTimestamp.entries()
+  ].sort(([left], [right]) => left - right)) {
+    if (currentValue == null) {
+      observedFrom = timestamp;
+      initialValue = observation.value;
+      currentValue = observation.value;
+      continue;
+    }
+    if (observation.value === currentValue) continue;
+    if (timestamp >= startTime) {
+      changes.push({
+        timestamp,
+        previousValue: currentValue,
+        value: observation.value
+      });
+    }
+    currentValue = observation.value;
+  }
+  return { observedFrom, initialValue, changes };
+};
+var isRuntimeStrategyLineageScope = (value) => {
+  if (!value || typeof value !== "object") return false;
+  const record = value;
+  const lineage = record.lineage;
+  return typeof record.strategy === "string" && typeof record.symbol === "string" && typeof record.firstTimestamp === "number" && Number.isFinite(record.firstTimestamp) && typeof record.lastTimestamp === "number" && Number.isFinite(record.lastTimestamp) && lineage != null && typeof lineage.gateFingerprint === "string" && lineage.gateFingerprint.trim().length > 0;
+};
+var buildRuntimeStrategyAiGateChanges = ({
+  scopes,
+  strategyName,
+  configId,
+  startTime,
+  endTime
+}) => {
+  const normalizedConfigId = configId ?? "config";
+  const observationsByTimestamp = /* @__PURE__ */ new Map();
+  for (const scope of scopes) {
+    if (scope.strategy !== strategyName || (scope.runtimeConfigId ?? "config") !== normalizedConfigId || scope.firstTimestamp > endTime) {
+      continue;
+    }
+    const fingerprint = scope.lineage.gateFingerprint.trim();
+    const existing = observationsByTimestamp.get(scope.firstTimestamp);
+    if (!existing || scope.lastTimestamp > existing.lastTimestamp || scope.lastTimestamp === existing.lastTimestamp && fingerprint > existing.fingerprint) {
+      observationsByTimestamp.set(scope.firstTimestamp, {
+        fingerprint,
+        lastTimestamp: scope.lastTimestamp
+      });
+    }
+  }
+  const changes = [];
+  let currentFingerprint = null;
+  for (const [timestamp, observation] of [
+    ...observationsByTimestamp.entries()
+  ].sort(([left], [right]) => left - right)) {
+    if (currentFingerprint == null) {
+      currentFingerprint = observation.fingerprint;
+      continue;
+    }
+    if (observation.fingerprint === currentFingerprint) continue;
+    if (timestamp >= startTime) {
+      changes.push({
+        timestamp,
+        previousFingerprint: currentFingerprint,
+        fingerprint: observation.fingerprint
+      });
+    }
+    currentFingerprint = observation.fingerprint;
+  }
+  return changes;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  assignLegacyRuntimeTradeAccountScopes,
+  buildRuntimeStrategyAiGateChanges,
+  buildRuntimeStrategyAnalytics,
+  buildRuntimeStrategyIdentityKey,
+  buildRuntimeStrategyMaxLossValueTimeline,
+  getRuntimeStrategyAiGateObservedFrom,
+  isRuntimeStrategyLineageScope,
+  isRuntimeTradeRecord,
+  resolveStrategyNameByOrderLinkId,
+  selectTradesForWindow,
+  toRuntimeTradeView
+});