@tradejs/node 3.0.1 → 3.1.0

package/dist/runtimeDashboard.mjs

@@ -0,0 +1,955 @@
+import {
+  buildExchangeFallbackRuntimeTrades,
+  takeClosedPnlMatch
+} from "./chunk-FB5NUEOQ.mjs";
+import "./chunk-LAJ7NA3Q.mjs";
+import {
+  getConnectorCreatorByProvider
+} from "./chunk-3TWULKHV.mjs";
+import "./chunk-MKLTJQLY.mjs";
+import {
+  getAvailableStrategyNames
+} from "./chunk-KOQSLFT2.mjs";
+import "./chunk-WS5DYEVZ.mjs";
+import "./chunk-Y6FXYEAI.mjs";
+
+// src/runtimeDashboard.ts
+import { getRuntimeStorageDayKeys } from "@tradejs/core/time";
+import { logger } from "@tradejs/infra/logger";
+import { strategyLogicConfigFingerprint } from "@tradejs/infra/strategyReleaseEvidence";
+import {
+  listTradingAccounts,
+  resolveTradingAccount
+} from "@tradejs/infra/tradingAccounts";
+import { listRuntimeDeployments } from "@tradejs/infra/runtimeDeployments";
+import { loadRuntimeStrategyConfigs as loadStoredRuntimeStrategyConfigs } from "@tradejs/infra/runtimeStrategyConfigs";
+import {
+  getData as getData2,
+  getHashJsonValues,
+  getKeys,
+  redisKeys as redisKeys2
+} from "@tradejs/infra/redis";
+import {
+  buildRuntimeStrategyAnalytics,
+  isRuntimeTradeRecord,
+  selectTradesForWindow,
+  toRuntimeTradeView,
+  assignLegacyRuntimeTradeAccountScopes,
+  buildRuntimeStrategyIdentityKey
+} from "@tradejs/core/runtimeTrades";
+
+// src/strategyEvidenceTimeline.ts
+import fs from "fs/promises";
+import path from "path";
+import {
+  canonicalStrategyEvidenceJson,
+  safeStrategyEvidenceSegment,
+  verifyStrategyEvidenceMarkerEnvelope
+} from "@tradejs/infra/strategyReleaseEvidence";
+var DEFAULT_MARKER_DIRECTORY = "data/strategy-release/markers";
+var asRecord = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : null;
+var isNonEmptyString = (value) => typeof value === "string" && value.trim().length > 0;
+var strategyEvidenceTimelineSelectorKey = (selector) => [
+  selector.strategy,
+  selector.compositionId ?? "",
+  selector.gitSha ?? "",
+  selector.gateFingerprint ?? "",
+  selector.configFingerprint ?? "",
+  selector.contextFingerprint ?? "",
+  selector.requireCompleteLineage ? "exact" : "partial"
+].join(":");
+var discoverJsonFiles = async (rootDir) => {
+  const files = [];
+  const visit = async (directory, depth) => {
+    if (depth > 12) return;
+    let entries;
+    try {
+      entries = await fs.readdir(directory, { withFileTypes: true });
+    } catch (error) {
+      if (error.code === "ENOENT") return;
+      throw error;
+    }
+    await Promise.all(
+      entries.map(async (entry) => {
+        if (entry.name.startsWith(".") || entry.name.includes(".tmp-")) return;
+        const entryPath = path.join(directory, entry.name);
+        if (entry.isDirectory()) {
+          await visit(entryPath, depth + 1);
+        } else if (entry.isFile() && entry.name.endsWith(".json")) {
+          files.push(entryPath);
+        }
+      })
+    );
+  };
+  await visit(rootDir, 0);
+  return files.sort();
+};
+var inferMatchingStrategies = ({
+  filePath,
+  rootDir,
+  parsed,
+  strategies
+}) => {
+  const payload = asRecord(asRecord(parsed)?.payload);
+  const declaredStrategy = isNonEmptyString(payload?.strategy) ? payload.strategy : null;
+  const directoryStrategy = path.relative(rootDir, filePath).split(path.sep)[0];
+  return strategies.filter(
+    (strategy) => strategy === declaredStrategy || directoryStrategy === safeStrategyEvidenceSegment(strategy)
+  );
+};
+var missingTimeline = () => ({
+  status: "missing",
+  observedFrom: null,
+  markers: []
+});
+var invalidTimeline = () => ({
+  status: "invalid",
+  observedFrom: null,
+  markers: []
+});
+var loadStrategyEvidenceTimelines = async ({
+  projectRoot,
+  markerDir,
+  selectors: requestedSelectors,
+  startTime,
+  endTime
+}) => {
+  const selectors = [...requestedSelectors].filter((selector) => selector.strategy.trim().length > 0).sort(
+    (left, right) => strategyEvidenceTimelineSelectorKey(left).localeCompare(
+      strategyEvidenceTimelineSelectorKey(right)
+    )
+  );
+  const strategies = [...new Set(selectors.map(({ strategy }) => strategy))];
+  const timelines = new Map(
+    selectors.map((selector) => [
+      strategyEvidenceTimelineSelectorKey(selector),
+      missingTimeline()
+    ])
+  );
+  if (!selectors.length) return timelines;
+  const configuredDir = markerDir?.trim() || DEFAULT_MARKER_DIRECTORY;
+  const rootDir = path.isAbsolute(configuredDir) ? configuredDir : path.resolve(projectRoot, configuredDir);
+  let files;
+  try {
+    files = await discoverJsonFiles(rootDir);
+  } catch {
+    for (const selector of selectors) {
+      timelines.set(
+        strategyEvidenceTimelineSelectorKey(selector),
+        invalidTimeline()
+      );
+    }
+    return timelines;
+  }
+  const envelopesByStrategy = /* @__PURE__ */ new Map();
+  const invalidStrategies = /* @__PURE__ */ new Set();
+  for (const filePath of files) {
+    let parsed = null;
+    try {
+      parsed = JSON.parse(await fs.readFile(filePath, "utf8"));
+    } catch {
+      for (const strategy of inferMatchingStrategies({
+        filePath,
+        rootDir,
+        parsed,
+        strategies
+      })) {
+        invalidStrategies.add(strategy);
+      }
+      continue;
+    }
+    const matchingStrategies = inferMatchingStrategies({
+      filePath,
+      rootDir,
+      parsed,
+      strategies
+    });
+    if (!matchingStrategies.length) continue;
+    try {
+      const envelope = verifyStrategyEvidenceMarkerEnvelope(parsed);
+      for (const strategy of matchingStrategies) {
+        if (strategy !== envelope.payload.strategy) {
+          invalidStrategies.add(strategy);
+        }
+      }
+      if (!strategies.includes(envelope.payload.strategy)) {
+        continue;
+      }
+      const envelopes = envelopesByStrategy.get(envelope.payload.strategy) ?? [];
+      envelopes.push(envelope);
+      envelopesByStrategy.set(envelope.payload.strategy, envelopes);
+    } catch {
+      for (const strategy of matchingStrategies) {
+        invalidStrategies.add(strategy);
+      }
+    }
+  }
+  for (const selector of selectors) {
+    const strategy = selector.strategy;
+    const selectorKey = strategyEvidenceTimelineSelectorKey(selector);
+    if (invalidStrategies.has(strategy)) {
+      timelines.set(selectorKey, invalidTimeline());
+      continue;
+    }
+    const envelopes = envelopesByStrategy.get(strategy) ?? [];
+    if (!envelopes.length) continue;
+    const hasCompleteSelector = Boolean(selector.compositionId) && Boolean(selector.gitSha) && Boolean(selector.gateFingerprint) && Boolean(selector.configFingerprint) && Boolean(selector.contextFingerprint);
+    if (selector.requireCompleteLineage && !hasCompleteSelector) continue;
+    const markersById = /* @__PURE__ */ new Map();
+    let hasConflict = false;
+    for (const envelope of envelopes) {
+      for (const marker of envelope.payload.markers) {
+        const existing = markersById.get(marker.id);
+        if (existing && canonicalStrategyEvidenceJson(existing) !== canonicalStrategyEvidenceJson(marker)) {
+          hasConflict = true;
+          break;
+        }
+        markersById.set(marker.id, marker);
+      }
+      if (hasConflict) break;
+    }
+    if (hasConflict) {
+      timelines.set(selectorKey, invalidTimeline());
+      continue;
+    }
+    const matchingMarkers = [...markersById.values()].filter(
+      (marker) => (!selector.compositionId || marker.compositionId === selector.compositionId) && (!selector.gitSha || marker.gitSha === selector.gitSha) && (!selector.gateFingerprint || marker.gateFingerprint === selector.gateFingerprint) && (!selector.configFingerprint || marker.configFingerprint === selector.configFingerprint) && (!selector.contextFingerprint || marker.contextFingerprint === selector.contextFingerprint) && marker.timestamp >= startTime && marker.timestamp < endTime
+    ).sort(
+      (left, right) => left.timestamp - right.timestamp || left.type.localeCompare(right.type) || left.id.localeCompare(right.id)
+    );
+    let lastLossValue;
+    let hasLastLossValue = false;
+    const markers = matchingMarkers.filter((marker) => {
+      if (marker.type !== "L") return true;
+      if (hasLastLossValue && marker.maxLossValue === lastLossValue) {
+        return false;
+      }
+      hasLastLossValue = true;
+      lastLossValue = marker.maxLossValue;
+      return true;
+    });
+    if (!markers.length && (selector.compositionId || selector.gitSha || selector.gateFingerprint || selector.configFingerprint || selector.contextFingerprint)) {
+      continue;
+    }
+    timelines.set(selectorKey, {
+      status: "verified",
+      observedFrom: markers.length ? Math.min(...markers.map((marker) => marker.timestamp)) : Math.min(...envelopes.map((envelope) => envelope.payload.createdAt)),
+      markers
+    });
+  }
+  return timelines;
+};
+
+// src/runtimeTradeSync.ts
+import { TTL_1M } from "@tradejs/core/constants";
+import { getRuntimeStorageDayKey } from "@tradejs/core/time";
+import {
+  delKey,
+  getData,
+  redisKeys,
+  setData,
+  setHashJsonField
+} from "@tradejs/infra/redis";
+var redisRuntimeTradeStore = {
+  async getActiveOrderId({ userName, symbol, scopeId }) {
+    const value = await getData(
+      redisKeys.runtimeActiveTrade(userName, symbol, scopeId),
+      null
+    );
+    return typeof value?.orderId === "string" ? value.orderId : null;
+  },
+  async saveTrade({ userName, trade, expire }) {
+    await Promise.all([
+      setData(redisKeys.runtimeTrade(userName, trade.orderId), trade, {
+        expire
+      }),
+      setHashJsonField(
+        redisKeys.runtimeTradeBucket(
+          userName,
+          getRuntimeStorageDayKey(trade.entryTimestamp)
+        ),
+        trade.orderId,
+        trade,
+        { expire }
+      )
+    ]);
+  },
+  async saveClosedTrade({ userName, trade, expire }) {
+    await setHashJsonField(
+      redisKeys.runtimeClosedTradeBucket(
+        userName,
+        getRuntimeStorageDayKey(trade.exitTimestamp)
+      ),
+      trade.orderId,
+      trade,
+      { expire }
+    );
+  },
+  async deleteActiveTrade({ userName, symbol, scopeId }) {
+    await delKey(redisKeys.runtimeActiveTrade(userName, symbol, scopeId));
+  }
+};
+var getRuntimeTradeScopeId = (trade) => trade.deploymentId ?? trade.accountId;
+var isRuntimeTradeInConnectorScope = (trade, connector) => {
+  if (trade.deploymentId && trade.deploymentId !== connector.deploymentId) {
+    return false;
+  }
+  if (trade.deploymentId && !connector.deploymentId) {
+    return false;
+  }
+  if (trade.accountId && trade.accountId !== connector.accountId) {
+    return false;
+  }
+  if (trade.accountId && !connector.accountId) {
+    return false;
+  }
+  return (trade.universe ?? "crypto") === connector.universe;
+};
+var buildRiskLevelsAnalysis = (position) => {
+  const takeProfitPrice = typeof position.takeProfitPrice === "number" && Number.isFinite(position.takeProfitPrice) ? position.takeProfitPrice : null;
+  const stopLossPrice = typeof position.stopLossPrice === "number" && Number.isFinite(position.stopLossPrice) ? position.stopLossPrice : null;
+  if (takeProfitPrice == null && stopLossPrice == null) {
+    return null;
+  }
+  return {
+    ...takeProfitPrice != null ? { takeProfitPrice } : {},
+    ...stopLossPrice != null ? { stopLossPrice } : {}
+  };
+};
+var hasExchangeCloseDetails = (trade) => trade.status === "closed" && typeof trade.exitPrice === "number" && Number.isFinite(trade.exitPrice) && typeof trade.actualExitPrice === "number" && Number.isFinite(trade.actualExitPrice) && typeof trade.closedPnl === "number" && Number.isFinite(trade.closedPnl) && typeof trade.openFee === "number" && Number.isFinite(trade.openFee) && typeof trade.closeFee === "number" && Number.isFinite(trade.closeFee);
+var syncRuntimeTrades = async ({
+  userName,
+  connector,
+  trades,
+  endTime,
+  openPositions,
+  openPositionsReliable,
+  closedPnlRows,
+  store = redisRuntimeTradeStore
+}) => {
+  const openPositionsBySymbol = new Map(
+    openPositions.map((position) => [position.symbol, position])
+  );
+  const activeOrderIdByScope = /* @__PURE__ */ new Map();
+  const activeTradeScopes = [
+    ...new Map(
+      trades.filter((trade) => isRuntimeTradeInConnectorScope(trade, connector)).map((trade) => {
+        const scope = {
+          symbol: trade.symbol,
+          scopeId: getRuntimeTradeScopeId(trade)
+        };
+        return [`${scope.scopeId ?? ""}:${scope.symbol}`, scope];
+      })
+    ).values()
+  ];
+  await Promise.all(
+    activeTradeScopes.map(async ({ symbol, scopeId }) => {
+      activeOrderIdByScope.set(
+        `${scopeId ?? ""}:${symbol}`,
+        await store.getActiveOrderId({ userName, symbol, scopeId })
+      );
+    })
+  );
+  const exactByOrderLinkId = new Map(
+    closedPnlRows.filter(
+      (row) => typeof row.orderLinkId === "string" && row.orderLinkId.length > 0
+    ).map((row) => [row.orderLinkId, row])
+  );
+  const exactByOrderId = new Map(
+    closedPnlRows.filter(
+      (row) => typeof row.orderId === "string" && row.orderId.length > 0
+    ).map((row) => [row.orderId, row])
+  );
+  const symbolBuckets = /* @__PURE__ */ new Map();
+  for (const row of closedPnlRows) {
+    const bucket = symbolBuckets.get(row.symbol) ?? [];
+    bucket.push(row);
+    symbolBuckets.set(row.symbol, bucket);
+  }
+  const syncedTrades = [];
+  for (const trade of trades) {
+    if (!isRuntimeTradeInConnectorScope(trade, connector)) {
+      syncedTrades.push(trade);
+      continue;
+    }
+    const scopeId = getRuntimeTradeScopeId(trade);
+    const isCurrentActiveTrade = activeOrderIdByScope.get(`${scopeId ?? ""}:${trade.symbol}`) === trade.orderId;
+    if (hasExchangeCloseDetails(trade)) {
+      if (isCurrentActiveTrade) {
+        await store.deleteActiveTrade({
+          userName,
+          symbol: trade.symbol,
+          scopeId
+        });
+      }
+      syncedTrades.push(trade);
+      continue;
+    }
+    const openPosition = openPositionsBySymbol.get(trade.symbol);
+    if (trade.status === "active" && !openPositionsReliable) {
+      syncedTrades.push(trade);
+      continue;
+    }
+    if (trade.status === "active" && isCurrentActiveTrade && openPosition && openPosition.direction === trade.direction) {
+      const riskLevelsAnalysis = buildRiskLevelsAnalysis(openPosition);
+      const nextTrade2 = {
+        ...trade,
+        status: "active",
+        currentPrice: openPosition.currentPrice,
+        currentPnl: openPosition.unrealizedPnl,
+        aiAnalysis: riskLevelsAnalysis ? { ...trade.aiAnalysis ?? {}, ...riskLevelsAnalysis } : trade.aiAnalysis,
+        lastSyncedAt: endTime
+      };
+      await store.saveTrade({ userName, trade: nextTrade2, expire: 0 });
+      syncedTrades.push(nextTrade2);
+      continue;
+    }
+    const matchedClosedPnl = takeClosedPnlMatch({
+      exactByOrderLinkId,
+      exactByOrderId,
+      symbolBuckets,
+      trade
+    });
+    if (!matchedClosedPnl) {
+      syncedTrades.push(trade);
+      continue;
+    }
+    const nextTrade = {
+      ...trade,
+      status: "closed",
+      currentPrice: matchedClosedPnl.exitPrice ?? trade.currentPrice ?? null,
+      currentPnl: matchedClosedPnl.closedPnl,
+      closedPnl: matchedClosedPnl.closedPnl,
+      actualEntryPrice: matchedClosedPnl.entryPrice ?? trade.actualEntryPrice ?? null,
+      exitPrice: matchedClosedPnl.exitPrice ?? trade.exitPrice ?? null,
+      actualExitPrice: matchedClosedPnl.exitPrice ?? trade.actualExitPrice ?? null,
+      exitTimestamp: matchedClosedPnl.closedAt,
+      exitType: trade.exitType ?? null,
+      openFee: matchedClosedPnl.openFee ?? trade.openFee ?? null,
+      closeFee: matchedClosedPnl.closeFee ?? trade.closeFee ?? null,
+      fundingFee: matchedClosedPnl.fundingFee ?? trade.fundingFee ?? null,
+      totalFee: matchedClosedPnl.totalFee ?? trade.totalFee ?? null,
+      lastSyncedAt: endTime
+    };
+    await Promise.all([
+      store.saveTrade({ userName, trade: nextTrade, expire: TTL_1M }),
+      store.saveClosedTrade({ userName, trade: nextTrade, expire: TTL_1M }),
+      ...isCurrentActiveTrade ? [
+        store.deleteActiveTrade({
+          userName,
+          symbol: trade.symbol,
+          scopeId
+        })
+      ] : []
+    ]);
+    syncedTrades.push(nextTrade);
+  }
+  return syncedTrades;
+};
+
+// src/runtimeDashboard.ts
+var DEFAULT_PROVIDER = "bybit";
+var DEFAULT_HOURS = 168;
+var MIN_HOURS = 6;
+var MAX_HOURS = 24 * 90;
+var BYBIT_MAX_TIME_RANGE_MS = 7 * 24 * 60 * 60 * 1e3 - 1e3;
+var EXCHANGE_REQUEST_TIMEOUT_MS = 15e3;
+var coerceHours = (value) => {
+  const parsed = Number(value ?? Number.NaN);
+  if (!Number.isFinite(parsed)) {
+    return DEFAULT_HOURS;
+  }
+  return Math.min(MAX_HOURS, Math.max(MIN_HOURS, Math.trunc(parsed)));
+};
+var isRuntimeStrategyConfigEnabled = (config) => {
+  if (!config || typeof config !== "object" || Array.isArray(config)) {
+    return false;
+  }
+  return config.ENABLE !== false;
+};
+var loadRuntimeStrategyConfigs = async (userName) => {
+  return (await loadStoredRuntimeStrategyConfigs(userName)).map(
+    ({ strategyConfig, ...record }) => ({
+      ...record,
+      config: strategyConfig
+    })
+  );
+};
+var loadConfiguredStrategyNames = async (projectRoot) => {
+  try {
+    return await getAvailableStrategyNames(projectRoot);
+  } catch (error) {
+    logger.warn(
+      "strategies runtime: failed to load configured strategies: %s",
+      error?.message || String(error)
+    );
+    return [];
+  }
+};
+var resolveConnectorCreatorByProvider = async (provider, projectRoot) => await getConnectorCreatorByProvider(provider, projectRoot) ?? await getConnectorCreatorByProvider(DEFAULT_PROVIDER, projectRoot) ?? null;
+var resolveConnectorAccountId = async ({
+  userName,
+  provider
+}) => (await resolveTradingAccount({
+  userName,
+  provider,
+  universe: "crypto"
+}))?.id;
+var loadRuntimeTrades = async (userName, {
+  startTime,
+  endTime
+}) => {
+  const filterByWindow = (trade) => trade.entryTimestamp >= startTime || typeof trade.exitTimestamp === "number" && trade.exitTimestamp >= startTime;
+  const dayKeys = getRuntimeStorageDayKeys(startTime, endTime);
+  const bucketTrades = (await Promise.all(
+    dayKeys.map(
+      (dayKey) => getHashJsonValues(
+        redisKeys2.runtimeTradeBucket(userName, dayKey)
+      )
+    )
+  )).flat();
+  const dedupedBucketTrades = /* @__PURE__ */ new Map();
+  for (const trade of bucketTrades) {
+    if (!isRuntimeTradeRecord(trade)) {
+      continue;
+    }
+    dedupedBucketTrades.set(trade.orderId, trade);
+  }
+  if (dedupedBucketTrades.size > 0 || dayKeys.length === 0) {
+    return [...dedupedBucketTrades.values()].filter(filterByWindow).sort((left, right) => left.entryTimestamp - right.entryTimestamp);
+  }
+  const keys = await getKeys(redisKeys2.runtimeTrades(userName));
+  const trades = await Promise.all(keys.map((key) => getData2(key, null)));
+  return trades.filter(isRuntimeTradeRecord).filter(filterByWindow).sort((left, right) => left.entryTimestamp - right.entryTimestamp);
+};
+var buildExchangeTimeRanges = (startTime, endTime) => {
+  const ranges = [];
+  let cursor = startTime;
+  while (cursor < endTime) {
+    const rangeEnd = Math.min(endTime, cursor + BYBIT_MAX_TIME_RANGE_MS);
+    ranges.push({ startTime: cursor, endTime: rangeEnd });
+    cursor = rangeEnd + 1;
+  }
+  return ranges;
+};
+var loadExchangeRange = async ({
+  label,
+  startTime,
+  endTime,
+  load,
+  errors
+}) => {
+  try {
+    return await Promise.race([
+      load(),
+      new Promise((_, reject) => {
+        setTimeout(
+          () => reject(
+            new Error(
+              `${label} timed out for ${new Date(startTime).toISOString()} - ${new Date(endTime).toISOString()}`
+            )
+          ),
+          EXCHANGE_REQUEST_TIMEOUT_MS
+        );
+      })
+    ]);
+  } catch (error) {
+    const message = error?.message || String(error);
+    errors?.push(`${label}: ${message}`);
+    logger.warn("strategies runtime: %s failed: %s", label, message);
+    return [];
+  }
+};
+var loadActiveRuntimeOrderIds = async (userName) => {
+  const keys = await getKeys(redisKeys2.runtimeActiveTrades(userName));
+  const refs = await Promise.all(keys.map((key) => getData2(key, null)));
+  return new Set(
+    refs.map(
+      (ref) => typeof ref?.orderId === "string" && ref.orderId.trim() ? ref.orderId.trim() : null
+    ).filter((value) => Boolean(value))
+  );
+};
+var loadClosedPnlRows = async ({
+  connector,
+  startTime,
+  endTime,
+  errors
+}) => {
+  if (typeof connector.getClosedPnl !== "function") {
+    return [];
+  }
+  try {
+    const rows = (await Promise.all(
+      buildExchangeTimeRanges(startTime, endTime).map(
+        (range) => loadExchangeRange({
+          label: "getClosedPnl",
+          ...range,
+          errors,
+          load: () => connector.getClosedPnl?.({
+            ...range,
+            limit: 100
+          }) ?? Promise.resolve([])
+        })
+      )
+    )).flatMap((items) => items ?? []);
+    return rows.sort((left, right) => left.closedAt - right.closedAt);
+  } catch (error) {
+    const message = error?.message || String(error);
+    errors?.push(`getClosedPnl: ${message}`);
+    logger.warn("strategies runtime: getClosedPnl failed: %s", message);
+    return [];
+  }
+};
+var loadExchangeEntryRows = async ({
+  connector,
+  startTime,
+  endTime,
+  errors
+}) => {
+  if (typeof connector.getEntryExecutions !== "function") {
+    return [];
+  }
+  try {
+    const rows = (await Promise.all(
+      buildExchangeTimeRanges(startTime, endTime).map(
+        (range) => loadExchangeRange({
+          label: "getEntryExecutions",
+          ...range,
+          errors,
+          load: () => connector.getEntryExecutions?.({
+            ...range,
+            limit: 100
+          }) ?? Promise.resolve([])
+        })
+      )
+    )).flatMap((items) => items ?? []);
+    return rows.sort(
+      (left, right) => left.entryTimestamp - right.entryTimestamp
+    );
+  } catch (error) {
+    const message = error?.message || String(error);
+    errors?.push(`getEntryExecutions: ${message}`);
+    logger.warn("strategies runtime: getEntryExecutions failed: %s", message);
+    return [];
+  }
+};
+var loadOpenPositions = async (connector, errors) => {
+  if (typeof connector.getOpenPositionPnl !== "function") {
+    return { positions: [], reliable: false };
+  }
+  try {
+    return {
+      positions: await connector.getOpenPositionPnl(),
+      reliable: true
+    };
+  } catch (error) {
+    const message = error?.message || String(error);
+    errors?.push(`getOpenPositionPnl: ${message}`);
+    logger.warn("strategies runtime: getOpenPositionPnl failed: %s", message);
+    return { positions: [], reliable: false };
+  }
+};
+var loadRuntimeDashboard = async ({
+  userName,
+  provider: requestedProvider,
+  hours: requestedHours,
+  now,
+  projectRoot: requestedProjectRoot
+}) => {
+  const provider = requestedProvider?.trim() || DEFAULT_PROVIDER;
+  const hours = coerceHours(requestedHours);
+  const endTime = now ?? Date.now();
+  const startTime = endTime - hours * 60 * 60 * 1e3;
+  const projectRoot = requestedProjectRoot?.trim() || String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd();
+  const exchangeErrors = [];
+  const connectorCreator = await resolveConnectorCreatorByProvider(
+    provider,
+    projectRoot
+  );
+  if (!connectorCreator) {
+    throw new Error(`No connector available for provider "${provider}"`);
+  }
+  const connectorAccountId = await resolveConnectorAccountId({
+    userName,
+    provider
+  });
+  const connector = await connectorCreator({
+    userName,
+    accountId: connectorAccountId,
+    universe: "crypto"
+  });
+  const [
+    runtimeStrategyConfigs,
+    configuredStrategyNames,
+    runtimeTrades,
+    activeOrderIds,
+    closedPnlRows,
+    entryRows,
+    openPositionsSnapshot,
+    runtimeDeployments,
+    tradingAccounts
+  ] = await Promise.all([
+    loadRuntimeStrategyConfigs(userName),
+    loadConfiguredStrategyNames(projectRoot),
+    loadRuntimeTrades(userName, { startTime, endTime }),
+    loadActiveRuntimeOrderIds(userName),
+    loadClosedPnlRows({
+      connector,
+      startTime,
+      endTime,
+      errors: exchangeErrors
+    }),
+    loadExchangeEntryRows({
+      connector,
+      startTime,
+      endTime,
+      errors: exchangeErrors
+    }),
+    loadOpenPositions(connector, exchangeErrors),
+    listRuntimeDeployments(userName),
+    listTradingAccounts(userName)
+  ]);
+  const relevantTrades = selectTradesForWindow(
+    runtimeTrades,
+    startTime,
+    activeOrderIds
+  );
+  const syncableTrades = relevantTrades.filter(
+    (trade) => isRuntimeTradeInConnectorScope(trade, connector)
+  );
+  const unsyncedTrades = relevantTrades.filter(
+    (trade) => !isRuntimeTradeInConnectorScope(trade, connector)
+  );
+  const syncedConnectorTrades = await syncRuntimeTrades({
+    userName,
+    connector,
+    trades: syncableTrades,
+    endTime,
+    openPositions: openPositionsSnapshot.positions,
+    openPositionsReliable: openPositionsSnapshot.reliable,
+    closedPnlRows
+  });
+  const syncedTrades = [...unsyncedTrades, ...syncedConnectorTrades];
+  const fallbackStrategyNames = [
+    .../* @__PURE__ */ new Set([
+      ...runtimeStrategyConfigs.map(({ strategyName }) => strategyName),
+      ...configuredStrategyNames
+    ])
+  ];
+  const fallbackTrades = buildExchangeFallbackRuntimeTrades({
+    entryRows,
+    closedPnlRows,
+    openPositions: openPositionsSnapshot.positions,
+    strategyNames: fallbackStrategyNames,
+    existingTrades: syncedTrades,
+    endTime
+  });
+  const allTrades = [...syncedTrades, ...fallbackTrades].filter(
+    isRuntimeTradeRecord
+  );
+  const connectedSet = new Set(
+    runtimeStrategyConfigs.map(
+      ({ strategyName, configId }) => `${strategyName}:${configId}`
+    )
+  );
+  const accountsById = new Map(
+    tradingAccounts.map((account) => [account.id, account])
+  );
+  const runtimeIdentityKey = (trade) => buildRuntimeStrategyIdentityKey({
+    strategyName: trade.strategy,
+    configId: trade.runtimeConfigId,
+    universe: trade.universe,
+    accountId: trade.accountId,
+    deploymentId: trade.deploymentId,
+    policyProfileId: trade.policyProfileId
+  });
+  const identityByKey = /* @__PURE__ */ new Map();
+  const runtimeConfigAccountScopes = new Array();
+  for (const deployment of runtimeDeployments) {
+    for (const deploymentStrategy of deployment.strategies) {
+      const runtimeKey = buildRuntimeStrategyIdentityKey({
+        strategyName: deploymentStrategy.strategyName,
+        configId: `deployment-${deployment.id}`,
+        universe: deployment.universe,
+        accountId: deployment.accountId,
+        deploymentId: deployment.id,
+        policyProfileId: deploymentStrategy.policyProfileId
+      });
+      identityByKey.set(runtimeKey, {
+        strategyName: deploymentStrategy.strategyName,
+        configId: `deployment-${deployment.id}`,
+        interval: String(deployment.interval),
+        universe: deployment.universe,
+        accountId: deployment.accountId,
+        accountLabel: accountsById.get(deployment.accountId)?.label,
+        deploymentId: deployment.id,
+        policyProfileId: deploymentStrategy.policyProfileId,
+        releaseCompositionId: deploymentStrategy.releaseCompositionId,
+        enabled: deployment.enabled && deploymentStrategy.enabled !== false,
+        config: deploymentStrategy.config,
+        connected: false,
+        configFingerprint: strategyLogicConfigFingerprint(
+          deploymentStrategy.config
+        )
+      });
+    }
+  }
+  for (const runtimeConfig of runtimeStrategyConfigs) {
+    const universe = runtimeConfig.config.UNIVERSE === "tradfi" ? "tradfi" : "crypto";
+    const configuredAccountId = typeof runtimeConfig.config.ACCOUNT_ID === "string" && runtimeConfig.config.ACCOUNT_ID.trim() ? runtimeConfig.config.ACCOUNT_ID.trim() : void 0;
+    const resolvedAccount = await resolveTradingAccount({
+      userName,
+      accountId: configuredAccountId,
+      provider,
+      universe
+    }).catch(() => null);
+    const accountId = resolvedAccount?.id ?? configuredAccountId;
+    runtimeConfigAccountScopes.push({
+      strategyName: runtimeConfig.strategyName,
+      configId: runtimeConfig.configId,
+      universe,
+      accountId
+    });
+    const runtimeKey = buildRuntimeStrategyIdentityKey({
+      strategyName: runtimeConfig.strategyName,
+      configId: runtimeConfig.configId,
+      universe,
+      accountId
+    });
+    identityByKey.set(runtimeKey, {
+      strategyName: runtimeConfig.strategyName,
+      configId: runtimeConfig.configId,
+      interval: String(runtimeConfig.config.INTERVAL ?? "15"),
+      universe,
+      accountId,
+      accountLabel: accountId ? accountsById.get(accountId)?.label : void 0,
+      enabled: isRuntimeStrategyConfigEnabled(runtimeConfig.config),
+      config: runtimeConfig.config,
+      connected: true,
+      configFingerprint: strategyLogicConfigFingerprint(runtimeConfig.config)
+    });
+  }
+  const accountScopedTrades = assignLegacyRuntimeTradeAccountScopes(
+    allTrades,
+    runtimeConfigAccountScopes
+  );
+  for (const trade of accountScopedTrades) {
+    const key = runtimeIdentityKey(trade);
+    const configuredCompositionId = identityByKey.get(key)?.releaseCompositionId;
+    const observedCompositionId = trade.runtimeLineage?.compositionId;
+    const releaseCompositionId = configuredCompositionId && observedCompositionId && configuredCompositionId !== observedCompositionId ? void 0 : observedCompositionId ?? configuredCompositionId;
+    identityByKey.set(key, {
+      ...identityByKey.get(key),
+      strategyName: trade.strategy,
+      configId: trade.runtimeConfigId ?? "config",
+      interval: String(trade.interval ?? "15"),
+      universe: trade.universe ?? "crypto",
+      accountId: trade.accountId,
+      accountLabel: trade.accountId ? accountsById.get(trade.accountId)?.label : void 0,
+      deploymentId: trade.deploymentId,
+      policyProfileId: trade.policyProfileId,
+      releaseCompositionId,
+      configFingerprint: trade.runtimeLineage?.configFingerprint,
+      gateFingerprint: trade.runtimeLineage?.gateFingerprint,
+      contextFingerprint: trade.runtimeLineage?.contextFingerprint,
+      gitSha: trade.runtimeLineage?.gitSha ?? void 0,
+      maxLossValue: trade.runtimeLineage?.maxLossValue ?? void 0
+    });
+  }
+  const evidenceTimelines = await loadStrategyEvidenceTimelines({
+    projectRoot,
+    markerDir: process.env.STRATEGY_RELEASE_MARKER_DIR,
+    selectors: [...identityByKey.values()].map((identity) => ({
+      strategy: identity.strategyName,
+      compositionId: identity.releaseCompositionId,
+      configFingerprint: identity.configFingerprint,
+      gateFingerprint: identity.gateFingerprint,
+      contextFingerprint: identity.contextFingerprint,
+      gitSha: identity.gitSha,
+      maxLossValue: identity.maxLossValue,
+      requireCompleteLineage: true
+    })),
+    startTime,
+    endTime
+  });
+  const strategies = await Promise.all(
+    [...identityByKey.entries()].map(async ([runtimeKey, identity]) => {
+      const { strategyName } = identity;
+      const strategyTrades = accountScopedTrades.filter((trade) => runtimeIdentityKey(trade) === runtimeKey).sort((left, right) => right.entryTimestamp - left.entryTimestamp);
+      const orders = strategyTrades.sort((left, right) => {
+        const leftDate = left.exitTimestamp ?? left.entryTimestamp;
+        const rightDate = right.exitTimestamp ?? right.entryTimestamp;
+        return rightDate - leftDate;
+      }).map((trade) => toRuntimeTradeView(trade, endTime));
+      const analytics = buildRuntimeStrategyAnalytics({
+        trades: strategyTrades,
+        startTime,
+        endTime
+      });
+      const effectiveStrategyConfig = identity.config ?? null;
+      return {
+        runtimeKey,
+        strategyName,
+        configId: identity.configId,
+        interval: identity.interval,
+        universe: identity.universe,
+        accountId: identity.accountId,
+        accountLabel: identity.accountLabel,
+        deploymentId: identity.deploymentId,
+        policyProfileId: identity.policyProfileId,
+        connected: identity.connected ?? connectedSet.has(`${strategyName}:${identity.configId}`),
+        enabled: identity.enabled ?? isRuntimeStrategyConfigEnabled(effectiveStrategyConfig),
+        config: effectiveStrategyConfig,
+        symbols: [...new Set(strategyTrades.map((trade) => trade.symbol))],
+        stat: analytics.stat,
+        summary: analytics.summary,
+        orderLog: analytics.orderLog,
+        evidenceTimeline: evidenceTimelines.get(
+          strategyEvidenceTimelineSelectorKey({
+            strategy: strategyName,
+            compositionId: identity.releaseCompositionId,
+            configFingerprint: identity.configFingerprint,
+            gateFingerprint: identity.gateFingerprint,
+            contextFingerprint: identity.contextFingerprint,
+            gitSha: identity.gitSha,
+            maxLossValue: identity.maxLossValue,
+            requireCompleteLineage: true
+          })
+        ) ?? {
+          status: "missing",
+          observedFrom: null,
+          markers: []
+        },
+        recentTrades: strategyTrades.slice(0, 8).map((trade) => toRuntimeTradeView(trade, endTime)),
+        orders
+      };
+    })
+  );
+  strategies.sort((left, right) => {
+    if (left.stat.netProfit !== right.stat.netProfit) {
+      return right.stat.netProfit - left.stat.netProfit;
+    }
+    if (left.summary.totalPnl !== right.summary.totalPnl) {
+      return right.summary.totalPnl - left.summary.totalPnl;
+    }
+    if (left.connected !== right.connected) {
+      return left.connected ? -1 : 1;
+    }
+    return left.strategyName.localeCompare(right.strategyName);
+  });
+  const response = {
+    provider,
+    hours,
+    generatedAt: endTime,
+    dataSources: {
+      localTrades: syncedTrades.length,
+      exchangeFallbackTrades: fallbackTrades.length,
+      exchangeErrors: [...new Set(exchangeErrors)].sort()
+    },
+    strategies
+  };
+  return response;
+};
+export {
+  loadRuntimeDashboard
+};