@tradejs/cli 2.0.6 → 2.0.8

package/dist/scripts/backtest.js

@@ -1681,6 +1681,7 @@ var import_time3 = require("@tradejs/core/time");
 var import_backtestArtifacts = require("@tradejs/infra/backtestArtifacts");
 var import_redis4 = require("@tradejs/infra/redis");
 var import_tradingAccounts = require("@tradejs/infra/tradingAccounts");
+var import_types3 = require("@tradejs/types");
 
 // src/lib/runFormatting.ts
 var import_date_fns = require("date-fns");
@@ -1710,6 +1711,7 @@ var import_progress = __toESM(require("progress"));
 var import_chalk = __toESM(require("chalk"));
 var import_connectors = require("@tradejs/connectors");
 var import_connectors2 = require("@tradejs/node/connectors");
+var import_strategies = require("@tradejs/node/strategies");
 var import_timescale = require("@tradejs/infra/timescale");
 
 // src/lib/binanceMarketData.ts
@@ -1719,14 +1721,6 @@ var MARKET_FEATURE_INTERVAL_MS = {
   "15m": 9e5,
   "1h": 36e5
 };
-var STABLE_QUOTE_SYMBOLS = /* @__PURE__ */ new Set([
-  "USDCUSDT",
-  "FDUSDUSDT",
-  "TUSDUSDT",
-  "BUSDUSDT",
-  "USDPUSDT",
-  "DAIUSDT"
-]);
 var safeDivide = (num, den) => Number.isFinite(num) && Number.isFinite(den) && den !== 0 ? num / den : null;
 var mean = (values) => values.length ? values.reduce((sum, value) => sum + value, 0) / values.length : null;
 var standardDeviation = (values) => {
@@ -1770,9 +1764,6 @@ var classifyBtcAltRegime = ({
   if (btcVsAltReturn24h < -5e-3) return "alt_lead";
   return "neutral";
 };
-var selectBreadthUniverseFromTickers = (tickers, limit) => tickers.filter(
-  (ticker) => ticker.symbol.endsWith("USDT") && ticker.symbol !== "BTCUSDT" && !STABLE_QUOTE_SYMBOLS.has(ticker.symbol) && Number.isFinite(ticker.turnover24h) && ticker.turnover24h > 0
-).sort((a, b) => b.turnover24h - a.turnover24h).slice(0, Math.max(0, limit)).map((ticker) => ticker.symbol);
 var aggregateAggTradesToRows = ({
   symbol,
   interval: interval2,
@@ -2254,10 +2245,6 @@ var backfillBinanceMarketContext = async (params, enabled) => {
     process.env.BINANCE_MARKET_CONTEXT_TRADE_FLOW_SYMBOL_LIMIT,
     2
   );
-  const breadthLimit = asInt(
-    process.env.BINANCE_MARKET_CONTEXT_BREADTH_LIMIT,
-    30
-  );
   const breadthChunkDays = asFloat(
     process.env.BINANCE_MARKET_CONTEXT_BREADTH_CHUNK_DAYS,
     30
@@ -2380,88 +2367,113 @@ var backfillBinanceMarketContext = async (params, enabled) => {
     }
   }
   if (includeBreadth) {
-    const tickers = await connector.getTickers();
-    const breadthSymbols = selectBreadthUniverseFromTickers(
-      tickers,
-      breadthLimit
-    );
-    const universe = `binance_top${breadthSymbols.length}_usdt`;
-    const coverage = await (0, import_timescale.getMarketBreadthCoverage)({
-      universe,
-      interval: interval2,
-      startMs: breadthStartMs,
-      endMs
-    });
-    const hasBtcAltMetrics = (coverage?.btcAltMetricsRows ?? 0) >= Math.floor(Math.max(1, coverage?.rows ?? 0) * 0.9);
-    if (!hasCoverage({
-      coverage,
+    const breadthUniverses = (0, import_strategies.getBinanceBreadthUniverses)();
+    const breadthSymbols = breadthUniverses.at(-1)?.symbols ?? [];
+    const connectorInterval = marketIntervalToConnectorInterval(interval2);
+    const chunks = buildBreadthBackfillChunks({
       startMs: breadthStartMs,
       endMs,
-      intervalMs
-    }) || !hasBtcAltMetrics) {
-      const connectorInterval = marketIntervalToConnectorInterval(interval2);
-      const chunks = buildBreadthBackfillChunks({
-        startMs: breadthStartMs,
-        endMs,
-        intervalMs,
-        chunkDays: breadthChunkDays
-      });
-      const missingChunks = filterMissingBreadthBackfillChunks({
-        chunks,
-        coverage,
-        intervalMs
-      });
-      const bar = new import_progress.default(
-        "breadth :current/:total [:bar][:percent] :etas(s) candles=:candles skip=:skip chunk=:chunk :symbol",
-        {
-          total: Math.max(1, missingChunks.length * breadthSymbols.length),
-          width: 24
-        }
-      );
-      let candlesRead = 0;
-      let skippedBreadthChunks = chunks.length - missingChunks.length;
-      if (!missingChunks.length) {
-        bar.tick(1, {
-          candles: 0,
-          skip: skippedBreadthChunks,
-          chunk: "cached",
-          symbol: universe
+      intervalMs,
+      chunkDays: breadthChunkDays
+    });
+    const plans = await Promise.all(
+      breadthUniverses.map(async (definition) => {
+        const coverage = await (0, import_timescale.getMarketBreadthCoverage)({
+          universe: definition.universe,
+          interval: interval2,
+          startMs: breadthStartMs,
+          endMs
         });
-      }
-      for (let chunkIndex = 0; chunkIndex < missingChunks.length; chunkIndex += 1) {
-        const chunk = missingChunks[chunkIndex];
-        const originalChunkIndex = chunks.findIndex(
-          (item) => item.startMs === chunk.startMs && item.endMs === chunk.endMs
-        );
-        const candlesBySymbol = {};
-        for (const symbol of breadthSymbols) {
-          const candles = await connector.kline({
-            symbol,
-            interval: connectorInterval,
-            start: chunk.fetchStartMs,
-            end: chunk.endMs,
-            silent: true
-          });
-          candlesBySymbol[symbol] = candles;
-          candlesRead += candles.length;
-          bar.tick(1, {
-            candles: candlesRead,
-            skip: skippedBreadthChunks,
-            chunk: `${originalChunkIndex + 1}/${chunks.length}`,
-            symbol
-          });
+        const hasBtcAltMetrics = (coverage?.btcAltMetricsRows ?? 0) >= Math.floor(Math.max(1, coverage?.rows ?? 0) * 0.9);
+        const missingChunks2 = !hasCoverage({
+          coverage,
+          startMs: breadthStartMs,
+          endMs,
+          intervalMs
+        }) || !hasBtcAltMetrics ? !hasBtcAltMetrics ? chunks : filterMissingBreadthBackfillChunks({
+          chunks,
+          coverage,
+          intervalMs
+        }) : [];
+        if (!missingChunks2.length) {
+          console.log(
+            import_chalk.default.gray(`breadth cached: universe=${definition.universe}`)
+          );
         }
-        const btcCandles = await connector.kline({
-          symbol: "BTCUSDT",
+        return {
+          definition,
+          missingChunkKeys: new Set(
+            missingChunks2.map((chunk) => `${chunk.startMs}:${chunk.endMs}`)
+          )
+        };
+      })
+    );
+    const missingChunks = chunks.filter((chunk) => {
+      const key = `${chunk.startMs}:${chunk.endMs}`;
+      return plans.some((plan) => plan.missingChunkKeys.has(key));
+    });
+    const bar = new import_progress.default(
+      "breadth :current/:total [:bar][:percent] :etas(s) candles=:candles skip=:skip chunk=:chunk :symbol",
+      {
+        total: Math.max(1, missingChunks.length * breadthSymbols.length),
+        width: 24
+      }
+    );
+    let candlesRead = 0;
+    const skippedBreadthChunks = chunks.length - missingChunks.length;
+    if (!missingChunks.length) {
+      bar.tick(1, {
+        candles: 0,
+        skip: skippedBreadthChunks,
+        chunk: "cached",
+        symbol: "top5/top10/top30/top50/top100"
+      });
+    }
+    for (let chunkIndex = 0; chunkIndex < missingChunks.length; chunkIndex += 1) {
+      const chunk = missingChunks[chunkIndex];
+      const originalChunkIndex = chunks.findIndex(
+        (item) => item.startMs === chunk.startMs && item.endMs === chunk.endMs
+      );
+      const candlesBySymbol = {};
+      for (const symbol of breadthSymbols) {
+        const candles = await connector.kline({
+          symbol,
           interval: connectorInterval,
           start: chunk.fetchStartMs,
           end: chunk.endMs,
           silent: true
         });
+        candlesBySymbol[symbol] = candles;
+        candlesRead += candles.length;
+        bar.tick(1, {
+          candles: candlesRead,
+          skip: skippedBreadthChunks,
+          chunk: `${originalChunkIndex + 1}/${chunks.length}`,
+          symbol
+        });
+      }
+      const btcCandles = await connector.kline({
+        symbol: "BTCUSDT",
+        interval: connectorInterval,
+        start: chunk.fetchStartMs,
+        end: chunk.endMs,
+        silent: true
+      });
+      const chunkKey = `${chunk.startMs}:${chunk.endMs}`;
+      for (const plan of plans) {
+        if (!plan.missingChunkKeys.has(chunkKey)) {
+          continue;
+        }
+        const symbolSet = new Set(plan.definition.symbols);
+        const universeCandles = Object.fromEntries(
+          Object.entries(candlesBySymbol).filter(
+            ([symbol]) => symbolSet.has(symbol)
+          )
+        );
         const rows = buildMarketBreadthRows({
-          universe,
+          universe: plan.definition.universe,
           interval: interval2,
-          candlesBySymbol,
+          candlesBySymbol: universeCandles,
           btcCandles
         }).filter((row) => {
           const ts = row.ts.getTime();
@@ -2470,8 +2482,6 @@ var backfillBinanceMarketContext = async (params, enabled) => {
         await (0, import_timescale.upsertMarketBreadthRows)(rows);
         breadthRows += rows.length;
       }
-    } else {
-      console.log(import_chalk.default.gray(`breadth cached: universe=${universe}`));
     }
   }
   console.log(
@@ -4666,11 +4676,30 @@ var resolveTimeWindow = ({
   endTime,
   nowMs = Date.now(),
   defaultStartMs,
-  defaultEndMs
+  defaultEndMs,
+  closedIntervalMs
 }) => {
   const explicitStart = toEpochMs(startTime);
   const explicitEnd = toEpochMs(endTime);
   const resolvedDays = toPositiveNumber(days);
+  const alignToLastClosedInterval = (window2, preserveDuration) => {
+    if (typeof closedIntervalMs !== "number" || !Number.isFinite(closedIntervalMs) || closedIntervalMs <= 0) {
+      return window2;
+    }
+    const alignedEnd = Math.floor(window2.end / closedIntervalMs) * closedIntervalMs - 1;
+    const delta = window2.end - alignedEnd;
+    const alignedStart = preserveDuration ? window2.start - delta : window2.start;
+    if (alignedStart >= alignedEnd) {
+      throw new Error(
+        `Invalid closed-candle window: start (${alignedStart}) must be less than end (${alignedEnd})`
+      );
+    }
+    return {
+      ...window2,
+      start: Math.trunc(alignedStart),
+      end: Math.trunc(alignedEnd)
+    };
+  };
   if (explicitStart != null || explicitEnd != null) {
     const resolvedStart = explicitStart ?? (resolvedDays != null && explicitEnd != null ? explicitEnd - resolvedDays * ONE_DAY_MS : defaultStartMs);
     const resolvedEnd2 = explicitEnd ?? (resolvedDays != null && explicitStart != null ? explicitStart + resolvedDays * ONE_DAY_MS : defaultEndMs ?? nowMs);
@@ -4679,11 +4708,14 @@ var resolveTimeWindow = ({
         `Invalid time window: startTime (${resolvedStart}) must be less than endTime (${resolvedEnd2})`
       );
     }
-    return {
-      start: resolvedStart,
-      end: resolvedEnd2,
-      source: "explicit"
-    };
+    return alignToLastClosedInterval(
+      {
+        start: resolvedStart,
+        end: resolvedEnd2,
+        source: "explicit"
+      },
+      explicitStart == null && resolvedDays != null
+    );
   }
   if (resolvedDays != null) {
     const resolvedEnd2 = defaultEndMs ?? nowMs;
@@ -4693,11 +4725,14 @@ var resolveTimeWindow = ({
         `Invalid time window: computed start (${resolvedStart}) must be less than end (${resolvedEnd2})`
       );
     }
-    return {
-      start: Math.trunc(resolvedStart),
-      end: Math.trunc(resolvedEnd2),
-      source: "days"
-    };
+    return alignToLastClosedInterval(
+      {
+        start: Math.trunc(resolvedStart),
+        end: Math.trunc(resolvedEnd2),
+        source: "days"
+      },
+      true
+    );
   }
   const resolvedEnd = defaultEndMs ?? nowMs;
   if (defaultStartMs >= resolvedEnd) {
@@ -4705,11 +4740,14 @@ var resolveTimeWindow = ({
       `Invalid default time window: start (${defaultStartMs}) must be less than end (${resolvedEnd})`
     );
   }
-  return {
-    start: Math.trunc(defaultStartMs),
-    end: Math.trunc(resolvedEnd),
-    source: "default"
-  };
+  return alignToLastClosedInterval(
+    {
+      start: Math.trunc(defaultStartMs),
+      end: Math.trunc(resolvedEnd),
+      source: "default"
+    },
+    true
+  );
 };
 
 // src/lib/runtimeStrategyBacktest.ts
@@ -5095,7 +5133,8 @@ var prepareRunEnvironment = async ({
   accountId,
   deploymentId,
   assetClasses,
-  deployment
+  deployment,
+  closedIntervalMs
 }) => {
   const connectorName = await resolveRunConnectorName({
     value: connector,
@@ -5158,7 +5197,8 @@ var prepareRunEnvironment = async ({
     startTime,
     endTime,
     defaultStartMs: (0, import_time2.getTimestamp)(import_constants2.BACKTEST_DEFAULT_DAYS),
-    defaultEndMs: (0, import_time2.getTimestamp)()
+    defaultEndMs: (0, import_time2.getTimestamp)(),
+    closedIntervalMs
   });
   const preloadStart = (0, import_time2.getBacktestPreloadStart)(
     window2.start,
@@ -5553,8 +5593,12 @@ var markBacktestRunStatus = async ({
 };
 
 // src/lib/backtest/runState.ts
+var import_types2 = require("@tradejs/types");
 var successTests = 0;
 var errorTests = 0;
+var warningCounts = {
+  [import_types2.BACKTEST_WARNING_CODES.TAKE_PROFIT_CROSSED_BEFORE_ENTRY]: 0
+};
 var errorMessages = [];
 var topResults = [];
 var bestTickerResults = /* @__PURE__ */ new Map();
@@ -5601,6 +5645,14 @@ var addResultToAggregate = (aggregate, result) => {
     aggregate.winRateCount += 1;
   }
 };
+var addResultWarnings = (result) => {
+  for (const code of Object.values(import_types2.BACKTEST_WARNING_CODES)) {
+    const count = Number(result.warningCounts?.[code] ?? 0);
+    if (Number.isFinite(count) && count > 0) {
+      warningCounts[code] = (warningCounts[code] ?? 0) + count;
+    }
+  }
+};
 var getAggregateAverageProfit = (aggregate) => aggregate.count > 0 ? aggregate.netProfitSum / aggregate.count : 0;
 var getAggregateWinRate = (aggregate) => {
   const closedTrades = aggregate.wins + aggregate.losses;
@@ -5626,6 +5678,7 @@ var markTestsStarted = () => {
 var getRunCounters = () => ({
   successTests,
   errorTests,
+  warningCounts: { ...warningCounts },
   errors: [...errorMessages]
 });
 var getTopResults = () => topResults;
@@ -5639,6 +5692,7 @@ var setBestTickerResultForSymbol = (symbol, result) => {
 };
 var recordResultAggregates = (result) => {
   addResultToAggregate(progressStats, result);
+  addResultWarnings(result);
   const configId = result.test.configId || result.test.name;
   const existing = configResultBuckets.get(configId);
   const bucket = existing ?? {
@@ -5688,6 +5742,9 @@ var setRuntimeCompareContext = ({
 var resetRunState = () => {
   successTests = 0;
   errorTests = 0;
+  for (const code of Object.values(import_types2.BACKTEST_WARNING_CODES)) {
+    warningCounts[code] = 0;
+  }
   errorMessages.length = 0;
   topResults = [];
   bestTickerResults.clear();
@@ -6284,9 +6341,15 @@ var printRunOutro = () => {
     import_chalk9.default.gray(`backtest total: done in ${formatDuration(getRunStartedAt())}`)
   );
   console.log("");
-  const { successTests: successTests2, errorTests: errorTests2 } = getRunCounters();
+  const { successTests: successTests2, errorTests: errorTests2, warningCounts: warningCounts2 } = getRunCounters();
   console.log(`${import_chalk9.default.green("SUCCESS TESTS")}: ${successTests2}`);
   console.log(`${import_chalk9.default.red("ERRORS")}: ${errorTests2}`);
+  const takeProfitCrossedWarnings = warningCounts2[import_types3.BACKTEST_WARNING_CODES.TAKE_PROFIT_CROSSED_BEFORE_ENTRY] ?? 0;
+  console.log(
+    import_chalk9.default.yellow(
+      `WARNINGS (${import_types3.BACKTEST_WARNING_CODES.TAKE_PROFIT_CROSSED_BEFORE_ENTRY}): ${takeProfitCrossedWarnings}`
+    )
+  );
   console.log("");
 };
 

package/dist/scripts/binanceBreadthUniversesUpdate.js

@@ -0,0 +1,120 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/scripts/binanceBreadthUniversesUpdate.ts
+var binanceBreadthUniversesUpdate_exports = {};
+__export(binanceBreadthUniversesUpdate_exports, {
+  BINANCE_BREADTH_UNIVERSES_RELATIVE_PATH: () => BINANCE_BREADTH_UNIVERSES_RELATIVE_PATH,
+  main: () => main
+});
+module.exports = __toCommonJS(binanceBreadthUniversesUpdate_exports);
+var import_config = require("dotenv/config");
+var import_args = __toESM(require("args"));
+var import_promises = __toESM(require("fs/promises"));
+var import_node_path = __toESM(require("path"));
+var import_chalk = __toESM(require("chalk"));
+var import_connectors = require("@tradejs/connectors");
+var import_connectors2 = require("@tradejs/node/connectors");
+var import_strategies = require("@tradejs/node/strategies");
+
+// src/lib/binanceMarketData.ts
+var STABLE_QUOTE_SYMBOLS = /* @__PURE__ */ new Set([
+  "USDCUSDT",
+  "FDUSDUSDT",
+  "TUSDUSDT",
+  "BUSDUSDT",
+  "USDPUSDT",
+  "DAIUSDT"
+]);
+var selectBreadthUniverseFromTickers = (tickers, limit) => tickers.filter(
+  (ticker) => ticker.symbol.endsWith("USDT") && ticker.symbol !== "BTCUSDT" && !STABLE_QUOTE_SYMBOLS.has(ticker.symbol) && Number.isFinite(ticker.turnover24h) && ticker.turnover24h > 0
+).sort((a, b) => b.turnover24h - a.turnover24h).slice(0, Math.max(0, limit)).map((ticker) => ticker.symbol);
+
+// src/scripts/binanceBreadthUniversesUpdate.ts
+import_args.default.example(
+  "yarn breadth:universes:update --write",
+  "Refresh the versioned Binance top5/top10/top30/top50/top100 breadth snapshot"
+);
+import_args.default.option(
+  ["w", "write"],
+  "Write the snapshot; without this flag only print the proposed update",
+  false
+);
+import_args.default.option(["u", "user"], "Connector user name", "root");
+var flags = import_args.default.parse(process.argv);
+var BINANCE_BREADTH_UNIVERSES_RELATIVE_PATH = "packages/node/src/config/binanceBreadthUniverses.json";
+var main = async () => {
+  const projectRoot = String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd();
+  const connectorCreator = await (0, import_connectors2.getConnectorCreatorByName)(
+    import_connectors.ConnectorNames.Binance,
+    projectRoot
+  );
+  if (!connectorCreator) {
+    throw new Error("Binance connector is not registered");
+  }
+  const connector = await connectorCreator({
+    userName: String(flags.user || "root"),
+    universe: "crypto"
+  });
+  const rankedSymbols = selectBreadthUniverseFromTickers(
+    await connector.getTickers(),
+    100
+  );
+  const snapshot = (0, import_strategies.buildBinanceBreadthUniverseSnapshot)({ rankedSymbols });
+  const serialized = `${JSON.stringify(snapshot, null, 2)}
+`;
+  console.log(
+    import_chalk.default.cyan(
+      `Binance breadth snapshot ${snapshot.fingerprint}: ${Object.entries(
+        snapshot.universes
+      ).map(
+        ([key, definition]) => `${key}=${definition.size}:${definition.fingerprint}`
+      ).join(" ")}`
+    )
+  );
+  if (!flags.write) {
+    console.log(serialized);
+    console.log(
+      import_chalk.default.yellow("Dry run only. Pass --write to update the snapshot file.")
+    );
+    return snapshot;
+  }
+  const outputPath = import_node_path.default.join(
+    projectRoot,
+    BINANCE_BREADTH_UNIVERSES_RELATIVE_PATH
+  );
+  await import_promises.default.writeFile(outputPath, serialized, "utf8");
+  console.log(import_chalk.default.green(`Updated ${outputPath}`));
+  return snapshot;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BINANCE_BREADTH_UNIVERSES_RELATIVE_PATH,
+  main
+});

package/dist/scripts/binanceMarketIngest.js

@@ -37,6 +37,7 @@ var import_config = require("dotenv/config");
 var import_args = __toESM(require("args"));
 var import_chalk = __toESM(require("chalk"));
 var import_connectors = require("@tradejs/connectors");
+var import_strategies = require("@tradejs/node/strategies");
 var import_timescale = require("@tradejs/infra/timescale");
 
 // src/lib/binanceMarketData.ts
@@ -46,14 +47,6 @@ var MARKET_FEATURE_INTERVAL_MS = {
   "15m": 9e5,
   "1h": 36e5
 };
-var STABLE_QUOTE_SYMBOLS = /* @__PURE__ */ new Set([
-  "USDCUSDT",
-  "FDUSDUSDT",
-  "TUSDUSDT",
-  "BUSDUSDT",
-  "USDPUSDT",
-  "DAIUSDT"
-]);
 var safeDivide = (num, den) => Number.isFinite(num) && Number.isFinite(den) && den !== 0 ? num / den : null;
 var mean = (values) => values.length ? values.reduce((sum, value) => sum + value, 0) / values.length : null;
 var standardDeviation = (values) => {
@@ -106,23 +99,23 @@ var normalizeMarketFeatureInterval = (value) => {
   return "15m";
 };
 var normalizeBinanceSymbols = (value) => String(value || "").split(",").map((item) => item.trim().toUpperCase()).filter(Boolean);
-var selectBreadthUniverseFromTickers = (tickers, limit) => tickers.filter(
-  (ticker) => ticker.symbol.endsWith("USDT") && ticker.symbol !== "BTCUSDT" && !STABLE_QUOTE_SYMBOLS.has(ticker.symbol) && Number.isFinite(ticker.turnover24h) && ticker.turnover24h > 0
-).sort((a, b) => b.turnover24h - a.turnover24h).slice(0, Math.max(0, limit)).map((ticker) => ticker.symbol);
 var estimateBinanceMarketDataVolume = ({
   symbols,
   days,
   interval,
   includeAggTrades,
   includeBreadth,
-  breadthLimit
+  breadthSizes
 }) => {
   const intervalMs = MARKET_FEATURE_INTERVAL_MS[interval];
   const bucketRowsPerSymbol = Math.ceil(days * 864e5 / intervalMs);
   const aggTradeBucketRows = includeAggTrades ? symbols.length * bucketRowsPerSymbol : 0;
-  const breadthSymbols = includeBreadth ? Math.max(0, breadthLimit) : 0;
+  const normalizedBreadthSizes = breadthSizes.filter(
+    (size) => Number.isFinite(size) && size > 0
+  );
+  const breadthSymbols = includeBreadth ? Math.max(0, ...normalizedBreadthSizes) : 0;
   const breadthCandleRows = breadthSymbols * bucketRowsPerSymbol;
-  const breadthRows = includeBreadth ? bucketRowsPerSymbol : 0;
+  const breadthRows = includeBreadth ? bucketRowsPerSymbol * normalizedBreadthSizes.length : 0;
   return {
     interval,
     days,
@@ -379,11 +372,6 @@ import_args.default.option(
   ["w", "write"],
   "Write rows to Timescale; without this flag only estimate"
 );
-import_args.default.option(
-  ["B", "breadthLimit"],
-  "Top USDT symbols used for breadth universe",
-  30
-);
 import_args.default.option(
   ["M", "batchMinutes"],
   "aggTrades request window size in minutes",
@@ -463,7 +451,7 @@ var main = async () => {
   const interval = normalizeMarketFeatureInterval(flags.interval);
   const hours = flags.hours == null ? null : asFloat(flags.hours, 0);
   const days = hours != null && hours > 0 ? hours / 24 : asFloat(flags.days, 1);
-  const breadthLimit = asInt(flags.breadthLimit, 30);
+  const breadthUniverses = (0, import_strategies.getBinanceBreadthUniverses)();
   const batchMinutes = asInt(flags.batchMinutes, 15);
   const requestDelayMs = asInt(flags.requestDelayMs, 75);
   const includeAll = Boolean(flags.all);
@@ -481,7 +469,7 @@ var main = async () => {
     interval,
     includeAggTrades: modes.includeAggTrades,
     includeBreadth: modes.includeBreadth,
-    breadthLimit
+    breadthSizes: breadthUniverses.map(({ size }) => size)
   });
   printEstimate(estimate);
   if (!flags.write) {
@@ -520,11 +508,7 @@ var main = async () => {
     }
   }
   if (modes.includeBreadth) {
-    const tickers = await connector.getTickers();
-    const breadthSymbols = selectBreadthUniverseFromTickers(
-      tickers,
-      breadthLimit
-    );
+    const breadthSymbols = breadthUniverses.at(-1)?.symbols ?? [];
     const connectorInterval = intervalToConnectorInterval(interval);
     const candlesBySymbol = {};
     for (const symbol of breadthSymbols) {
@@ -541,14 +525,29 @@ var main = async () => {
       process.stdout.write(`${candles.length}
 `);
     }
-    const universe = `binance_top${breadthSymbols.length}_usdt`;
-    const rows = buildMarketBreadthRows({
-      universe,
-      interval,
-      candlesBySymbol
+    const btcCandles = await connector.kline({
+      symbol: "BTCUSDT",
+      interval: connectorInterval,
+      start: fromMs,
+      end: toMs,
+      silent: true
     });
-    await (0, import_timescale.upsertMarketBreadthRows)(rows);
-    breadthRows += rows.length;
+    for (const definition of breadthUniverses) {
+      const symbolSet = new Set(definition.symbols);
+      const universeCandles = Object.fromEntries(
+        Object.entries(candlesBySymbol).filter(
+          ([symbol]) => symbolSet.has(symbol)
+        )
+      );
+      const rows = buildMarketBreadthRows({
+        universe: definition.universe,
+        interval,
+        candlesBySymbol: universeCandles,
+        btcCandles
+      });
+      await (0, import_timescale.upsertMarketBreadthRows)(rows);
+      breadthRows += rows.length;
+    }
   }
   console.log(import_chalk.default.green("Binance market ingest done"));
   console.log(`aggTrades raw rows: ${aggTradesRaw}`);