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

package/dist/strategies.d.ts

@@ -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.js';
-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.js';
+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.js';
 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 };

package/dist/strategies.js

@@ -77,6 +77,7 @@ __export(strategies_exports, {
   isKnownStrategy: () => isKnownStrategy,
   isTrackedHyperliquidPerp: () => isTrackedHyperliquidPerp,
   isTrackedHyperliquidWhale: () => isTrackedHyperliquidWhale,
+  preloadBinanceMarketContextForWindow: () => preloadBinanceMarketContextForWindow,
   registerStrategyEntries: () => registerStrategyEntries,
   resetAiRuntimeCache: () => resetAiRuntimeCache,
   resetStrategyRegistryCache: () => resetStrategyRegistryCache,
@@ -968,6 +969,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;
@@ -1029,7 +1031,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);
@@ -1091,6 +1093,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) {
@@ -1169,7 +1237,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);
@@ -1179,7 +1251,11 @@ var getStrategyDefaults = async (name, cwd = getTradejsProjectCwd()) => {
   const { state } = getStrategyRegistryState(cwd);
   return state.strategyEntriesMap.get(name)?.defaults;
 };
-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);
@@ -2462,9 +2538,50 @@ 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 TRADE_FLOW_NUMERIC_FIELDS = [
+  "trades",
+  "buyBaseVolume",
+  "sellBaseVolume",
+  "buyQuoteVolume",
+  "sellQuoteVolume",
+  "netBaseDelta",
+  "netQuoteDelta",
+  "buyPressurePct"
+];
+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)
@@ -2500,6 +2617,240 @@ 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 createNumericColumns = (fields, length) => Object.fromEntries(
+  fields.map((field) => [field, new Float64Array(length)])
+);
+var packedNumber = (value) => {
+  const numeric = typeof value === "number" ? value : Number(value);
+  return Number.isFinite(numeric) ? numeric : Number.NaN;
+};
+var unpackedNumber = (value) => value == null || Number.isNaN(value) ? null : value;
+var packTradeFlowRows = (rows) => {
+  const counts = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    counts.set(row.symbol, (counts.get(row.symbol) ?? 0) + 1);
+  }
+  const packed = /* @__PURE__ */ new Map();
+  for (const [symbol, length] of counts) {
+    packed.set(symbol, {
+      symbol,
+      interval: rows.find((row) => row.symbol === symbol)?.interval ?? "15m",
+      timestamps: new Float64Array(length),
+      columns: createNumericColumns(TRADE_FLOW_NUMERIC_FIELDS, length)
+    });
+  }
+  const offsets = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const target = packed.get(row.symbol);
+    if (!target) continue;
+    const index = offsets.get(row.symbol) ?? 0;
+    target.timestamps[index] = row.ts.getTime();
+    for (const field of TRADE_FLOW_NUMERIC_FIELDS) {
+      target.columns[field][index] = packedNumber(row[field]);
+    }
+    offsets.set(row.symbol, index + 1);
+  }
+  return packed;
+};
+var packBreadthRows = (rows, primaryUniverse) => {
+  const counts = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    counts.set(row.universe, (counts.get(row.universe) ?? 0) + 1);
+  }
+  const packed = /* @__PURE__ */ new Map();
+  for (const [universe, length] of counts) {
+    packed.set(universe, {
+      universe,
+      interval: rows.find((row) => row.universe === universe)?.interval ?? "15m",
+      timestamps: new Float64Array(length),
+      commonColumns: createNumericColumns(
+        BREADTH_COMMON_NUMERIC_FIELDS,
+        length
+      ),
+      ...universe === primaryUniverse ? {
+        regimeColumns: createNumericColumns(
+          BREADTH_REGIME_NUMERIC_FIELDS,
+          length
+        ),
+        regimes: new Array(length)
+      } : {}
+    });
+  }
+  const offsets = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const target = packed.get(row.universe);
+    if (!target) continue;
+    const index = offsets.get(row.universe) ?? 0;
+    target.timestamps[index] = row.ts.getTime();
+    for (const field of BREADTH_COMMON_NUMERIC_FIELDS) {
+      target.commonColumns[field][index] = packedNumber(row[field]);
+    }
+    if (target.regimeColumns) {
+      for (const field of BREADTH_REGIME_NUMERIC_FIELDS) {
+        target.regimeColumns[field][index] = packedNumber(row[field]);
+      }
+    }
+    if (target.regimes) target.regimes[index] = row.btcAltRegime;
+    offsets.set(row.universe, index + 1);
+  }
+  return packed;
+};
+var appendPackedChunks = (target, source) => {
+  for (const [key, rows] of source) {
+    const chunks = target.get(key) ?? [];
+    chunks.push(rows);
+    target.set(key, chunks);
+  }
+};
+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 preloadBinanceMarketContextForWindow = async (params) => {
+  const maxAgeMs = params.maxAgeMs ?? DEFAULT_MAX_AGE_BY_INTERVAL[params.interval];
+  const referenceSymbols = getReferenceSymbols();
+  const breadthDefinitions = getBinanceBreadthUniverses();
+  const breadthUniverses = breadthDefinitions.map(({ universe }) => universe);
+  const primaryBreadthUniverse = breadthDefinitions.find(
+    ({ key }) => key === "top30"
+  ).universe;
+  const timeoutMs = params.timeoutMs ?? 5 * 6e4;
+  const chunkMs = params.chunkMs ?? MARKET_CONTEXT_PRELOAD_CHUNK_MS;
+  if (!Number.isSafeInteger(chunkMs) || chunkMs <= 0) {
+    throw new Error(`Invalid market context preload chunk: ${chunkMs}`);
+  }
+  const packedTradeFlow = /* @__PURE__ */ new Map();
+  const packedBreadth = /* @__PURE__ */ new Map();
+  let tradeFlowRowsCount = 0;
+  let breadthRowsCount = 0;
+  let fromMs = params.startMs - maxAgeMs;
+  while (fromMs <= params.endMs) {
+    const toMs = Math.min(params.endMs, fromMs + chunkMs - 1);
+    const [tradeFlowRows, breadthRows] = await Promise.all([
+      (0, import_marketContext.getMarketTradeFlowRows)({
+        symbols: referenceSymbols,
+        interval: params.interval,
+        fromMs,
+        toMs,
+        timeoutMs,
+        ...params.abortSignal ? { signal: params.abortSignal } : {}
+      }),
+      (0, import_marketContext.getMarketBreadthRows)({
+        universes: breadthUniverses,
+        interval: params.interval,
+        fromMs,
+        toMs,
+        timeoutMs,
+        ...params.abortSignal ? { signal: params.abortSignal } : {}
+      })
+    ]);
+    tradeFlowRowsCount += tradeFlowRows.length;
+    breadthRowsCount += breadthRows.length;
+    appendPackedChunks(packedTradeFlow, packTradeFlowRows(tradeFlowRows));
+    appendPackedChunks(
+      packedBreadth,
+      packBreadthRows(breadthRows, primaryBreadthUniverse)
+    );
+    fromMs = toMs + 1;
+  }
+  preloadedTradeFlowBySymbol = packedTradeFlow;
+  preloadedBreadthByUniverse = packedBreadth;
+  referenceRowsCache.clear();
+  breadthCache.clear();
+  return {
+    tradeFlowRows: tradeFlowRowsCount,
+    breadthRows: breadthRowsCount
+  };
+};
 var toTradeFlowContext = (row, interval) => row ? {
   source: "binance_agg_trades",
   interval,
@@ -2522,6 +2873,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;
@@ -2551,6 +2920,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;
@@ -2757,12 +3138,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) {
@@ -2869,7 +3258,7 @@ var getCachedGlobalContext = ({
     maxAgeMs,
     ...abortSignal ? { signal: abortSignal } : {}
   });
-  globalContextCache.set(key, promise);
+  setBoundedCache(globalContextCache, key, promise);
   void promise.catch(() => globalContextCache.delete(key));
   return promise;
 };
@@ -2889,7 +3278,7 @@ var getCachedReferenceContexts = ({
     maxAgeMs,
     ...abortSignal ? { signal: abortSignal } : {}
   });
-  referenceContextCache.set(key, promise);
+  setBoundedCache(referenceContextCache, key, promise);
   void promise.catch(() => referenceContextCache.delete(key));
   return promise;
 };
@@ -2908,7 +3297,7 @@ var getCachedExchangeLiquidityContext = ({
     maxAgeMs,
     ...abortSignal ? { signal: abortSignal } : {}
   });
-  exchangeLiquidityContextCache.set(key, promise);
+  setBoundedCache(exchangeLiquidityContextCache, key, promise);
   void promise.catch(() => exchangeLiquidityContextCache.delete(key));
   return promise;
 };
@@ -2927,7 +3316,7 @@ var getCachedFearGreedContext = ({
     maxAgeMs,
     ...abortSignal ? { signal: abortSignal } : {}
   });
-  fearGreedContextCache.set(key, promise);
+  setBoundedCache(fearGreedContextCache, key, promise);
   void promise.catch(() => fearGreedContextCache.delete(key));
   return promise;
 };
@@ -2947,7 +3336,7 @@ var getCachedIndexContexts = ({
     maxAgeMs,
     ...abortSignal ? { signal: abortSignal } : {}
   });
-  indexContextCache.set(key, promise);
+  setBoundedCache(indexContextCache, key, promise);
   void promise.catch(() => indexContextCache.delete(key));
   return promise;
 };
@@ -3761,7 +4150,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);
@@ -4008,7 +4397,7 @@ var loadHyperliquidWhaleFlowContext = async (params) => {
           whaleRegistryFingerprint: whales.fingerprint,
           ...params.abortSignal ? { signal: params.abortSignal } : {}
         });
-        setBoundedCache(cacheKey, pending);
+        setBoundedCache2(cacheKey, pending);
       }
       row = await pending;
     }
@@ -5156,20 +5545,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
@@ -6900,6 +7292,7 @@ var createCloseAllOnGlobalProfitBeforeSignalsHook = ({
   isKnownStrategy,
   isTrackedHyperliquidPerp,
   isTrackedHyperliquidWhale,
+  preloadBinanceMarketContextForWindow,
   registerStrategyEntries,
   resetAiRuntimeCache,
   resetStrategyRegistryCache,

package/dist/strategies.mjs

@@ -19,10 +19,11 @@ import {
   getPrimaryBinanceBreadthUniverse,
   isTrackedHyperliquidPerp,
   isTrackedHyperliquidWhale,
+  preloadBinanceMarketContextForWindow,
   resolveHyperliquidPerpFromSignalSymbol,
   resolveStrategyConfig,
   validateEntryProtectionAtArrival
-} from "./chunk-XHNJ757K.mjs";
+} from "./chunk-VQSGH7YA.mjs";
 import {
   DEFAULT_AI_MODEL,
   MAX_AI_SERIES_POINTS,
@@ -52,7 +53,7 @@ import {
   runAiPromptLocal,
   strategies,
   trimSeriesDeep
-} from "./chunk-IKRSNRP6.mjs";
+} from "./chunk-UITD6LG6.mjs";
 import "./chunk-LZDXRXIU.mjs";
 import "./chunk-Y6FXYEAI.mjs";
 
@@ -472,6 +473,7 @@ export {
   isKnownStrategy,
   isTrackedHyperliquidPerp,
   isTrackedHyperliquidWhale,
+  preloadBinanceMarketContextForWindow,
   registerStrategyEntries,
   resetAiRuntimeCache,
   resetStrategyRegistryCache,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tradejs/node",
-  "version": "3.1.27-beta.250",
+  "version": "3.1.28-beta.251",
   "description": "Node-only runtime for the TradeJS TypeScript framework: strategies, backtests, Pine strategy loading, and plugin registries.",
   "keywords": [
     "tradejs",
@@ -89,9 +89,9 @@
   "dependencies": {
     "@langchain/core": "^1.2.3",
     "@langchain/openai": "^1.5.5",
-    "@tradejs/core": "^3.1.27-beta.250",
-    "@tradejs/infra": "^3.1.27-beta.250",
-    "@tradejs/types": "^3.1.27-beta.250",
+    "@tradejs/core": "^3.1.28-beta.251",
+    "@tradejs/infra": "^3.1.28-beta.251",
+    "@tradejs/types": "^3.1.28-beta.251",
     "@types/node": "^24",
     "chalk": "4.1.2",
     "ioredis": "5.11.1",
@@ -104,7 +104,7 @@
     "typescript": "^5.9"
   },
   "devDependencies": {
-    "@tradejs/indicators": "^3.1.27-beta.250",
+    "@tradejs/indicators": "^3.1.28-beta.251",
     "@tradejs/strategy-adaptive-momentum-ribbon": "3.0.2",
     "@tradejs/strategy-hyperliquid-consensus": "3.0.2",
     "@tradejs/strategy-kit": "3.0.4",