@tradejs/node 3.1.27 → 3.1.28-beta.252

package/dist/registry.js

@@ -932,6 +932,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;
@@ -993,7 +994,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);
@@ -1055,6 +1056,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) {
@@ -1133,7 +1200,11 @@ var ensureStrategyPluginsLoaded = async (cwd = getTradejsProjectCwd()) => {
   await state.pluginsLoadPromise;
 };
 var ensureIndicatorPluginsLoaded = async (cwd = getTradejsProjectCwd()) => ensureStrategyPluginsLoaded(cwd);
-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);
@@ -2393,9 +2464,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)
@@ -2431,6 +2533,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,
@@ -2453,6 +2649,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;
@@ -2482,6 +2696,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;
@@ -2688,12 +2914,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) {
@@ -2800,7 +3034,7 @@ var getCachedGlobalContext = ({
     maxAgeMs,
     ...abortSignal ? { signal: abortSignal } : {}
   });
-  globalContextCache.set(key, promise);
+  setBoundedCache(globalContextCache, key, promise);
   void promise.catch(() => globalContextCache.delete(key));
   return promise;
 };
@@ -2820,7 +3054,7 @@ var getCachedReferenceContexts = ({
     maxAgeMs,
     ...abortSignal ? { signal: abortSignal } : {}
   });
-  referenceContextCache.set(key, promise);
+  setBoundedCache(referenceContextCache, key, promise);
   void promise.catch(() => referenceContextCache.delete(key));
   return promise;
 };
@@ -2839,7 +3073,7 @@ var getCachedExchangeLiquidityContext = ({
     maxAgeMs,
     ...abortSignal ? { signal: abortSignal } : {}
   });
-  exchangeLiquidityContextCache.set(key, promise);
+  setBoundedCache(exchangeLiquidityContextCache, key, promise);
   void promise.catch(() => exchangeLiquidityContextCache.delete(key));
   return promise;
 };
@@ -2858,7 +3092,7 @@ var getCachedFearGreedContext = ({
     maxAgeMs,
     ...abortSignal ? { signal: abortSignal } : {}
   });
-  fearGreedContextCache.set(key, promise);
+  setBoundedCache(fearGreedContextCache, key, promise);
   void promise.catch(() => fearGreedContextCache.delete(key));
   return promise;
 };
@@ -2878,7 +3112,7 @@ var getCachedIndexContexts = ({
     maxAgeMs,
     ...abortSignal ? { signal: abortSignal } : {}
   });
-  indexContextCache.set(key, promise);
+  setBoundedCache(indexContextCache, key, promise);
   void promise.catch(() => indexContextCache.delete(key));
   return promise;
 };
@@ -3688,7 +3922,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);
@@ -3935,7 +4169,7 @@ var loadHyperliquidWhaleFlowContext = async (params) => {
           whaleRegistryFingerprint: whales.fingerprint,
           ...params.abortSignal ? { signal: params.abortSignal } : {}
         });
-        setBoundedCache(cacheKey, pending);
+        setBoundedCache2(cacheKey, pending);
       }
       row = await pending;
     }
@@ -5070,20 +5304,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

package/dist/registry.mjs

@@ -1,4 +1,4 @@
-import "./chunk-XHNJ757K.mjs";
+import "./chunk-VQSGH7YA.mjs";
 import {
   ensureIndicatorPluginsLoaded,
   ensureStrategyPluginsLoaded,
@@ -12,7 +12,7 @@ import {
   registerStrategyEntries,
   resetStrategyRegistryCache,
   strategies
-} from "./chunk-IKRSNRP6.mjs";
+} from "./chunk-UITD6LG6.mjs";
 import "./chunk-LZDXRXIU.mjs";
 import "./chunk-Y6FXYEAI.mjs";
 export {