@tradejs/cli 1.0.9 → 1.0.10

package/dist/lib/derivativesContextBackfill.js

@@ -32,12 +32,19 @@ var derivativesContextBackfill_exports = {};
 __export(derivativesContextBackfill_exports, {
   backfillDerivativesContextForBacktest: () => backfillDerivativesContextForBacktest,
   backfillDerivativesContextForSignals: () => backfillDerivativesContextForSignals,
+  formatCoinalyzeRequestError: () => formatCoinalyzeRequestError,
+  groupDerivativesContextMissingFetchRanges: () => groupDerivativesContextMissingFetchRanges,
+  hasDerivativesContextCoverageRange: () => hasDerivativesContextCoverageRange,
   isBacktestDerivativesContextEnabled: () => isBacktestDerivativesContextEnabled,
+  isDerivativesTargetContextEnabled: () => isDerivativesTargetContextEnabled,
   isSignalsDerivativesContextEnabled: () => isSignalsDerivativesContextEnabled,
   resolveDerivativesContextBackfillSymbols: () => resolveDerivativesContextBackfillSymbols,
   resolveDerivativesContextBackfillWindow: () => resolveDerivativesContextBackfillWindow,
+  resolveDerivativesContextIntervalBackfillWindow: () => resolveDerivativesContextIntervalBackfillWindow,
   resolveDerivativesContextIntervals: () => resolveDerivativesContextIntervals,
   resolveDerivativesContextLookbackMs: () => resolveDerivativesContextLookbackMs,
+  resolveDerivativesContextMissingCoverageFetchFromMs: () => resolveDerivativesContextMissingCoverageFetchFromMs,
+  resolveDerivativesContextMissingFetchFromMs: () => resolveDerivativesContextMissingFetchFromMs,
   shouldBackfillDerivativesContextForBacktest: () => shouldBackfillDerivativesContextForBacktest,
   shouldBackfillDerivativesContextForSignals: () => shouldBackfillDerivativesContextForSignals
 });
@@ -57,12 +64,20 @@ var coinalyzeIntervalMap = {
   "15m": "15min",
   "1h": "1hour"
 };
+var derivativesIntervalMs = (interval) => interval === "1h" ? HOUR_MS : 15 * 60 * 1e3;
 var lastRequestTs = 0;
 var asInt = (value, fallback) => {
   const parsed = Number.parseInt(String(value ?? ""), 10);
   return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
 };
 var parseList = (value) => String(value ?? "").split(",").map((item) => item.trim().toUpperCase()).filter(Boolean);
+var parseBooleanFlag = (value, fallback = false) => {
+  const normalized = String(value ?? "").trim().toLowerCase();
+  if (!normalized) return fallback;
+  if (["1", "true", "yes", "on"].includes(normalized)) return true;
+  if (["0", "false", "no", "off"].includes(normalized)) return false;
+  return fallback;
+};
 var normalizeSymbols = (symbols) => [
   ...new Set(
     symbols.map(
@@ -70,7 +85,13 @@ var normalizeSymbols = (symbols) => [
     ).filter(Boolean)
   )
 ];
-var resolveDerivativesContextBackfillSymbols = (_requestedSymbols = []) => [...import_constants.DERIVATIVES_CONTEXT_REFERENCE_SYMBOLS];
+var isDerivativesTargetContextEnabled = () => parseBooleanFlag(process.env.DERIVATIVES_CONTEXT_TARGET_ENABLED, false);
+var resolveDerivativesContextBackfillSymbols = (requestedSymbols = []) => {
+  const referenceSymbols = (0, import_constants.resolveDerivativesContextReferenceSymbols)(
+    process.env.DERIVATIVES_CONTEXT_EXTRA_REFERENCE_SYMBOLS
+  );
+  return isDerivativesTargetContextEnabled() ? normalizeSymbols([...referenceSymbols, ...requestedSymbols]) : referenceSymbols;
+};
 var chunkArray = (items, size) => {
   const chunks = [];
   for (let i = 0; i < items.length; i += size) {
@@ -84,7 +105,7 @@ var isBacktestDerivativesContextEnabled = () => {
 var isSignalsDerivativesContextEnabled = () => isDerivativesContextBackfillEnabled("CRON");
 var isDerivativesContextBackfillEnabled = (env) => {
   const normalized = String(process.env.DERIVATIVES_CONTEXT_ENABLED ?? "").trim().toLowerCase();
-  if (!normalized) return false;
+  if (!normalized) return true;
   if (["1", "true", "yes", "on"].includes(normalized)) {
     return true;
   }
@@ -110,11 +131,18 @@ var resolveDerivativesContextLookbackMs = () => {
   return normalizedHours * HOUR_MS;
 };
 var resolveDerivativesContextBackfillWindow = (params) => {
-  const { startMs, endMs, preloadStartMs, nowMs = Date.now() } = params;
+  const {
+    mode = "signals",
+    startMs,
+    endMs,
+    preloadStartMs,
+    nowMs = Date.now()
+  } = params;
   const safeEndMs = Math.min(endMs, nowMs);
   const safeStartMs = Math.max(0, Math.min(startMs, safeEndMs));
   const lookbackFromMs = safeStartMs - resolveDerivativesContextLookbackMs();
-  const requestedFromMs = preloadStartMs != null ? Math.max(Number(preloadStartMs), lookbackFromMs) : lookbackFromMs;
+  const defaultFromMs = mode === "backtest" ? safeStartMs : lookbackFromMs;
+  const requestedFromMs = mode === "signals" ? defaultFromMs : preloadStartMs ?? defaultFromMs;
   const fromMs = Math.max(
     0,
     Math.min(
@@ -128,6 +156,104 @@ var resolveDerivativesContextBackfillWindow = (params) => {
     testStartMs: Math.trunc(safeStartMs)
   };
 };
+var resolveDerivativesContextIntervalBackfillWindow = (params) => {
+  const intervalMs = derivativesIntervalMs(params.interval);
+  return {
+    fromMs: Math.floor(params.fromMs / intervalMs) * intervalMs,
+    toMs: Math.floor(params.toMs / intervalMs) * intervalMs,
+    intervalMs
+  };
+};
+var resolveDerivativesContextMissingFetchFromMs = (params) => {
+  const min = params.edges?.min;
+  const max = params.edges?.max;
+  if (min == null || max == null) {
+    return params.fromMs;
+  }
+  if (min > params.fromMs) {
+    return params.fromMs;
+  }
+  if (max < params.toMs) {
+    return Math.max(params.fromMs, max + params.intervalMs);
+  }
+  return null;
+};
+var countBackfillWindows = (params) => {
+  let count = 0;
+  let cursor = params.fromMs;
+  while (cursor < params.toMs) {
+    const toMs = Math.min(params.toMs, cursor + params.batchMs);
+    count += 1;
+    cursor = toMs + params.intervalMs;
+  }
+  return count;
+};
+var buildBackfillWindows = (params) => {
+  const windows = [];
+  let cursor = params.fromMs;
+  while (cursor < params.toMs) {
+    const toMs = Math.min(params.toMs, cursor + params.batchMs);
+    windows.push({ fromMs: cursor, toMs });
+    cursor = toMs + params.intervalMs;
+  }
+  return windows;
+};
+var hasDerivativesWindowCoverage = (params) => params.edges?.min != null && params.edges?.max != null && params.edges.min <= params.fromMs && params.edges.max >= params.toMs;
+var hasDerivativesContextCoverageRange = (ranges, fromMs, toMs) => (ranges ?? []).some(
+  (range) => Number.isFinite(range.fromMs) && Number.isFinite(range.toMs) && range.fromMs <= fromMs && range.toMs >= toMs
+);
+var resolveDerivativesContextMissingCoverageFetchFromMs = (params) => {
+  const ranges = (params.ranges ?? []).filter(
+    (range) => Number.isFinite(range.fromMs) && Number.isFinite(range.toMs)
+  ).sort((a, b) => a.fromMs - b.fromMs);
+  let coveredUntil;
+  for (const range of ranges) {
+    if (range.toMs < params.fromMs) {
+      continue;
+    }
+    if (coveredUntil == null) {
+      if (range.fromMs > params.fromMs) {
+        return params.fromMs;
+      }
+      coveredUntil = range.toMs;
+      if (coveredUntil >= params.toMs) {
+        return null;
+      }
+      continue;
+    }
+    if (range.fromMs > coveredUntil + params.intervalMs) {
+      break;
+    }
+    coveredUntil = Math.max(coveredUntil, range.toMs);
+    if (coveredUntil >= params.toMs) {
+      return null;
+    }
+  }
+  if (coveredUntil == null) {
+    return params.fromMs;
+  }
+  return Math.max(params.fromMs, coveredUntil + params.intervalMs);
+};
+var groupDerivativesContextMissingFetchRanges = (ranges) => {
+  const groups = /* @__PURE__ */ new Map();
+  for (const range of ranges) {
+    const fromMs = Math.trunc(range.fromMs);
+    const items = groups.get(fromMs) ?? [];
+    items.push(range.item);
+    groups.set(fromMs, items);
+  }
+  return [...groups.entries()].sort(([a], [b]) => a - b).map(([fromMs, items]) => ({ fromMs, items }));
+};
+var coverageKey = (params) => [
+  params.symbol.trim().toUpperCase(),
+  params.interval,
+  Math.trunc(params.fromMs),
+  Math.trunc(params.toMs)
+].join(":");
+var extendEdges = (current, fromMs, toMs) => ({
+  min: current?.min == null ? fromMs : Math.min(current.min, Math.trunc(fromMs)),
+  max: current?.max == null ? toMs : Math.max(current.max, Math.trunc(toMs))
+});
 var getCoinalyzeApiKey = async (userName) => {
   const settings = await (0, import_userSettings.getUserSettings)(userName);
   return settings.COINALYZE_API_KEY.trim() || String(process.env.COINALYZE_API_KEY ?? "").trim();
@@ -141,10 +267,67 @@ var getRequestDelayMs = () => Math.max(
   )
 );
 var getRequestTimeoutMs = () => Math.max(5e3, asInt(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 = getRequestDelayMs();
   const requestTimeoutMs = getRequestTimeoutMs();
   const maxRetries = asInt(process.env.COINALYZE_MAX_RETRIES, 4);
+  let lastError = null;
   for (let attempt = 0; attempt <= maxRetries; attempt += 1) {
     const waitMs = Math.max(0, lastRequestTs + requestDelayMs - Date.now());
     if (waitMs > 0) {
@@ -165,12 +348,19 @@ var fetchJsonWithRateLimit = async (url, apiKey) => {
       });
     } catch (error) {
       clearTimeout(timer);
-      const abortError = error instanceof Error && (error.name === "AbortError" || String(error.message).toLowerCase().includes("aborted"));
-      if (attempt < maxRetries && abortError) {
+      lastError = error;
+      if (attempt < maxRetries && isRetryableCoinalyzeFetchError(error)) {
         await (0, import_async.delay)(Math.min(12e3, 800 * 2 ** attempt));
         continue;
       }
-      throw error;
+      throw new Error(
+        formatCoinalyzeRequestError({
+          url,
+          error,
+          attempts: attempt + 1,
+          timeoutMs: requestTimeoutMs
+        })
+      );
     } finally {
       clearTimeout(timer);
     }
@@ -187,7 +377,14 @@ var fetchJsonWithRateLimit = async (url, apiKey) => {
     }
     throw new Error(`Coinalyze ${response.status}: ${text}`);
   }
-  throw new Error("Coinalyze request failed after retries");
+  throw new Error(
+    formatCoinalyzeRequestError({
+      url,
+      error: lastError,
+      attempts: maxRetries + 1,
+      timeoutMs: requestTimeoutMs
+    })
+  );
 };
 var fetchCoinalyzeMarkets = async (apiKey) => {
   const raw = await fetchJsonWithRateLimit(
@@ -292,7 +489,7 @@ var skippedBackfillResult = () => ({
   failedWindows: 0,
   skippedWindows: 0
 });
-var backfillDerivativesContext = async (params, enabled) => {
+var backfillDerivativesContext = async (params, enabled, mode) => {
   const { userName, startMs, endMs } = params;
   const requestedSymbols = normalizeSymbols(params.symbols);
   const symbols = resolveDerivativesContextBackfillSymbols(requestedSymbols);
@@ -303,17 +500,12 @@ var backfillDerivativesContext = async (params, enabled) => {
   if (!intervals.length) {
     return skippedBackfillResult();
   }
-  const apiKey = await getCoinalyzeApiKey(userName);
-  if (!apiKey) {
-    throw new Error(
-      `Missing COINALYZE_API_KEY for derivatives context backfill (user=${userName})`
-    );
-  }
   const {
     fromMs,
     toMs: safeEndMs,
     testStartMs: safeStartMs
   } = resolveDerivativesContextBackfillWindow({
+    mode,
     startMs,
     endMs,
     preloadStartMs: params.preloadStartMs
@@ -321,6 +513,129 @@ var backfillDerivativesContext = async (params, enabled) => {
   if (safeEndMs <= fromMs) {
     return skippedBackfillResult();
   }
+  const batchDays = asInt(
+    process.env.DERIVATIVES_CONTEXT_BACKFILL_BATCH_DAYS,
+    30
+  );
+  const batchMs = batchDays * DAY_MS;
+  const intervalWindows = intervals.map((interval) => ({
+    interval,
+    ...resolveDerivativesContextIntervalBackfillWindow({
+      fromMs,
+      toMs: safeEndMs,
+      interval
+    })
+  })).filter((item) => item.toMs > item.fromMs);
+  if (!intervalWindows.length) {
+    return skippedBackfillResult();
+  }
+  await (0, import_timescale.waitForDbReady)();
+  const edgesByInterval = /* @__PURE__ */ new Map();
+  await Promise.all(
+    intervalWindows.map(async ({ interval }) => {
+      edgesByInterval.set(
+        interval,
+        await (0, import_timescale.getDerivativesDataEdgesForSymbols)(symbols, interval)
+      );
+    })
+  );
+  const coverageKeysByInterval = /* @__PURE__ */ new Map();
+  const coverageRangesByInterval = /* @__PURE__ */ new Map();
+  await Promise.all(
+    intervalWindows.map(async (window) => {
+      const coverageRows = await (0, import_timescale.getDerivativesBackfillCoverage)({
+        source: "coinalyze",
+        symbols,
+        interval: window.interval,
+        fromMs: window.fromMs,
+        toMs: window.toMs
+      });
+      coverageKeysByInterval.set(
+        window.interval,
+        new Set(
+          coverageRows.map(
+            (row) => coverageKey({
+              symbol: row.symbol,
+              interval: row.interval,
+              fromMs: row.fromMs,
+              toMs: row.toMs
+            })
+          )
+        )
+      );
+      const rangesBySymbol = /* @__PURE__ */ new Map();
+      for (const row of coverageRows) {
+        const symbol = row.symbol.toUpperCase();
+        const ranges = rangesBySymbol.get(symbol) ?? [];
+        ranges.push({ fromMs: row.fromMs, toMs: row.toMs });
+        rangesBySymbol.set(symbol, ranges);
+      }
+      coverageRangesByInterval.set(window.interval, rangesBySymbol);
+    })
+  );
+  const cachedWindows = intervalWindows.reduce(
+    (sum, window) => sum + countBackfillWindows({
+      fromMs: window.fromMs,
+      toMs: window.toMs,
+      batchMs,
+      intervalMs: window.intervalMs
+    }),
+    0
+  );
+  const allBackfillWindowsCached = intervalWindows.every((window) => {
+    const edgesBySymbol = edgesByInterval.get(window.interval);
+    const coverageKeys = coverageKeysByInterval.get(window.interval);
+    const backfillWindows = buildBackfillWindows({
+      fromMs: window.fromMs,
+      toMs: window.toMs,
+      batchMs,
+      intervalMs: window.intervalMs
+    });
+    return symbols.every(
+      (symbol) => backfillWindows.every((backfillWindow) => {
+        const normalizedSymbol = symbol.toUpperCase();
+        const coverageRanges = coverageRangesByInterval.get(window.interval)?.get(normalizedSymbol) ?? [];
+        return hasDerivativesWindowCoverage({
+          edges: edgesBySymbol?.get(normalizedSymbol),
+          fromMs: backfillWindow.fromMs,
+          toMs: backfillWindow.toMs
+        }) || resolveDerivativesContextMissingCoverageFetchFromMs({
+          ranges: coverageRanges,
+          fromMs: backfillWindow.fromMs,
+          toMs: backfillWindow.toMs,
+          intervalMs: window.intervalMs
+        }) == null || coverageKeys?.has(
+          coverageKey({
+            symbol: normalizedSymbol,
+            interval: window.interval,
+            fromMs: backfillWindow.fromMs,
+            toMs: backfillWindow.toMs
+          })
+        );
+      })
+    );
+  });
+  if (allBackfillWindowsCached) {
+    console.log(
+      import_chalk.default.gray(
+        `derivatives context backfill: cached symbols=${symbols.length}, requestedSymbols=${requestedSymbols.length}, intervals=${intervals.join(",")}, window=${new Date(fromMs).toISOString()}..${new Date(safeEndMs).toISOString()}`
+      )
+    );
+    return {
+      skipped: false,
+      rows: 0,
+      matchedSymbols: symbols.length,
+      unmatchedSymbols: 0,
+      failedWindows: 0,
+      skippedWindows: cachedWindows
+    };
+  }
+  const apiKey = await getCoinalyzeApiKey(userName);
+  if (!apiKey) {
+    throw new Error(
+      `Missing COINALYZE_API_KEY for derivatives context backfill (user=${userName})`
+    );
+  }
   const exchangePriority = parseList(
     process.env.COINALYZE_EXCHANGE_PRIORITY || process.env.DERIVATIVES_CONTEXT_EXCHANGE_PRIORITY || "A,6,0"
   );
@@ -335,21 +650,24 @@ var backfillDerivativesContext = async (params, enabled) => {
   );
   if (!matches.length) {
     throw new Error(
-      "No matched derivatives reference symbols between BTC/ETH and Coinalyze"
+      "No matched derivatives context symbols between requested symbols and Coinalyze"
     );
   }
-  await (0, import_timescale.waitForDbReady)();
-  const batchDays = asInt(
-    process.env.DERIVATIVES_CONTEXT_BACKFILL_BATCH_DAYS,
-    30
-  );
   const symbolBatchSize = asInt(
     process.env.DERIVATIVES_CONTEXT_BACKFILL_SYMBOL_BATCH_SIZE,
     8
   );
   const symbolBatches = chunkArray(matches, symbolBatchSize);
-  const windowsPerPair = Math.ceil((safeEndMs - fromMs) / (batchDays * DAY_MS));
-  const totalWindows = symbolBatches.length * intervals.length * windowsPerPair;
+  const windowsPerPair = intervalWindows.reduce(
+    (sum, window) => sum + countBackfillWindows({
+      fromMs: window.fromMs,
+      toMs: window.toMs,
+      batchMs,
+      intervalMs: window.intervalMs
+    }),
+    0
+  );
+  const totalWindows = symbolBatches.length * windowsPerPair;
   const bar = new import_progress.default(
     ":current/:total [:bar][:percent] :eta(s) :batch rows=:rows fail=:fail skip=:skip",
     {
@@ -365,68 +683,148 @@ var backfillDerivativesContext = async (params, enabled) => {
   let skippedWindows = 0;
   console.log(
     import_chalk.default.cyan(
-      `derivatives context backfill: referenceSymbols=${matches.length}, requestedSymbols=${requestedSymbols.length}, unmatched=${unmatched.length}, intervals=${intervals.join(",")}, window=${new Date(fromMs).toISOString()}..${new Date(safeEndMs).toISOString()}, testStart=${new Date(safeStartMs).toISOString()}`
+      `derivatives context backfill: symbols=${matches.length}, requestedSymbols=${requestedSymbols.length}, unmatched=${unmatched.length}, intervals=${intervals.join(",")}, window=${new Date(fromMs).toISOString()}..${new Date(safeEndMs).toISOString()}, testStart=${new Date(safeStartMs).toISOString()}`
     )
   );
-  for (const interval of intervals) {
-    const edgesBySymbol = await (0, import_timescale.getDerivativesDataEdgesForSymbols)(
+  for (const window of intervalWindows) {
+    const { interval, intervalMs } = window;
+    const edgesBySymbol = edgesByInterval.get(interval) ?? await (0, import_timescale.getDerivativesDataEdgesForSymbols)(
       matches.map((item) => item.symbol),
       interval
     );
+    const coverageKeys = coverageKeysByInterval.get(interval) ?? /* @__PURE__ */ new Set();
+    coverageKeysByInterval.set(interval, coverageKeys);
+    const coverageRangesBySymbol = coverageRangesByInterval.get(interval) ?? /* @__PURE__ */ new Map();
+    coverageRangesByInterval.set(interval, coverageRangesBySymbol);
     for (let batchIdx = 0; batchIdx < symbolBatches.length; batchIdx += 1) {
       const batch = symbolBatches[batchIdx];
-      let cursor = fromMs;
-      while (cursor < safeEndMs) {
-        const toMs = Math.min(safeEndMs, cursor + batchDays * DAY_MS);
-        const missingBatch = batch.filter((item) => {
-          const edges = edgesBySymbol.get(item.symbol.toUpperCase());
-          return edges?.min == null || edges?.max == null || edges.min > cursor || edges.max < toMs;
-        });
+      let cursor = window.fromMs;
+      while (cursor < window.toMs) {
+        const toMs = Math.min(window.toMs, cursor + batchMs);
+        const missingRanges = batch.map((item) => {
+          const key = coverageKey({
+            symbol: item.symbol,
+            interval,
+            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) };
+        }).filter(
+          (item) => item != null
+        );
         try {
-          if (!missingBatch.length) {
+          if (!missingRanges.length) {
             skippedWindows += 1;
           } else {
-            const marketSymbols = missingBatch.map((item) => item.marketSymbol);
-            const oiMap = await fetchMetricBatch({
-              endpoint: oiPath,
-              metric: "oi",
-              marketSymbols,
-              apiKey,
-              interval,
-              fromMs: cursor,
-              toMs
-            });
-            const fundingMap = await fetchMetricBatch({
-              endpoint: fundingPath,
-              metric: "funding",
-              marketSymbols,
-              apiKey,
-              interval,
-              fromMs: cursor,
-              toMs
-            });
-            const liqMap = await fetchMetricBatch({
-              endpoint: liqPath,
-              metric: "liq",
-              marketSymbols,
-              apiKey,
-              interval,
-              fromMs: cursor,
-              toMs
-            });
-            const rows = missingBatch.flatMap((item) => {
-              const marketSymbol = item.marketSymbol.toUpperCase();
-              const points = (0, import_indicators.mergeCoinalyzeMetrics)({
-                symbol: item.symbol,
-                oiRaw: oiMap.get(marketSymbol) ?? [],
-                fundingRaw: fundingMap.get(marketSymbol) ?? [],
-                liqRaw: liqMap.get(marketSymbol) ?? []
+            const groupedMissingRanges = groupDerivativesContextMissingFetchRanges(missingRanges);
+            for (const group of groupedMissingRanges) {
+              const missingBatch = group.items;
+              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
               });
-              return (0, import_indicators.coinalyzePointsToRows)(points, interval, "coinalyze");
-            });
-            if (rows.length) {
-              await (0, import_timescale.upsertDerivatives)(rows);
-              totalRows += rows.length;
+              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) ?? []
+                });
+                return (0, import_indicators.coinalyzePointsToRows)(points, interval, "coinalyze");
+              });
+              if (rows.length) {
+                await (0, import_timescale.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
+                };
+              });
+              await (0, import_timescale.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);
+              }
             }
           }
         } catch (error) {
@@ -446,7 +844,7 @@ var backfillDerivativesContext = async (params, enabled) => {
             skip: skippedWindows
           });
         }
-        cursor = toMs + 1;
+        cursor = toMs + intervalMs;
       }
     }
   }
@@ -470,18 +868,33 @@ var backfillDerivativesContext = async (params, enabled) => {
     skippedWindows
   };
 };
-var backfillDerivativesContextForBacktest = async (params) => backfillDerivativesContext(params, isBacktestDerivativesContextEnabled());
-var backfillDerivativesContextForSignals = async (params) => backfillDerivativesContext(params, isSignalsDerivativesContextEnabled());
+var backfillDerivativesContextForBacktest = async (params) => backfillDerivativesContext(
+  params,
+  isBacktestDerivativesContextEnabled(),
+  "backtest"
+);
+var backfillDerivativesContextForSignals = async (params) => backfillDerivativesContext(
+  params,
+  isSignalsDerivativesContextEnabled(),
+  "signals"
+);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   backfillDerivativesContextForBacktest,
   backfillDerivativesContextForSignals,
+  formatCoinalyzeRequestError,
+  groupDerivativesContextMissingFetchRanges,
+  hasDerivativesContextCoverageRange,
   isBacktestDerivativesContextEnabled,
+  isDerivativesTargetContextEnabled,
   isSignalsDerivativesContextEnabled,
   resolveDerivativesContextBackfillSymbols,
   resolveDerivativesContextBackfillWindow,
+  resolveDerivativesContextIntervalBackfillWindow,
   resolveDerivativesContextIntervals,
   resolveDerivativesContextLookbackMs,
+  resolveDerivativesContextMissingCoverageFetchFromMs,
+  resolveDerivativesContextMissingFetchFromMs,
   shouldBackfillDerivativesContextForBacktest,
   shouldBackfillDerivativesContextForSignals
 });