@tradejs/node 3.1.27 → 3.1.28-beta.252

package/dist/runtimeStrategies.js

@@ -934,6 +934,7 @@ var createStrategyRegistryState = () => ({
   strategyManifestsMap: /* @__PURE__ */ new Map(),
   strategyEntriesMap: /* @__PURE__ */ new Map(),
   strategySourcesMap: /* @__PURE__ */ new Map(),
+  strategyModuleResolutions: /* @__PURE__ */ new Map(),
   pluginsLoadPromise: null
 });
 var registryStateByProjectRoot = sharedStrategyRegistry.registryStateByProjectRoot;
@@ -995,7 +996,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);
@@ -1057,6 +1058,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) {
@@ -1134,17 +1201,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);
@@ -2363,9 +2442,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)
@@ -2401,6 +2511,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,
@@ -2423,6 +2627,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;
@@ -2452,6 +2674,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;
@@ -2658,12 +2892,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) {
@@ -2770,7 +3012,7 @@ var getCachedGlobalContext = ({
     maxAgeMs,
     ...abortSignal ? { signal: abortSignal } : {}
   });
-  globalContextCache.set(key, promise);
+  setBoundedCache(globalContextCache, key, promise);
   void promise.catch(() => globalContextCache.delete(key));
   return promise;
 };
@@ -2790,7 +3032,7 @@ var getCachedReferenceContexts = ({
     maxAgeMs,
     ...abortSignal ? { signal: abortSignal } : {}
   });
-  referenceContextCache.set(key, promise);
+  setBoundedCache(referenceContextCache, key, promise);
   void promise.catch(() => referenceContextCache.delete(key));
   return promise;
 };
@@ -2809,7 +3051,7 @@ var getCachedExchangeLiquidityContext = ({
     maxAgeMs,
     ...abortSignal ? { signal: abortSignal } : {}
   });
-  exchangeLiquidityContextCache.set(key, promise);
+  setBoundedCache(exchangeLiquidityContextCache, key, promise);
   void promise.catch(() => exchangeLiquidityContextCache.delete(key));
   return promise;
 };
@@ -2828,7 +3070,7 @@ var getCachedFearGreedContext = ({
     maxAgeMs,
     ...abortSignal ? { signal: abortSignal } : {}
   });
-  fearGreedContextCache.set(key, promise);
+  setBoundedCache(fearGreedContextCache, key, promise);
   void promise.catch(() => fearGreedContextCache.delete(key));
   return promise;
 };
@@ -2848,7 +3090,7 @@ var getCachedIndexContexts = ({
     maxAgeMs,
     ...abortSignal ? { signal: abortSignal } : {}
   });
-  indexContextCache.set(key, promise);
+  setBoundedCache(indexContextCache, key, promise);
   void promise.catch(() => indexContextCache.delete(key));
   return promise;
 };
@@ -3658,7 +3900,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);
@@ -3905,7 +4147,7 @@ var loadHyperliquidWhaleFlowContext = async (params) => {
           whaleRegistryFingerprint: whales.fingerprint,
           ...params.abortSignal ? { signal: params.abortSignal } : {}
         });
-        setBoundedCache(cacheKey, pending);
+        setBoundedCache2(cacheKey, pending);
       }
       row = await pending;
     }
@@ -5040,20 +5282,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
@@ -6398,7 +6643,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",
@@ -6470,6 +6721,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,
@@ -6483,9 +6767,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) : []
@@ -6580,7 +6871,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(
@@ -6614,9 +6905,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}`);
@@ -6666,6 +6957,7 @@ var resolveStrategyComposition = async ({
   });
   return {
     strategyName,
+    strategyModule: pluginSource ?? strategyPackage.name,
     strategyRevision: computeStrategyRevision({
       strategyName,
       strategyPackage: strategyPackage.name,
@@ -6854,11 +7146,12 @@ var loadResolvedRuntimeStrategies = async ({
 };
 var getRuntimeStrategyPackageMetadata = async ({
   strategyName,
-  projectRoot
+  projectRoot,
+  strategyModule
 }) => {
   const [packageManifest, pluginSource] = await Promise.all([
     readRuntimePackageManifest(projectRoot),
-    getStrategyPluginSource(strategyName, projectRoot)
+    getStrategyPluginSource(strategyName, projectRoot, strategyModule)
   ]);
   const strategyPackage = await resolveStrategyPackage({
     pluginSource: pluginSource ?? null,

package/dist/runtimeStrategies.mjs

@@ -8,9 +8,9 @@ import {
   loadResolvedRuntimeStrategies,
   resolveRuntimeComposition,
   verifyRuntimeDeclaration
-} from "./chunk-NQO2MFP6.mjs";
-import "./chunk-XHNJ757K.mjs";
-import "./chunk-IKRSNRP6.mjs";
+} from "./chunk-K2YQ3MQC.mjs";
+import "./chunk-VQSGH7YA.mjs";
+import "./chunk-UITD6LG6.mjs";
 import "./chunk-LZDXRXIU.mjs";
 import "./chunk-Y6FXYEAI.mjs";
 export {

package/dist/runtimeTrades.d.mts

@@ -19,13 +19,14 @@ declare const takeClosedPnlMatch: ({ exactByOrderLinkId, exactByOrderId, symbolB
     trade: RuntimeTradeRecord;
 }) => ClosedPnlRecordWithOrderLinkId | null;
 
-declare const buildExchangeFallbackRuntimeTrades: ({ entryRows, closedPnlRows, openPositions, strategyNames, existingTrades, endTime, }: {
+declare const buildExchangeFallbackRuntimeTrades: ({ entryRows, closedPnlRows, openPositions, strategyNames, existingTrades, endTime, scope, }: {
     entryRows: ExchangeEntryRecord[];
     closedPnlRows: ClosedPnlRecordWithOrderLinkId[];
     openPositions: PositionPnlSnapshot[];
     strategyNames: string[];
     existingTrades: RuntimeTradeRecord[];
     endTime: number;
+    scope?: Pick<RuntimeTradeRecord, "accountId" | "deploymentId" | "universe">;
 }) => RuntimeTradeRecord[];
 
 export { type ClosedPnlRecordWithOrderLinkId, buildExchangeFallbackRuntimeTrades, takeClosedPnlMatch, takeExactClosedPnlMatch };

package/dist/runtimeTrades.d.ts

@@ -19,13 +19,14 @@ declare const takeClosedPnlMatch: ({ exactByOrderLinkId, exactByOrderId, symbolB
     trade: RuntimeTradeRecord;
 }) => ClosedPnlRecordWithOrderLinkId | null;
 
-declare const buildExchangeFallbackRuntimeTrades: ({ entryRows, closedPnlRows, openPositions, strategyNames, existingTrades, endTime, }: {
+declare const buildExchangeFallbackRuntimeTrades: ({ entryRows, closedPnlRows, openPositions, strategyNames, existingTrades, endTime, scope, }: {
     entryRows: ExchangeEntryRecord[];
     closedPnlRows: ClosedPnlRecordWithOrderLinkId[];
     openPositions: PositionPnlSnapshot[];
     strategyNames: string[];
     existingTrades: RuntimeTradeRecord[];
     endTime: number;
+    scope?: Pick<RuntimeTradeRecord, "accountId" | "deploymentId" | "universe">;
 }) => RuntimeTradeRecord[];
 
 export { type ClosedPnlRecordWithOrderLinkId, buildExchangeFallbackRuntimeTrades, takeClosedPnlMatch, takeExactClosedPnlMatch };

package/dist/runtimeTrades.js

@@ -190,7 +190,8 @@ var buildExchangeFallbackRuntimeTrades = ({
   openPositions,
   strategyNames,
   existingTrades,
-  endTime
+  endTime,
+  scope
 }) => {
   if (!entryRows.length && !closedPnlRows.length) return [];
   const strategyNameByOrderId = new Map(
@@ -245,6 +246,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,
@@ -287,6 +289,7 @@ var buildExchangeFallbackRuntimeTrades = ({
       return null;
     }
     return {
+      ...scope,
       orderId: runtimeOrderId,
       strategy,
       symbol: row.symbol,

package/dist/runtimeTrades.mjs

@@ -2,7 +2,7 @@ import {
   buildExchangeFallbackRuntimeTrades,
   takeClosedPnlMatch,
   takeExactClosedPnlMatch
-} from "./chunk-FB5NUEOQ.mjs";
+} from "./chunk-OFVUEYUR.mjs";
 import "./chunk-Y6FXYEAI.mjs";
 export {
   buildExchangeFallbackRuntimeTrades,

package/dist/strategies.d.mts

@@ -1,6 +1,6 @@
 export * from '@tradejs/core/strategies';
 export { AiChatMessage, DEFAULT_AI_MODEL, InvokeAiChatOptions, MAX_AI_SERIES_POINTS, askAI, buildAiHumanPrompt, buildAiPayload, buildAiPrompts, buildAiSystemPrompt, buildCompactAiIndicatorsSnapshot, getDeterministicAiGateContext, getOpenRouterModelKwargs, invokeAiChat, resetAiRuntimeCache, runAiPrompt, runAiPromptLocal, trimSeriesDeep } from './ai.mjs';
-export { e as ensureIndicatorPluginsLoaded, a as ensureStrategyPluginsLoaded, g as getAvailableStrategyNames, b as getRegisteredManifests, c as getRegisteredStrategies, d as getStrategyCreator, f as getStrategyDefaults, h as getStrategyManifest, i as getStrategyPluginSource, j as isKnownStrategy, r as registerStrategyEntries, k as resetStrategyRegistryCache, s as strategies } from './registry-DHTLjQcr.mjs';
+export { e as ensureIndicatorPluginsLoaded, a as ensureStrategyPluginsLoaded, g as getAvailableStrategyNames, b as getRegisteredManifests, c as getRegisteredStrategies, d as getStrategyCreator, f as getStrategyDefaults, h as getStrategyManifest, i as getStrategyPluginSource, j as isKnownStrategy, r as registerStrategyEntries, k as resetStrategyRegistryCache, s as strategies } from './registry-3TsO1Ff1.mjs';
 import { StrategyConfig, CreateStrategyCore, StrategyManifest, StrategyCreator, RuntimeStrategyConfigSnapshot, Signal, Direction, StrategyRuntimeMlOptions, StrategyRuntimeAiOptions, Connector, Tp, MarketFeatureInterval, StrategyEntrySignalContext } from '@tradejs/types';
 import { TradejsConfigOnBarHook, TradejsConfigBeforeSignalsHook } from '@tradejs/core/config';
 
@@ -79,6 +79,18 @@ declare const validateEntryProtectionAtArrival: ({ direction, signalPrice, bid,
 }) => void;
 declare const executeEntryOrder: ({ connector, userName, symbol, direction, qty, currentPrice, timestamp, takeProfits, stopLossPrice, positionIntent, signal, beforePlaceOrder, recordRuntimeTrade, leverage, }: ExecuteEntryOrderParams) => Promise<number>;
 
+declare const preloadBinanceMarketContextForWindow: (params: {
+    startMs: number;
+    endMs: number;
+    interval: MarketFeatureInterval;
+    maxAgeMs?: number;
+    timeoutMs?: number;
+    chunkMs?: number;
+    abortSignal?: AbortSignal;
+}) => Promise<{
+    tradeFlowRows: number;
+    breadthRows: number;
+}>;
 declare const enrichSignalWithBinanceMarketContext: (params: {
     signal: Signal;
     env: string;
@@ -200,4 +212,4 @@ interface CreateCloseAllOnGlobalProfitBeforeSignalsHookParams {
 }
 declare const createCloseAllOnGlobalProfitBeforeSignalsHook: ({ getStrategyDefaultConfig, profitRiskMultiplier, }?: CreateCloseAllOnGlobalProfitBeforeSignalsHookParams) => TradejsConfigBeforeSignalsHook;
 
-export { BINANCE_BREADTH_UNIVERSE_KEYS, type BinanceBreadthUniverseDefinition, type BinanceBreadthUniverseKey, type BinanceBreadthUniverseSnapshot, type HyperliquidPerpUniverseSnapshot, type HyperliquidWhaleRegistrySnapshot, buildBinanceBreadthUniverseSnapshot, closeOppositePositionsBeforeOpen, createCloseAllOnGlobalProfitBeforeSignalsHook, createCloseOppositeBeforePlaceOrderHook, createMoveStopToBreakEvenAfterCoreDecisionHook, createMoveStopToBreakEvenOnBarHook, createStrategyRuntime, enrichSignalWithAi, enrichSignalWithBinanceMarketContext, enrichSignalWithCoinMarketCapContext, enrichSignalWithHyperliquidWhaleContext, enrichSignalWithMl, enrichSignalWithMlAi, executeEntryOrder, getBinanceBreadthUniverseSnapshot, getBinanceBreadthUniverses, getHyperliquidPerpSymbols, getHyperliquidPerpUniverseSnapshot, getHyperliquidWhaleAddresses, getHyperliquidWhaleRegistrySnapshot, getOrderArrivalSnapshot, getPrimaryBinanceBreadthUniverse, isTrackedHyperliquidPerp, isTrackedHyperliquidWhale, resolveHyperliquidPerpFromSignalSymbol, resolveStrategyConfig, validateEntryProtectionAtArrival };
+export { BINANCE_BREADTH_UNIVERSE_KEYS, type BinanceBreadthUniverseDefinition, type BinanceBreadthUniverseKey, type BinanceBreadthUniverseSnapshot, type HyperliquidPerpUniverseSnapshot, type HyperliquidWhaleRegistrySnapshot, buildBinanceBreadthUniverseSnapshot, closeOppositePositionsBeforeOpen, createCloseAllOnGlobalProfitBeforeSignalsHook, createCloseOppositeBeforePlaceOrderHook, createMoveStopToBreakEvenAfterCoreDecisionHook, createMoveStopToBreakEvenOnBarHook, createStrategyRuntime, enrichSignalWithAi, enrichSignalWithBinanceMarketContext, enrichSignalWithCoinMarketCapContext, enrichSignalWithHyperliquidWhaleContext, enrichSignalWithMl, enrichSignalWithMlAi, executeEntryOrder, getBinanceBreadthUniverseSnapshot, getBinanceBreadthUniverses, getHyperliquidPerpSymbols, getHyperliquidPerpUniverseSnapshot, getHyperliquidWhaleAddresses, getHyperliquidWhaleRegistrySnapshot, getOrderArrivalSnapshot, getPrimaryBinanceBreadthUniverse, isTrackedHyperliquidPerp, isTrackedHyperliquidWhale, preloadBinanceMarketContextForWindow, resolveHyperliquidPerpFromSignalSymbol, resolveStrategyConfig, validateEntryProtectionAtArrival };