@tradejs/node 3.1.27-beta.250 → 3.1.28-beta.251

package/dist/runtimeDashboard.js

@@ -1006,7 +1006,8 @@ var buildExchangeFallbackRuntimeTrades = ({
   openPositions,
   strategyNames,
   existingTrades,
-  endTime
+  endTime,
+  scope
 }) => {
   if (!entryRows.length && !closedPnlRows.length) return [];
   const strategyNameByOrderId = new Map(
@@ -1061,6 +1062,7 @@ var buildExchangeFallbackRuntimeTrades = ({
     const entryPrice = typeof entry.entryPrice === "number" && Number.isFinite(entry.entryPrice) ? entry.entryPrice : typeof closed?.entryPrice === "number" && Number.isFinite(closed.entryPrice) ? closed.entryPrice : null;
     if (entryPrice == null) return null;
     return {
+      ...scope,
       orderId: runtimeOrderId,
       strategy,
       symbol: entry.symbol,
@@ -1103,6 +1105,7 @@ var buildExchangeFallbackRuntimeTrades = ({
       return null;
     }
     return {
+      ...scope,
       orderId: runtimeOrderId,
       strategy,
       symbol: row.symbol,
@@ -1933,6 +1936,7 @@ var createStrategyRegistryState = () => ({
   strategyManifestsMap: /* @__PURE__ */ new Map(),
   strategyEntriesMap: /* @__PURE__ */ new Map(),
   strategySourcesMap: /* @__PURE__ */ new Map(),
+  strategyModuleResolutions: /* @__PURE__ */ new Map(),
   pluginsLoadPromise: null
 });
 var registryStateByProjectRoot2 = sharedStrategyRegistry.registryStateByProjectRoot;
@@ -1994,7 +1998,7 @@ var validateStrategyEntries = (moduleName, entries, state) => {
     const strategyName = entry?.manifest?.name;
     if (typeof strategyName !== "string" || !strategyName.trim()) {
       issues.push(`${entryPath}: manifest.name is required`);
-    } else if (names.has(strategyName) || state.strategyEntriesMap.has(strategyName)) {
+    } else if (names.has(strategyName) || state?.strategyEntriesMap.has(strategyName)) {
       issues.push(`${entryPath}: duplicate strategy ${strategyName}`);
     } else {
       names.add(strategyName);
@@ -2056,6 +2060,72 @@ var importStrategyPluginModule = async (moduleName, cwd = getTradejsProjectCwd()
     moduleName
   );
 };
+var resolveStrategyModuleEntry = async ({
+  strategyName,
+  moduleName,
+  cwd
+}) => {
+  const { projectRoot, state } = getStrategyRegistryState(cwd);
+  const source = moduleName.trim();
+  const resolvedModuleName = resolvePluginModuleSpecifier(source, projectRoot);
+  const cacheKey = `${resolvedModuleName}\0${strategyName}`;
+  const cached = state.strategyModuleResolutions.get(cacheKey);
+  if (cached) return cached;
+  const resolution = (async () => {
+    const moduleExport = await importStrategyPluginModule(
+      resolvedModuleName,
+      projectRoot
+    );
+    const pluginDefinition = extractStrategyPluginDefinition(moduleExport);
+    if (!pluginDefinition) {
+      throw new Error(`${source}: export { strategyEntries } is missing`);
+    }
+    const issues = validateStrategyEntries(
+      source,
+      pluginDefinition.strategyEntries
+    );
+    if (issues.length > 0) {
+      throw new Error(
+        ["Invalid TradeJS strategy module:", ...issues].join("\n")
+      );
+    }
+    const entry = pluginDefinition.strategyEntries.find(
+      (candidate) => candidate.manifest.name === strategyName
+    );
+    if (!entry) {
+      throw new Error(`${source}: strategy ${strategyName} is missing`);
+    }
+    const factory = sharedStrategyRegistry.strategyRuntimeFactory;
+    if (!factory) {
+      throw new Error("Strategy runtime factory is not configured");
+    }
+    const manifestsByName = new Map(
+      pluginDefinition.strategyEntries.map(
+        (candidate) => [candidate.manifest.name, candidate.manifest]
+      )
+    );
+    return {
+      entry,
+      creator: factory({
+        strategyName,
+        defaults: entry.defaults,
+        createCore: entry.createCore,
+        manifest: entry.manifest,
+        detectorKey: entry.detectorKey,
+        detectorNoSignalSkipReason: entry.detectorNoSignalSkipReason,
+        resolveRegisteredManifest: (name) => manifestsByName.get(name) ?? state.strategyManifestsMap.get(name)
+      }),
+      source
+    };
+  })();
+  state.strategyModuleResolutions.set(cacheKey, resolution);
+  try {
+    return await resolution;
+  } catch (error) {
+    state.strategyModuleResolutions.delete(cacheKey);
+    throw error;
+  }
+};
 var ensureStrategyPluginsLoaded = async (cwd = getTradejsProjectCwd()) => {
   const { projectRoot, state } = getStrategyRegistryState(cwd);
   if (!state.pluginsLoadPromise) {
@@ -2133,17 +2203,29 @@ var ensureStrategyPluginsLoaded = async (cwd = getTradejsProjectCwd()) => {
   }
   await state.pluginsLoadPromise;
 };
-var getStrategyCreator = async (name, cwd = getTradejsProjectCwd()) => {
+var getStrategyCreator = async (name, cwd = getTradejsProjectCwd(), moduleName) => {
+  if (moduleName?.trim()) {
+    await ensureStrategyPluginsLoaded(cwd);
+    return (await resolveStrategyModuleEntry({ strategyName: name, moduleName, cwd })).creator;
+  }
   await ensureStrategyPluginsLoaded(cwd);
   const { state } = getStrategyRegistryState(cwd);
   return state.strategyCreators.get(name);
 };
-var getStrategyEntry = async (name, cwd = getTradejsProjectCwd()) => {
+var getStrategyEntry = async (name, cwd = getTradejsProjectCwd(), moduleName) => {
+  if (moduleName?.trim()) {
+    await ensureStrategyPluginsLoaded(cwd);
+    return (await resolveStrategyModuleEntry({ strategyName: name, moduleName, cwd })).entry;
+  }
   await ensureStrategyPluginsLoaded(cwd);
   const { state } = getStrategyRegistryState(cwd);
   return state.strategyEntriesMap.get(name);
 };
-var getStrategyPluginSource = async (name, cwd = getTradejsProjectCwd()) => {
+var getStrategyPluginSource = async (name, cwd = getTradejsProjectCwd(), moduleName) => {
+  if (moduleName?.trim()) {
+    await ensureStrategyPluginsLoaded(cwd);
+    return (await resolveStrategyModuleEntry({ strategyName: name, moduleName, cwd })).source;
+  }
   await ensureStrategyPluginsLoaded(cwd);
   const { state } = getStrategyRegistryState(cwd);
   return state.strategySourcesMap.get(name);
@@ -3362,9 +3444,40 @@ var DEFAULT_MAX_AGE_BY_INTERVAL = {
   "15m": 30 * 6e4,
   "1h": 2 * 60 * 6e4
 };
+var MARKET_CONTEXT_PRELOAD_CHUNK_MS = 7 * 24 * 60 * 6e4;
 var binanceMarketContextUnavailable = false;
 var referenceRowsCache = /* @__PURE__ */ new Map();
 var breadthCache = /* @__PURE__ */ new Map();
+var BREADTH_COMMON_NUMERIC_FIELDS = [
+  "symbolsCount",
+  "advancers",
+  "decliners",
+  "unchanged",
+  "advanceDeclineRatio",
+  "pctAboveMa20",
+  "pctAboveMa50",
+  "equalWeightedReturn",
+  "volumeWeightedReturn",
+  "dispersion"
+];
+var BREADTH_REGIME_NUMERIC_FIELDS = [
+  "btcReturn1h",
+  "btcReturn4h",
+  "btcReturn24h",
+  "altBasketReturn1h",
+  "altBasketReturn4h",
+  "altBasketReturn24h",
+  "btcVsAltReturn1h",
+  "btcVsAltReturn4h",
+  "btcVsAltReturn24h",
+  "btcTurnoverShare1h",
+  "btcTurnoverShare24h",
+  "btcTurnoverShareChange24h",
+  "altVolToBtcVol24h",
+  "altDispersion24h"
+];
+var preloadedTradeFlowBySymbol = null;
+var preloadedBreadthByUniverse = null;
 var parseEnabledFlag = (value, env) => {
   const normalized = String(value ?? "").trim().toLowerCase();
   if (!normalized)
@@ -3400,6 +3513,100 @@ var hasBaseContext = (signal) => Boolean(
   signal.additionalIndicators?.baseContext && typeof signal.additionalIndicators.baseContext === "object" && !Array.isArray(signal.additionalIndicators.baseContext)
 );
 var isBinanceMarketContextEnabled = (env) => parseEnabledFlag(process.env.BINANCE_MARKET_CONTEXT_ENABLED, env);
+var latestIndexAtOrBefore = (timestamps, timestamp) => {
+  if (!timestamps?.length) return -1;
+  let low = 0;
+  let high = timestamps.length - 1;
+  let match = -1;
+  while (low <= high) {
+    const middle = Math.floor((low + high) / 2);
+    const rowTimestamp = timestamps[middle];
+    if (rowTimestamp == null) break;
+    if (rowTimestamp <= timestamp) {
+      match = middle;
+      low = middle + 1;
+    } else {
+      high = middle - 1;
+    }
+  }
+  return match;
+};
+var latestChunkAtOrBefore = (chunks, timestamp) => {
+  if (!chunks?.length) return null;
+  let low = 0;
+  let high = chunks.length - 1;
+  let match = null;
+  while (low <= high) {
+    const middle = Math.floor((low + high) / 2);
+    const chunk = chunks[middle];
+    const firstTimestamp = chunk?.timestamps[0];
+    if (!chunk || firstTimestamp == null) break;
+    if (firstTimestamp <= timestamp) {
+      match = chunk;
+      low = middle + 1;
+    } else {
+      high = middle - 1;
+    }
+  }
+  return match;
+};
+var unpackedNumber = (value) => value == null || Number.isNaN(value) ? null : value;
+var unpackTradeFlowRow = (chunks, timestamp) => {
+  const rows = latestChunkAtOrBefore(chunks, timestamp);
+  const index = latestIndexAtOrBefore(rows?.timestamps, timestamp);
+  if (!rows || index < 0) return null;
+  return {
+    symbol: rows.symbol,
+    interval: rows.interval,
+    ts: new Date(rows.timestamps[index]),
+    trades: unpackedNumber(rows.columns.trades[index]) ?? 0,
+    buyBaseVolume: unpackedNumber(rows.columns.buyBaseVolume[index]),
+    sellBaseVolume: unpackedNumber(rows.columns.sellBaseVolume[index]),
+    buyQuoteVolume: unpackedNumber(rows.columns.buyQuoteVolume[index]),
+    sellQuoteVolume: unpackedNumber(rows.columns.sellQuoteVolume[index]),
+    netBaseDelta: unpackedNumber(rows.columns.netBaseDelta[index]),
+    netQuoteDelta: unpackedNumber(rows.columns.netQuoteDelta[index]),
+    buyPressurePct: unpackedNumber(rows.columns.buyPressurePct[index])
+  };
+};
+var unpackBreadthRow = (chunks, timestamp) => {
+  const rows = latestChunkAtOrBefore(chunks, timestamp);
+  const index = latestIndexAtOrBefore(rows?.timestamps, timestamp);
+  if (!rows || index < 0) return null;
+  const commonNumeric = Object.fromEntries(
+    BREADTH_COMMON_NUMERIC_FIELDS.map((field) => [
+      field,
+      unpackedNumber(rows.commonColumns[field][index])
+    ])
+  );
+  const regimeNumeric = Object.fromEntries(
+    BREADTH_REGIME_NUMERIC_FIELDS.map((field) => [
+      field,
+      unpackedNumber(rows.regimeColumns?.[field][index])
+    ])
+  );
+  return {
+    universe: rows.universe,
+    interval: rows.interval,
+    ts: new Date(rows.timestamps[index]),
+    ...commonNumeric,
+    ...regimeNumeric,
+    symbolsCount: commonNumeric.symbolsCount ?? 0,
+    advancers: commonNumeric.advancers ?? 0,
+    decliners: commonNumeric.decliners ?? 0,
+    unchanged: commonNumeric.unchanged ?? 0,
+    btcAltRegime: rows.regimes?.[index] ?? null
+  };
+};
+var toAsOfRow = (row, timestamp, maxAgeMs) => {
+  if (!row) return null;
+  const ageMs = timestamp - row.ts.getTime();
+  return {
+    ...row,
+    ageMs: Number.isFinite(ageMs) ? ageMs : null,
+    stale: !Number.isFinite(ageMs) || ageMs < 0 || ageMs > maxAgeMs
+  };
+};
 var toTradeFlowContext = (row, interval) => row ? {
   source: "binance_agg_trades",
   interval,
@@ -3422,6 +3629,24 @@ var getCachedReferenceRows = ({
   maxAgeMs,
   abortSignal
 }) => {
+  if (preloadedTradeFlowBySymbol) {
+    return Promise.resolve(
+      referenceSymbols.map((symbol) => ({
+        symbol,
+        tradeFlow: toTradeFlowContext(
+          toAsOfRow(
+            unpackTradeFlowRow(
+              preloadedTradeFlowBySymbol?.get(symbol),
+              timestamp
+            ),
+            timestamp,
+            maxAgeMs
+          ),
+          interval
+        )
+      }))
+    );
+  }
   const key = `${referenceSymbols.join(",")}:${interval}:${timestamp}:${maxAgeMs}`;
   const cached = referenceRowsCache.get(key);
   if (cached) return cached;
@@ -3451,6 +3676,18 @@ var getCachedBreadth = ({
   maxAgeMs,
   abortSignal
 }) => {
+  if (preloadedBreadthByUniverse) {
+    return Promise.resolve(
+      toAsOfRow(
+        unpackBreadthRow(
+          preloadedBreadthByUniverse.get(breadthUniverse),
+          timestamp
+        ),
+        timestamp,
+        maxAgeMs
+      )
+    );
+  }
   const key = `${breadthUniverse}:${interval}:${timestamp}:${maxAgeMs}`;
   const cached = breadthCache.get(key);
   if (cached) return cached;
@@ -3657,12 +3894,20 @@ var SOURCE_EXCHANGE_LIQUIDITY = "coinmarketcap_exchange_liquidity";
 var SOURCE_FEAR_GREED = "coinmarketcap_fear_greed";
 var SOURCE_INDEX = "coinmarketcap_index";
 var DAY_MS = 864e5;
+var MAX_TIMESTAMP_CACHE_ENTRIES = 512;
 var coinMarketCapContextUnavailable = false;
 var globalContextCache = /* @__PURE__ */ new Map();
 var referenceContextCache = /* @__PURE__ */ new Map();
 var exchangeLiquidityContextCache = /* @__PURE__ */ new Map();
 var fearGreedContextCache = /* @__PURE__ */ new Map();
 var indexContextCache = /* @__PURE__ */ new Map();
+var setBoundedCache = (cache, key, value) => {
+  if (cache.size >= MAX_TIMESTAMP_CACHE_ENTRIES) {
+    const oldestKey = cache.keys().next().value;
+    if (oldestKey != null) cache.delete(oldestKey);
+  }
+  cache.set(key, value);
+};
 var parseEnabledFlag2 = (value, env) => {
   const normalized = String(value ?? "").trim().toLowerCase();
   if (!normalized) {
@@ -3769,7 +4014,7 @@ var getCachedGlobalContext = ({
     maxAgeMs,
     ...abortSignal ? { signal: abortSignal } : {}
   });
-  globalContextCache.set(key, promise);
+  setBoundedCache(globalContextCache, key, promise);
   void promise.catch(() => globalContextCache.delete(key));
   return promise;
 };
@@ -3789,7 +4034,7 @@ var getCachedReferenceContexts = ({
     maxAgeMs,
     ...abortSignal ? { signal: abortSignal } : {}
   });
-  referenceContextCache.set(key, promise);
+  setBoundedCache(referenceContextCache, key, promise);
   void promise.catch(() => referenceContextCache.delete(key));
   return promise;
 };
@@ -3808,7 +4053,7 @@ var getCachedExchangeLiquidityContext = ({
     maxAgeMs,
     ...abortSignal ? { signal: abortSignal } : {}
   });
-  exchangeLiquidityContextCache.set(key, promise);
+  setBoundedCache(exchangeLiquidityContextCache, key, promise);
   void promise.catch(() => exchangeLiquidityContextCache.delete(key));
   return promise;
 };
@@ -3827,7 +4072,7 @@ var getCachedFearGreedContext = ({
     maxAgeMs,
     ...abortSignal ? { signal: abortSignal } : {}
   });
-  fearGreedContextCache.set(key, promise);
+  setBoundedCache(fearGreedContextCache, key, promise);
   void promise.catch(() => fearGreedContextCache.delete(key));
   return promise;
 };
@@ -3847,7 +4092,7 @@ var getCachedIndexContexts = ({
     maxAgeMs,
     ...abortSignal ? { signal: abortSignal } : {}
   });
-  indexContextCache.set(key, promise);
+  setBoundedCache(indexContextCache, key, promise);
   void promise.catch(() => indexContextCache.delete(key));
   return promise;
 };
@@ -4657,7 +4902,7 @@ var signalIntervalToMarketInterval2 = (value) => {
 var hasBaseContext3 = (signal) => Boolean(
   signal.additionalIndicators?.baseContext && typeof signal.additionalIndicators.baseContext === "object" && !Array.isArray(signal.additionalIndicators.baseContext)
 );
-var setBoundedCache = (key, value) => {
+var setBoundedCache2 = (key, value) => {
   if (contextCache.size >= MAX_CACHE_ENTRIES) {
     const oldestKey = contextCache.keys().next().value;
     if (oldestKey != null) contextCache.delete(oldestKey);
@@ -4904,7 +5149,7 @@ var loadHyperliquidWhaleFlowContext = async (params) => {
           whaleRegistryFingerprint: whales.fingerprint,
           ...params.abortSignal ? { signal: params.abortSignal } : {}
         });
-        setBoundedCache(cacheKey, pending);
+        setBoundedCache2(cacheKey, pending);
       }
       row = await pending;
     }
@@ -6039,20 +6284,23 @@ var buildHookCtx = ({
   strategyConfig,
   env,
   isConfigFromBacktest
-}) => ({
-  connector,
-  strategyName,
-  userName,
-  symbol,
-  ...universe ? { universe } : {},
-  ...assetClass ? { assetClass } : {},
-  ...accountId ? { accountId } : {},
-  ...deploymentId ? { deploymentId } : {},
-  ...policyProfileId ? { policyProfileId } : {},
-  strategyConfig,
-  env,
-  isConfigFromBacktest
-});
+}) => {
+  const context = {
+    connector,
+    strategyName,
+    userName,
+    symbol
+  };
+  if (universe) context.universe = universe;
+  if (assetClass) context.assetClass = assetClass;
+  if (accountId) context.accountId = accountId;
+  if (deploymentId) context.deploymentId = deploymentId;
+  if (policyProfileId) context.policyProfileId = policyProfileId;
+  context.strategyConfig = strategyConfig;
+  context.env = env;
+  context.isConfigFromBacktest = isConfigFromBacktest;
+  return context;
+};
 var shouldRecordRuntimeJournal = ({
   env,
   config
@@ -7397,7 +7645,13 @@ var DEPLOYMENT_KEYS = /* @__PURE__ */ new Set([
   "assetClasses",
   "tickers"
 ]);
-var STRATEGY_KEYS = /* @__PURE__ */ new Set(["generation", "enabled", "selection", "config"]);
+var STRATEGY_KEYS = /* @__PURE__ */ new Set([
+  "module",
+  "generation",
+  "enabled",
+  "selection",
+  "config"
+]);
 var SELECTION_KEYS = /* @__PURE__ */ new Set(["tickers"]);
 var FORBIDDEN_CONFIG_KEYS = /* @__PURE__ */ new Set([
   "ACCOUNT_ID",
@@ -7469,6 +7723,39 @@ var readRuntimePackageManifest = async (projectRoot) => {
   }
   return value;
 };
+var parseNpmAliasReference = (value) => {
+  if (typeof value !== "string" || !value.startsWith("npm:")) return null;
+  const target = value.slice("npm:".length);
+  const versionSeparator = target.lastIndexOf("@");
+  if (versionSeparator <= 0 || versionSeparator === target.length - 1) {
+    return null;
+  }
+  return {
+    packageName: target.slice(0, versionSeparator),
+    version: target.slice(versionSeparator + 1)
+  };
+};
+var verifyInstalledPackageName = async ({
+  projectRoot,
+  packageName,
+  installedName,
+  installedVersion,
+  projectPackage
+}) => {
+  if (installedName === void 0 || installedName === packageName) return;
+  if (projectPackage || typeof installedName !== "string") {
+    throw new Error("name is invalid");
+  }
+  const projectManifest = JSON.parse(
+    await (0, import_promises.readFile)(import_node_path.default.join(projectRoot, "package.json"), "utf8")
+  );
+  const alias = parseNpmAliasReference(
+    projectManifest.dependencies?.[packageName]
+  );
+  if (alias?.packageName !== installedName || alias.version !== installedVersion) {
+    throw new Error("name or alias target is invalid");
+  }
+};
 var readInstalledPackageMetadata = async ({
   projectRoot,
   packageName,
@@ -7482,9 +7769,16 @@ var readInstalledPackageMetadata = async ({
   );
   try {
     const packageJson = JSON.parse(await (0, import_promises.readFile)(packageJsonPath, "utf8"));
-    if (packageJson.name !== void 0 && packageJson.name !== packageName || typeof packageJson.version !== "string" || !packageJson.version.trim()) {
-      throw new Error("name or version is invalid");
+    if (typeof packageJson.version !== "string" || !packageJson.version.trim()) {
+      throw new Error("version is invalid");
     }
+    await verifyInstalledPackageName({
+      projectRoot,
+      packageName,
+      installedName: packageJson.name,
+      installedVersion: packageJson.version,
+      projectPackage
+    });
     const dependencyNames = [
       ...isRecord(packageJson.dependencies) ? Object.keys(packageJson.dependencies) : [],
       ...isRecord(packageJson.peerDependencies) ? Object.keys(packageJson.peerDependencies) : []
@@ -7579,7 +7873,7 @@ var verifyDeploymentDeclaration = (deploymentId, value) => {
   for (const [strategyName, strategyValue] of Object.entries(
     value.strategies
   )) {
-    if (!strategyName.trim() || !isRecord(strategyValue) || Object.keys(strategyValue).some((key) => !STRATEGY_KEYS.has(key)) || strategyValue.generation !== void 0 && (typeof strategyValue.generation !== "string" || !strategyValue.generation.trim()) || typeof strategyValue.enabled !== "boolean" || !verifyStrategySelection(strategyValue.selection) || !isRecord(strategyValue.config) || Object.keys(strategyValue.config).some(
+    if (!strategyName.trim() || !isRecord(strategyValue) || Object.keys(strategyValue).some((key) => !STRATEGY_KEYS.has(key)) || strategyValue.generation !== void 0 && (typeof strategyValue.generation !== "string" || !strategyValue.generation.trim()) || strategyValue.module !== void 0 && (typeof strategyValue.module !== "string" || !strategyValue.module.trim()) || typeof strategyValue.enabled !== "boolean" || !verifyStrategySelection(strategyValue.selection) || !isRecord(strategyValue.config) || Object.keys(strategyValue.config).some(
       (key) => FORBIDDEN_CONFIG_KEYS.has(key)
     ) || !INTERVALS.has(String(strategyValue.config.INTERVAL)) || !["crypto", "tradfi"].includes(String(strategyValue.config.UNIVERSE))) {
       throw new Error(
@@ -7613,9 +7907,9 @@ var resolveStrategyComposition = async ({
   packageManifest
 }) => {
   const [strategyEntry, strategyCreator, pluginSource] = await Promise.all([
-    getStrategyEntry(strategyName, projectRoot),
-    getStrategyCreator(strategyName, projectRoot),
-    getStrategyPluginSource(strategyName, projectRoot)
+    getStrategyEntry(strategyName, projectRoot, declaration.module),
+    getStrategyCreator(strategyName, projectRoot, declaration.module),
+    getStrategyPluginSource(strategyName, projectRoot, declaration.module)
   ]);
   if (!strategyEntry || !strategyCreator) {
     throw new Error(`Unknown strategy: ${strategyName}`);
@@ -7665,6 +7959,7 @@ var resolveStrategyComposition = async ({
   });
   return {
     strategyName,
+    strategyModule: pluginSource ?? strategyPackage.name,
     strategyRevision: computeStrategyRevision({
       strategyName,
       strategyPackage: strategyPackage.name,
@@ -7851,6 +8146,32 @@ 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 groupRuntimeTradesByIdentity = (trades, identities) => {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const trade of trades) {
+    const matches = [...identities.entries()].filter(([, identity]) => {
+      if (trade.strategy !== identity.strategyName || String(trade.interval) !== String(identity.interval)) {
+        return false;
+      }
+      if (trade.deploymentId && trade.deploymentId !== identity.deploymentId) {
+        return false;
+      }
+      if (trade.accountId && trade.accountId !== identity.accountId) {
+        return false;
+      }
+      if (trade.universe && trade.universe !== identity.universe) {
+        return false;
+      }
+      return true;
+    });
+    if (matches.length !== 1) continue;
+    const [runtimeKey] = matches[0];
+    const bucket = grouped.get(runtimeKey) ?? [];
+    bucket.push(trade);
+    grouped.set(runtimeKey, bucket);
+  }
+  return grouped;
+};
 var coerceHours = (value) => {
   const parsed = Number(value ?? Number.NaN);
   if (!Number.isFinite(parsed)) {
@@ -8181,6 +8502,7 @@ var loadRuntimeDashboard = async ({
   const syncedTrades = [...unsyncedTrades, ...syncedConnectorTrades];
   const fallbackTrades = [];
   for (const {
+    connector,
     strategyNames,
     entryRows,
     closedPnlRows,
@@ -8193,7 +8515,12 @@ var loadRuntimeDashboard = async ({
         openPositions: openPositionsSnapshot.positions,
         strategyNames,
         existingTrades: [...syncedTrades, ...fallbackTrades],
-        endTime
+        endTime,
+        scope: {
+          accountId: connector.accountId,
+          deploymentId: connector.deploymentId,
+          universe: connector.universe
+        }
       })
     );
   }
@@ -8236,6 +8563,9 @@ var loadRuntimeDashboard = async ({
       });
       identityByKey.set(runtimeKey, {
         strategyName: resolvedStrategy.strategyName,
+        strategyModule: resolvedStrategy.strategyModule,
+        strategyPackage: resolvedStrategy.strategyPackage,
+        strategyPackageVersion: resolvedStrategy.strategyPackageVersion,
         configId: strategyConfigId,
         strategyRevision: resolvedStrategy.strategyRevision,
         controlState: resolvedStrategy.controlState,
@@ -8244,6 +8574,8 @@ var loadRuntimeDashboard = async ({
         accountId: deployment.accountId,
         accountLabel: accountsById.get(deployment.accountId)?.label,
         deploymentId: deployment.id,
+        deploymentLabel: deployment.label,
+        ...resolvedStrategy.generation ? { generation: resolvedStrategy.generation } : {},
         policyProfileId: strategyPolicyProfileId,
         enabled: resolvedStrategy.controlState !== "entries_paused",
         config: resolvedStrategy.strategyConfig,
@@ -8252,12 +8584,16 @@ var loadRuntimeDashboard = async ({
       });
     }
   }
+  const tradesByRuntimeKey = groupRuntimeTradesByIdentity(
+    allTrades,
+    identityByKey
+  );
   const strategies2 = await Promise.all(
     [...identityByKey.entries()].map(async ([runtimeKey, identity]) => {
       const { strategyName } = identity;
-      const strategyTrades = allTrades.filter(
-        (trade) => trade.strategy === strategyName && String(trade.interval) === String(identity.interval)
-      ).sort((left, right) => right.entryTimestamp - left.entryTimestamp);
+      const strategyTrades = (tradesByRuntimeKey.get(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;
@@ -8272,14 +8608,19 @@ var loadRuntimeDashboard = async ({
       return {
         runtimeKey,
         strategyName,
+        strategyModule: identity.strategyModule,
+        strategyPackage: identity.strategyPackage,
+        strategyPackageVersion: identity.strategyPackageVersion,
         configId: identity.configId,
         strategyRevision: identity.strategyRevision,
+        ...identity.generation ? { generation: identity.generation } : {},
         controlState: identity.controlState,
         interval: identity.interval,
         universe: identity.universe,
         accountId: identity.accountId,
         accountLabel: identity.accountLabel,
         deploymentId: identity.deploymentId,
+        deploymentLabel: identity.deploymentLabel,
         ...identity.selection ? { selection: identity.selection } : {},
         policyProfileId: identity.policyProfileId,
         connected: identity.connected,