@tradejs/cli 2.0.0 → 2.0.2

package/dist/scripts/derivativesIngest.js

@@ -41,11 +41,11 @@ var import_timescale = require("@tradejs/infra/timescale");
 var import_userSettings = require("@tradejs/infra/userSettings");
 var import_connectors = require("@tradejs/connectors");
 import_args.default.example(
-  "yarn ts-node ./src/scripts/derivativesIngest --provider coinalyze --symbols BTCUSDT,ETHUSDT --intervals 15m,1h --days 120",
+  "yarn ts-node ./src/scripts/derivativesIngest --provider coinalyze --symbols BTCUSDT,ETHUSDT --intervals 15m --days 120",
   "Ingest market features (derivatives/spread) into Timescale by provider"
 );
 import_args.default.option(["s", "symbols"], "Comma-separated symbols", "BTCUSDT,ETHUSDT");
-import_args.default.option(["t", "intervals"], "Comma-separated intervals: 15m,1h", "15m,1h");
+import_args.default.option(["t", "intervals"], "Comma-separated intervals: 15m,1h", "15m");
 import_args.default.option(["d", "days"], "Lookback in days", 120);
 import_args.default.option(
   ["p", "provider"],
@@ -82,9 +82,16 @@ var main = async () => {
   let totalSpreadRows = 0;
   for (const symbol of symbols) {
     for (const interval of intervals) {
+      const lastClosedStartMs = (0, import_indicators.getLastClosedDerivativesBarStartMs)(
+        now,
+        interval
+      );
       let cursor = fromMs;
-      while (cursor < now) {
-        const toMs = Math.min(now, cursor + batchDays * 24 * 60 * 60 * 1e3);
+      while (cursor < lastClosedStartMs) {
+        const toMs = Math.min(
+          lastClosedStartMs,
+          cursor + batchDays * 24 * 60 * 60 * 1e3
+        );
         process.stdout.write(
           `\r${import_chalk.default.cyan(providerName)} ${import_chalk.default.yellow(symbol)} ${interval} ${new Date(cursor).toISOString()} .. ${new Date(toMs).toISOString()}   `
         );

package/dist/scripts/derivativesIngestCoinalyzeAll.js

@@ -49,7 +49,7 @@ var coinalyzeIntervalMap = {
   "1h": "1hour"
 };
 import_args.default.example(
-  "yarn ts-node ./src/scripts/derivativesIngestCoinalyzeAll --days 120 --intervals 15m,1h",
+  "yarn ts-node ./src/scripts/derivativesIngestCoinalyzeAll --days 120 --intervals 15m",
   "Fetch derivatives for all getTickers symbols matched to Coinalyze markets"
 );
 import_args.default.option(["U", "user"], "User settings profile name from Redis", "root");
@@ -57,7 +57,7 @@ import_args.default.option(["t", "tickers"], "Comma-separated include symbols");
 import_args.default.option(["e", "exclude"], "Comma-separated exclude symbols");
 import_args.default.option(["l", "tickersLimit"], "Tickers limit");
 import_args.default.option(["c", "chunk"], "Chunk selector, e.g. 1/4");
-import_args.default.option(["i", "intervals"], "Intervals: 15m,1h", "15m,1h");
+import_args.default.option(["i", "intervals"], "Intervals: 15m,1h", "15m");
 import_args.default.option(["d", "days"], "Lookback in days", 120);
 import_args.default.option(["b", "batchDays"], "Request chunk size in days", 120);
 import_args.default.option(
@@ -326,12 +326,16 @@ var main = async () => {
   let totalRows = 0;
   let failedWindows = 0;
   for (const interval of intervals) {
+    const lastClosedStartMs = (0, import_indicators.getLastClosedDerivativesBarStartMs)(now, interval);
     for (let batchIdx = 0; batchIdx < symbolBatches.length; batchIdx += 1) {
       const batch = symbolBatches[batchIdx];
       const marketSymbols = batch.map((item) => item.marketSymbol);
       let cursor = fromMs;
-      while (cursor < now) {
-        const toMs = Math.min(now, cursor + batchDays * 24 * 60 * 60 * 1e3);
+      while (cursor < lastClosedStartMs) {
+        const toMs = Math.min(
+          lastClosedStartMs,
+          cursor + batchDays * 24 * 60 * 60 * 1e3
+        );
         try {
           const oiMap = await fetchMetricBatch({
             endpoint: oiPath,
@@ -374,6 +378,36 @@ var main = async () => {
             await (0, import_timescale.upsertDerivatives)(rows);
             totalRows += rows.length;
           }
+          const confirmedLiquidationWindow = (0, import_indicators.resolveCoinalyzeConfirmedIntradayCoverage)({
+            interval,
+            fromMs: cursor,
+            toMs,
+            nowMs: now
+          });
+          if (confirmedLiquidationWindow) {
+            await (0, import_timescale.applyDerivativesMetricCoverage)(
+              batch.map((item) => {
+                const marketSymbol = item.marketSymbol.toUpperCase();
+                const eventRowsCount = (liqMap.get(marketSymbol) ?? []).filter(
+                  (point) => {
+                    const timestamp = (0, import_indicators.toCoinalyzeTimestampMs)(
+                      point.t ?? point.ts ?? point.time ?? point.timestamp
+                    );
+                    return timestamp != null && timestamp >= confirmedLiquidationWindow.fromMs && timestamp <= confirmedLiquidationWindow.toMs;
+                  }
+                ).length;
+                return {
+                  source: "coinalyze",
+                  metric: "liquidation",
+                  symbol: item.symbol,
+                  interval,
+                  fromMs: confirmedLiquidationWindow.fromMs,
+                  toMs: confirmedLiquidationWindow.toMs,
+                  eventRowsCount
+                };
+              })
+            );
+          }
         } catch (error) {
           failedWindows += 1;
           console.error(

package/dist/scripts/replay.js

@@ -3106,7 +3106,7 @@ var import_userSettings = require("@tradejs/infra/userSettings");
 var HOUR_MS = 60 * 60 * 1e3;
 var DAY_MS2 = 24 * HOUR_MS;
 var DEFAULT_LOOKBACK_HOURS = 48;
-var DEFAULT_INTERVALS = ["15m", "1h"];
+var SOURCE_INTERVALS = ["15m"];
 var coinalyzeIntervalMap = {
   "15m": "15min",
   "1h": "1hour"
@@ -3167,10 +3167,7 @@ var isDerivativesContextBackfillEnabled = (env) => {
 var shouldBackfillDerivativesContextForBacktest = (params) => !params.cacheOnly && (params.aiEnabled || params.mlEnabled) && isBacktestDerivativesContextEnabled();
 var shouldBackfillDerivativesContextForSignals = (params) => !params.cacheOnly && isSignalsDerivativesContextEnabled();
 var resolveDerivativesContextIntervals = () => {
-  const intervals = (0, import_indicators.normalizeDerivativesIntervals)(
-    process.env.DERIVATIVES_CONTEXT_INTERVALS
-  );
-  return intervals.length ? intervals : DEFAULT_INTERVALS;
+  return [...SOURCE_INTERVALS];
 };
 var resolveDerivativesContextLookbackMs = () => {
   const hours = Number(process.env.DERIVATIVES_CONTEXT_LOOKBACK_HOURS);
@@ -3205,9 +3202,10 @@ var resolveDerivativesContextBackfillWindow = (params) => {
 };
 var resolveDerivativesContextIntervalBackfillWindow = (params) => {
   const intervalMs = derivativesIntervalMs(params.interval);
+  const alignedToMs = params.closedOnly ? (0, import_indicators.getLastClosedDerivativesBarStartMs)(params.toMs, params.interval) : Math.floor(params.toMs / intervalMs) * intervalMs;
   return {
     fromMs: Math.floor(params.fromMs / intervalMs) * intervalMs,
-    toMs: Math.floor(params.toMs / intervalMs) * intervalMs,
+    toMs: alignedToMs,
     intervalMs
   };
 };
@@ -3225,6 +3223,39 @@ var resolveDerivativesContextMissingFetchFromMs = (params) => {
   }
   return null;
 };
+var resolveDerivativesContextFetchFromMs = (params) => resolveDerivativesContextMissingFetchFromMs(params) ?? (params.refreshClosedTail ? params.toMs : null);
+var resolveDerivativesContextRequiredFetchFromMs = (params) => {
+  const dataCoverageFromMs = params.dataCoverageKeyExists ? null : params.mode === "signals" ? params.fromMs : resolveDerivativesContextMissingCoverageFetchFromMs({
+    ranges: params.dataCoverageRanges,
+    fromMs: params.fromMs,
+    toMs: params.toMs,
+    intervalMs: params.intervalMs
+  });
+  const edgesFromMs = dataCoverageFromMs == null ? null : resolveDerivativesContextFetchFromMs({
+    edges: params.edges,
+    fromMs: params.fromMs,
+    toMs: params.toMs,
+    intervalMs: params.intervalMs,
+    refreshClosedTail: params.mode === "signals"
+  });
+  const dataFetchFromMs = dataCoverageFromMs != null && edgesFromMs != null ? Math.max(dataCoverageFromMs, edgesFromMs) : null;
+  const confirmedLiquidationWindow = (0, import_indicators.resolveCoinalyzeConfirmedIntradayCoverage)({
+    interval: params.interval,
+    fromMs: params.fromMs,
+    toMs: params.toMs,
+    nowMs: params.nowMs
+  });
+  const liquidationFetchFromMs = confirmedLiquidationWindow ? resolveDerivativesContextMissingCoverageFetchFromMs({
+    ranges: params.liquidationCoverageRanges,
+    fromMs: confirmedLiquidationWindow.fromMs,
+    toMs: confirmedLiquidationWindow.toMs,
+    intervalMs: params.intervalMs
+  }) : null;
+  const fetchStarts = [dataFetchFromMs, liquidationFetchFromMs].filter(
+    (value) => value != null
+  );
+  return fetchStarts.length ? Math.min(...fetchStarts) : null;
+};
 var countBackfillWindows = (params) => {
   let count = 0;
   let cursor = params.fromMs;
@@ -3288,6 +3319,14 @@ var groupDerivativesContextMissingFetchRanges = (ranges) => {
   }
   return [...groups.entries()].sort(([a], [b]) => a - b).map(([fromMs, items]) => ({ fromMs, items }));
 };
+var getMissingClosedDerivativesSymbols = (params) => {
+  const availableSymbols = new Set(
+    params.rows.filter((row) => row.ts.getTime() === params.expectedTimestamp).map((row) => row.symbol.trim().toUpperCase())
+  );
+  return params.symbols.filter(
+    (symbol) => !availableSymbols.has(symbol.trim().toUpperCase())
+  );
+};
 var coverageKey = (params) => [
   params.symbol.trim().toUpperCase(),
   params.interval,
@@ -3552,7 +3591,8 @@ var backfillDerivativesContext = async (params, enabled, mode) => {
     mode,
     startMs,
     endMs,
-    preloadStartMs: params.preloadStartMs
+    preloadStartMs: params.preloadStartMs,
+    nowMs: Date.now()
   });
   if (safeEndMs <= fromMs) {
     return skippedBackfillResult2();
@@ -3567,7 +3607,8 @@ var backfillDerivativesContext = async (params, enabled, mode) => {
     ...resolveDerivativesContextIntervalBackfillWindow({
       fromMs,
       toMs: safeEndMs,
-      interval
+      interval,
+      closedOnly: mode === "signals"
     })
   })).filter((item) => item.toMs > item.fromMs);
   if (!intervalWindows.length) {
@@ -3585,15 +3626,33 @@ var backfillDerivativesContext = async (params, enabled, mode) => {
   );
   const coverageKeysByInterval = /* @__PURE__ */ new Map();
   const coverageRangesByInterval = /* @__PURE__ */ new Map();
+  const liquidationCoverageRangesByInterval = /* @__PURE__ */ new Map();
+  const coverageNowMs = Date.now();
   await Promise.all(
     intervalWindows.map(async (window2) => {
-      const coverageRows = await (0, import_timescale2.getDerivativesBackfillCoverage)({
-        source: "coinalyze",
-        symbols,
+      const confirmedLiquidationWindow = (0, import_indicators.resolveCoinalyzeConfirmedIntradayCoverage)({
         interval: window2.interval,
         fromMs: window2.fromMs,
-        toMs: window2.toMs
+        toMs: window2.toMs,
+        nowMs: coverageNowMs
       });
+      const [coverageRows, liquidationCoverageRows] = await Promise.all([
+        (0, import_timescale2.getDerivativesBackfillCoverage)({
+          source: "coinalyze",
+          symbols,
+          interval: window2.interval,
+          fromMs: window2.fromMs,
+          toMs: window2.toMs
+        }),
+        confirmedLiquidationWindow ? (0, import_timescale2.getDerivativesMetricCoverage)({
+          source: "coinalyze",
+          metric: "liquidation",
+          symbols,
+          interval: window2.interval,
+          fromMs: confirmedLiquidationWindow.fromMs,
+          toMs: confirmedLiquidationWindow.toMs
+        }) : Promise.resolve([])
+      ]);
       coverageKeysByInterval.set(
         window2.interval,
         new Set(
@@ -3615,6 +3674,17 @@ var backfillDerivativesContext = async (params, enabled, mode) => {
         rangesBySymbol.set(symbol, ranges);
       }
       coverageRangesByInterval.set(window2.interval, rangesBySymbol);
+      const liquidationRangesBySymbol = /* @__PURE__ */ new Map();
+      for (const row of liquidationCoverageRows) {
+        const symbol = row.symbol.toUpperCase();
+        const ranges = liquidationRangesBySymbol.get(symbol) ?? [];
+        ranges.push({ fromMs: row.fromMs, toMs: row.toMs });
+        liquidationRangesBySymbol.set(symbol, ranges);
+      }
+      liquidationCoverageRangesByInterval.set(
+        window2.interval,
+        liquidationRangesBySymbol
+      );
     })
   );
   const cachedWindows = intervalWindows.reduce(
@@ -3626,7 +3696,7 @@ var backfillDerivativesContext = async (params, enabled, mode) => {
     }),
     0
   );
-  const allBackfillWindowsCached = intervalWindows.every((window2) => {
+  const allBackfillWindowsCached = mode !== "signals" && intervalWindows.every((window2) => {
     const edgesBySymbol = edgesByInterval.get(window2.interval);
     const coverageKeys = coverageKeysByInterval.get(window2.interval);
     const backfillWindows = buildBackfillWindows({
@@ -3639,7 +3709,7 @@ var backfillDerivativesContext = async (params, enabled, mode) => {
       (symbol) => backfillWindows.every((backfillWindow) => {
         const normalizedSymbol = symbol.toUpperCase();
         const coverageRanges = coverageRangesByInterval.get(window2.interval)?.get(normalizedSymbol) ?? [];
-        return hasDerivativesWindowCoverage({
+        const dataCovered = hasDerivativesWindowCoverage({
           edges: edgesBySymbol?.get(normalizedSymbol),
           fromMs: backfillWindow.fromMs,
           toMs: backfillWindow.toMs
@@ -3656,6 +3726,19 @@ var backfillDerivativesContext = async (params, enabled, mode) => {
             toMs: backfillWindow.toMs
           })
         );
+        const confirmedLiquidationWindow = (0, import_indicators.resolveCoinalyzeConfirmedIntradayCoverage)({
+          interval: window2.interval,
+          fromMs: backfillWindow.fromMs,
+          toMs: backfillWindow.toMs,
+          nowMs: coverageNowMs
+        });
+        const liquidationCovered = confirmedLiquidationWindow == null || resolveDerivativesContextMissingCoverageFetchFromMs({
+          ranges: liquidationCoverageRangesByInterval.get(window2.interval)?.get(normalizedSymbol) ?? [],
+          fromMs: confirmedLiquidationWindow.fromMs,
+          toMs: confirmedLiquidationWindow.toMs,
+          intervalMs: window2.intervalMs
+        }) == null;
+        return dataCovered && liquidationCovered;
       })
     );
   });
@@ -3740,6 +3823,11 @@ var backfillDerivativesContext = async (params, enabled, mode) => {
     coverageKeysByInterval.set(interval, coverageKeys);
     const coverageRangesBySymbol = coverageRangesByInterval.get(interval) ?? /* @__PURE__ */ new Map();
     coverageRangesByInterval.set(interval, coverageRangesBySymbol);
+    const liquidationCoverageRangesBySymbol = liquidationCoverageRangesByInterval.get(interval) ?? /* @__PURE__ */ new Map();
+    liquidationCoverageRangesByInterval.set(
+      interval,
+      liquidationCoverageRangesBySymbol
+    );
     for (let batchIdx = 0; batchIdx < symbolBatches.length; batchIdx += 1) {
       const batch = symbolBatches[batchIdx];
       let cursor = window2.fromMs;
@@ -3752,30 +3840,26 @@ var backfillDerivativesContext = async (params, enabled, mode) => {
             fromMs: cursor,
             toMs
           });
-          if (coverageKeys.has(key)) {
-            return null;
-          }
           const normalizedSymbol = item.symbol.toUpperCase();
-          const coverageFromMs = resolveDerivativesContextMissingCoverageFetchFromMs({
-            ranges: coverageRangesBySymbol.get(normalizedSymbol),
-            fromMs: cursor,
-            toMs,
-            intervalMs
-          });
-          if (coverageFromMs == null) {
-            return null;
-          }
-          const edges = edgesBySymbol.get(normalizedSymbol);
-          const edgesFromMs = resolveDerivativesContextMissingFetchFromMs({
-            edges,
-            fromMs: cursor,
-            toMs,
-            intervalMs
-          });
-          if (edgesFromMs == null) {
-            return null;
-          }
-          return { item, fromMs: Math.max(coverageFromMs, edgesFromMs) };
+          const requiredFromMs = resolveDerivativesContextRequiredFetchFromMs(
+            {
+              mode,
+              interval,
+              intervalMs,
+              fromMs: cursor,
+              toMs,
+              nowMs: coverageNowMs,
+              dataCoverageKeyExists: coverageKeys.has(key),
+              dataCoverageRanges: coverageRangesBySymbol.get(normalizedSymbol),
+              liquidationCoverageRanges: liquidationCoverageRangesBySymbol.get(normalizedSymbol),
+              edges: edgesBySymbol.get(normalizedSymbol)
+            }
+          );
+          if (requiredFromMs == null) return null;
+          return {
+            item,
+            fromMs: requiredFromMs
+          };
         }).filter(
           (item) => item != null
         );
@@ -3789,85 +3873,150 @@ var backfillDerivativesContext = async (params, enabled, mode) => {
               const marketSymbols = missingBatch.map(
                 (item) => item.marketSymbol
               );
-              const oiMap = await fetchMetricBatch({
-                endpoint: oiPath,
-                metric: "oi",
-                marketSymbols,
-                apiKey,
-                interval,
-                fromMs: group.fromMs,
-                toMs
-              });
-              const fundingMap = await fetchMetricBatch({
-                endpoint: fundingPath,
-                metric: "funding",
-                marketSymbols,
-                apiKey,
-                interval,
-                fromMs: group.fromMs,
-                toMs
-              });
-              const liqMap = await fetchMetricBatch({
-                endpoint: liqPath,
-                metric: "liq",
-                marketSymbols,
-                apiKey,
-                interval,
-                fromMs: group.fromMs,
-                toMs
-              });
-              const rows = missingBatch.flatMap((item) => {
-                const marketSymbol = item.marketSymbol.toUpperCase();
-                const points = (0, import_indicators.mergeCoinalyzeMetrics)({
-                  symbol: item.symbol,
-                  oiRaw: oiMap.get(marketSymbol) ?? [],
-                  fundingRaw: fundingMap.get(marketSymbol) ?? [],
-                  liqRaw: liqMap.get(marketSymbol) ?? []
+              const maxClosedBarAttempts = mode === "signals" ? asInt2(
+                process.env.DERIVATIVES_CONTEXT_CLOSED_BAR_MAX_ATTEMPTS,
+                3
+              ) : 1;
+              const closedBarRetryDelayMs = asInt2(
+                process.env.DERIVATIVES_CONTEXT_CLOSED_BAR_RETRY_DELAY_MS,
+                2e3
+              );
+              let rows = [];
+              let missingClosedSymbols = [];
+              let liquidationRowsByMarket = /* @__PURE__ */ new Map();
+              for (let attempt = 1; attempt <= maxClosedBarAttempts; attempt += 1) {
+                const oiMap = await fetchMetricBatch({
+                  endpoint: oiPath,
+                  metric: "oi",
+                  marketSymbols,
+                  apiKey,
+                  interval,
+                  fromMs: group.fromMs,
+                  toMs
                 });
-                return (0, import_indicators.coinalyzePointsToRows)(points, interval, "coinalyze");
-              });
+                const fundingMap = await fetchMetricBatch({
+                  endpoint: fundingPath,
+                  metric: "funding",
+                  marketSymbols,
+                  apiKey,
+                  interval,
+                  fromMs: group.fromMs,
+                  toMs
+                });
+                liquidationRowsByMarket = await fetchMetricBatch({
+                  endpoint: liqPath,
+                  metric: "liq",
+                  marketSymbols,
+                  apiKey,
+                  interval,
+                  fromMs: group.fromMs,
+                  toMs
+                });
+                rows = missingBatch.flatMap((item) => {
+                  const marketSymbol = item.marketSymbol.toUpperCase();
+                  const points = (0, import_indicators.mergeCoinalyzeMetrics)({
+                    symbol: item.symbol,
+                    oiRaw: oiMap.get(marketSymbol) ?? [],
+                    fundingRaw: fundingMap.get(marketSymbol) ?? [],
+                    liqRaw: liquidationRowsByMarket.get(marketSymbol) ?? []
+                  });
+                  return (0, import_indicators.coinalyzePointsToRows)(points, interval, "coinalyze");
+                });
+                missingClosedSymbols = mode === "signals" ? getMissingClosedDerivativesSymbols({
+                  symbols: missingBatch.map((item) => item.symbol),
+                  rows,
+                  expectedTimestamp: toMs
+                }) : [];
+                if (!missingClosedSymbols.length) break;
+                if (attempt < maxClosedBarAttempts) {
+                  await (0, import_async.delay)(closedBarRetryDelayMs);
+                }
+              }
+              if (missingClosedSymbols.length) {
+                throw new Error(
+                  `Coinalyze closed ${interval} bar ${new Date(toMs).toISOString()} unavailable for ${missingClosedSymbols.join(",")}`
+                );
+              }
               if (rows.length) {
                 await (0, import_timescale2.upsertDerivatives)(rows);
                 totalRows += rows.length;
               }
-              const rowsCountBySymbol = /* @__PURE__ */ new Map();
-              for (const row of rows) {
-                const symbol = row.symbol.toUpperCase();
-                rowsCountBySymbol.set(
-                  symbol,
-                  (rowsCountBySymbol.get(symbol) ?? 0) + 1
-                );
-              }
-              const coverageRows = missingBatch.map((item) => {
-                const normalizedSymbol = item.symbol.toUpperCase();
-                const rowsCount = rowsCountBySymbol.get(normalizedSymbol) ?? 0;
-                return {
-                  source: "coinalyze",
-                  symbol: item.symbol,
-                  interval,
-                  fromMs: cursor,
-                  toMs,
-                  rowsCount
-                };
+              const confirmedLiquidationWindow = (0, import_indicators.resolveCoinalyzeConfirmedIntradayCoverage)({
+                interval,
+                fromMs: group.fromMs,
+                toMs,
+                nowMs: coverageNowMs
               });
-              await (0, import_timescale2.upsertDerivativesBackfillCoverage)(coverageRows);
-              for (const coverageRow of coverageRows) {
-                const symbol = coverageRow.symbol.toUpperCase();
-                edgesBySymbol.set(
-                  symbol,
-                  extendEdges(edgesBySymbol.get(symbol), cursor, toMs)
-                );
-                coverageKeys.add(
-                  coverageKey({
+              if (confirmedLiquidationWindow) {
+                const metricCoverageRows = missingBatch.map((item) => {
+                  const marketSymbol = item.marketSymbol.toUpperCase();
+                  const eventRowsCount = (liquidationRowsByMarket.get(marketSymbol) ?? []).filter((point) => {
+                    const timestamp = (0, import_indicators.toCoinalyzeTimestampMs)(
+                      point.t ?? point.ts ?? point.time ?? point.timestamp
+                    );
+                    return timestamp != null && timestamp >= confirmedLiquidationWindow.fromMs && timestamp <= confirmedLiquidationWindow.toMs;
+                  }).length;
+                  return {
+                    source: "coinalyze",
+                    metric: "liquidation",
+                    symbol: item.symbol,
+                    interval,
+                    fromMs: confirmedLiquidationWindow.fromMs,
+                    toMs: confirmedLiquidationWindow.toMs,
+                    eventRowsCount
+                  };
+                });
+                await (0, import_timescale2.applyDerivativesMetricCoverage)(metricCoverageRows);
+                for (const coverageRow of metricCoverageRows) {
+                  const symbol = coverageRow.symbol.toUpperCase();
+                  const ranges = liquidationCoverageRangesBySymbol.get(symbol) ?? [];
+                  ranges.push({
+                    fromMs: coverageRow.fromMs,
+                    toMs: coverageRow.toMs
+                  });
+                  liquidationCoverageRangesBySymbol.set(symbol, ranges);
+                }
+              }
+              if (mode === "backtest") {
+                const rowsCountBySymbol = /* @__PURE__ */ new Map();
+                for (const row of rows) {
+                  const symbol = row.symbol.toUpperCase();
+                  rowsCountBySymbol.set(
                     symbol,
+                    (rowsCountBySymbol.get(symbol) ?? 0) + 1
+                  );
+                }
+                const coverageRows = missingBatch.map((item) => {
+                  const normalizedSymbol = item.symbol.toUpperCase();
+                  const rowsCount = rowsCountBySymbol.get(normalizedSymbol) ?? 0;
+                  return {
+                    source: "coinalyze",
+                    symbol: item.symbol,
                     interval,
                     fromMs: cursor,
-                    toMs
-                  })
-                );
-                const coverageRanges = coverageRangesBySymbol.get(symbol) ?? [];
-                coverageRanges.push({ fromMs: cursor, toMs });
-                coverageRangesBySymbol.set(symbol, coverageRanges);
+                    toMs,
+                    rowsCount
+                  };
+                });
+                await (0, import_timescale2.upsertDerivativesBackfillCoverage)(coverageRows);
+                for (const coverageRow of coverageRows) {
+                  const symbol = coverageRow.symbol.toUpperCase();
+                  edgesBySymbol.set(
+                    symbol,
+                    extendEdges(edgesBySymbol.get(symbol), cursor, toMs)
+                  );
+                  coverageKeys.add(
+                    coverageKey({
+                      symbol,
+                      interval,
+                      fromMs: cursor,
+                      toMs
+                    })
+                  );
+                  const coverageRanges = coverageRangesBySymbol.get(symbol) ?? [];
+                  coverageRanges.push({ fromMs: cursor, toMs });
+                  coverageRangesBySymbol.set(symbol, coverageRanges);
+                }
               }
             }
           }