@tradejs/cli 1.0.5 → 1.0.8

package/dist/scripts/backtest.js

@@ -8,6 +8,10 @@ var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __commonJS = (cb, mod) => function __require() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -24,6 +28,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
   mod
 ));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // ../../node_modules/debug/node_modules/ms/index.js
 var require_ms = __commonJS({
@@ -497,19 +502,21 @@ var require_supports_color = __commonJS({
     var tty = require("tty");
     var hasFlag = require_has_flag();
     var { env } = process;
-    var forceColor;
+    var flagForceColor;
     if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
-      forceColor = 0;
+      flagForceColor = 0;
     } else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
-      forceColor = 1;
+      flagForceColor = 1;
     }
-    if ("FORCE_COLOR" in env) {
-      if (env.FORCE_COLOR === "true") {
-        forceColor = 1;
-      } else if (env.FORCE_COLOR === "false") {
-        forceColor = 0;
-      } else {
-        forceColor = env.FORCE_COLOR.length === 0 ? 1 : Math.min(parseInt(env.FORCE_COLOR, 10), 3);
+    function envForceColor() {
+      if ("FORCE_COLOR" in env) {
+        if (env.FORCE_COLOR === "true") {
+          return 1;
+        }
+        if (env.FORCE_COLOR === "false") {
+          return 0;
+        }
+        return env.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3);
       }
     }
     function translateLevel(level) {
@@ -523,15 +530,22 @@ var require_supports_color = __commonJS({
         has16m: level >= 3
       };
     }
-    function supportsColor(haveStream, streamIsTTY) {
+    function supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
+      const noFlagForceColor = envForceColor();
+      if (noFlagForceColor !== void 0) {
+        flagForceColor = noFlagForceColor;
+      }
+      const forceColor = sniffFlags ? flagForceColor : noFlagForceColor;
       if (forceColor === 0) {
         return 0;
       }
-      if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
-        return 3;
-      }
-      if (hasFlag("color=256")) {
-        return 2;
+      if (sniffFlags) {
+        if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
+          return 3;
+        }
+        if (hasFlag("color=256")) {
+          return 2;
+        }
       }
       if (haveStream && !streamIsTTY && forceColor === void 0) {
         return 0;
@@ -548,7 +562,7 @@ var require_supports_color = __commonJS({
         return 1;
       }
       if ("CI" in env) {
-        if (["TRAVIS", "CIRCLECI", "APPVEYOR", "GITLAB_CI", "GITHUB_ACTIONS", "BUILDKITE"].some((sign) => sign in env) || env.CI_NAME === "codeship") {
+        if (["TRAVIS", "CIRCLECI", "APPVEYOR", "GITLAB_CI", "GITHUB_ACTIONS", "BUILDKITE", "DRONE"].some((sign) => sign in env) || env.CI_NAME === "codeship") {
           return 1;
         }
         return min;
@@ -560,7 +574,7 @@ var require_supports_color = __commonJS({
         return 3;
       }
       if ("TERM_PROGRAM" in env) {
-        const version = parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+        const version = Number.parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
         switch (env.TERM_PROGRAM) {
           case "iTerm.app":
             return version >= 3 ? 3 : 2;
@@ -579,14 +593,17 @@ var require_supports_color = __commonJS({
       }
       return min;
     }
-    function getSupportLevel(stream) {
-      const level = supportsColor(stream, stream && stream.isTTY);
+    function getSupportLevel(stream, options = {}) {
+      const level = supportsColor(stream, {
+        streamIsTTY: stream && stream.isTTY,
+        ...options
+      });
       return translateLevel(level);
     }
     module2.exports = {
       supportsColor: getSupportLevel,
-      stdout: translateLevel(supportsColor(true, tty.isatty(1))),
-      stderr: translateLevel(supportsColor(true, tty.isatty(2)))
+      stdout: getSupportLevel({ isTTY: tty.isatty(1) }),
+      stderr: getSupportLevel({ isTTY: tty.isatty(2) })
     };
   }
 });
@@ -1610,25 +1627,561 @@ var require_list_it = __commonJS({
 });
 
 // src/scripts/backtest.ts
+var backtest_exports = {};
+__export(backtest_exports, {
+  backtest: () => backtest,
+  mergePersistedTestSummaries: () => mergePersistedTestSummaries,
+  resolveEffectiveParallel: () => resolveEffectiveParallel,
+  resolveWorkerHeapMb: () => resolveWorkerHeapMb
+});
+module.exports = __toCommonJS(backtest_exports);
 var import_args = __toESM(require("args"));
-var import_progress = __toESM(require("progress"));
+var import_progress2 = __toESM(require("progress"));
 var import_child_process = require("child_process");
 var import_fs = __toESM(require("fs"));
 var import_path = __toESM(require("path"));
 var import_os = __toESM(require("os"));
-var import_chalk = __toESM(require("chalk"));
+var import_node_crypto = require("crypto");
+var import_chalk2 = __toESM(require("chalk"));
 var import_lodash = __toESM(require("lodash"));
 var import_date_fns = require("date-fns");
-var import_uuid = require("uuid");
 var import_connectors = require("@tradejs/connectors");
 var import_connectors2 = require("@tradejs/node/connectors");
 var import_cli = require("@tradejs/node/cli");
 var import_backtest = require("@tradejs/core/backtest");
 var import_data = require("@tradejs/core/data");
-var import_constants = require("@tradejs/core/constants");
+var import_constants2 = require("@tradejs/core/constants");
+var import_time = require("@tradejs/core/time");
 var import_redis = require("@tradejs/infra/redis");
+
+// src/lib/derivativesContextBackfill.ts
+var import_chalk = __toESM(require("chalk"));
+var import_progress = __toESM(require("progress"));
+var import_async = require("@tradejs/core/async");
+var import_constants = require("@tradejs/core/constants");
+var import_indicators = require("@tradejs/core/indicators");
+var import_timescale = require("@tradejs/infra/timescale");
+var import_userSettings = require("@tradejs/infra/userSettings");
+var HOUR_MS = 60 * 60 * 1e3;
+var DAY_MS = 24 * HOUR_MS;
+var DEFAULT_LOOKBACK_HOURS = 48;
+var DEFAULT_INTERVALS = ["15m", "1h"];
+var coinalyzeIntervalMap = {
+  "15m": "15min",
+  "1h": "1hour"
+};
+var lastRequestTs = 0;
+var asInt = (value, fallback) => {
+  const parsed = Number.parseInt(String(value ?? ""), 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+};
+var parseList = (value) => String(value ?? "").split(",").map((item) => item.trim().toUpperCase()).filter(Boolean);
+var normalizeSymbols = (symbols) => [
+  ...new Set(
+    symbols.map(
+      (symbol) => String(symbol || "").trim().toUpperCase()
+    ).filter(Boolean)
+  )
+];
+var resolveDerivativesContextBackfillSymbols = (_requestedSymbols = []) => [...import_constants.DERIVATIVES_CONTEXT_REFERENCE_SYMBOLS];
+var chunkArray = (items, size) => {
+  const chunks = [];
+  for (let i = 0; i < items.length; i += size) {
+    chunks.push(items.slice(i, i + size));
+  }
+  return chunks;
+};
+var isBacktestDerivativesContextEnabled = () => {
+  return isDerivativesContextBackfillEnabled("BACKTEST");
+};
+var isDerivativesContextBackfillEnabled = (env) => {
+  const normalized = String(process.env.DERIVATIVES_CONTEXT_ENABLED ?? "").trim().toLowerCase();
+  if (!normalized) return false;
+  if (["1", "true", "yes", "on"].includes(normalized)) {
+    return true;
+  }
+  if (normalized === "backtest") {
+    return env === "BACKTEST";
+  }
+  if (normalized === "live") {
+    return env !== "BACKTEST";
+  }
+  return false;
+};
+var shouldBackfillDerivativesContextForBacktest = (params) => !params.cacheOnly && (params.aiEnabled || params.mlEnabled) && isBacktestDerivativesContextEnabled();
+var resolveDerivativesContextIntervals = () => {
+  const intervals = (0, import_indicators.normalizeDerivativesIntervals)(
+    process.env.DERIVATIVES_CONTEXT_INTERVALS
+  );
+  return intervals.length ? intervals : DEFAULT_INTERVALS;
+};
+var resolveDerivativesContextLookbackMs = () => {
+  const hours = Number(process.env.DERIVATIVES_CONTEXT_LOOKBACK_HOURS);
+  const normalizedHours = Number.isFinite(hours) && hours > 0 ? hours : DEFAULT_LOOKBACK_HOURS;
+  return normalizedHours * HOUR_MS;
+};
+var resolveDerivativesContextBackfillWindow = (params) => {
+  const { startMs, endMs, preloadStartMs, nowMs = Date.now() } = params;
+  const safeEndMs = Math.min(endMs, nowMs);
+  const safeStartMs = Math.max(0, Math.min(startMs, safeEndMs));
+  const lookbackFromMs = safeStartMs - resolveDerivativesContextLookbackMs();
+  const requestedFromMs = preloadStartMs != null ? Math.max(Number(preloadStartMs), lookbackFromMs) : lookbackFromMs;
+  const fromMs = Math.max(
+    0,
+    Math.min(
+      Number.isFinite(requestedFromMs) ? requestedFromMs : safeStartMs,
+      safeStartMs
+    )
+  );
+  return {
+    fromMs: Math.trunc(fromMs),
+    toMs: Math.trunc(safeEndMs),
+    testStartMs: Math.trunc(safeStartMs)
+  };
+};
+var getCoinalyzeApiKey = async (userName2) => {
+  const settings = await (0, import_userSettings.getUserSettings)(userName2);
+  return settings.COINALYZE_API_KEY.trim() || String(process.env.COINALYZE_API_KEY ?? "").trim();
+};
+var getCoinalyzeBaseUrl = () => process.env.COINALYZE_BASE_URL?.trim() || "https://api.coinalyze.net/v1";
+var getRequestDelayMs = () => Math.max(
+  100,
+  asInt(
+    process.env.DERIVATIVES_CONTEXT_BACKFILL_REQUEST_DELAY_MS ?? process.env.COINALYZE_MIN_REQUEST_DELAY_MS,
+    200
+  )
+);
+var getRequestTimeoutMs = () => Math.max(5e3, asInt(process.env.COINALYZE_REQUEST_TIMEOUT_MS, 45e3));
+var fetchJsonWithRateLimit = async (url, apiKey) => {
+  const requestDelayMs = getRequestDelayMs();
+  const requestTimeoutMs = getRequestTimeoutMs();
+  const maxRetries = asInt(process.env.COINALYZE_MAX_RETRIES, 4);
+  for (let attempt = 0; attempt <= maxRetries; attempt += 1) {
+    const waitMs = Math.max(0, lastRequestTs + requestDelayMs - Date.now());
+    if (waitMs > 0) {
+      await (0, import_async.delay)(waitMs);
+    }
+    lastRequestTs = Date.now();
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), requestTimeoutMs);
+    let response;
+    try {
+      response = await fetch(url, {
+        headers: {
+          api_key: apiKey,
+          "x-api-key": apiKey,
+          Authorization: `Bearer ${apiKey}`
+        },
+        signal: controller.signal
+      });
+    } catch (error) {
+      clearTimeout(timer);
+      const abortError = error instanceof Error && (error.name === "AbortError" || String(error.message).toLowerCase().includes("aborted"));
+      if (attempt < maxRetries && abortError) {
+        await (0, import_async.delay)(Math.min(12e3, 800 * 2 ** attempt));
+        continue;
+      }
+      throw error;
+    } finally {
+      clearTimeout(timer);
+    }
+    if (response.ok) {
+      return response.json();
+    }
+    const text = await response.text();
+    const retryAfterRaw = Number(response.headers.get("retry-after") ?? "");
+    const retryAfterMs = Number.isFinite(retryAfterRaw) && retryAfterRaw > 0 ? retryAfterRaw * 1e3 : null;
+    const transient = response.status === 429 || response.status >= 500;
+    if (attempt < maxRetries && transient) {
+      await (0, import_async.delay)(retryAfterMs ?? Math.min(12e3, 800 * 2 ** attempt));
+      continue;
+    }
+    throw new Error(`Coinalyze ${response.status}: ${text}`);
+  }
+  throw new Error("Coinalyze request failed after retries");
+};
+var fetchCoinalyzeMarkets = async (apiKey) => {
+  const raw = await fetchJsonWithRateLimit(
+    `${getCoinalyzeBaseUrl()}/future-markets`,
+    apiKey
+  );
+  return Array.isArray(raw) ? raw : [];
+};
+var selectBestMarket = (candidates, exchangePriority) => {
+  const scored = candidates.map((item) => {
+    let score = 0;
+    if (item.is_perpetual) score += 50;
+    if (String(item.quote_asset || "").toUpperCase() === "USDT") score += 25;
+    if (item.symbol.includes("_PERP")) score += 10;
+    const exchange = String(item.exchange || "").toUpperCase();
+    const idx = exchangePriority.indexOf(exchange);
+    if (idx >= 0) {
+      score += (exchangePriority.length - idx) * 10;
+    }
+    return { item, score };
+  });
+  scored.sort((a, b) => {
+    if (b.score !== a.score) return b.score - a.score;
+    return a.item.symbol.localeCompare(b.item.symbol);
+  });
+  return scored[0]?.item ?? null;
+};
+var buildMatches = (tickers, markets, exchangePriority) => {
+  const marketByTicker = /* @__PURE__ */ new Map();
+  for (const market of markets) {
+    const key = String(market.symbol_on_exchange || "").trim().toUpperCase();
+    if (!key) continue;
+    const list = marketByTicker.get(key) ?? [];
+    list.push(market);
+    marketByTicker.set(key, list);
+  }
+  const matches = [];
+  const unmatched = [];
+  for (const ticker of tickers) {
+    const candidates = marketByTicker.get(ticker) ?? [];
+    const selected = selectBestMarket(candidates, exchangePriority);
+    if (!selected) {
+      unmatched.push(ticker);
+      continue;
+    }
+    matches.push({
+      symbol: ticker,
+      marketSymbol: selected.symbol,
+      exchange: selected.exchange
+    });
+  }
+  return { matches, unmatched };
+};
+var normalizeMetricPoint = (metric, point) => {
+  if (metric === "oi") {
+    return {
+      ...point,
+      open_interest: point.open_interest ?? point.openInterest ?? point.oi ?? point.c
+    };
+  }
+  if (metric === "funding") {
+    return {
+      ...point,
+      funding_rate: point.funding_rate ?? point.fundingRate ?? point.rate ?? point.c
+    };
+  }
+  return {
+    ...point,
+    liq_long: point.liq_long ?? point.long_liq ?? point.long ?? point.l,
+    liq_short: point.liq_short ?? point.short_liq ?? point.short ?? point.s
+  };
+};
+var toSeriesMap = (raw, metric) => {
+  const out = /* @__PURE__ */ new Map();
+  if (!Array.isArray(raw)) return out;
+  for (const item of raw) {
+    const symbol = String(item.symbol || "").trim().toUpperCase();
+    const history = Array.isArray(item.history) ? item.history : [];
+    if (!symbol) continue;
+    out.set(
+      symbol,
+      history.filter((point) => point && typeof point === "object").map((point) => normalizeMetricPoint(metric, point))
+    );
+  }
+  return out;
+};
+var fetchMetricBatch = async (params) => {
+  const { endpoint, metric, marketSymbols, apiKey, interval: interval2, fromMs, toMs } = params;
+  const url = new URL(`${getCoinalyzeBaseUrl()}${endpoint}`);
+  url.searchParams.set("symbols", marketSymbols.join(","));
+  url.searchParams.set("interval", coinalyzeIntervalMap[interval2] || interval2);
+  url.searchParams.set("from", String(Math.floor(fromMs / 1e3)));
+  url.searchParams.set("to", String(Math.floor(toMs / 1e3)));
+  const raw = await fetchJsonWithRateLimit(url.toString(), apiKey);
+  return toSeriesMap(raw, metric);
+};
+var skippedBackfillResult = () => ({
+  skipped: true,
+  rows: 0,
+  matchedSymbols: 0,
+  unmatchedSymbols: 0,
+  failedWindows: 0,
+  skippedWindows: 0
+});
+var backfillDerivativesContext = async (params, enabled) => {
+  const { userName: userName2, startMs, endMs } = params;
+  const requestedSymbols = normalizeSymbols(params.symbols);
+  const symbols = resolveDerivativesContextBackfillSymbols(requestedSymbols);
+  if (!enabled || !requestedSymbols.length || !symbols.length) {
+    return skippedBackfillResult();
+  }
+  const intervals = resolveDerivativesContextIntervals();
+  if (!intervals.length) {
+    return skippedBackfillResult();
+  }
+  const apiKey = await getCoinalyzeApiKey(userName2);
+  if (!apiKey) {
+    throw new Error(
+      `Missing COINALYZE_API_KEY for derivatives context backfill (user=${userName2})`
+    );
+  }
+  const {
+    fromMs,
+    toMs: safeEndMs,
+    testStartMs: safeStartMs
+  } = resolveDerivativesContextBackfillWindow({
+    startMs,
+    endMs,
+    preloadStartMs: params.preloadStartMs
+  });
+  if (safeEndMs <= fromMs) {
+    return skippedBackfillResult();
+  }
+  const exchangePriority = parseList(
+    process.env.COINALYZE_EXCHANGE_PRIORITY || process.env.DERIVATIVES_CONTEXT_EXCHANGE_PRIORITY || "A,6,0"
+  );
+  const markets = await fetchCoinalyzeMarkets(apiKey);
+  if (!markets.length) {
+    throw new Error("No markets returned by Coinalyze /future-markets");
+  }
+  const { matches, unmatched } = buildMatches(
+    symbols,
+    markets,
+    exchangePriority
+  );
+  if (!matches.length) {
+    throw new Error(
+      "No matched derivatives reference symbols between BTC/ETH and Coinalyze"
+    );
+  }
+  await (0, import_timescale.waitForDbReady)();
+  const batchDays = asInt(
+    process.env.DERIVATIVES_CONTEXT_BACKFILL_BATCH_DAYS,
+    30
+  );
+  const symbolBatchSize = asInt(
+    process.env.DERIVATIVES_CONTEXT_BACKFILL_SYMBOL_BATCH_SIZE,
+    8
+  );
+  const symbolBatches = chunkArray(matches, symbolBatchSize);
+  const windowsPerPair = Math.ceil((safeEndMs - fromMs) / (batchDays * DAY_MS));
+  const totalWindows = symbolBatches.length * intervals.length * windowsPerPair;
+  const bar = new import_progress.default(
+    ":current/:total [:bar][:percent] :eta(s) :batch rows=:rows fail=:fail skip=:skip",
+    {
+      total: Math.max(1, totalWindows),
+      width: 24
+    }
+  );
+  const oiPath = process.env.COINALYZE_OI_PATH?.trim() || "/open-interest-history";
+  const fundingPath = process.env.COINALYZE_FUNDING_PATH?.trim() || "/funding-rate-history";
+  const liqPath = process.env.COINALYZE_LIQ_PATH?.trim() || "/liquidation-history";
+  let totalRows = 0;
+  let failedWindows = 0;
+  let skippedWindows = 0;
+  console.log(
+    import_chalk.default.cyan(
+      `derivatives context backfill: referenceSymbols=${matches.length}, requestedSymbols=${requestedSymbols.length}, unmatched=${unmatched.length}, intervals=${intervals.join(",")}, window=${new Date(fromMs).toISOString()}..${new Date(safeEndMs).toISOString()}, testStart=${new Date(safeStartMs).toISOString()}`
+    )
+  );
+  for (const interval2 of intervals) {
+    const edgesBySymbol = await (0, import_timescale.getDerivativesDataEdgesForSymbols)(
+      matches.map((item) => item.symbol),
+      interval2
+    );
+    for (let batchIdx = 0; batchIdx < symbolBatches.length; batchIdx += 1) {
+      const batch = symbolBatches[batchIdx];
+      let cursor = fromMs;
+      while (cursor < safeEndMs) {
+        const toMs = Math.min(safeEndMs, cursor + batchDays * DAY_MS);
+        const missingBatch = batch.filter((item) => {
+          const edges = edgesBySymbol.get(item.symbol.toUpperCase());
+          return edges?.min == null || edges?.max == null || edges.min > cursor || edges.max < toMs;
+        });
+        try {
+          if (!missingBatch.length) {
+            skippedWindows += 1;
+          } else {
+            const marketSymbols = missingBatch.map((item) => item.marketSymbol);
+            const oiMap = await fetchMetricBatch({
+              endpoint: oiPath,
+              metric: "oi",
+              marketSymbols,
+              apiKey,
+              interval: interval2,
+              fromMs: cursor,
+              toMs
+            });
+            const fundingMap = await fetchMetricBatch({
+              endpoint: fundingPath,
+              metric: "funding",
+              marketSymbols,
+              apiKey,
+              interval: interval2,
+              fromMs: cursor,
+              toMs
+            });
+            const liqMap = await fetchMetricBatch({
+              endpoint: liqPath,
+              metric: "liq",
+              marketSymbols,
+              apiKey,
+              interval: interval2,
+              fromMs: cursor,
+              toMs
+            });
+            const rows = missingBatch.flatMap((item) => {
+              const marketSymbol = item.marketSymbol.toUpperCase();
+              const points = (0, import_indicators.mergeCoinalyzeMetrics)({
+                symbol: item.symbol,
+                oiRaw: oiMap.get(marketSymbol) ?? [],
+                fundingRaw: fundingMap.get(marketSymbol) ?? [],
+                liqRaw: liqMap.get(marketSymbol) ?? []
+              });
+              return (0, import_indicators.coinalyzePointsToRows)(points, interval2, "coinalyze");
+            });
+            if (rows.length) {
+              await (0, import_timescale.upsertDerivatives)(rows);
+              totalRows += rows.length;
+            }
+          }
+        } catch (error) {
+          failedWindows += 1;
+          console.error(
+            import_chalk.default.red(
+              `derivatives context backfill window failed batch=${batchIdx + 1}/${symbolBatches.length} interval=${interval2} ${new Date(cursor).toISOString()}..${new Date(toMs).toISOString()}: ${error}`
+            )
+          );
+        } finally {
+          bar.tick(1, {
+            batch: import_chalk.default.gray(
+              `${batchIdx + 1}/${symbolBatches.length} ${interval2}`
+            ),
+            rows: totalRows,
+            fail: failedWindows,
+            skip: skippedWindows
+          });
+        }
+        cursor = toMs + 1;
+      }
+    }
+  }
+  console.log("");
+  console.log(
+    import_chalk.default.green(
+      `derivatives context backfill done: rows=${totalRows}, failed_windows=${failedWindows}, skipped_windows=${skippedWindows}`
+    )
+  );
+  if (failedWindows > 0) {
+    throw new Error(
+      `Derivatives context backfill failed for ${failedWindows} window(s)`
+    );
+  }
+  return {
+    skipped: false,
+    rows: totalRows,
+    matchedSymbols: matches.length,
+    unmatchedSymbols: unmatched.length,
+    failedWindows,
+    skippedWindows
+  };
+};
+var backfillDerivativesContextForBacktest = async (params) => backfillDerivativesContext(params, isBacktestDerivativesContextEnabled());
+
+// src/lib/cliArgs.ts
+var normalizeCliArgv = (argv, legacyFlagMap) => argv.map((arg) => {
+  const [flag, ...rest] = String(arg).split("=");
+  const normalizedFlag = legacyFlagMap[flag];
+  if (!normalizedFlag) {
+    return arg;
+  }
+  if (!rest.length) {
+    return normalizedFlag;
+  }
+  return `${normalizedFlag}=${rest.join("=")}`;
+});
+
+// src/lib/timeWindow.ts
+var ONE_DAY_MS = 24 * 60 * 60 * 1e3;
+var toEpochMs = (value) => {
+  if (value == null || value === "") {
+    return null;
+  }
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    return null;
+  }
+  return parsed < 1e12 ? Math.trunc(parsed * 1e3) : Math.trunc(parsed);
+};
+var toPositiveNumber = (value) => {
+  if (value == null || value === "") {
+    return null;
+  }
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    return null;
+  }
+  return parsed;
+};
+var resolveTimeWindow = ({
+  days,
+  startTime,
+  endTime,
+  nowMs = Date.now(),
+  defaultStartMs,
+  defaultEndMs
+}) => {
+  const explicitStart = toEpochMs(startTime);
+  const explicitEnd = toEpochMs(endTime);
+  if (explicitStart != null || explicitEnd != null) {
+    const resolvedEnd2 = explicitEnd ?? defaultEndMs ?? nowMs;
+    const resolvedStart = explicitStart ?? defaultStartMs;
+    if (resolvedStart >= resolvedEnd2) {
+      throw new Error(
+        `Invalid time window: startTime (${resolvedStart}) must be less than endTime (${resolvedEnd2})`
+      );
+    }
+    return {
+      start: resolvedStart,
+      end: resolvedEnd2,
+      source: "explicit"
+    };
+  }
+  const resolvedDays = toPositiveNumber(days);
+  if (resolvedDays != null) {
+    const resolvedEnd2 = defaultEndMs ?? nowMs;
+    const resolvedStart = resolvedEnd2 - resolvedDays * ONE_DAY_MS;
+    if (resolvedStart >= resolvedEnd2) {
+      throw new Error(
+        `Invalid time window: computed start (${resolvedStart}) must be less than end (${resolvedEnd2})`
+      );
+    }
+    return {
+      start: Math.trunc(resolvedStart),
+      end: Math.trunc(resolvedEnd2),
+      source: "days"
+    };
+  }
+  const resolvedEnd = defaultEndMs ?? nowMs;
+  if (defaultStartMs >= resolvedEnd) {
+    throw new Error(
+      `Invalid default time window: start (${defaultStartMs}) must be less than end (${resolvedEnd})`
+    );
+  }
+  return {
+    start: Math.trunc(defaultStartMs),
+    end: Math.trunc(resolvedEnd),
+    source: "default"
+  };
+};
+
+// src/scripts/backtest.ts
 var ListIt = require_list_it();
 var MAX_PARALLEL = Math.min(import_os.default.cpus().length, 6);
+var DEFAULT_WORKER_HEAP_MB = 8192;
+var resolveWorkerHeapMb = (value = process.env.BACKTEST_WORKER_HEAP_MB, fallback = DEFAULT_WORKER_HEAP_MB) => Math.max(256, parseInt(String(value ?? fallback), 10) || fallback);
+var resolveEffectiveParallel = (flagValue, envValue = process.env.BACKTEST_MAX_PARALLEL, fallback = MAX_PARALLEL) => Math.max(
+  1,
+  Math.min(
+    parseInt(String(flagValue), 10) || fallback,
+    parseInt(String(envValue ?? fallback), 10) || fallback
+  )
+);
 import_args.default.example(
   " yarn backtest -t 400 --cacheOnly",
   "Run tests on uploaded data for 400 tickers"
@@ -1636,18 +2189,22 @@ import_args.default.example(
 import_args.default.option(["t", "tickers"], "Selected tickers");
 import_args.default.option(["e", "exclude"], "Exclude tickers from tests");
 import_args.default.option(["l", "tickersLimit"], "Tickers limit");
-import_args.default.option(["n", "tests"], "Tests limit", import_constants.TESTS_LIMIT);
+import_args.default.option(["n", "tests"], "Tests limit", import_constants2.TESTS_LIMIT);
+import_args.default.option(["s", "skip"], "Skip first N tests", 0);
 import_args.default.option(["p", "parallel"], "Parallel tasks", MAX_PARALLEL);
 import_args.default.option(["f", "timeframe"], "Timeframe", 15);
-import_args.default.option(["T", "top"], "Return N best tests", import_constants.TESTS_TOP_LIMIT);
+import_args.default.option(["d", "days"], "Run backtest only for the last N days");
+import_args.default.option("startTime", "Explicit backtest start timestamp (ms or seconds)");
+import_args.default.option("endTime", "Explicit backtest end timestamp (ms or seconds)");
+import_args.default.option(["T", "top"], "Return N best tests", import_constants2.TESTS_TOP_LIMIT);
 import_args.default.option(["u", "updateOnly"], "Only update tickers history", false);
 import_args.default.option(["C", "cacheOnly"], "Do not update tickers history", false);
 import_args.default.option(["c", "config"], "Backtest config", "breakout");
 import_args.default.option(["L", "showTickersList"], "Just show only ticker list", false);
-import_args.default.option(["S", "progressStep"], "Progress step", 100);
+import_args.default.option(["g", "progressStep"], "Progress step", 100);
 import_args.default.option(["U", "user"], "Use user config", "root");
 import_args.default.option(
-  "connector",
+  ["o", "connector"],
   "Connector provider or name for backtest (e.g. bybit, binance, coinbase, custom)",
   "bybit"
 );
@@ -1656,10 +2213,31 @@ import_args.default.option(
   "Write ML dataset rows to per-worker JSONL chunks",
   false
 );
+import_args.default.option(
+  ["A", "ai"],
+  "Write AI prompt rows to per-worker JSONL chunks",
+  false
+);
+var normalizedArgv = normalizeCliArgv(process.argv, {
+  "--AI": "--ai",
+  "--ML": "--ml",
+  "-C": "--cacheOnly",
+  "-E": "--endTime",
+  "-P": "--progressStep",
+  "-S": "--startTime",
+  "-T": "--top",
+  "-U": "--user"
+});
+process.argv = normalizedArgv;
 var flags = import_args.default.parse(process.argv);
 var interval = flags.timeframe.toString();
-var progressStep = flags.progressStep;
-var uuid = (len = 12) => (0, import_uuid.v4)().slice(-len);
+var progressStep = Math.max(1, parseInt(String(flags.progressStep), 10));
+var testsLimit = Math.max(0, parseInt(String(flags.tests), 10));
+var testsSkip = Math.max(0, parseInt(String(flags.skip ?? 0), 10));
+var testItemTimeoutMs = 12e4;
+var workerHeapMb = resolveWorkerHeapMb();
+var effectiveParallel = resolveEffectiveParallel(flags.parallel);
+var uuid = (len = 12) => (0, import_node_crypto.randomUUID)().slice(-len);
 var projectRoot = String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd();
 var testerWorkerPathCandidates = [
   // `tradejs` bin runs from dist/cli.js, so bundled commands resolve from `dist`.
@@ -1679,40 +2257,163 @@ if (!testerWorkerPath) {
 }
 var testerNeedsTsRuntime = testerWorkerPath.endsWith(".ts");
 var HEADERS_RESULTS = [
-  import_chalk.default.blue("ID"),
-  import_chalk.default.yellow("SYMBOL"),
-  import_chalk.default.cyan("PROFIT"),
-  import_chalk.default.cyan("ORDERS"),
-  import_chalk.default.cyan("WIN/LOSS (%)"),
-  import_chalk.default.cyan("RISK"),
-  import_chalk.default.cyan("MAX DRAWDOWN (%)")
+  import_chalk2.default.blue("ID"),
+  import_chalk2.default.yellow("SYMBOL"),
+  import_chalk2.default.cyan("PROFIT"),
+  import_chalk2.default.cyan("ORDERS"),
+  import_chalk2.default.cyan("WIN/LOSS (%)"),
+  import_chalk2.default.cyan("RISK"),
+  import_chalk2.default.cyan("MAX DRAWDOWN (%)")
 ];
 var HEADERS_RESULTS_BY_TICKERS = [
-  import_chalk.default.blue("ID"),
-  import_chalk.default.yellow("SYMBOL"),
-  import_chalk.default.cyan("PROFIT"),
-  import_chalk.default.cyan("ORDERS"),
-  import_chalk.default.cyan("WIN/LOSS (%)"),
-  import_chalk.default.cyan("RISK"),
-  import_chalk.default.cyan("MAX DRAWDOWN (%)")
+  import_chalk2.default.blue("ID"),
+  import_chalk2.default.yellow("SYMBOL"),
+  import_chalk2.default.cyan("PROFIT"),
+  import_chalk2.default.cyan("ORDERS"),
+  import_chalk2.default.cyan("WIN/LOSS (%)"),
+  import_chalk2.default.cyan("RISK"),
+  import_chalk2.default.cyan("MAX DRAWDOWN (%)")
 ];
 var successTests = 0;
 var errorTests = 0;
 var errorMessages = [];
 var results = [];
 var resultsByTickers = /* @__PURE__ */ new Map();
+var resultArtifactsByTestName = /* @__PURE__ */ new Map();
+var artifactRefCountsByTestName = /* @__PURE__ */ new Map();
+var bestTickerTestNameBySymbol = /* @__PURE__ */ new Map();
+var topResultNames = /* @__PURE__ */ new Set();
+var persistedTestSummaryByKey = /* @__PURE__ */ new Map();
 var userName = flags.user;
 var runStartedAt = Date.now();
+var testsStartedAt = runStartedAt;
 var createListIt = () => new ListIt({
   autoAlign: true,
   headerUnderline: true
 });
 var createTable = (headers, rows) => createListIt().setHeaderRow(headers).d(rows).toString();
 var createTimestamp = (date) => (0, import_date_fns.format)(date, "yyyyMMddHHmm");
-var filterGoodTests = (tests) => tests.filter((res) => res.stat?.orders > 5 && res.stat?.profit > 10);
+var formatDuration = (startedAt) => {
+  const seconds = (Date.now() - startedAt) / 1e3;
+  if (seconds < 60) return `${seconds.toFixed(1)}s`;
+  const minutes = Math.floor(seconds / 60);
+  const restSeconds = Math.round(seconds % 60);
+  return `${minutes}m ${restSeconds}s`;
+};
+var formatWindowDays = (startMs, endMs) => {
+  const days = Math.max(0, (endMs - startMs) / (24 * 60 * 60 * 1e3));
+  return Number.isInteger(days) ? String(days) : days.toFixed(2);
+};
+var timeOperation = async (label, operation) => {
+  const startedAt = Date.now();
+  try {
+    return await operation();
+  } finally {
+    console.log(import_chalk2.default.gray(`${label}: done in ${formatDuration(startedAt)}`));
+  }
+};
+var isGoodTest = (result) => result.stat?.orders > 5 && result.stat?.profit > 10;
+var getResultAmount = (result) => result.stat.amount ?? 0;
 var recordError = (error) => {
   errorMessages.push(error);
 };
+var stripInlineLogs = (result) => {
+  const { inlineOrderLog, inlinePositionLog, ...resultWithoutLogs } = result;
+  return resultWithoutLogs;
+};
+var getInlineArtifacts = (result) => {
+  if (!result.inlineOrderLog && !result.inlinePositionLog) {
+    return null;
+  }
+  return {
+    orderLog: result.inlineOrderLog,
+    positionLog: result.inlinePositionLog
+  };
+};
+var retainArtifacts = (testName, artifacts) => {
+  if (artifacts) {
+    resultArtifactsByTestName.set(testName, artifacts);
+  }
+  artifactRefCountsByTestName.set(
+    testName,
+    (artifactRefCountsByTestName.get(testName) ?? 0) + 1
+  );
+};
+var releaseArtifacts = (testName) => {
+  const nextCount = (artifactRefCountsByTestName.get(testName) ?? 0) - 1;
+  if (nextCount <= 0) {
+    artifactRefCountsByTestName.delete(testName);
+    resultArtifactsByTestName.delete(testName);
+    return;
+  }
+  artifactRefCountsByTestName.set(testName, nextCount);
+};
+var insertTopResult = (currentResults, nextResult, limit) => {
+  if (limit <= 0) {
+    return {
+      results: [],
+      added: false
+    };
+  }
+  const nextResults = [...currentResults];
+  const nextAmount = getResultAmount(nextResult);
+  let insertIndex = nextResults.length;
+  for (let index = 0; index < nextResults.length; index += 1) {
+    if (nextAmount > getResultAmount(nextResults[index])) {
+      insertIndex = index;
+      break;
+    }
+  }
+  if (insertIndex === nextResults.length && nextResults.length >= limit) {
+    return {
+      results: currentResults,
+      added: false
+    };
+  }
+  nextResults.splice(insertIndex, 0, nextResult);
+  if (nextResults.length > limit) {
+    nextResults.length = limit;
+  }
+  return {
+    results: nextResults,
+    added: nextResults.some(
+      (candidate) => candidate.test.name === nextResult.test.name
+    )
+  };
+};
+var updateTopResults = (nextResults, nextResult, artifacts) => {
+  const previousTopNames = topResultNames;
+  const nextTopNames = new Set(nextResults.map((result) => result.test.name));
+  if (artifacts && !previousTopNames.has(nextResult.test.name) && nextTopNames.has(nextResult.test.name)) {
+    retainArtifacts(nextResult.test.name, artifacts);
+  }
+  for (const testName of previousTopNames) {
+    if (!nextTopNames.has(testName)) {
+      releaseArtifacts(testName);
+    }
+  }
+  results = nextResults;
+  topResultNames = nextTopNames;
+};
+var updateBestTickerResult = (result, artifacts) => {
+  if (!isGoodTest(result)) {
+    return false;
+  }
+  const previousResult = resultsByTickers.get(result.test.symbol);
+  if (previousResult && previousResult.stat.profit >= result.stat.profit) {
+    return false;
+  }
+  const previousTestName = bestTickerTestNameBySymbol.get(result.test.symbol);
+  if (previousTestName) {
+    releaseArtifacts(previousTestName);
+  }
+  resultsByTickers.set(result.test.symbol, result);
+  bestTickerTestNameBySymbol.set(result.test.symbol, result.test.name);
+  if (artifacts) {
+    retainArtifacts(result.test.name, artifacts);
+  }
+  return true;
+};
 var isStrategyConfigGrid = (value) => {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     return false;
@@ -1721,13 +2422,27 @@ var isStrategyConfigGrid = (value) => {
     (item) => Array.isArray(item)
   );
 };
+var mergePersistedTestSummaries = (existing, persisted) => {
+  const mergedByKey = /* @__PURE__ */ new Map();
+  for (const item of existing || []) {
+    const strategyName = typeof item?.data?.strategyName === "string" ? item.data.strategyName : "";
+    if (!strategyName || typeof item?.value !== "string") {
+      continue;
+    }
+    mergedByKey.set(`${strategyName}:${item.value}`, item);
+  }
+  for (const [key, item] of persisted) {
+    mergedByKey.set(key, item);
+  }
+  return [...mergedByKey.values()];
+};
 var resolveBacktestConnectorName = async (value) => {
   const connectorName = await (0, import_connectors2.resolveConnectorName)(value, projectRoot);
   if (connectorName) {
     return connectorName;
   }
   console.log(
-    import_chalk.default.yellow(
+    import_chalk2.default.yellow(
       `Unknown connector "${String(value || "").trim() || String(value)}". Fallback to ${import_connectors2.DEFAULT_CONNECTOR_NAME}.`
     )
   );
@@ -1735,33 +2450,79 @@ var resolveBacktestConnectorName = async (value) => {
 };
 var getLogsById = async (orderLogId) => {
   const orderLog = await (0, import_redis.getData)(
-    import_redis.redisKeys.cacheOrders(userName, orderLogId)
+    import_redis.redisKeys.cacheOrders(userName, orderLogId),
+    null
   );
   const positionLog = await (0, import_redis.getData)(
-    import_redis.redisKeys.cachePositions(userName, orderLogId)
+    import_redis.redisKeys.cachePositions(userName, orderLogId),
+    null
   );
   return { orderLog, positionLog };
 };
+var cacheArtifactsById = async (orderLogId, artifacts) => {
+  if (!artifacts || !Array.isArray(artifacts.orderLog) || !Array.isArray(artifacts.positionLog)) {
+    return;
+  }
+  await Promise.all([
+    (0, import_redis.setData)(import_redis.redisKeys.cacheOrders(userName, orderLogId), artifacts.orderLog, {
+      expire: import_constants2.TTL_1D
+    }),
+    (0, import_redis.setData)(
+      import_redis.redisKeys.cachePositions(userName, orderLogId),
+      artifacts.positionLog,
+      {
+        expire: import_constants2.TTL_1D
+      }
+    )
+  ]);
+};
+var resolveResultArtifacts = async (result) => {
+  const inlineArtifacts = resultArtifactsByTestName.get(result.test.name);
+  if (inlineArtifacts?.orderLog && inlineArtifacts?.positionLog) {
+    return inlineArtifacts;
+  }
+  return getLogsById(result.orderLogId);
+};
 var setTestData = async (test, stat, orderLog) => {
   await (0, import_redis.setData)(
     import_redis.redisKeys.testOrders(test.userName, test.strategyName, test.name),
     orderLog,
     {
-      expire: import_constants.TTL_1M
+      expire: import_constants2.TTL_1M
     }
   );
   await (0, import_redis.setData)(
     import_redis.redisKeys.testConfig(test.userName, test.strategyName, test.name),
     test,
     {
-      expire: import_constants.TTL_1M
+      expire: import_constants2.TTL_1M
     }
   );
   await (0, import_redis.setData)(
     import_redis.redisKeys.testStat(test.userName, test.strategyName, test.name),
     stat,
     {
-      expire: import_constants.TTL_1M
+      expire: import_constants2.TTL_1M
+    }
+  );
+  const { testId } = (0, import_backtest.parseTestName)(test.name);
+  persistedTestSummaryByKey.set(`${test.strategyName}:${test.name}`, {
+    value: test.name,
+    label: `${test.symbol}_${testId}`,
+    description: `${stat.netProfit || 0}$`,
+    data: {
+      netProfit: stat.netProfit || 0,
+      strategyName: test.strategyName
+    }
+  });
+};
+var persistTestSummariesIndex = async () => {
+  const existing = await (0, import_redis.getData)(import_redis.redisKeys.testSummaries(userName), []);
+  await (0, import_redis.setData)(
+    import_redis.redisKeys.testSummaries(userName),
+    mergePersistedTestSummaries(existing, persistedTestSummaryByKey),
+    {
+      expire: 0
     }
   );
 };
@@ -1797,18 +2558,39 @@ var backtest = async () => {
   const marketConnector = await connectorFactory({
     userName: flags.user
   });
-  const tickers = await (0, import_cli.getTickers)(
-    marketConnector,
-    flags.tickers,
-    flags.exclude,
-    flags.tickersLimit
+  const tickers = await timeOperation(
+    "tickers load",
+    () => (0, import_cli.getTickers)(
+      marketConnector,
+      flags.tickers,
+      flags.exclude,
+      flags.tickersLimit
+    )
   );
   if (flags.showTickersList) {
-    console.log(import_chalk.default.gray(JSON.stringify(tickers.sort(), null, 2)));
+    console.log(import_chalk2.default.gray(JSON.stringify(tickers.sort(), null, 2)));
     return;
   }
+  const window2 = resolveTimeWindow({
+    days: flags.days,
+    startTime: flags.startTime,
+    endTime: flags.endTime,
+    defaultStartMs: (0, import_time.getTimestamp)(import_constants2.BACKTEST_DEFAULT_DAYS),
+    defaultEndMs: (0, import_time.getTimestamp)()
+  });
+  const preloadStart = (0, import_time.getBacktestPreloadStart)(
+    window2.start,
+    import_constants2.BACKTEST_PRELOAD_DAYS
+  );
   if (!flags.cacheOnly) {
-    await (0, import_cli.update)(marketConnector, interval, tickers);
+    await timeOperation(
+      `update ${connectorName}`,
+      () => (0, import_cli.update)(marketConnector, interval, tickers, void 0, {
+        connectorLabel: connectorName,
+        preloadStart,
+        preloadEnd: window2.end
+      })
+    );
     const binanceConnectorCreator = await (0, import_connectors2.getConnectorCreatorByName)(
       import_connectors.ConnectorNames.Binance,
       projectRoot
@@ -1826,8 +2608,22 @@ var backtest = async () => {
     const coinbaseConnector = await coinbaseConnectorCreator({
       userName: flags.user
     });
-    await (0, import_cli.update)(binanceConnector, interval, ["BTCUSDT"]);
-    await (0, import_cli.update)(coinbaseConnector, interval, ["BTCUSDT"]);
+    await timeOperation(
+      `update ${import_connectors.ConnectorNames.Binance}`,
+      () => (0, import_cli.update)(binanceConnector, interval, ["BTCUSDT"], void 0, {
+        connectorLabel: import_connectors.ConnectorNames.Binance,
+        preloadStart,
+        preloadEnd: window2.end
+      })
+    );
+    await timeOperation(
+      `update ${import_connectors.ConnectorNames.Coinbase}`,
+      () => (0, import_cli.update)(coinbaseConnector, interval, ["BTCUSDT"], void 0, {
+        connectorLabel: import_connectors.ConnectorNames.Coinbase,
+        preloadStart,
+        preloadEnd: window2.end
+      })
+    );
   }
   if (flags.updateOnly) {
     return;
@@ -1838,15 +2634,59 @@ var backtest = async () => {
     strategyName,
     typedBacktestConfig,
     connectorName
-  ).slice(0, parseInt(flags.tests));
+  );
   const mlEnabled = Boolean(flags.ml);
-  testSuite = testSuite.map((test) => ({ ...test, ml: mlEnabled }));
-  const chunkSize = Math.ceil(testSuite.length / parseInt(flags.parallel));
+  const aiEnabled = Boolean(flags.ai);
+  testSuite = testSuite.map((test) => ({
+    ...test,
+    options: {
+      start: window2.start,
+      end: window2.end
+    },
+    ml: mlEnabled,
+    ai: aiEnabled,
+    timeoutMs: testItemTimeoutMs
+  })).slice(testsSkip, testsSkip + testsLimit);
+  if (!testSuite.length) {
+    console.log(
+      import_chalk2.default.yellow(
+        `No tests selected (skip=${testsSkip}, limit=${testsLimit}).`
+      )
+    );
+    return;
+  }
+  if (shouldBackfillDerivativesContextForBacktest({
+    aiEnabled,
+    cacheOnly: Boolean(flags.cacheOnly),
+    mlEnabled
+  })) {
+    await timeOperation(
+      "derivatives context backfill",
+      () => backfillDerivativesContextForBacktest({
+        userName,
+        symbols: testSuite.map((test) => test.symbol),
+        startMs: window2.start,
+        endMs: window2.end,
+        preloadStartMs: preloadStart
+      })
+    );
+  }
+  testsStartedAt = Date.now();
+  const chunkSize = Math.ceil(testSuite.length / effectiveParallel);
   const chunks = import_lodash.default.chunk(testSuite, chunkSize);
-  let completedWorkers = 0;
   let completedTests = 0;
   let isFinishing = false;
   const workers = /* @__PURE__ */ new Set();
+  const maybeFinish = async () => {
+    if (isFinishing) {
+      return;
+    }
+    if (completedTests !== testSuite.length || workers.size > 0) {
+      return;
+    }
+    isFinishing = true;
+    await finish();
+  };
   const stopWorkers = () => {
     for (const worker of workers) {
       if (!worker.killed) {
@@ -1862,9 +2702,22 @@ var backtest = async () => {
     stopWorkers();
     process.exit(143);
   });
-  console.log(import_chalk.default.yellow(`tests: ${testSuite.length}`));
+  console.log(import_chalk2.default.yellow(`tests: ${testSuite.length}`));
+  console.log(
+    import_chalk2.default.gray(`parallel: ${effectiveParallel}, workerHeapMb: ${workerHeapMb}`)
+  );
+  console.log(
+    import_chalk2.default.gray(
+      `window: ${(0, import_time.formatUnix)(window2.start)} -> ${(0, import_time.formatUnix)(window2.end)} (${formatWindowDays(window2.start, window2.end)}d, ${window2.source})`
+    )
+  );
+  console.log(
+    import_chalk2.default.gray(
+      `preload: ${(0, import_time.formatUnix)(preloadStart)} -> ${(0, import_time.formatUnix)(window2.end)} (${import_constants2.BACKTEST_PRELOAD_DAYS}d warmup)`
+    )
+  );
   console.log("");
-  const bar = new import_progress.default(
+  const bar = new import_progress2.default(
     ":current/:total [:bar][:percent] :symbol :amount :eta(s)",
     {
       total: testSuite.length,
@@ -1876,23 +2729,18 @@ var backtest = async () => {
     const chunkWithId = chunk.map((test) => ({ ...test, chunkId }));
     const tester = (0, import_child_process.fork)(testerWorkerPath, [], {
       execArgv: testerNeedsTsRuntime ? [
-        "--max-old-space-size=8192",
+        `--max-old-space-size=${workerHeapMb}`,
         "-r",
         "ts-node/register",
         "-r",
         "tsconfig-paths/register"
-      ] : ["--max-old-space-size=8192"]
+      ] : [`--max-old-space-size=${workerHeapMb}`]
     });
     workers.add(tester);
     tester.on("message", async (msg) => {
       if (msg.done) {
-        completedWorkers++;
         workers.delete(tester);
-        if (completedWorkers === chunks.length && !isFinishing) {
-          isFinishing = true;
-          results = (0, import_backtest.sortBestTests)(results, flags.top);
-          await finish();
-        }
+        await maybeFinish();
         return;
       }
       completedTests++;
@@ -1904,49 +2752,55 @@ var backtest = async () => {
           payload: msg
         });
         console.error(
-          import_chalk.default.red(`Error in test #${msg.id}: ${JSON.stringify(msg)}`)
+          import_chalk2.default.red(`Error in test #${msg.id}: ${JSON.stringify(msg)}`)
         );
         return;
       } else {
         successTests++;
       }
-      results.push(msg);
-      const goodResults = filterGoodTests(results);
-      goodResults.forEach((res) => {
-        const prevValue = resultsByTickers.get(res.test.symbol);
-        if (!prevValue || prevValue.stat.profit < res.stat.profit) {
-          resultsByTickers.set(res.test.symbol, res);
-        }
-      });
+      const fullResult = msg;
+      const result = stripInlineLogs(fullResult);
+      const inlineArtifacts = getInlineArtifacts(fullResult);
+      const nextTopResults = insertTopResult(results, result, flags.top);
+      const shouldCacheTopArtifacts = nextTopResults.added;
+      if (nextTopResults.added || results !== nextTopResults.results) {
+        updateTopResults(nextTopResults.results, result, inlineArtifacts);
+      }
+      const updatedBestTickerResult = updateBestTickerResult(
+        result,
+        inlineArtifacts
+      );
+      if ((shouldCacheTopArtifacts || updatedBestTickerResult) && inlineArtifacts) {
+        await cacheArtifactsById(result.orderLogId, inlineArtifacts);
+      }
       if (completedTests % progressStep === 0 || completedTests === testSuite.length) {
-        results = (0, import_backtest.sortBestTests)(results, flags.top);
-        const {
-          test: { symbol, name },
-          stat: { profit }
-        } = results[0];
+        const bestResult = results[0];
+        const symbol = bestResult?.test.symbol || "-";
+        const profit = bestResult?.stat.profit || 0;
         const profitStr = `${(profit || 0).toFixed(2)}$`;
         bar.tick(
           completedTests === testSuite.length ? completedTests % progressStep : progressStep,
           {
-            symbol: import_chalk.default.yellow(symbol),
-            amount: profit > 0 ? import_chalk.default.green(profitStr) : import_chalk.default.red(profitStr)
+            symbol: import_chalk2.default.yellow(symbol),
+            amount: profit > 0 ? import_chalk2.default.green(profitStr) : import_chalk2.default.red(profitStr)
           }
         );
       }
     });
     tester.on("error", (err) => {
       recordError({ error: err?.message ?? err });
-      console.error(import_chalk.default.red(`Worker error: ${err.message}`));
+      console.error(import_chalk2.default.red(`Worker error: ${err.message}`));
     });
     tester.on("exit", (code) => {
       workers.delete(tester);
       if (code !== 0) {
         recordError({ error: `Worker exited with code ${code}` });
-        console.error(import_chalk.default.red(`Worker exited with code ${code}`));
+        console.error(import_chalk2.default.red(`Worker exited with code ${code}`));
       }
+      void maybeFinish();
     });
     await (0, import_redis.setData)(import_redis.redisKeys.cacheChunk(userName, chunkId), chunkWithId, {
-      expire: import_constants.TTL_1D
+      expire: import_constants2.TTL_1D
     });
     tester.send({ chunkId, userName });
   }
@@ -1954,14 +2808,22 @@ var backtest = async () => {
 var saveAndPrintResults = async () => {
   const colorizedResults = [];
   for await (const result of results) {
-    const { test, orderLogId } = result;
+    const { test } = result;
     const { symbol, name } = test;
-    const { orderLog, positionLog } = await getLogsById(orderLogId);
+    const { orderLog, positionLog } = await resolveResultArtifacts(result);
+    if (!orderLog || !positionLog) {
+      throw new Error(`Logs not found for test ${name}`);
+    }
     const stat = (0, import_backtest.calculateStatsFull)(positionLog);
+    if (!stat && result.stat.orders > 0) {
+      throw new Error(
+        `Position log is empty for test ${name} despite ${result.stat.orders} closed orders`
+      );
+    }
     await setTestData(test, stat, orderLog);
     const statRow = [
-      import_chalk.default.blue(name),
-      import_chalk.default.yellow(symbol),
+      import_chalk2.default.blue(name),
+      import_chalk2.default.yellow(symbol),
       ...(0, import_cli.drawStatInCLI)(stat, [
         "netProfit",
         "orders",
@@ -1980,14 +2842,22 @@ var saveAndPrintResults = async () => {
 var saveAndPrintResultsByTickers = async () => {
   const colorizedResultsByTickers = [];
   for await (const result of resultsByTickers.values()) {
-    const { test, orderLogId } = result;
+    const { test } = result;
     const { symbol, name } = test;
-    const { orderLog, positionLog } = await getLogsById(orderLogId);
+    const { orderLog, positionLog } = await resolveResultArtifacts(result);
+    if (!orderLog || !positionLog) {
+      throw new Error(`Logs not found for ticker result ${name}`);
+    }
     const stat = (0, import_backtest.calculateStatsFull)(positionLog);
+    if (!stat && result.stat.orders > 0) {
+      throw new Error(
+        `Position log is empty for ticker result ${name} despite ${result.stat.orders} closed orders`
+      );
+    }
     await setTestData(test, stat, orderLog);
     const statRow = [
-      import_chalk.default.blue(name),
-      import_chalk.default.yellow(symbol),
+      import_chalk2.default.blue(name),
+      import_chalk2.default.yellow(symbol),
       ...(0, import_cli.drawStatInCLI)(stat, [
         "netProfit",
         "orders",
@@ -2011,18 +2881,26 @@ var finish = async () => {
   } else {
     await saveAndPrintResultsByTickers();
   }
+  await persistTestSummariesIndex();
+  console.log(
+    import_chalk2.default.gray(`tests run: done in ${formatDuration(testsStartedAt)}`)
+  );
+  console.log(
+    import_chalk2.default.gray(`backtest total: done in ${formatDuration(runStartedAt)}`)
+  );
+  console.log("");
   const bestConfig = results[0]?.test.strategyConfig;
-  console.log(import_chalk.default.gray("BEST CONFIG:"));
-  console.log(import_chalk.default.green((0, import_data.toJson)(bestConfig, true)));
+  console.log(import_chalk2.default.gray("BEST CONFIG:"));
+  console.log(import_chalk2.default.green((0, import_data.toJson)(bestConfig, true)));
   console.log("");
   const mergedConfig = (0, import_backtest.mergeConfigs)(
     results.map(({ test: { strategyConfig } }) => strategyConfig)
   );
-  console.log(import_chalk.default.gray("MERGED CONFIG:"));
-  console.log(import_chalk.default.blue((0, import_data.toJson)(mergedConfig, true)));
+  console.log(import_chalk2.default.gray("MERGED CONFIG:"));
+  console.log(import_chalk2.default.blue((0, import_data.toJson)(mergedConfig, true)));
   console.log("");
-  console.log(`${import_chalk.default.green("SUCCESS TESTS")}: ${successTests}`);
-  console.log(`${import_chalk.default.red("ERRORS")}: ${errorTests}`);
+  console.log(`${import_chalk2.default.green("SUCCESS TESTS")}: ${successTests}`);
+  console.log(`${import_chalk2.default.red("ERRORS")}: ${errorTests}`);
   console.log("");
   const finishedAt = /* @__PURE__ */ new Date();
   const durationSeconds = Number(
@@ -2038,7 +2916,7 @@ var finish = async () => {
       finishedAt: finishedAt.toISOString(),
       durationSeconds,
       results,
-      resultsByTickers: resultsByTickers.values(),
+      resultsByTickers: Array.from(resultsByTickers.values()),
       bestConfig,
       mergedConfig,
       successTests,
@@ -2051,4 +2929,13 @@ var finish = async () => {
   );
   process.exit();
 };
-backtest();
+if (require.main === module) {
+  void backtest();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  backtest,
+  mergePersistedTestSummaries,
+  resolveEffectiveParallel,
+  resolveWorkerHeapMb
+});