@tradejs/infra 1.0.8 → 1.0.10

package/dist/{chunk-DSTV67R5.mjs → chunk-DXG2UDNA.mjs}

@@ -12,9 +12,12 @@ var logger = {
 };
 var redisConnectionWarningShown = false;
 var redisUnavailable = false;
-var isRedisConnectivityError = (error) => /ECONNREFUSED|ENOTFOUND|EAI_AGAIN|ETIMEDOUT|MaxRetriesPerRequestError|Connection is closed|Stream isn't writeable/i.test(
-  error.message
-);
+var isRedisConnectivityError = (error) => {
+  const errorText = [error.name, error.message, String(error)].join(" ");
+  return /ECONNREFUSED|ECONNRESET|ECONNABORTED|EPIPE|ENOTFOUND|EAI_AGAIN|ETIMEDOUT|MaxRetriesPerRequestError|Connection is closed|Stream isn't writeable/i.test(
+    errorText
+  );
+};
 var toNonNegativeInt = (value, fallback) => {
   const parsed = Number.parseInt(String(value ?? ""), 10);
   return Number.isFinite(parsed) && parsed >= 0 ? parsed : fallback;
@@ -70,6 +73,16 @@ var getRedis = () => {
   }
   return global.__redis__;
 };
+var closeRedisConnection = async () => {
+  const redis = global.__redis__;
+  if (!redis) {
+    return;
+  }
+  global.__redis__ = void 0;
+  redisUnavailable = false;
+  redisConnectionWarningShown = false;
+  redis.disconnect();
+};
 var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 var getRedisStatus = (redis) => String(redis.status ?? "ready");
 var waitForRedisReady = async (redis) => {
@@ -110,6 +123,11 @@ var toResultString = (result) => {
   if (Buffer.isBuffer(result)) return result.toString("utf8");
   return String(result);
 };
+var publishData = async (channel, value) => {
+  const redis = await getReadyRedis();
+  if (!redis) return 0;
+  return redis.publish(channel, toJson(value));
+};
 var DEFAULT_OPTIONS = {
   expire: TTL_1D
 };
@@ -122,6 +140,31 @@ var parseJsonOrDeleteKey = async (redis, key, raw, fallback) => {
     return fallback;
   }
 };
+var parseHashMap = (value) => {
+  if (!value) {
+    return {};
+  }
+  if (Array.isArray(value)) {
+    const result = {};
+    for (let index = 0; index < value.length; index += 2) {
+      const field = value[index];
+      const fieldValue = value[index + 1];
+      if (field == null || fieldValue == null) {
+        continue;
+      }
+      result[String(field)] = toResultString(fieldValue) ?? "";
+    }
+    return result;
+  }
+  if (typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).map(
+        ([field, fieldValue]) => [field, toResultString(fieldValue) ?? ""]
+      )
+    );
+  }
+  return {};
+};
 var getKeys = async (prefix) => {
   if (redisUnavailable) return [];
   const redis = await getReadyRedis();
@@ -258,6 +301,115 @@ var setData = async (key, data, options = {}) => {
     }
   }
 };
+var setHashJsonField = async (key, field, data, options = {}) => {
+  if (redisUnavailable) return;
+  const { expire } = { ...DEFAULT_OPTIONS, ...options };
+  const redis = await getReadyRedis();
+  if (!redis) return;
+  try {
+    await redis.call("HSET", key, field, toJson(data));
+    if (expire) {
+      await redis.expire(key, expire);
+    }
+  } catch (e) {
+    if (e instanceof Error && isRedisConnectivityError(e)) {
+      markRedisUnavailable(e);
+      return;
+    }
+    logger.log("error", "failed HSET %s[%s]: %s", key, field, String(e));
+  }
+};
+var getHashJsonField = async (key, field, fallback = null) => {
+  if (redisUnavailable) return fallback;
+  const redis = await getReadyRedis();
+  if (!redis) return fallback;
+  try {
+    const value = await redis.call("HGET", key, field);
+    if (typeof value !== "string" || !value) {
+      return fallback;
+    }
+    return JSON.parse(value);
+  } catch (e) {
+    if (e instanceof Error && isRedisConnectivityError(e)) {
+      markRedisUnavailable(e);
+      return fallback;
+    }
+    logger.log("error", "failed HGET %s[%s]: %s", key, field, String(e));
+    return fallback;
+  }
+};
+var getHashJsonValues = async (key) => {
+  if (redisUnavailable) return [];
+  const redis = await getReadyRedis();
+  if (!redis) return [];
+  try {
+    const raw = await redis.call("HGETALL", key);
+    const values = Object.values(parseHashMap(raw));
+    const parsed = [];
+    for (const value of values) {
+      if (!value) {
+        continue;
+      }
+      try {
+        parsed.push(JSON.parse(value));
+      } catch (e) {
+        logger.log(
+          "error",
+          "failed JSON.parse(HGETALL %s value): %s",
+          key,
+          String(e)
+        );
+      }
+    }
+    return parsed;
+  } catch (e) {
+    if (e instanceof Error && isRedisConnectivityError(e)) {
+      markRedisUnavailable(e);
+      return [];
+    }
+    logger.log("error", "failed HGETALL %s: %s", key, String(e));
+    return [];
+  }
+};
+var incrHashFields = async (key, increments, options = {}) => {
+  if (redisUnavailable) return;
+  const { expire } = { ...DEFAULT_OPTIONS, ...options };
+  const redis = await getReadyRedis();
+  if (!redis) return;
+  try {
+    for (const [field, increment] of Object.entries(increments)) {
+      if (!Number.isFinite(increment) || increment === 0) {
+        continue;
+      }
+      await redis.call("HINCRBY", key, field, Math.trunc(increment));
+    }
+    if (expire) {
+      await redis.expire(key, expire);
+    }
+  } catch (e) {
+    if (e instanceof Error && isRedisConnectivityError(e)) {
+      markRedisUnavailable(e);
+      return;
+    }
+    logger.log("error", "failed HINCRBY %s: %s", key, String(e));
+  }
+};
+var getHashData = async (key) => {
+  if (redisUnavailable) return {};
+  const redis = await getReadyRedis();
+  if (!redis) return {};
+  try {
+    const raw = await redis.call("HGETALL", key);
+    return parseHashMap(raw);
+  } catch (e) {
+    if (e instanceof Error && isRedisConnectivityError(e)) {
+      markRedisUnavailable(e);
+      return {};
+    }
+    logger.log("error", "failed HGETALL %s: %s", key, String(e));
+    return {};
+  }
+};
 var createScreenshotSessionToken = async (userName) => {
   const token = randomBytes(24).toString("hex");
   await setData(
@@ -291,13 +443,21 @@ var consumeScreenshotSessionToken = async (token) => {
 var redisKeys = {
   users: () => "users:index:",
   user: (userName) => `users:index:${userName}`,
+  tradingAccounts: (userName) => `users:${userName}:trading-accounts:`,
+  tradingAccount: (userName, accountId) => `users:${userName}:trading-accounts:${accountId}`,
+  runtimeDeployments: (userName) => `users:${userName}:runtime:deployments:`,
+  runtimeDeployment: (userName, deploymentId) => `users:${userName}:runtime:deployments:${deploymentId}`,
+  runtimeDeploymentHeartbeat: (userName, deploymentId) => `users:${userName}:runtime:deployments:${deploymentId}:heartbeat`,
   bots: (userName) => `users:${userName}:bots`,
   botsPrefix: () => "users:",
   bot: (userName, botId) => `users:${userName}:bots:${botId}`,
   backtestConfig: (userName, config) => `users:${userName}:backtests:configs:${config}`,
   strategies: (userName) => `users:${userName}:strategies`,
-  strategyConfig: (userName, strategyName) => `users:${userName}:strategies:${strategyName}:config`,
+  strategyConfig: (userName, strategyName, configId = "config") => `users:${userName}:strategies:${strategyName}:${configId}`,
   strategyResults: (userName, strategyName) => `users:${userName}:strategies:${strategyName}:results`,
+  strategyCharts: (userName, mode) => `users:${userName}:strategies:charts:${mode}`,
+  strategyChartCards: (userName, mode) => `users:${userName}:strategies:charts:${mode}:cards:`,
+  strategyChartCard: (userName, mode, cardId) => `users:${userName}:strategies:charts:${mode}:cards:${cardId}`,
   tests: (userName, strategyName) => strategyName ? `users:${userName}:tests:${strategyName}` : `users:${userName}:tests:`,
   testOrders: (userName, strategyName, testName) => `users:${userName}:tests:${strategyName}:${testName}:orders`,
   testConfig: (userName, strategyName, testName) => `users:${userName}:tests:${strategyName}:${testName}:config`,
@@ -306,21 +466,34 @@ var redisKeys = {
   cacheChunk: (userName, chunkId) => `users:${userName}:cache:tests:chunks:${chunkId}`,
   cacheOrders: (userName, orderLogId) => `users:${userName}:cache:tests:orders:${orderLogId}`,
   cachePositions: (userName, orderLogId) => `users:${userName}:cache:tests:positions:${orderLogId}`,
+  tickerUniverse: (userName, connectorName, universe, accountId) => universe || accountId ? `users:${userName}:cache:tickers:${connectorName}:${universe ?? "crypto"}:${accountId ?? "default"}` : `users:${userName}:cache:tickers:${connectorName}`,
   signal: (symbol, signalId) => `signals:${symbol}:${signalId}`,
   signalsBySymbol: (symbol) => `signals:${symbol}:`,
   storeSignal: (symbol, signalId) => `store:signals:${symbol}:${signalId}`,
   runtimeSignals: (userName) => `users:${userName}:runtime:signals:`,
   runtimeSignal: (userName, signalId) => `users:${userName}:runtime:signals:${signalId}`,
+  runtimeSignalBuckets: (userName) => `users:${userName}:runtime:signals:days:`,
+  runtimeSignalBucket: (userName, dayKey, strategyName) => `users:${userName}:runtime:signals:days:${dayKey}:${strategyName}`,
   runtimeSignalEvaluations: (userName) => `users:${userName}:runtime:signal-evaluations:`,
   runtimeSignalEvaluation: (userName, evaluationId) => `users:${userName}:runtime:signal-evaluations:${evaluationId}`,
+  runtimeSignalEvaluationBuckets: (userName) => `users:${userName}:runtime:signal-evaluations:days:`,
+  runtimeSignalEvaluationBucket: (userName, dayKey, strategyName) => `users:${userName}:runtime:signal-evaluations:days:${dayKey}:${strategyName}`,
+  runtimeSignalEvaluationStatsBuckets: (userName) => `users:${userName}:runtime:signal-evaluation-stats:days:`,
+  runtimeSignalEvaluationStatsBucket: (userName, dayKey, strategyName) => `users:${userName}:runtime:signal-evaluation-stats:days:${dayKey}:${strategyName}`,
   runtimeTrades: (userName) => `users:${userName}:runtime:trade-records:`,
   runtimeTrade: (userName, orderId) => `users:${userName}:runtime:trade-records:${orderId}`,
+  runtimeTradeBuckets: (userName) => `users:${userName}:runtime:trade-records:days:`,
+  runtimeTradeBucket: (userName, dayKey) => `users:${userName}:runtime:trade-records:days:${dayKey}`,
   runtimeActiveTrades: (userName) => `users:${userName}:runtime:active-trades:`,
-  runtimeActiveTrade: (userName, symbol) => `users:${userName}:runtime:active-trades:${symbol}`,
+  runtimeActiveTrade: (userName, symbol, scopeId) => scopeId ? `users:${userName}:runtime:active-trades:${scopeId}:${symbol}` : `users:${userName}:runtime:active-trades:${symbol}`,
   aiChatHistory: (userName, symbolKey) => `users:${userName}:ai:chats:${symbolKey}`,
   analysis: (symbol, signalId) => `analysis:${symbol}:${signalId}`,
   screenshotSessionToken: (token) => `auth:screenshot:${token}`,
   backtestResults: (userName, config, timestamp) => `users:${userName}:backtests:results:${config}:${timestamp}`,
+  backtestRuns: (userName) => `users:${userName}:backtests:runs:`,
+  backtestRun: (userName, runId) => `users:${userName}:backtests:runs:${runId}`,
+  backtestRunResults: (userName, runId) => `users:${userName}:backtests:runs:${runId}:results`,
+  backtestLatestRun: (userName, config) => `users:${userName}:backtests:latest:${config}`,
   researchRuns: (userName) => `users:${userName}:research:runs:`,
   researchRun: (userName, runId) => `users:${userName}:research:runs:${runId}`,
   researchLatestRun: (userName, strategyName) => `users:${userName}:research:latest:${strategyName}`,
@@ -333,12 +506,19 @@ var redisKeys = {
 };
 
 export {
+  closeRedisConnection,
+  publishData,
   getKeys,
   getData,
   delKey,
   RedisWriteBlockedError,
   delKeyWithOptions,
   setData,
+  setHashJsonField,
+  getHashJsonField,
+  getHashJsonValues,
+  incrHashFields,
+  getHashData,
   createScreenshotSessionToken,
   consumeScreenshotSessionToken,
   redisKeys

package/dist/{chunk-KVEZORMS.mjs → chunk-RQP5VSTH.mjs}

@@ -3,15 +3,26 @@ import { once } from "events";
 import { createReadStream, createWriteStream } from "fs";
 import fs from "fs/promises";
 import path from "path";
+import readline from "readline";
 var DEFAULT_DIR = "data/ml/export";
 var ML_DATASET_WRITE_BATCH_SIZE = 200;
 var ML_CHUNK_FILE_RE = /^ml-dataset-(.+)-chunk-[^.]+\.jsonl$/;
+var BACKTEST_RUN_CHUNK_ID_RE = /^(\d{12}-[a-f0-9]{8})-/;
 var writerByPath = /* @__PURE__ */ new Map();
 var toFileToken = (value) => value.trim().toLowerCase().replace(/[^a-z0-9_-]+/g, "_").replace(/^_+|_+$/g, "") || "any";
 var getMlChunkFilePath = (strategyName, chunkId, outDir = DEFAULT_DIR) => path.join(
   outDir,
   `ml-dataset-${toFileToken(strategyName)}-chunk-${toFileToken(chunkId)}.jsonl`
 );
+var getMlChunkFilePrefix = (strategyName, runId) => `ml-dataset-${toFileToken(strategyName)}-chunk-${runId ? `${toFileToken(runId)}-` : ""}`;
+var getRunIdFromMlChunkFileName = (strategyName, fileName) => {
+  const prefix = getMlChunkFilePrefix(strategyName);
+  if (!fileName.startsWith(prefix) || !fileName.endsWith(".jsonl")) {
+    return "";
+  }
+  const chunkToken = fileName.slice(prefix.length, -".jsonl".length);
+  return chunkToken.match(BACKTEST_RUN_CHUNK_ID_RE)?.[1] ?? "";
+};
 var appendMlDatasetRow = async (params) => {
   const { strategyName, chunkId, row, outDir = DEFAULT_DIR } = params;
   const filePath = getMlChunkFilePath(strategyName, chunkId, outDir);
@@ -85,8 +96,8 @@ var closeAllMlDatasetWriters = async () => {
   }
 };
 var listMlChunkFiles = async (params) => {
-  const { strategyName, outDir = DEFAULT_DIR } = params;
-  const prefix = `ml-dataset-${toFileToken(strategyName)}-chunk-`;
+  const { strategyName, outDir = DEFAULT_DIR, runId } = params;
+  const prefix = getMlChunkFilePrefix(strategyName, runId);
   let entries = [];
   try {
     entries = await fs.readdir(outDir);
@@ -95,6 +106,20 @@ var listMlChunkFiles = async (params) => {
   }
   return entries.filter((name) => name.startsWith(prefix) && name.endsWith(".jsonl")).map((name) => path.join(outDir, name)).sort();
 };
+var listMlChunkRunIds = async (params) => {
+  const { strategyName, outDir = DEFAULT_DIR } = params;
+  let entries = [];
+  try {
+    entries = await fs.readdir(outDir);
+  } catch {
+    return [];
+  }
+  return [
+    ...new Set(
+      entries.map((name) => getRunIdFromMlChunkFileName(strategyName, name)).filter(Boolean)
+    )
+  ].sort();
+};
 var listMlChunkStrategies = async (params) => {
   const outDir = params?.outDir ?? DEFAULT_DIR;
   let entries = [];
@@ -110,12 +135,37 @@ var listMlChunkStrategies = async (params) => {
   ].sort();
 };
 var mergeJsonlFiles = async (params) => {
-  const { filePaths, outPath } = params;
+  const { filePaths, outPath, shouldIncludeRow } = params;
   await fs.mkdir(path.dirname(outPath), { recursive: true });
   const stream = createWriteStream(outPath, { encoding: "utf8" });
   const done = Promise.all([once(stream, "finish"), once(stream, "close")]);
   try {
     for (const filePath of filePaths) {
+      if (shouldIncludeRow) {
+        const reader2 = readline.createInterface({
+          input: createReadStream(filePath, { encoding: "utf8" }),
+          crlfDelay: Infinity
+        });
+        try {
+          for await (const line of reader2) {
+            const trimmed = line.trim();
+            if (!trimmed) {
+              continue;
+            }
+            const row = JSON.parse(trimmed);
+            if (!shouldIncludeRow(row)) {
+              continue;
+            }
+            if (!stream.write(`${trimmed}
+`)) {
+              await once(stream, "drain");
+            }
+          }
+        } finally {
+          reader2.close();
+        }
+        continue;
+      }
       const reader = createReadStream(filePath, { encoding: "utf8" });
       for await (const chunk of reader) {
         if (!stream.write(chunk)) {
@@ -137,6 +187,7 @@ export {
   closeMlDatasetWriter,
   closeAllMlDatasetWriters,
   listMlChunkFiles,
+  listMlChunkRunIds,
   listMlChunkStrategies,
   mergeJsonlFiles
 };

package/dist/ml.d.mts

@@ -1,4 +1,4 @@
-export { a as appendMlDatasetRow, c as closeAllMlDatasetWriters, b as closeMlDatasetWriter, f as flushMlDatasetWriter, g as getMlChunkFilePath, l as listMlChunkFiles, d as listMlChunkStrategies, m as mergeJsonlFiles, t as toFileToken } from './mlDatasetFile-sRGWgR_o.mjs';
+export { a as appendMlDatasetRow, c as closeAllMlDatasetWriters, b as closeMlDatasetWriter, f as flushMlDatasetWriter, g as getMlChunkFilePath, l as listMlChunkFiles, d as listMlChunkRunIds, e as listMlChunkStrategies, m as mergeJsonlFiles, t as toFileToken } from './mlDatasetFile-Czx__g9M.mjs';
 
 type MlPredictResponse = {
     probability: number;

package/dist/ml.d.ts

@@ -1,4 +1,4 @@
-export { a as appendMlDatasetRow, c as closeAllMlDatasetWriters, b as closeMlDatasetWriter, f as flushMlDatasetWriter, g as getMlChunkFilePath, l as listMlChunkFiles, d as listMlChunkStrategies, m as mergeJsonlFiles, t as toFileToken } from './mlDatasetFile-sRGWgR_o.js';
+export { a as appendMlDatasetRow, c as closeAllMlDatasetWriters, b as closeMlDatasetWriter, f as flushMlDatasetWriter, g as getMlChunkFilePath, l as listMlChunkFiles, d as listMlChunkRunIds, e as listMlChunkStrategies, m as mergeJsonlFiles, t as toFileToken } from './mlDatasetFile-Czx__g9M.js';
 
 type MlPredictResponse = {
     probability: number;

package/dist/ml.js

@@ -45,6 +45,7 @@ __export(ml_exports, {
   isDerivedDatasetFileName: () => isDerivedDatasetFileName,
   isTimestampFeatureKey: () => isTimestampFeatureKey,
   listMlChunkFiles: () => listMlChunkFiles,
+  listMlChunkRunIds: () => listMlChunkRunIds,
   listMlChunkStrategies: () => listMlChunkStrategies,
   mergeJsonlFiles: () => mergeJsonlFiles,
   toFileToken: () => toFileToken,
@@ -58,15 +59,26 @@ var import_events = require("events");
 var import_fs = require("fs");
 var import_promises = __toESM(require("fs/promises"));
 var import_path = __toESM(require("path"));
+var import_node_readline = __toESM(require("readline"));
 var DEFAULT_DIR = "data/ml/export";
 var ML_DATASET_WRITE_BATCH_SIZE = 200;
 var ML_CHUNK_FILE_RE = /^ml-dataset-(.+)-chunk-[^.]+\.jsonl$/;
+var BACKTEST_RUN_CHUNK_ID_RE = /^(\d{12}-[a-f0-9]{8})-/;
 var writerByPath = /* @__PURE__ */ new Map();
 var toFileToken = (value) => value.trim().toLowerCase().replace(/[^a-z0-9_-]+/g, "_").replace(/^_+|_+$/g, "") || "any";
 var getMlChunkFilePath = (strategyName, chunkId, outDir = DEFAULT_DIR) => import_path.default.join(
   outDir,
   `ml-dataset-${toFileToken(strategyName)}-chunk-${toFileToken(chunkId)}.jsonl`
 );
+var getMlChunkFilePrefix = (strategyName, runId) => `ml-dataset-${toFileToken(strategyName)}-chunk-${runId ? `${toFileToken(runId)}-` : ""}`;
+var getRunIdFromMlChunkFileName = (strategyName, fileName) => {
+  const prefix = getMlChunkFilePrefix(strategyName);
+  if (!fileName.startsWith(prefix) || !fileName.endsWith(".jsonl")) {
+    return "";
+  }
+  const chunkToken = fileName.slice(prefix.length, -".jsonl".length);
+  return chunkToken.match(BACKTEST_RUN_CHUNK_ID_RE)?.[1] ?? "";
+};
 var appendMlDatasetRow = async (params) => {
   const { strategyName, chunkId, row, outDir = DEFAULT_DIR } = params;
   const filePath = getMlChunkFilePath(strategyName, chunkId, outDir);
@@ -140,8 +152,8 @@ var closeAllMlDatasetWriters = async () => {
   }
 };
 var listMlChunkFiles = async (params) => {
-  const { strategyName, outDir = DEFAULT_DIR } = params;
-  const prefix = `ml-dataset-${toFileToken(strategyName)}-chunk-`;
+  const { strategyName, outDir = DEFAULT_DIR, runId } = params;
+  const prefix = getMlChunkFilePrefix(strategyName, runId);
   let entries = [];
   try {
     entries = await import_promises.default.readdir(outDir);
@@ -150,6 +162,20 @@ var listMlChunkFiles = async (params) => {
   }
   return entries.filter((name) => name.startsWith(prefix) && name.endsWith(".jsonl")).map((name) => import_path.default.join(outDir, name)).sort();
 };
+var listMlChunkRunIds = async (params) => {
+  const { strategyName, outDir = DEFAULT_DIR } = params;
+  let entries = [];
+  try {
+    entries = await import_promises.default.readdir(outDir);
+  } catch {
+    return [];
+  }
+  return [
+    ...new Set(
+      entries.map((name) => getRunIdFromMlChunkFileName(strategyName, name)).filter(Boolean)
+    )
+  ].sort();
+};
 var listMlChunkStrategies = async (params) => {
   const outDir = params?.outDir ?? DEFAULT_DIR;
   let entries = [];
@@ -165,12 +191,37 @@ var listMlChunkStrategies = async (params) => {
   ].sort();
 };
 var mergeJsonlFiles = async (params) => {
-  const { filePaths, outPath } = params;
+  const { filePaths, outPath, shouldIncludeRow } = params;
   await import_promises.default.mkdir(import_path.default.dirname(outPath), { recursive: true });
   const stream = (0, import_fs.createWriteStream)(outPath, { encoding: "utf8" });
   const done = Promise.all([(0, import_events.once)(stream, "finish"), (0, import_events.once)(stream, "close")]);
   try {
     for (const filePath of filePaths) {
+      if (shouldIncludeRow) {
+        const reader2 = import_node_readline.default.createInterface({
+          input: (0, import_fs.createReadStream)(filePath, { encoding: "utf8" }),
+          crlfDelay: Infinity
+        });
+        try {
+          for await (const line of reader2) {
+            const trimmed = line.trim();
+            if (!trimmed) {
+              continue;
+            }
+            const row = JSON.parse(trimmed);
+            if (!shouldIncludeRow(row)) {
+              continue;
+            }
+            if (!stream.write(`${trimmed}
+`)) {
+              await (0, import_events.once)(stream, "drain");
+            }
+          }
+        } finally {
+          reader2.close();
+        }
+        continue;
+      }
       const reader = (0, import_fs.createReadStream)(filePath, { encoding: "utf8" });
       for await (const chunk of reader) {
         if (!stream.write(chunk)) {
@@ -1740,6 +1791,7 @@ var findLookaheadViolations = (row) => {
   isDerivedDatasetFileName,
   isTimestampFeatureKey,
   listMlChunkFiles,
+  listMlChunkRunIds,
   listMlChunkStrategies,
   mergeJsonlFiles,
   toFileToken,

package/dist/ml.mjs

@@ -5,10 +5,11 @@ import {
   flushMlDatasetWriter,
   getMlChunkFilePath,
   listMlChunkFiles,
+  listMlChunkRunIds,
   listMlChunkStrategies,
   mergeJsonlFiles,
   toFileToken
-} from "./chunk-KVEZORMS.mjs";
+} from "./chunk-RQP5VSTH.mjs";
 import {
   logger
 } from "./chunk-LNFUOXDW.mjs";
@@ -1527,6 +1528,7 @@ export {
   isDerivedDatasetFileName,
   isTimestampFeatureKey,
   listMlChunkFiles,
+  listMlChunkRunIds,
   listMlChunkStrategies,
   mergeJsonlFiles,
   toFileToken,

package/dist/{mlDatasetFile-sRGWgR_o.d.mts → mlDatasetFile-Czx__g9M.d.mts}

@@ -12,6 +12,11 @@ declare const closeAllMlDatasetWriters: () => Promise<void>;
 declare const listMlChunkFiles: (params: {
     strategyName: string;
     outDir?: string;
+    runId?: string;
+}) => Promise<string[]>;
+declare const listMlChunkRunIds: (params: {
+    strategyName: string;
+    outDir?: string;
 }) => Promise<string[]>;
 declare const listMlChunkStrategies: (params?: {
     outDir?: string;
@@ -19,6 +24,7 @@ declare const listMlChunkStrategies: (params?: {
 declare const mergeJsonlFiles: (params: {
     filePaths: string[];
     outPath: string;
+    shouldIncludeRow?: (row: Record<string, unknown>) => boolean;
 }) => Promise<void>;
 
-export { appendMlDatasetRow as a, closeMlDatasetWriter as b, closeAllMlDatasetWriters as c, listMlChunkStrategies as d, flushMlDatasetWriter as f, getMlChunkFilePath as g, listMlChunkFiles as l, mergeJsonlFiles as m, toFileToken as t };
+export { appendMlDatasetRow as a, closeMlDatasetWriter as b, closeAllMlDatasetWriters as c, listMlChunkRunIds as d, listMlChunkStrategies as e, flushMlDatasetWriter as f, getMlChunkFilePath as g, listMlChunkFiles as l, mergeJsonlFiles as m, toFileToken as t };

package/dist/{mlDatasetFile-sRGWgR_o.d.ts → mlDatasetFile-Czx__g9M.d.ts}

@@ -12,6 +12,11 @@ declare const closeAllMlDatasetWriters: () => Promise<void>;
 declare const listMlChunkFiles: (params: {
     strategyName: string;
     outDir?: string;
+    runId?: string;
+}) => Promise<string[]>;
+declare const listMlChunkRunIds: (params: {
+    strategyName: string;
+    outDir?: string;
 }) => Promise<string[]>;
 declare const listMlChunkStrategies: (params?: {
     outDir?: string;
@@ -19,6 +24,7 @@ declare const listMlChunkStrategies: (params?: {
 declare const mergeJsonlFiles: (params: {
     filePaths: string[];
     outPath: string;
+    shouldIncludeRow?: (row: Record<string, unknown>) => boolean;
 }) => Promise<void>;
 
-export { appendMlDatasetRow as a, closeMlDatasetWriter as b, closeAllMlDatasetWriters as c, listMlChunkStrategies as d, flushMlDatasetWriter as f, getMlChunkFilePath as g, listMlChunkFiles as l, mergeJsonlFiles as m, toFileToken as t };
+export { appendMlDatasetRow as a, closeMlDatasetWriter as b, closeAllMlDatasetWriters as c, listMlChunkRunIds as d, listMlChunkStrategies as e, flushMlDatasetWriter as f, getMlChunkFilePath as g, listMlChunkFiles as l, mergeJsonlFiles as m, toFileToken as t };

package/dist/redis.d.mts

@@ -3,9 +3,11 @@ import Redis from 'ioredis';
 declare global {
     var __redis__: Redis | undefined;
 }
+declare const closeRedisConnection: () => Promise<void>;
 interface Options {
     expire?: number;
 }
+declare const publishData: (channel: string, value: unknown) => Promise<number>;
 interface DelKeyOptions {
     raiseOnMisconf?: boolean;
 }
@@ -17,18 +19,31 @@ declare class RedisWriteBlockedError extends Error {
 }
 declare const delKeyWithOptions: (key: string, options?: DelKeyOptions) => Promise<boolean>;
 declare const setData: <T>(key: string, data: T, options?: Options) => Promise<void>;
+declare const setHashJsonField: <T>(key: string, field: string, data: T, options?: Options) => Promise<void>;
+declare const getHashJsonField: <T>(key: string, field: string, fallback?: T | null) => Promise<T | null>;
+declare const getHashJsonValues: <T>(key: string) => Promise<T[]>;
+declare const incrHashFields: (key: string, increments: Record<string, number>, options?: Options) => Promise<void>;
+declare const getHashData: (key: string) => Promise<Record<string, string>>;
 declare const createScreenshotSessionToken: (userName: string) => Promise<string | null>;
 declare const consumeScreenshotSessionToken: (token: string) => Promise<string | null>;
 declare const redisKeys: {
     users: () => string;
     user: (userName: string) => string;
+    tradingAccounts: (userName: string) => string;
+    tradingAccount: (userName: string, accountId: string) => string;
+    runtimeDeployments: (userName: string) => string;
+    runtimeDeployment: (userName: string, deploymentId: string) => string;
+    runtimeDeploymentHeartbeat: (userName: string, deploymentId: string) => string;
     bots: (userName: string) => string;
     botsPrefix: () => string;
     bot: (userName: string, botId: string) => string;
     backtestConfig: (userName: string, config: string) => string;
     strategies: (userName: string) => string;
-    strategyConfig: (userName: string, strategyName: string) => string;
+    strategyConfig: (userName: string, strategyName: string, configId?: string) => string;
     strategyResults: (userName: string, strategyName: string) => string;
+    strategyCharts: (userName: string, mode: string) => string;
+    strategyChartCards: (userName: string, mode: string) => string;
+    strategyChartCard: (userName: string, mode: string, cardId: string) => string;
     tests: (userName: string, strategyName?: string) => string;
     testOrders: (userName: string, strategyName: string, testName: string) => string;
     testConfig: (userName: string, strategyName: string, testName: string) => string;
@@ -37,21 +52,34 @@ declare const redisKeys: {
     cacheChunk: (userName: string, chunkId: string) => string;
     cacheOrders: (userName: string, orderLogId: string) => string;
     cachePositions: (userName: string, orderLogId: string) => string;
+    tickerUniverse: (userName: string, connectorName: string, universe?: string, accountId?: string) => string;
     signal: (symbol: string, signalId: string) => string;
     signalsBySymbol: (symbol: string) => string;
     storeSignal: (symbol: string, signalId: string) => string;
     runtimeSignals: (userName: string) => string;
     runtimeSignal: (userName: string, signalId: string) => string;
+    runtimeSignalBuckets: (userName: string) => string;
+    runtimeSignalBucket: (userName: string, dayKey: string, strategyName: string) => string;
     runtimeSignalEvaluations: (userName: string) => string;
     runtimeSignalEvaluation: (userName: string, evaluationId: string) => string;
+    runtimeSignalEvaluationBuckets: (userName: string) => string;
+    runtimeSignalEvaluationBucket: (userName: string, dayKey: string, strategyName: string) => string;
+    runtimeSignalEvaluationStatsBuckets: (userName: string) => string;
+    runtimeSignalEvaluationStatsBucket: (userName: string, dayKey: string, strategyName: string) => string;
     runtimeTrades: (userName: string) => string;
     runtimeTrade: (userName: string, orderId: string) => string;
+    runtimeTradeBuckets: (userName: string) => string;
+    runtimeTradeBucket: (userName: string, dayKey: string) => string;
     runtimeActiveTrades: (userName: string) => string;
-    runtimeActiveTrade: (userName: string, symbol: string) => string;
+    runtimeActiveTrade: (userName: string, symbol: string, scopeId?: string) => string;
     aiChatHistory: (userName: string, symbolKey: string) => string;
     analysis: (symbol: string, signalId: string) => string;
     screenshotSessionToken: (token: string) => string;
     backtestResults: (userName: string, config: string, timestamp: string) => string;
+    backtestRuns: (userName: string) => string;
+    backtestRun: (userName: string, runId: string) => string;
+    backtestRunResults: (userName: string, runId: string) => string;
+    backtestLatestRun: (userName: string, config: string) => string;
     researchRuns: (userName: string) => string;
     researchRun: (userName: string, runId: string) => string;
     researchLatestRun: (userName: string, strategyName: string) => string;
@@ -63,4 +91,4 @@ declare const redisKeys: {
     mlResult: (strategyName: string, signalId: string) => string;
 };
 
-export { RedisWriteBlockedError, consumeScreenshotSessionToken, createScreenshotSessionToken, delKey, delKeyWithOptions, getData, getKeys, redisKeys, setData };
+export { RedisWriteBlockedError, closeRedisConnection, consumeScreenshotSessionToken, createScreenshotSessionToken, delKey, delKeyWithOptions, getData, getHashData, getHashJsonField, getHashJsonValues, getKeys, incrHashFields, publishData, redisKeys, setData, setHashJsonField };