@tradejs/cli 3.1.29-beta.296 → 3.1.29-beta.298

package/dist/scripts/coverageBackfill.js

@@ -0,0 +1,1731 @@
+"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/coverageBackfill.ts
+var coverageBackfill_exports = {};
+__export(coverageBackfill_exports, {
+  main: () => main
+});
+module.exports = __toCommonJS(coverageBackfill_exports);
+var import_connectors = require("@tradejs/connectors");
+var import_candles = require("@tradejs/infra/timescale/candles");
+var import_client3 = require("@tradejs/infra/timescale/client");
+var import_dataCoverage = require("@tradejs/infra/timescale/dataCoverage");
+var import_derivatives2 = require("@tradejs/infra/timescale/derivatives");
+var import_marketContext2 = require("@tradejs/infra/timescale/marketContext");
+var import_spread = require("@tradejs/infra/timescale/spread");
+var import_strategies = require("@tradejs/node/strategies");
+
+// src/lib/binanceMarketData.ts
+var MARKET_FEATURE_INTERVAL_MS = {
+  "1m": 6e4,
+  "5m": 3e5,
+  "15m": 9e5,
+  "1h": 36e5
+};
+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) => {
+  const avg = mean(values);
+  if (avg == null || values.length < 2) return null;
+  const variance = values.reduce((sum, value) => sum + (value - avg) ** 2, 0) / values.length;
+  return Math.sqrt(variance);
+};
+var buildPrefixSum = (values) => {
+  const prefix = [0];
+  for (const value of values) prefix.push(prefix[prefix.length - 1] + value);
+  return prefix;
+};
+var sumPrefixRange = (prefix, startIndex, endIndexInclusive) => {
+  if (endIndexInclusive < startIndex) return 0;
+  const start = Math.max(0, startIndex);
+  const end = Math.min(prefix.length - 2, endIndexInclusive);
+  if (end < start) return 0;
+  return prefix[end + 1] - prefix[start];
+};
+var windowReturn = (candles, index, lookbackBars) => {
+  const previous = candles[index - lookbackBars];
+  const current = candles[index];
+  return previous && previous.close > 0 ? (current.close - previous.close) / previous.close : null;
+};
+var classifyBtcAltRegime = ({
+  btcReturn24h,
+  altBasketReturn24h,
+  btcVsAltReturn24h
+}) => {
+  if (btcReturn24h == null || altBasketReturn24h == null || btcVsAltReturn24h == null) {
+    return "unknown";
+  }
+  if (btcReturn24h < -0.015 && altBasketReturn24h < -0.025) {
+    return "risk_off";
+  }
+  if (btcReturn24h > 5e-3 && altBasketReturn24h > 5e-3 && altBasketReturn24h > btcReturn24h) {
+    return "risk_on";
+  }
+  if (btcVsAltReturn24h > 5e-3) return "btc_lead";
+  if (btcVsAltReturn24h < -5e-3) return "alt_lead";
+  return "neutral";
+};
+var buildKlineTradeFlowRows = ({
+  symbol,
+  interval,
+  candles,
+  source = "binance_klines"
+}) => candles.map((candle) => {
+  const buyBaseVolume = candle.takerBuyBaseVolume;
+  const buyQuoteVolume = candle.takerBuyQuoteVolume;
+  if (buyBaseVolume == null || buyQuoteVolume == null || !Number.isFinite(buyBaseVolume) || !Number.isFinite(buyQuoteVolume)) {
+    return null;
+  }
+  const sellBaseVolume = candle.takerSellBaseVolume != null && Number.isFinite(candle.takerSellBaseVolume) ? candle.takerSellBaseVolume : Math.max(0, candle.volume - buyBaseVolume);
+  const sellQuoteVolume = candle.takerSellQuoteVolume != null && Number.isFinite(candle.takerSellQuoteVolume) ? candle.takerSellQuoteVolume : Math.max(0, candle.turnover - buyQuoteVolume);
+  const trades = candle.trades != null && Number.isFinite(candle.trades) ? Math.max(0, Math.trunc(candle.trades)) : 0;
+  return {
+    symbol,
+    interval,
+    ts: new Date(candle.timestamp),
+    trades,
+    buyBaseVolume,
+    sellBaseVolume,
+    buyQuoteVolume,
+    sellQuoteVolume,
+    netBaseDelta: buyBaseVolume - sellBaseVolume,
+    netQuoteDelta: buyQuoteVolume - sellQuoteVolume,
+    buyPressurePct: safeDivide(
+      buyBaseVolume,
+      buyBaseVolume + sellBaseVolume
+    ),
+    source
+  };
+}).filter((row) => row != null);
+var buildMarketBreadthRows = ({
+  universe,
+  interval,
+  candlesBySymbol,
+  btcCandles,
+  source = "binance_klines"
+}) => {
+  const timestamps = /* @__PURE__ */ new Set();
+  const indexedSymbols = Object.values(candlesBySymbol).map((candles) => ({
+    candles,
+    byTimestamp: new Map(
+      candles.map((candle, index) => [candle.timestamp, index])
+    ),
+    turnoverPrefix: buildPrefixSum(
+      candles.map((candle) => Math.max(0, candle.turnover ?? 0))
+    ),
+    closePrefix: buildPrefixSum(candles.map((candle) => candle.close))
+  }));
+  const btcIndexed = btcCandles ? {
+    candles: btcCandles,
+    byTimestamp: new Map(
+      btcCandles.map((candle, index) => [candle.timestamp, index])
+    ),
+    turnoverPrefix: buildPrefixSum(
+      btcCandles.map((candle) => Math.max(0, candle.turnover ?? 0))
+    )
+  } : null;
+  const intervalMs = MARKET_FEATURE_INTERVAL_MS[interval];
+  const bars1h = Math.max(1, Math.round(36e5 / intervalMs));
+  const bars4h = Math.max(1, Math.round(144e5 / intervalMs));
+  const bars24h = Math.max(1, Math.round(864e5 / intervalMs));
+  for (const candles of Object.values(candlesBySymbol)) {
+    for (const candle of candles) timestamps.add(candle.timestamp);
+  }
+  return [...timestamps].sort((a, b) => a - b).map((timestamp) => {
+    const returns = [];
+    const weightedReturns = [];
+    let advancers = 0;
+    let decliners = 0;
+    let unchanged = 0;
+    let aboveMa20 = 0;
+    let aboveMa20Eligible = 0;
+    let aboveMa50 = 0;
+    let aboveMa50Eligible = 0;
+    const altReturns1h = [];
+    const altReturns4h = [];
+    const altReturns24h = [];
+    let altTurnover1h = 0;
+    let altTurnover24h = 0;
+    let previousAltTurnover24h = 0;
+    for (const indexed of indexedSymbols) {
+      const { candles, byTimestamp, turnoverPrefix, closePrefix } = indexed;
+      const index = byTimestamp.get(timestamp);
+      if (index == null) continue;
+      const candle = candles[index];
+      const previous = candles[index - 1];
+      const ret = previous && previous.close > 0 ? (candle.close - previous.close) / previous.close : 0;
+      if (ret > 0) advancers += 1;
+      else if (ret < 0) decliners += 1;
+      else unchanged += 1;
+      returns.push(ret);
+      weightedReturns.push({
+        value: ret,
+        weight: Math.max(0, candle.turnover ?? 0)
+      });
+      const ma20Start = index - 19;
+      if (ma20Start >= 0) {
+        aboveMa20Eligible += 1;
+        const ma20 = sumPrefixRange(closePrefix, ma20Start, index) / 20;
+        if (candle.close > ma20) aboveMa20 += 1;
+      }
+      const ma50Start = index - 49;
+      if (ma50Start >= 0) {
+        aboveMa50Eligible += 1;
+        const ma50 = sumPrefixRange(closePrefix, ma50Start, index) / 50;
+        if (candle.close > ma50) aboveMa50 += 1;
+      }
+      const altReturn1h = windowReturn(candles, index, bars1h);
+      const altReturn4h = windowReturn(candles, index, bars4h);
+      const altReturn24h = windowReturn(candles, index, bars24h);
+      if (altReturn1h != null) altReturns1h.push(altReturn1h);
+      if (altReturn4h != null) altReturns4h.push(altReturn4h);
+      if (altReturn24h != null) altReturns24h.push(altReturn24h);
+      altTurnover1h += sumPrefixRange(
+        turnoverPrefix,
+        index - bars1h + 1,
+        index
+      );
+      altTurnover24h += sumPrefixRange(
+        turnoverPrefix,
+        index - bars24h + 1,
+        index
+      );
+      previousAltTurnover24h += sumPrefixRange(
+        turnoverPrefix,
+        index - bars24h * 2 + 1,
+        index - bars24h
+      );
+    }
+    const weightSum = weightedReturns.reduce(
+      (sum, item) => sum + item.weight,
+      0
+    );
+    const volumeWeightedReturn = weightSum > 0 ? weightedReturns.reduce(
+      (sum, item) => sum + item.value * item.weight,
+      0
+    ) / weightSum : null;
+    const btcIndex = btcIndexed?.byTimestamp.get(timestamp);
+    const btcReturn1h = btcIndexed && btcIndex != null ? windowReturn(btcIndexed.candles, btcIndex, bars1h) : null;
+    const btcReturn4h = btcIndexed && btcIndex != null ? windowReturn(btcIndexed.candles, btcIndex, bars4h) : null;
+    const btcReturn24h = btcIndexed && btcIndex != null ? windowReturn(btcIndexed.candles, btcIndex, bars24h) : null;
+    const btcTurnover1h = btcIndexed && btcIndex != null ? sumPrefixRange(
+      btcIndexed.turnoverPrefix,
+      btcIndex - bars1h + 1,
+      btcIndex
+    ) : null;
+    const btcTurnover24h = btcIndexed && btcIndex != null ? sumPrefixRange(
+      btcIndexed.turnoverPrefix,
+      btcIndex - bars24h + 1,
+      btcIndex
+    ) : null;
+    const previousBtcTurnover24h = btcIndexed && btcIndex != null ? sumPrefixRange(
+      btcIndexed.turnoverPrefix,
+      btcIndex - bars24h * 2 + 1,
+      btcIndex - bars24h
+    ) : null;
+    const altBasketReturn1h = mean(altReturns1h);
+    const altBasketReturn4h = mean(altReturns4h);
+    const altBasketReturn24h = mean(altReturns24h);
+    const btcVsAltReturn1h = btcReturn1h == null || altBasketReturn1h == null ? null : btcReturn1h - altBasketReturn1h;
+    const btcVsAltReturn4h = btcReturn4h == null || altBasketReturn4h == null ? null : btcReturn4h - altBasketReturn4h;
+    const btcVsAltReturn24h = btcReturn24h == null || altBasketReturn24h == null ? null : btcReturn24h - altBasketReturn24h;
+    const btcTurnoverShare1h = btcTurnover1h == null ? null : safeDivide(btcTurnover1h, btcTurnover1h + altTurnover1h);
+    const btcTurnoverShare24h = btcTurnover24h == null ? null : safeDivide(btcTurnover24h, btcTurnover24h + altTurnover24h);
+    const previousBtcTurnoverShare24h = previousBtcTurnover24h == null ? null : safeDivide(
+      previousBtcTurnover24h,
+      previousBtcTurnover24h + previousAltTurnover24h
+    );
+    const btcTurnoverShareChange24h = btcTurnoverShare24h == null || previousBtcTurnoverShare24h == null ? null : btcTurnoverShare24h - previousBtcTurnoverShare24h;
+    return {
+      universe,
+      interval,
+      ts: new Date(timestamp),
+      symbolsCount: returns.length,
+      advancers,
+      decliners,
+      unchanged,
+      advanceDeclineRatio: safeDivide(advancers, decliners || 1),
+      pctAboveMa20: safeDivide(aboveMa20, aboveMa20Eligible),
+      pctAboveMa50: safeDivide(aboveMa50, aboveMa50Eligible),
+      equalWeightedReturn: mean(returns),
+      volumeWeightedReturn,
+      dispersion: standardDeviation(returns),
+      btcReturn1h,
+      btcReturn4h,
+      btcReturn24h,
+      altBasketReturn1h,
+      altBasketReturn4h,
+      altBasketReturn24h,
+      btcVsAltReturn1h,
+      btcVsAltReturn4h,
+      btcVsAltReturn24h,
+      btcTurnoverShare1h,
+      btcTurnoverShare24h,
+      btcTurnoverShareChange24h,
+      altVolToBtcVol24h: btcTurnover24h == null ? null : safeDivide(altTurnover24h, btcTurnover24h),
+      altDispersion24h: standardDeviation(altReturns24h),
+      btcAltRegime: classifyBtcAltRegime({
+        btcReturn24h,
+        altBasketReturn24h,
+        btcVsAltReturn24h
+      }),
+      source
+    };
+  }).filter((row) => row.symbolsCount > 0);
+};
+
+// src/lib/coinMarketCapContextBackfill.ts
+var import_chalk = __toESM(require("chalk"));
+var import_async = require("@tradejs/core/async");
+var import_marketContext = require("@tradejs/infra/timescale/marketContext");
+var import_client = require("@tradejs/infra/timescale/client");
+var import_userSettings = require("@tradejs/infra/userSettings");
+var DAY_MS = 864e5;
+var DEFAULT_CONTEXT_MAX_AGE_MS = 48 * 60 * 6e4;
+var DEFAULT_FEAR_GREED_STALE_RETRY_MS = 60 * 6e4;
+var SOURCE_GLOBAL_DAILY = "coinmarketcap_global";
+var SOURCE_REFERENCE = "coinmarketcap_reference_asset";
+var SOURCE_EXCHANGE_LIQUIDITY = "coinmarketcap_exchange_liquidity";
+var SOURCE_FEAR_GREED = "coinmarketcap_fear_greed";
+var SOURCE_INDEX = "coinmarketcap_index";
+var COVERAGE_SCOPE_ALL = "all";
+var REFERENCE_ASSETS = [
+  { symbol: "BTCUSDT", cmcId: 1 },
+  { symbol: "ETHUSDT", cmcId: 1027 }
+];
+var CMC_INDEXES = [
+  { slug: "cmc100", path: "/v3/index/cmc100-historical" },
+  { slug: "cmc20", path: "/v3/index/cmc20-historical" }
+];
+var DEFAULT_EXCHANGE_SLUGS = [
+  "binance",
+  "coinbase-exchange",
+  "okx",
+  "bybit",
+  "kraken"
+];
+var lastRequestTs = 0;
+var asInt = (value, fallback) => {
+  const parsed = Number.parseInt(String(value ?? ""), 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+};
+var parseEnabledFlag = (value, defaultValue) => {
+  const normalized = String(value ?? "").trim().toLowerCase();
+  if (!normalized) return defaultValue;
+  if (["1", "true", "yes", "on"].includes(normalized)) return true;
+  if (["0", "false", "no", "off"].includes(normalized)) return false;
+  return defaultValue;
+};
+var getBaseUrl = () => process.env.COINMARKETCAP_BASE_URL?.trim() || "https://pro-api.coinmarketcap.com";
+var getRequestDelayMs = () => asInt(process.env.COINMARKETCAP_MIN_REQUEST_DELAY_MS, 2100);
+var getMaxRetries = () => asInt(process.env.COINMARKETCAP_MAX_RETRIES, 4);
+var getMaxBackfillDays = () => asInt(process.env.COINMARKETCAP_CONTEXT_BACKFILL_MAX_DAYS, 1098);
+var getHistoricalAccessMonths = () => asInt(process.env.COINMARKETCAP_CONTEXT_HISTORICAL_ACCESS_MONTHS, 36);
+var isExchangeLiquidityBackfillEnabled = () => parseEnabledFlag(
+  process.env.COINMARKETCAP_CONTEXT_EXCHANGE_LIQUIDITY_ENABLED,
+  true
+);
+var isFearGreedBackfillEnabled = () => parseEnabledFlag(process.env.COINMARKETCAP_CONTEXT_FEAR_GREED_ENABLED, true);
+var isVerboseRequestLoggingEnabled = () => parseEnabledFlag(process.env.COINMARKETCAP_CONTEXT_VERBOSE_REQUESTS, false);
+var getFearGreedPageSize = () => asInt(process.env.COINMARKETCAP_CONTEXT_FEAR_GREED_PAGE_SIZE, 500);
+var getContextMaxAgeMs = () => asInt(
+  process.env.COINMARKETCAP_CONTEXT_MAX_AGE_MS,
+  DEFAULT_CONTEXT_MAX_AGE_MS
+);
+var getFearGreedStaleRetryMs = () => asInt(
+  process.env.COINMARKETCAP_CONTEXT_FEAR_GREED_STALE_RETRY_MS,
+  DEFAULT_FEAR_GREED_STALE_RETRY_MS
+);
+var getExchangeSlugs = () => {
+  const raw = process.env.COINMARKETCAP_CONTEXT_EXCHANGE_SLUGS;
+  const values = String(raw ?? "").split(",").map((item) => item.trim().toLowerCase()).filter(Boolean);
+  return values.length ? [...new Set(values)] : [...DEFAULT_EXCHANGE_SLUGS];
+};
+var toFiniteNumberOrNull = (value) => {
+  const numeric = typeof value === "number" ? value : typeof value === "string" && value.trim() ? Number(value) : Number.NaN;
+  return Number.isFinite(numeric) ? numeric : null;
+};
+var toIntOrNull = (value) => {
+  const numeric = toFiniteNumberOrNull(value);
+  return numeric == null ? null : Math.trunc(numeric);
+};
+var getRecord = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : {};
+var getNestedRecord = (value, key) => getRecord(value[key]);
+var safeDivide2 = (numerator, denominator) => numerator != null && denominator != null && denominator > 0 ? numerator / denominator : null;
+var sumFinite = (values) => values.reduce((sum, value) => sum + (value ?? 0), 0);
+var toExchangeLiquidityRegime = ({
+  binanceVolumeShare,
+  topExchangeVolumeShare
+}) => {
+  if (binanceVolumeShare == null && topExchangeVolumeShare == null) {
+    return "unknown";
+  }
+  if ((binanceVolumeShare ?? 0) >= 0.55) return "binance_led";
+  if ((topExchangeVolumeShare ?? 0) >= 0.6) return "concentrated";
+  return "balanced";
+};
+var normalizeFearGreedClassification = (value) => {
+  const normalized = String(value ?? "").trim().toLowerCase();
+  if (normalized === "extreme fear") return "Extreme Fear";
+  if (normalized === "fear") return "Fear";
+  if (normalized === "neutral") return "Neutral";
+  if (normalized === "greed") return "Greed";
+  if (normalized === "extreme greed") return "Extreme Greed";
+  return "Unknown";
+};
+var toFearGreedRegime = ({
+  value,
+  classification
+}) => {
+  if (value == null) return "unknown";
+  if (classification === "Extreme Fear" || value <= 24) return "capitulation";
+  if (classification === "Fear" || value <= 44) return "risk_off";
+  if (classification === "Extreme Greed" || value >= 75) return "euphoric";
+  if (classification === "Greed" || value >= 55) return "risk_on";
+  if (classification === "Neutral" || value >= 45 && value <= 54) {
+    return "neutral";
+  }
+  return "unknown";
+};
+var dayStartUtc = (ms) => {
+  const date = new Date(ms);
+  return Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate());
+};
+var toIsoDate = (ms) => new Date(ms).toISOString().slice(0, 10);
+var subtractUtcMonths = (ms, months) => {
+  const date = new Date(ms);
+  const targetMonthIndex = date.getUTCMonth() - months;
+  const targetMonthStart = new Date(
+    Date.UTC(
+      date.getUTCFullYear(),
+      targetMonthIndex,
+      1,
+      date.getUTCHours(),
+      date.getUTCMinutes(),
+      date.getUTCSeconds(),
+      date.getUTCMilliseconds()
+    )
+  );
+  const daysInTargetMonth = new Date(
+    Date.UTC(
+      targetMonthStart.getUTCFullYear(),
+      targetMonthStart.getUTCMonth() + 1,
+      0
+    )
+  ).getUTCDate();
+  targetMonthStart.setUTCDate(Math.min(date.getUTCDate(), daysInTargetMonth));
+  return targetMonthStart.getTime();
+};
+var nextUtcDayStart = (ms) => dayStartUtc(ms) + DAY_MS;
+var resolveCoinMarketCapBackfillWindow = (params) => {
+  const warmupMs = asInt(process.env.COINMARKETCAP_CONTEXT_BACKFILL_WARMUP_DAYS, 35) * DAY_MS;
+  const maxWindowMs = getMaxBackfillDays() * DAY_MS;
+  const requestedStart = params.preloadStartMs ?? params.startMs - warmupMs;
+  const cappedStart = Math.max(requestedStart, params.endMs - maxWindowMs);
+  const accessFloorMs = nextUtcDayStart(
+    subtractUtcMonths(params.nowMs ?? Date.now(), getHistoricalAccessMonths())
+  );
+  return {
+    fromMs: dayStartUtc(Math.max(cappedStart, accessFloorMs)),
+    toMs: dayStartUtc(params.endMs)
+  };
+};
+var hasIntervalCoverage = (coverage, fromMs, toMs, intervalMs) => {
+  if (!coverage) return false;
+  const expectedRows = Math.max(1, Math.floor((toMs - fromMs) / intervalMs));
+  return coverage.firstMs <= fromMs + intervalMs && coverage.lastMs >= toMs - intervalMs && coverage.rows >= Math.floor(expectedRows * 0.9);
+};
+var hasDailyCoverage = (coverage, fromMs, toMs) => hasIntervalCoverage(coverage, fromMs, toMs, DAY_MS);
+var coverageKey = (params) => [
+  params.source.trim().toLowerCase(),
+  params.scope.trim().toLowerCase(),
+  params.interval.trim().toLowerCase(),
+  Math.trunc(params.fromMs),
+  Math.trunc(params.toMs)
+].join(":");
+var isMarketContextBackfillCoverageDataBearing = (row) => Number(row.rowsCount ?? 0) > 0;
+var coverageRowsToKeySet = (rows) => new Set(
+  rows.filter(isMarketContextBackfillCoverageDataBearing).map(
+    (row) => coverageKey({
+      source: row.source,
+      scope: row.scope,
+      interval: row.interval,
+      fromMs: row.fromMs,
+      toMs: row.toMs
+    })
+  )
+);
+var hasBackfillCoverage = (coverageKeys, params) => coverageKeys.has(coverageKey(params));
+var hasRecentBackfillCoverage = (rows, params) => {
+  const key = coverageKey(params);
+  return rows.some((row) => {
+    if (!isMarketContextBackfillCoverageDataBearing(row)) return false;
+    if (coverageKey({
+      source: row.source,
+      scope: row.scope,
+      interval: row.interval,
+      fromMs: row.fromMs,
+      toMs: row.toMs
+    }) !== key) {
+      return false;
+    }
+    const checkedAtMs = Number(row.checkedAtMs);
+    return Number.isFinite(checkedAtMs) && Math.max(0, params.atMs - checkedAtMs) <= params.maxAgeMs;
+  });
+};
+var formatCoverageRange = (coverage) => {
+  if (!coverage) return "coverage=none";
+  return `coverage=${new Date(coverage.firstMs).toISOString()}..${new Date(
+    coverage.lastMs
+  ).toISOString()} rows=${coverage.rows}`;
+};
+var formatReferenceCoverage = (coverage) => REFERENCE_ASSETS.map(
+  (asset) => `${asset.symbol}:${formatCoverageRange(coverage.get(asset.symbol))}`
+).join(" ");
+var resolveBackfillStatus = ({
+  enabled = true,
+  cached,
+  covered
+}) => {
+  if (!enabled) return "disabled";
+  if (cached) return "cached";
+  if (covered) return "backfill_covered";
+  return "fetch_pending";
+};
+var formatSourceStatus = ({
+  name,
+  status,
+  rows,
+  coverage
+}) => `${name}=${status}${rows == null ? "" : ` rows=${rows}`} ${coverage}`;
+var createCoinMarketCapFetchStats = () => ({
+  requests: 0,
+  totalCredits: 0,
+  byPath: /* @__PURE__ */ new Map()
+});
+var getCoinMarketCapPathLabel = (path) => {
+  if (path.includes("global-metrics")) return "global";
+  if (path.includes("cryptocurrency/quotes")) return "reference";
+  if (path.includes("exchange/quotes")) return "exchangeLiquidity";
+  if (path.includes("fear-and-greed")) return "fearGreed";
+  if (path.includes("cmc100")) return "cmc100";
+  if (path.includes("cmc20")) return "cmc20";
+  return path;
+};
+var recordCoinMarketCapFetchStats = (stats, path, creditCount) => {
+  if (!stats) return;
+  const existing = stats.byPath.get(path) ?? { requests: 0, credits: 0 };
+  existing.requests += 1;
+  existing.credits += creditCount ?? 0;
+  stats.requests += 1;
+  stats.totalCredits += creditCount ?? 0;
+  stats.byPath.set(path, existing);
+};
+var formatCoinMarketCapFetchStats = (stats) => {
+  const byPath = [...stats.byPath.entries()].map(
+    ([path, item]) => `${getCoinMarketCapPathLabel(path)}=${item.requests}req/${item.credits}cr`
+  ).join(" ");
+  return `apiRequests=${stats.requests} apiCredits=${stats.totalCredits}${byPath ? ` ${byPath}` : ""}`;
+};
+var formatRowTimeRange = (rows) => {
+  if (!rows.length) return "range=none";
+  const times = rows.map((row) => row.ts.getTime()).filter((value) => Number.isFinite(value));
+  if (!times.length) return "range=none";
+  return `range=${new Date(Math.min(...times)).toISOString()}..${new Date(
+    Math.max(...times)
+  ).toISOString()}`;
+};
+var logBackfillSourceDone = (params) => {
+  console.log(
+    import_chalk.default.gray(
+      `coinmarketcap context source done: ${params.name}=${params.status} rows=${params.rows}${params.details ? ` ${params.details}` : ""}`
+    )
+  );
+};
+var markBackfillCoverage = (rows) => (0, import_marketContext.upsertMarketContextBackfillCoverage)(rows);
+var coinMarketCapFetch = async (params) => {
+  const url = new URL(`${getBaseUrl()}${params.path}`);
+  for (const [key, value] of Object.entries(params.searchParams)) {
+    url.searchParams.set(key, value);
+  }
+  for (let attempt = 0; attempt <= getMaxRetries(); attempt += 1) {
+    const waitMs = Math.max(
+      0,
+      lastRequestTs + getRequestDelayMs() - Date.now()
+    );
+    if (waitMs > 0) {
+      await (0, import_async.delay)(waitMs);
+    }
+    lastRequestTs = Date.now();
+    const response = await fetch(url.toString(), {
+      headers: {
+        accept: "application/json",
+        "X-CMC_PRO_API_KEY": params.apiKey
+      }
+    });
+    if (response.ok) {
+      const payload = await response.json();
+      const creditCount = toFiniteNumberOrNull(
+        getRecord(getRecord(payload).status).credit_count
+      );
+      recordCoinMarketCapFetchStats(params.stats, params.path, creditCount);
+      if (creditCount != null && isVerboseRequestLoggingEnabled()) {
+        console.log(
+          import_chalk.default.gray(`coinmarketcap ${params.path}: credits=${creditCount}`)
+        );
+      }
+      return payload;
+    }
+    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 < getMaxRetries() && transient) {
+      await (0, import_async.delay)(retryAfterMs ?? Math.min(3e4, 1e3 * 2 ** attempt));
+      continue;
+    }
+    throw new Error(`CoinMarketCap ${params.path} ${response.status}: ${text}`);
+  }
+  return null;
+};
+var fetchCoinMarketCapIndexRows = async (params) => {
+  const rows = [];
+  const maxChunkDays = 4;
+  const totalChunks = Math.max(
+    1,
+    Math.ceil(
+      (params.toMs - params.fromMs + DAY_MS) / ((maxChunkDays + 1) * DAY_MS)
+    )
+  );
+  let chunk = 0;
+  for (let cursorMs = params.fromMs; cursorMs <= params.toMs; cursorMs += (maxChunkDays + 1) * DAY_MS) {
+    chunk += 1;
+    const chunkEndMs = Math.min(params.toMs, cursorMs + maxChunkDays * DAY_MS);
+    const payload = await coinMarketCapFetch({
+      path: params.index.path,
+      apiKey: params.apiKey,
+      stats: params.stats,
+      searchParams: {
+        time_start: new Date(cursorMs).toISOString(),
+        time_end: new Date(chunkEndMs).toISOString(),
+        interval: "daily"
+      }
+    });
+    rows.push(
+      ...coinMarketCapIndexPayloadToRows(payload, params.index.slug, "1d")
+    );
+    if (chunk === 1 || chunk === totalChunks || chunk % 25 === 0) {
+      console.log(
+        import_chalk.default.gray(
+          `coinmarketcap index backfill progress: ${params.index.slug} chunk=${chunk}/${totalChunks} rows=${rows.length} chunkRange=${new Date(cursorMs).toISOString()}..${new Date(chunkEndMs).toISOString()}`
+        )
+      );
+    }
+  }
+  return { rows, chunks: chunk };
+};
+var coinMarketCapGlobalPayloadToRows = (payload, source = SOURCE_GLOBAL_DAILY) => {
+  const quotes = getRecord(getRecord(payload).data).quotes;
+  if (!Array.isArray(quotes)) return [];
+  return quotes.map((item) => {
+    const record = getRecord(item);
+    const quote = getRecord(getRecord(record.quote).USD);
+    const tsRaw = record.timestamp ?? quote.timestamp;
+    const ts = typeof tsRaw === "string" ? new Date(tsRaw) : null;
+    if (!ts || Number.isNaN(ts.getTime())) return null;
+    const totalMarketCapUsd = toFiniteNumberOrNull(quote.total_market_cap);
+    const altMarketCapUsd = toFiniteNumberOrNull(quote.altcoin_market_cap);
+    const btcToAltMarketCapRatio = totalMarketCapUsd != null && altMarketCapUsd != null && altMarketCapUsd > 0 ? Math.max(0, totalMarketCapUsd - altMarketCapUsd) / altMarketCapUsd : null;
+    return {
+      source,
+      ts,
+      updatedAt: ts,
+      activeCryptocurrencies: toIntOrNull(record.active_cryptocurrencies),
+      activeExchanges: toIntOrNull(record.active_exchanges),
+      activeMarketPairs: toIntOrNull(record.active_market_pairs),
+      markets: toIntOrNull(record.active_exchanges),
+      totalMarketCapUsd,
+      totalVolumeUsd: toFiniteNumberOrNull(quote.total_volume_24h),
+      totalVolumeReportedUsd: toFiniteNumberOrNull(
+        quote.total_volume_24h_reported
+      ),
+      btcDominancePct: toFiniteNumberOrNull(record.btc_dominance),
+      ethDominancePct: toFiniteNumberOrNull(record.eth_dominance),
+      altMarketCapUsd,
+      altVolumeUsd: toFiniteNumberOrNull(quote.altcoin_volume_24h),
+      altVolumeReportedUsd: toFiniteNumberOrNull(
+        quote.altcoin_volume_24h_reported
+      ),
+      btcToAltMarketCapRatio,
+      marketCapChangePct24hUsd: null
+    };
+  }).filter((row) => row != null);
+};
+var normalizeAssetDataItems = (payload) => {
+  const data = getRecord(payload).data;
+  if (!data) return [];
+  if (Array.isArray(data)) {
+    return data.filter(
+      (item) => item != null && typeof item === "object" && !Array.isArray(item)
+    );
+  }
+  if (typeof data === "object" && !Array.isArray(data)) {
+    const record = data;
+    if (Array.isArray(record.quotes)) return [record];
+    return Object.values(record).filter(
+      (item) => item != null && typeof item === "object" && !Array.isArray(item)
+    );
+  }
+  return [];
+};
+var coinMarketCapHistoricalQuotesPayloadToRows = (payload, interval = "1d") => {
+  return normalizeAssetDataItems(payload).flatMap((asset) => {
+    const cmcId = toIntOrNull(asset.id);
+    const symbolRaw = String(asset.symbol ?? "").trim().toUpperCase();
+    const target = REFERENCE_ASSETS.find(
+      (item) => item.cmcId === cmcId || item.symbol.replace("USDT", "") === symbolRaw
+    );
+    const quotes = Array.isArray(asset.quotes) ? asset.quotes : Object.values(getRecord(asset.quotes));
+    if (!target || !cmcId || !quotes.length) return [];
+    return quotes.map((item) => {
+      const record = getRecord(item);
+      const quote = getNestedRecord(getRecord(record.quote), "USD");
+      const tsRaw = record.timestamp ?? quote.timestamp ?? quote.last_updated;
+      const ts = typeof tsRaw === "string" ? new Date(tsRaw) : null;
+      if (!ts || Number.isNaN(ts.getTime())) return null;
+      return {
+        source: SOURCE_REFERENCE,
+        symbol: target.symbol,
+        cmcId,
+        interval,
+        ts,
+        openUsd: null,
+        highUsd: null,
+        lowUsd: null,
+        closeUsd: toFiniteNumberOrNull(quote.price),
+        volumeUsd: toFiniteNumberOrNull(quote.volume_24h),
+        marketCapUsd: toFiniteNumberOrNull(quote.market_cap)
+      };
+    }).filter((row) => row != null);
+  });
+};
+var coinMarketCapExchangeQuotesPayloadToLiquidityRows = (payload, interval = "1d") => {
+  const data = getRecord(payload).data;
+  const exchangeItems = Array.isArray(data) ? data : Object.values(getRecord(data));
+  const rowsByTs = /* @__PURE__ */ new Map();
+  for (const item of exchangeItems) {
+    const exchange = getRecord(item);
+    const slug = String(exchange.slug ?? "").trim().toLowerCase();
+    const name = String(exchange.name ?? "").trim().toLowerCase();
+    const quotes = Array.isArray(exchange.quotes) ? exchange.quotes : Array.isArray(exchange.quote) ? exchange.quote : [exchange];
+    for (const quoteItem of quotes) {
+      const record = getRecord(quoteItem);
+      const quote = getNestedRecord(getNestedRecord(record, "quote"), "USD");
+      const fallbackQuote = getNestedRecord(exchange, "quote");
+      const usd = Object.keys(quote).length ? quote : getNestedRecord(fallbackQuote, "USD");
+      const tsRaw = record.timestamp ?? usd.timestamp ?? usd.last_updated ?? exchange.last_updated;
+      const ts = typeof tsRaw === "string" ? new Date(tsRaw) : null;
+      if (!ts || Number.isNaN(ts.getTime())) continue;
+      const volumeUsd = toFiniteNumberOrNull(usd.volume_24h) ?? toFiniteNumberOrNull(usd.volume_24h_adjusted) ?? toFiniteNumberOrNull(usd.spot_volume_usd) ?? toFiniteNumberOrNull(usd.reported_volume_24h);
+      const key = ts.getTime();
+      const rows = rowsByTs.get(key) ?? [];
+      rows.push({ slug, name, volumeUsd });
+      rowsByTs.set(key, rows);
+    }
+  }
+  return [...rowsByTs.entries()].sort(([left], [right]) => left - right).map(([ts, exchanges]) => {
+    const volumes = exchanges.map((exchange) => exchange.volumeUsd);
+    const totalVolumeUsd = sumFinite(volumes);
+    const binanceVolumeUsd = exchanges.find(
+      (exchange) => exchange.slug === "binance" || exchange.name.includes("binance")
+    )?.volumeUsd ?? null;
+    const topExchangeVolume = Math.max(
+      ...volumes.map((value) => value ?? 0),
+      0
+    );
+    const binanceVolumeShare = safeDivide2(binanceVolumeUsd, totalVolumeUsd);
+    const topExchangeVolumeShare = safeDivide2(
+      topExchangeVolume,
+      totalVolumeUsd
+    );
+    return {
+      source: SOURCE_EXCHANGE_LIQUIDITY,
+      interval,
+      ts: new Date(ts),
+      exchangesCount: exchanges.length,
+      totalVolumeUsd,
+      binanceVolumeUsd,
+      binanceVolumeShare,
+      topExchangeVolumeShare,
+      liquidityRegime: toExchangeLiquidityRegime({
+        binanceVolumeShare,
+        topExchangeVolumeShare
+      })
+    };
+  });
+};
+var coinMarketCapFearGreedPayloadToRows = (payload) => {
+  const data = getRecord(payload).data;
+  const items = Array.isArray(data) ? data : [];
+  return items.map((item) => {
+    const record = getRecord(item);
+    const timestampValue = toFiniteNumberOrNull(record.timestamp);
+    const value = toIntOrNull(record.value);
+    if (timestampValue == null || value == null) return null;
+    const ts = new Date(timestampValue * 1e3);
+    if (Number.isNaN(ts.getTime())) return null;
+    const classification = normalizeFearGreedClassification(
+      record.value_classification
+    );
+    return {
+      source: SOURCE_FEAR_GREED,
+      interval: "1d",
+      ts,
+      value,
+      classification,
+      sentimentRegime: toFearGreedRegime({ value, classification })
+    };
+  }).filter((row) => row != null);
+};
+var toCmcIndexWeightPct = (value) => {
+  if (typeof value === "string") {
+    return toFiniteNumberOrNull(value.replace("%", ""));
+  }
+  return toFiniteNumberOrNull(value);
+};
+var coinMarketCapIndexPayloadToRows = (payload, indexSlug, interval = "1d") => {
+  const data = getRecord(payload).data;
+  const items = Array.isArray(data) ? data : [];
+  return items.map((item) => {
+    const record = getRecord(item);
+    const tsRaw = record.update_time ?? record.timestamp;
+    const ts = typeof tsRaw === "string" ? new Date(tsRaw) : null;
+    const value = toFiniteNumberOrNull(record.value);
+    if (!ts || Number.isNaN(ts.getTime()) || value == null) return null;
+    const constituentsRaw = Array.isArray(record.constituents) ? record.constituents : [];
+    const constituents = constituentsRaw.map((constituent) => {
+      const constituentRecord = getRecord(constituent);
+      return {
+        id: toIntOrNull(constituentRecord.id),
+        name: typeof constituentRecord.name === "string" ? constituentRecord.name : null,
+        symbol: typeof constituentRecord.symbol === "string" ? constituentRecord.symbol : null,
+        url: typeof constituentRecord.url === "string" ? constituentRecord.url : null,
+        weightPct: toCmcIndexWeightPct(constituentRecord.weight),
+        priceUsd: toFiniteNumberOrNull(constituentRecord.priceUsd),
+        units: toFiniteNumberOrNull(constituentRecord.units)
+      };
+    });
+    const topConstituent = constituents.reduce((top, constituent) => {
+      if (top == null) return constituent;
+      return (constituent.weightPct ?? Number.NEGATIVE_INFINITY) > (top.weightPct ?? Number.NEGATIVE_INFINITY) ? constituent : top;
+    }, null);
+    return {
+      source: SOURCE_INDEX,
+      indexSlug,
+      interval,
+      ts,
+      value,
+      constituentsCount: constituents.length,
+      topConstituentSymbol: topConstituent?.symbol ?? null,
+      topConstituentWeightPct: topConstituent?.weightPct ?? null,
+      constituents
+    };
+  }).filter((row) => row != null);
+};
+var skippedResult = (cached = false) => ({
+  skipped: true,
+  globalRows: 0,
+  referenceRows: 0,
+  breadthRows: 0,
+  exchangeLiquidityRows: 0,
+  fearGreedRows: 0,
+  indexRows: 0,
+  cached
+});
+var backfillCoinMarketCapContext = async (params) => {
+  if (!Number.isFinite(params.startMs) || !Number.isFinite(params.endMs)) {
+    return skippedResult();
+  }
+  const { fromMs, toMs } = resolveCoinMarketCapBackfillWindow(params);
+  if (toMs <= fromMs) return skippedResult();
+  const exchangeLiquidityEnabled = isExchangeLiquidityBackfillEnabled();
+  const fearGreedEnabled = isFearGreedBackfillEnabled();
+  await (0, import_client.waitForDbReady)();
+  const [
+    globalDailyCoverage,
+    referenceDailyCoverage,
+    exchangeLiquidityCoverage,
+    fearGreedCoverage,
+    indexCoverage,
+    globalDailyBackfillCoverage,
+    referenceDailyBackfillCoverage,
+    exchangeLiquidityBackfillCoverage,
+    fearGreedBackfillCoverage,
+    indexBackfillCoverage
+  ] = await Promise.all([
+    (0, import_marketContext.getMarketGlobalContextCoverage)({
+      source: SOURCE_GLOBAL_DAILY,
+      startMs: fromMs,
+      endMs: toMs
+    }),
+    (0, import_marketContext.getMarketReferenceAssetContextCoverage)({
+      source: SOURCE_REFERENCE,
+      symbols: REFERENCE_ASSETS.map((item) => item.symbol),
+      interval: "1d",
+      startMs: fromMs,
+      endMs: toMs
+    }),
+    exchangeLiquidityEnabled ? (0, import_marketContext.getMarketCmcExchangeLiquidityContextCoverage)({
+      source: SOURCE_EXCHANGE_LIQUIDITY,
+      interval: "1d",
+      startMs: fromMs,
+      endMs: toMs
+    }) : Promise.resolve(null),
+    fearGreedEnabled ? (0, import_marketContext.getMarketCmcFearGreedContextCoverage)({
+      source: SOURCE_FEAR_GREED,
+      interval: "1d",
+      startMs: fromMs,
+      endMs: toMs
+    }) : Promise.resolve(null),
+    (0, import_marketContext.getMarketCmcIndexContextCoverage)({
+      source: SOURCE_INDEX,
+      indexSlugs: CMC_INDEXES.map((index) => index.slug),
+      interval: "1d",
+      startMs: fromMs,
+      endMs: toMs
+    }),
+    (0, import_marketContext.getMarketContextBackfillCoverage)({
+      source: SOURCE_GLOBAL_DAILY,
+      scopes: [COVERAGE_SCOPE_ALL],
+      interval: "1d",
+      fromMs,
+      toMs
+    }),
+    (0, import_marketContext.getMarketContextBackfillCoverage)({
+      source: SOURCE_REFERENCE,
+      scopes: REFERENCE_ASSETS.map((item) => item.symbol),
+      interval: "1d",
+      fromMs,
+      toMs
+    }),
+    exchangeLiquidityEnabled ? (0, import_marketContext.getMarketContextBackfillCoverage)({
+      source: SOURCE_EXCHANGE_LIQUIDITY,
+      scopes: [COVERAGE_SCOPE_ALL],
+      interval: "1d",
+      fromMs,
+      toMs
+    }) : Promise.resolve([]),
+    fearGreedEnabled ? (0, import_marketContext.getMarketContextBackfillCoverage)({
+      source: SOURCE_FEAR_GREED,
+      scopes: [COVERAGE_SCOPE_ALL],
+      interval: "1d",
+      fromMs,
+      toMs
+    }) : Promise.resolve([]),
+    (0, import_marketContext.getMarketContextBackfillCoverage)({
+      source: SOURCE_INDEX,
+      scopes: CMC_INDEXES.map((index) => index.slug),
+      interval: "1d",
+      fromMs,
+      toMs
+    })
+  ]);
+  const globalDailyBackfillKeys = coverageRowsToKeySet(
+    globalDailyBackfillCoverage
+  );
+  const referenceDailyBackfillKeys = coverageRowsToKeySet(
+    referenceDailyBackfillCoverage
+  );
+  const exchangeLiquidityBackfillKeys = coverageRowsToKeySet(
+    exchangeLiquidityBackfillCoverage
+  );
+  const fearGreedBackfillKeys = coverageRowsToKeySet(fearGreedBackfillCoverage);
+  const indexBackfillKeys = coverageRowsToKeySet(indexBackfillCoverage);
+  const globalDailyCached = hasDailyCoverage(globalDailyCoverage, fromMs, toMs);
+  const referencesDailyCached = REFERENCE_ASSETS.every(
+    (asset) => hasDailyCoverage(referenceDailyCoverage.get(asset.symbol), fromMs, toMs)
+  );
+  const exchangeLiquidityCached = !exchangeLiquidityEnabled || hasDailyCoverage(exchangeLiquidityCoverage, fromMs, toMs);
+  const fearGreedCached = !fearGreedEnabled || hasDailyCoverage(fearGreedCoverage, fromMs, toMs);
+  const indexesCached = CMC_INDEXES.every(
+    (index) => hasDailyCoverage(indexCoverage.get(index.slug), fromMs, toMs)
+  );
+  const globalDailyBackfillCovered = hasBackfillCoverage(
+    globalDailyBackfillKeys,
+    {
+      source: SOURCE_GLOBAL_DAILY,
+      scope: COVERAGE_SCOPE_ALL,
+      interval: "1d",
+      fromMs,
+      toMs
+    }
+  );
+  const referencesDailyBackfillCovered = REFERENCE_ASSETS.every(
+    (asset) => hasBackfillCoverage(referenceDailyBackfillKeys, {
+      source: SOURCE_REFERENCE,
+      scope: asset.symbol,
+      interval: "1d",
+      fromMs,
+      toMs
+    })
+  );
+  const exchangeLiquidityBackfillCovered = hasBackfillCoverage(
+    exchangeLiquidityBackfillKeys,
+    {
+      source: SOURCE_EXCHANGE_LIQUIDITY,
+      scope: COVERAGE_SCOPE_ALL,
+      interval: "1d",
+      fromMs,
+      toMs
+    }
+  );
+  const fearGreedBackfillParams = {
+    source: SOURCE_FEAR_GREED,
+    scope: COVERAGE_SCOPE_ALL,
+    interval: "1d",
+    fromMs,
+    toMs
+  };
+  const fearGreedBackfillWasCovered = hasBackfillCoverage(
+    fearGreedBackfillKeys,
+    fearGreedBackfillParams
+  );
+  const fearGreedLatestAgeMs = fearGreedCoverage == null ? Number.POSITIVE_INFINITY : Math.max(0, params.endMs - fearGreedCoverage.lastMs);
+  const refreshStaleFearGreed = params.refreshStaleFearGreed === true && fearGreedLatestAgeMs > getContextMaxAgeMs();
+  const fearGreedBackfillCovered = fearGreedBackfillWasCovered && (!refreshStaleFearGreed || hasRecentBackfillCoverage(fearGreedBackfillCoverage, {
+    ...fearGreedBackfillParams,
+    atMs: params.endMs,
+    maxAgeMs: getFearGreedStaleRetryMs()
+  }));
+  const indexesBackfillCovered = CMC_INDEXES.every(
+    (index) => hasBackfillCoverage(indexBackfillKeys, {
+      source: SOURCE_INDEX,
+      scope: index.slug,
+      interval: "1d",
+      fromMs,
+      toMs
+    })
+  );
+  const ready = (dataset, existing) => params.repairDataset ? params.repairDataset !== dataset : existing;
+  const globalDailyReady = ready(
+    "cmc-global-1d",
+    globalDailyCached || globalDailyBackfillCovered
+  );
+  const referencesDailyReady = ready(
+    "cmc-reference_asset-1d",
+    referencesDailyCached || referencesDailyBackfillCovered
+  );
+  const exchangeLiquidityReady = ready(
+    "cmc-exchange_liquidity-1d",
+    exchangeLiquidityCached || !exchangeLiquidityEnabled || exchangeLiquidityBackfillCovered
+  );
+  const fearGreedReady = ready(
+    "cmc-fear_greed-1d",
+    fearGreedCached || !fearGreedEnabled || fearGreedBackfillCovered
+  );
+  const indexesReady = ready(
+    "cmc-index-1d",
+    indexesCached || indexesBackfillCovered
+  );
+  let globalStatus = resolveBackfillStatus({
+    cached: globalDailyCached,
+    covered: globalDailyBackfillCovered
+  });
+  let referenceStatus = resolveBackfillStatus({
+    cached: referencesDailyCached,
+    covered: referencesDailyBackfillCovered
+  });
+  let exchangeLiquidityStatus = resolveBackfillStatus({
+    enabled: exchangeLiquidityEnabled,
+    cached: exchangeLiquidityCached,
+    covered: exchangeLiquidityBackfillCovered
+  });
+  let fearGreedStatus = resolveBackfillStatus({
+    enabled: fearGreedEnabled,
+    cached: fearGreedCached,
+    covered: fearGreedBackfillCovered
+  });
+  let indexStatus = resolveBackfillStatus({
+    cached: indexesCached,
+    covered: indexesBackfillCovered
+  });
+  console.log(
+    import_chalk.default.gray(
+      [
+        "coinmarketcap context status:",
+        formatSourceStatus({
+          name: "global",
+          status: globalStatus,
+          coverage: formatCoverageRange(globalDailyCoverage)
+        }),
+        formatSourceStatus({
+          name: "reference",
+          status: referenceStatus,
+          coverage: formatReferenceCoverage(referenceDailyCoverage)
+        }),
+        formatSourceStatus({
+          name: "exchangeLiquidity",
+          status: exchangeLiquidityStatus,
+          coverage: formatCoverageRange(exchangeLiquidityCoverage)
+        }),
+        formatSourceStatus({
+          name: "fearGreed",
+          status: fearGreedStatus,
+          coverage: formatCoverageRange(fearGreedCoverage)
+        }),
+        formatSourceStatus({
+          name: "indexes",
+          status: indexStatus,
+          coverage: CMC_INDEXES.map(
+            (index) => `${index.slug}:${formatCoverageRange(indexCoverage.get(index.slug))}`
+          ).join(" ")
+        })
+      ].join(" ")
+    )
+  );
+  if (globalDailyReady && referencesDailyReady && exchangeLiquidityReady && fearGreedReady && indexesReady) {
+    console.log(
+      import_chalk.default.gray(
+        `coinmarketcap context cached: ${new Date(fromMs).toISOString()}..${new Date(toMs).toISOString()}`
+      )
+    );
+    return skippedResult(true);
+  }
+  const settings = await (0, import_userSettings.getUserSettings)(params.userName);
+  const apiKey = settings.COINMARKETCAP_API_KEY.trim();
+  if (!apiKey) {
+    throw new Error(
+      `Missing COINMARKETCAP_API_KEY for historical context backfill (user=${params.userName})`
+    );
+  }
+  let globalRows = 0;
+  let referenceRows = 0;
+  let exchangeLiquidityRows = 0;
+  let fearGreedRows = 0;
+  let indexRows = 0;
+  const fetchStats = createCoinMarketCapFetchStats();
+  const pendingSources = [
+    !globalDailyReady ? "global" : null,
+    !referencesDailyReady ? "reference" : null,
+    exchangeLiquidityEnabled && !exchangeLiquidityReady ? "exchangeLiquidity" : null,
+    fearGreedEnabled && !fearGreedReady ? "fearGreed" : null,
+    !indexesReady ? "indexes" : null
+  ].filter((source) => source != null);
+  console.log(
+    import_chalk.default.cyan(
+      `coinmarketcap context backfill: window=${new Date(fromMs).toISOString()}..${new Date(toMs).toISOString()} days=${Math.floor((toMs - fromMs) / DAY_MS) + 1} fetch=${pendingSources.join(",")}`
+    )
+  );
+  if (!globalDailyReady) {
+    const payload = await coinMarketCapFetch({
+      path: "/v1/global-metrics/quotes/historical",
+      apiKey,
+      stats: fetchStats,
+      searchParams: {
+        time_start: toIsoDate(fromMs),
+        time_end: toIsoDate(toMs),
+        interval: "1d",
+        convert: "USD"
+      }
+    });
+    const rows = coinMarketCapGlobalPayloadToRows(payload, SOURCE_GLOBAL_DAILY);
+    await (0, import_marketContext.upsertMarketGlobalContextRows)(rows);
+    await markBackfillCoverage([
+      {
+        source: SOURCE_GLOBAL_DAILY,
+        scope: COVERAGE_SCOPE_ALL,
+        interval: "1d",
+        fromMs,
+        toMs,
+        rowsCount: rows.length
+      }
+    ]);
+    globalRows += rows.length;
+    globalStatus = "fetched";
+    logBackfillSourceDone({
+      name: "global",
+      status: globalStatus,
+      rows: rows.length,
+      details: formatRowTimeRange(rows)
+    });
+  }
+  if (!referencesDailyReady) {
+    const payload = await coinMarketCapFetch({
+      path: "/v3/cryptocurrency/quotes/historical",
+      apiKey,
+      stats: fetchStats,
+      searchParams: {
+        id: REFERENCE_ASSETS.map((item) => item.cmcId).join(","),
+        time_start: toIsoDate(fromMs),
+        time_end: toIsoDate(toMs),
+        interval: "1d",
+        convert: "USD"
+      }
+    });
+    const rows = coinMarketCapHistoricalQuotesPayloadToRows(payload, "1d");
+    await (0, import_marketContext.upsertMarketReferenceAssetContextRows)(rows);
+    await markBackfillCoverage(
+      REFERENCE_ASSETS.map((asset) => ({
+        source: SOURCE_REFERENCE,
+        scope: asset.symbol,
+        interval: "1d",
+        fromMs,
+        toMs,
+        rowsCount: rows.filter((row) => row.symbol === asset.symbol).length
+      }))
+    );
+    referenceRows += rows.length;
+    referenceStatus = "fetched";
+    logBackfillSourceDone({
+      name: "reference",
+      status: referenceStatus,
+      rows: rows.length,
+      details: `${REFERENCE_ASSETS.map(
+        (asset) => `${asset.symbol}:${rows.filter((row) => row.symbol === asset.symbol).length}`
+      ).join(" ")} ${formatRowTimeRange(rows)}`
+    });
+  }
+  if (exchangeLiquidityEnabled && !exchangeLiquidityReady) {
+    const payload = await coinMarketCapFetch({
+      path: "/v1/exchange/quotes/historical",
+      apiKey,
+      stats: fetchStats,
+      searchParams: {
+        slug: getExchangeSlugs().join(","),
+        time_start: toIsoDate(fromMs),
+        time_end: toIsoDate(toMs),
+        interval: "1d",
+        convert: "USD"
+      }
+    });
+    const rows = coinMarketCapExchangeQuotesPayloadToLiquidityRows(
+      payload,
+      "1d"
+    );
+    await (0, import_marketContext.upsertMarketCmcExchangeLiquidityContextRows)(rows);
+    await markBackfillCoverage([
+      {
+        source: SOURCE_EXCHANGE_LIQUIDITY,
+        scope: COVERAGE_SCOPE_ALL,
+        interval: "1d",
+        fromMs,
+        toMs,
+        rowsCount: rows.length
+      }
+    ]);
+    exchangeLiquidityRows = rows.length;
+    exchangeLiquidityStatus = "fetched";
+    logBackfillSourceDone({
+      name: "exchangeLiquidity",
+      status: exchangeLiquidityStatus,
+      rows: rows.length,
+      details: formatRowTimeRange(rows)
+    });
+  }
+  if (fearGreedEnabled && !fearGreedReady) {
+    const rows = [];
+    const pageSize = getFearGreedPageSize();
+    let pages = 0;
+    for (let start = 1; ; start += pageSize) {
+      const payload = await coinMarketCapFetch({
+        path: "/v3/fear-and-greed/historical",
+        apiKey,
+        stats: fetchStats,
+        searchParams: {
+          start: String(start),
+          limit: String(pageSize)
+        }
+      });
+      pages += 1;
+      const pageRows = coinMarketCapFearGreedPayloadToRows(payload);
+      if (!pageRows.length) break;
+      const matchingRows = pageRows.filter((row) => {
+        const ts = row.ts.getTime();
+        return ts >= fromMs && ts <= toMs;
+      });
+      rows.push(...matchingRows);
+      const oldestPageTs = Math.min(...pageRows.map((row) => row.ts.getTime()));
+      if (oldestPageTs < fromMs || pageRows.length < pageSize) break;
+    }
+    await (0, import_marketContext.upsertMarketCmcFearGreedContextRows)(rows);
+    await markBackfillCoverage([
+      {
+        source: SOURCE_FEAR_GREED,
+        scope: COVERAGE_SCOPE_ALL,
+        interval: "1d",
+        fromMs,
+        toMs,
+        rowsCount: rows.length
+      }
+    ]);
+    fearGreedRows = rows.length;
+    fearGreedStatus = "fetched";
+    logBackfillSourceDone({
+      name: "fearGreed",
+      status: fearGreedStatus,
+      rows: rows.length,
+      details: `pages=${pages} ${formatRowTimeRange(rows)}`
+    });
+  }
+  if (!indexesReady) {
+    const rowsByIndex = await Promise.all(
+      CMC_INDEXES.map(async (index) => ({
+        index,
+        result: await fetchCoinMarketCapIndexRows({
+          apiKey,
+          index,
+          fromMs,
+          toMs,
+          stats: fetchStats
+        })
+      }))
+    );
+    const rows = rowsByIndex.flatMap((item) => item.result.rows);
+    await (0, import_marketContext.upsertMarketCmcIndexContextRows)(rows);
+    await markBackfillCoverage(
+      rowsByIndex.map(({ index, result }) => ({
+        source: SOURCE_INDEX,
+        scope: index.slug,
+        interval: "1d",
+        fromMs,
+        toMs,
+        rowsCount: result.rows.length
+      }))
+    );
+    indexRows = rows.length;
+    indexStatus = "fetched";
+    logBackfillSourceDone({
+      name: "indexes",
+      status: indexStatus,
+      rows: rows.length,
+      details: `${rowsByIndex.map(
+        ({ index, result }) => `${index.slug}:${result.rows.length} rows/${result.chunks} chunks`
+      ).join(" ")} ${formatRowTimeRange(rows)}`
+    });
+  }
+  console.log(
+    import_chalk.default.green(
+      [
+        "coinmarketcap context backfill done:",
+        `global=${globalStatus} rows=${globalRows}`,
+        `reference=${referenceStatus} rows=${referenceRows}`,
+        `exchangeLiquidity=${exchangeLiquidityStatus} rows=${exchangeLiquidityRows}`,
+        `fearGreed=${fearGreedStatus} rows=${fearGreedRows}`,
+        `indexes=${indexStatus} rows=${indexRows}`,
+        formatCoinMarketCapFetchStats(fetchStats)
+      ].join(" ")
+    )
+  );
+  return {
+    skipped: false,
+    globalRows,
+    referenceRows,
+    breadthRows: 0,
+    exchangeLiquidityRows,
+    fearGreedRows,
+    indexRows,
+    cached: false
+  };
+};
+
+// src/lib/derivativesContextBackfill.ts
+var import_chalk2 = __toESM(require("chalk"));
+var import_progress = __toESM(require("progress"));
+var import_async2 = require("@tradejs/core/async");
+var import_constants = require("@tradejs/core/constants");
+var import_indicators = require("@tradejs/core/indicators");
+var import_derivatives = require("@tradejs/infra/timescale/derivatives");
+var import_client2 = require("@tradejs/infra/timescale/client");
+var import_userSettings2 = require("@tradejs/infra/userSettings");
+var HOUR_MS = 60 * 60 * 1e3;
+var DAY_MS2 = 24 * HOUR_MS;
+var lastRequestTs2 = 0;
+var asInt2 = (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 getCoinalyzeApiKey = async (userName) => {
+  const settings = await (0, import_userSettings2.getUserSettings)(userName);
+  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 getRequestDelayMs2 = () => Math.max(
+  100,
+  asInt2(
+    process.env.DERIVATIVES_CONTEXT_BACKFILL_REQUEST_DELAY_MS ?? process.env.COINALYZE_MIN_REQUEST_DELAY_MS,
+    200
+  )
+);
+var getRequestTimeoutMs = () => Math.max(5e3, asInt2(process.env.COINALYZE_REQUEST_TIMEOUT_MS, 45e3));
+var networkErrorCodes = /* @__PURE__ */ new Set([
+  "UND_ERR_CONNECT_TIMEOUT",
+  "ETIMEDOUT",
+  "ECONNRESET",
+  "ECONNREFUSED",
+  "ENOTFOUND",
+  "EAI_AGAIN",
+  "EHOSTUNREACH"
+]);
+var getNestedErrorValue = (error, key) => {
+  let current = error;
+  const seen = /* @__PURE__ */ new Set();
+  while (current && typeof current === "object" && !seen.has(current)) {
+    seen.add(current);
+    const record = current;
+    const value = record[key];
+    if (typeof value === "string" && value.trim()) {
+      return value.trim();
+    }
+    current = record.cause;
+  }
+  return null;
+};
+var getCoinalyzeErrorCause = (error) => {
+  const code = getNestedErrorValue(error, "code");
+  const message = getNestedErrorValue(error, "message") ?? String(error || "unknown error");
+  return code ? `${code}: ${message}` : message;
+};
+var isRetryableCoinalyzeFetchError = (error) => {
+  const name = getNestedErrorValue(error, "name");
+  const code = getNestedErrorValue(error, "code");
+  const message = getNestedErrorValue(error, "message")?.toLowerCase() ?? "";
+  return name === "AbortError" || code != null && networkErrorCodes.has(code) || message.includes("aborted") || message.includes("fetch failed");
+};
+var formatCoinalyzeRequestError = ({
+  url,
+  error,
+  attempts,
+  timeoutMs
+}) => {
+  const endpoint = (() => {
+    try {
+      const parsed = new URL(url);
+      return `${parsed.origin}${parsed.pathname}`;
+    } catch {
+      return url;
+    }
+  })();
+  return [
+    `Coinalyze request failed: ${endpoint}`,
+    `cause=${getCoinalyzeErrorCause(error)}`,
+    `attempts=${attempts}`,
+    `timeout=${timeoutMs}ms`,
+    "Set COINALYZE_REQUEST_TIMEOUT_MS/COINALYZE_MAX_RETRIES to retry longer, or DERIVATIVES_CONTEXT_ENABLED=live to skip derivatives backfill during backtests."
+  ].join("; ");
+};
+var fetchJsonWithRateLimit = async (url, apiKey) => {
+  const requestDelayMs = getRequestDelayMs2();
+  const requestTimeoutMs = getRequestTimeoutMs();
+  const maxRetries = asInt2(process.env.COINALYZE_MAX_RETRIES, 4);
+  let lastError = null;
+  for (let attempt = 0; attempt <= maxRetries; attempt += 1) {
+    const waitMs = Math.max(0, lastRequestTs2 + requestDelayMs - Date.now());
+    if (waitMs > 0) {
+      await (0, import_async2.delay)(waitMs);
+    }
+    lastRequestTs2 = 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);
+      lastError = error;
+      if (attempt < maxRetries && isRetryableCoinalyzeFetchError(error)) {
+        await (0, import_async2.delay)(Math.min(12e3, 800 * 2 ** attempt));
+        continue;
+      }
+      throw new Error(
+        formatCoinalyzeRequestError({
+          url,
+          error,
+          attempts: attempt + 1,
+          timeoutMs: requestTimeoutMs
+        })
+      );
+    } 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_async2.delay)(retryAfterMs ?? Math.min(12e3, 800 * 2 ** attempt));
+      continue;
+    }
+    throw new Error(`Coinalyze ${response.status}: ${text}`);
+  }
+  throw new Error(
+    formatCoinalyzeRequestError({
+      url,
+      error: lastError,
+      attempts: maxRetries + 1,
+      timeoutMs: requestTimeoutMs
+    })
+  );
+};
+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 };
+};
+async function resolveCoinalyzeBackfillMarket(userName, symbol) {
+  const apiKey = await getCoinalyzeApiKey(userName);
+  if (!apiKey) throw new Error("Missing Coinalyze API key.");
+  const markets = (await fetchCoinalyzeMarkets(apiKey)).filter(
+    (market) => market.quote_asset?.toUpperCase() === "USDT" && market.is_perpetual
+  );
+  const priority = parseList(
+    process.env.COINALYZE_EXCHANGE_PRIORITY || process.env.DERIVATIVES_CONTEXT_EXCHANGE_PRIORITY || "A,6,0"
+  );
+  const { matches } = buildMatches([symbol], markets, priority);
+  return { apiKey, marketSymbol: matches[0]?.marketSymbol };
+}
+
+// src/scripts/coverageBackfill.ts
+var DAY_MS3 = 864e5;
+async function fetchTarget(userName, request, target, loaded) {
+  const { dataset, end } = target;
+  const { series, day } = request;
+  const endMs = end - 1;
+  const interval = dataset.interval;
+  const missing = (time) => time >= day && time < end && !loaded.has(time);
+  if (dataset.provider === "CoinMarketCap") {
+    await backfillCoinMarketCapContext({
+      userName,
+      startMs: day,
+      preloadStartMs: day,
+      endMs: end,
+      repairDataset: dataset.id
+    });
+    return;
+  }
+  if (dataset.provider === "Coinalyze") {
+    if (interval !== "15m" && interval !== "1h") return;
+    const { apiKey, marketSymbol } = await resolveCoinalyzeBackfillMarket(
+      userName,
+      series
+    );
+    if (!marketSymbol) return;
+    const { derivativesRows = [] } = await import_connectors.marketDataProviders.coinalyze.fetchWindow({
+      symbol: series,
+      marketSymbol,
+      apiKey,
+      interval,
+      fromMs: day,
+      toMs: endMs
+    });
+    await (0, import_derivatives2.upsertDerivatives)(
+      derivativesRows.filter(({ ts }) => missing(ts.getTime())).flatMap((row) => {
+        const { symbol, ts, interval: interval2, source } = row;
+        if (dataset.id.startsWith("coinalyze-open-interest-")) {
+          return row.openInterest == null ? [] : [
+            {
+              symbol,
+              ts,
+              interval: interval2,
+              source,
+              openInterest: row.openInterest
+            }
+          ];
+        }
+        if (dataset.id.startsWith("coinalyze-funding-")) {
+          return row.fundingRate == null ? [] : [
+            {
+              symbol,
+              ts,
+              interval: interval2,
+              source,
+              fundingRate: row.fundingRate
+            }
+          ];
+        }
+        const { liqLong, liqShort, liqTotal } = row;
+        return liqLong == null && liqShort == null && liqTotal == null ? [] : [{ symbol, ts, interval: interval2, source, liqLong, liqShort, liqTotal }];
+      })
+    );
+    return;
+  }
+  if (dataset.id === "binance-coinbase-spread-15m") {
+    const { spreadRows = [] } = await import_connectors.marketDataProviders.binance_coinbase_spread.fetchWindow({
+      symbol: series,
+      interval: "15m",
+      fromMs: day,
+      toMs: endMs
+    });
+    await (0, import_spread.upsertSpreadRows)(
+      spreadRows.filter(({ ts }) => missing(ts.getTime()))
+    );
+    return;
+  }
+  const provider = dataset.provider === "Bybit" ? "bybit" : "binance";
+  const connector = await import_connectors.connectors[provider === "bybit" ? import_connectors.ConnectorNames.ByBit : import_connectors.ConnectorNames.Binance]({ userName });
+  const connectorInterval = interval === "5m" ? "5" : interval === "1h" ? "60" : "15";
+  const fetchCandles = async (symbol, start) => {
+    const candles = await connector.kline({
+      symbol,
+      interval: connectorInterval,
+      start,
+      end: endMs,
+      silent: true
+    });
+    return candles.filter(
+      ({ timestamp }) => timestamp >= start && timestamp < end
+    );
+  };
+  if (dataset.id.includes("-candles-")) {
+    const candles = (await fetchCandles(series, day)).filter(
+      ({ timestamp }) => missing(timestamp)
+    );
+    await (0, import_candles.upsertCandles)(
+      (0, import_candles.toRows)(provider, series, Number(connectorInterval), candles)
+    );
+    return;
+  }
+  if (interval === "1d") return;
+  if (dataset.id.startsWith("binance-trade-flow-")) {
+    await (0, import_marketContext2.upsertMarketTradeFlowRows)(
+      buildKlineTradeFlowRows({
+        symbol: series,
+        interval,
+        candles: (await fetchCandles(series, day)).filter(
+          ({ timestamp }) => missing(timestamp)
+        )
+      })
+    );
+    return;
+  }
+  const universe = (0, import_strategies.getBinanceBreadthUniverses)().find(
+    (item) => item.universe === series
+  );
+  if (!universe)
+    throw new Error("The historical Binance basket is unavailable.");
+  const candlesBySymbol = {};
+  const warmup = day - 2 * DAY_MS3;
+  for (let offset = 0; offset < universe.symbols.length; offset += 4) {
+    const entries = await Promise.all(
+      universe.symbols.slice(offset, offset + 4).map(
+        async (symbol) => [symbol, await fetchCandles(symbol, warmup)]
+      )
+    );
+    Object.assign(candlesBySymbol, Object.fromEntries(entries));
+  }
+  const rows = buildMarketBreadthRows({
+    universe: series,
+    interval,
+    candlesBySymbol,
+    btcCandles: candlesBySymbol.BTCUSDT ?? await fetchCandles("BTCUSDT", warmup)
+  });
+  await (0, import_marketContext2.upsertMarketBreadthRows)(rows.filter(({ ts }) => missing(ts.getTime())));
+}
+async function main() {
+  const [userName, dataset, series, day] = process.argv.slice(2);
+  const request = { dataset, series, day: Number(day) };
+  const target = (0, import_dataCoverage.resolveDataBackfill)(request);
+  if (!target || !userName)
+    throw new Error(
+      "Expected user, dataset, series and UTC day in milliseconds."
+    );
+  await (0, import_client3.waitForDbReady)();
+  const before = await (0, import_dataCoverage.readDataBackfillSlots)(request, target.end);
+  if (before.loaded.size < before.expected)
+    await fetchTarget(userName, request, target, before.loaded);
+  const after = await (0, import_dataCoverage.readDataBackfillSlots)(request, target.end);
+  const result = {
+    loaded: after.loaded.size,
+    added: Math.max(0, after.loaded.size - before.loaded.size),
+    missing: Math.max(0, after.expected - after.loaded.size)
+  };
+  console.log(`TRADEJS_DATA_BACKFILL ${JSON.stringify(result)}`);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  main
+});