@tradejs/cli 2.0.18 → 2.0.20

package/dist/lib/aiPocketSearchCli.js

@@ -22,9 +22,96 @@ var aiPocketSearchCli_exports = {};
 __export(aiPocketSearchCli_exports, {
   AI_POCKET_SEARCH_CLI_DECIMAL_DEFAULTS: () => AI_POCKET_SEARCH_CLI_DECIMAL_DEFAULTS,
   readAiPocketSearchCliOption: () => readAiPocketSearchCliOption,
+  resolveAiPocketCadenceProfile: () => resolveAiPocketCadenceProfile,
+  sealAiPocketTestPartition: () => sealAiPocketTestPartition,
+  splitAiPocketCoverageRowsByTimestamp: () => splitAiPocketCoverageRowsByTimestamp,
   splitAiPocketResearchRowsByTimestamp: () => splitAiPocketResearchRowsByTimestamp
 });
 module.exports = __toCommonJS(aiPocketSearchCli_exports);
+var DAY_MS = 24 * 60 * 60 * 1e3;
+var DEFAULT_MIN_SUPPORT = 20;
+var LOW_CADENCE_EVENT_LIMIT = 200;
+var LOW_CADENCE_MAX_EVENT_SHARE = 1 / 3;
+var countIndependentEvents = (rows) => {
+  const timestampEvents = /* @__PURE__ */ new Set();
+  let rowsWithoutTimestamp = 0;
+  for (const row of rows) {
+    if (typeof row.timestamp === "number" && Number.isFinite(row.timestamp)) {
+      timestampEvents.add(row.timestamp);
+    } else {
+      rowsWithoutTimestamp += 1;
+    }
+  }
+  return timestampEvents.size + rowsWithoutTimestamp;
+};
+var getPeriodDays = (rows) => {
+  let minTimestamp = null;
+  let maxTimestamp = null;
+  for (const row of rows) {
+    const timestamp = row.timestamp;
+    if (typeof timestamp !== "number" || !Number.isFinite(timestamp)) {
+      continue;
+    }
+    minTimestamp = minTimestamp == null ? timestamp : Math.min(minTimestamp, timestamp);
+    maxTimestamp = maxTimestamp == null ? timestamp : Math.max(maxTimestamp, timestamp);
+  }
+  if (minTimestamp == null || maxTimestamp == null) {
+    return null;
+  }
+  return Math.max((maxTimestamp - minTimestamp) / DAY_MS, 1);
+};
+var clampInt = (value, minimum, maximum) => Math.max(minimum, Math.min(maximum, Math.ceil(value)));
+var resolveAiPocketCadenceProfile = ({
+  trainRows,
+  validationRows = [],
+  testRows = [],
+  mode = "auto",
+  validationSplit = 0.25,
+  minSupport,
+  minEvents,
+  minValidationSupport,
+  minValidationEvents,
+  maxEventCountShare = 0.25,
+  explicitMaxEventCountShare = false
+}) => {
+  const trainEvents = countIndependentEvents(trainRows);
+  const validationEvents = countIndependentEvents(validationRows);
+  const testEvents = countIndependentEvents(testRows);
+  const trainPeriodDays = getPeriodDays(trainRows);
+  const trainEventsPerDay = trainPeriodDays == null ? null : trainEvents / trainPeriodDays;
+  const sparseSample = trainEvents < LOW_CADENCE_EVENT_LIMIT;
+  const lowCadence = trainEventsPerDay != null && trainEventsPerDay < 0.25;
+  const adaptiveSample = mode === "auto" && sparseSample;
+  const adaptiveThresholds = adaptiveSample && (minSupport == null || minEvents == null || validationRows.length > 0 && (minValidationSupport == null || minValidationEvents == null) || !explicitMaxEventCountShare);
+  const resolvedMinSupport = minSupport ?? (adaptiveSample ? clampInt(trainEvents * 0.1, 3, DEFAULT_MIN_SUPPORT) : DEFAULT_MIN_SUPPORT);
+  const resolvedMinEvents = minEvents ?? (minSupport != null || !adaptiveSample ? Math.max(5, Math.ceil(resolvedMinSupport * 0.5)) : clampInt(resolvedMinSupport * 0.5, 3, 10));
+  const hasValidation = validationRows.length > 0;
+  const resolvedMinValidationSupport = minValidationSupport ?? (hasValidation ? Math.max(3, Math.ceil(resolvedMinSupport * validationSplit * 0.5)) : 0);
+  const resolvedMinValidationEvents = minValidationEvents ?? (hasValidation ? Math.max(
+    adaptiveSample ? 3 : 2,
+    Math.ceil(resolvedMinEvents * validationSplit * 0.5)
+  ) : 0);
+  const resolvedMaxEventCountShare = adaptiveSample && !explicitMaxEventCountShare ? Math.max(maxEventCountShare, LOW_CADENCE_MAX_EVENT_SHARE) : maxEventCountShare;
+  return {
+    mode,
+    lowCadence,
+    sparseSample,
+    adaptiveThresholds,
+    trainRows: trainRows.length,
+    trainEvents,
+    trainPeriodDays,
+    trainEventsPerDay,
+    validationRows: validationRows.length,
+    validationEvents,
+    testRows: testRows.length,
+    testEvents,
+    minSupport: resolvedMinSupport,
+    minEvents: resolvedMinEvents,
+    minValidationSupport: resolvedMinValidationSupport,
+    minValidationEvents: resolvedMinValidationEvents,
+    maxEventCountShare: resolvedMaxEventCountShare
+  };
+};
 var AI_POCKET_SEARCH_CLI_DECIMAL_DEFAULTS = {
   minProfitFactor: "1.2",
   minWinRate: "0",
@@ -71,6 +158,29 @@ var splitAiPocketResearchRowsByTimestamp = (rows, validationSplit, testSplit = 0
     testRows: rows.filter((row) => isIn(testTimestamps, row.timestamp))
   };
 };
+var splitAiPocketCoverageRowsByTimestamp = (rows, family, validationSplit, testSplit = 0) => splitAiPocketResearchRowsByTimestamp(
+  rows.filter((row) => row.featureCoverage?.[family] === true),
+  validationSplit,
+  testSplit
+);
+var sealAiPocketTestPartition = (split, sealed) => {
+  const finiteTimestamps = split.testRows.map((row) => row.timestamp).filter((timestamp) => Number.isFinite(timestamp));
+  return {
+    discoveryRows: [
+      ...split.trainRows,
+      ...split.validationRows,
+      ...sealed ? [] : split.testRows
+    ],
+    searchTestRows: sealed ? [] : split.testRows,
+    evidence: {
+      sealed,
+      rows: split.testRows.length,
+      events: countIndependentEvents(split.testRows),
+      startTimestamp: finiteTimestamps.length ? Math.min(...finiteTimestamps) : null,
+      endTimestamp: finiteTimestamps.length ? Math.max(...finiteTimestamps) : null
+    }
+  };
+};
 var readAiPocketSearchCliOption = ({
   argv,
   longName,
@@ -92,5 +202,8 @@ var readAiPocketSearchCliOption = ({
 0 && (module.exports = {
   AI_POCKET_SEARCH_CLI_DECIMAL_DEFAULTS,
   readAiPocketSearchCliOption,
+  resolveAiPocketCadenceProfile,
+  sealAiPocketTestPartition,
+  splitAiPocketCoverageRowsByTimestamp,
   splitAiPocketResearchRowsByTimestamp
 });

package/dist/lib/aiTrainCharts.js

@@ -20,6 +20,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/lib/aiTrainCharts.ts
 var aiTrainCharts_exports = {};
 __export(aiTrainCharts_exports, {
+  buildAiChartPersistenceReceipt: () => buildAiChartPersistenceReceipt,
   buildAiChartSnapshot: () => buildAiChartSnapshot
 });
 module.exports = __toCommonJS(aiTrainCharts_exports);
@@ -303,7 +304,10 @@ var getDirectionSortKey = (direction) => {
   return 2;
 };
 var summarizeAiTrainEvaluationsByDirection = (evaluations) => {
-  const grouped = /* @__PURE__ */ new Map();
+  const grouped = /* @__PURE__ */ new Map([
+    ["LONG", []],
+    ["SHORT", []]
+  ]);
   for (const evaluation of evaluations) {
     const direction = typeof evaluation.direction === "string" && evaluation.direction.trim() ? evaluation.direction : "UNKNOWN";
     const bucket = grouped.get(direction) ?? [];
@@ -752,7 +756,16 @@ var buildAiChartSnapshot = (params) => {
     strategies: cards
   };
 };
+var buildAiChartPersistenceReceipt = (params) => ({
+  persisted: true,
+  mode: params.snapshot.mode,
+  datasetId: params.datasetId,
+  generatedAt: params.snapshot.generatedAt,
+  cardIds: params.snapshot.strategies.map((card) => card.cardId),
+  ttlMs: params.ttlMs
+});
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  buildAiChartPersistenceReceipt,
   buildAiChartSnapshot
 });

package/dist/lib/aiTrainMetrics.js

@@ -314,7 +314,10 @@ var isDirectionMatchAtThreshold = (evaluation, threshold) => {
   return directionMatches === true && evaluation.quality != null && evaluation.quality >= threshold;
 };
 var summarizeAiTrainEvaluationsByDirection = (evaluations) => {
-  const grouped = /* @__PURE__ */ new Map();
+  const grouped = /* @__PURE__ */ new Map([
+    ["LONG", []],
+    ["SHORT", []]
+  ]);
   for (const evaluation of evaluations) {
     const direction = typeof evaluation.direction === "string" && evaluation.direction.trim() ? evaluation.direction : "UNKNOWN";
     const bucket = grouped.get(direction) ?? [];

package/dist/lib/aiTrainResearch.js

@@ -39,9 +39,9 @@ __export(aiTrainResearch_exports, {
 });
 module.exports = __toCommonJS(aiTrainResearch_exports);
 var import_node_child_process = require("child_process");
-var import_node_crypto = require("crypto");
-var import_promises = __toESM(require("fs/promises"));
-var import_node_path = __toESM(require("path"));
+var import_node_crypto2 = require("crypto");
+var import_promises2 = __toESM(require("fs/promises"));
+var import_node_path2 = __toESM(require("path"));
 
 // src/lib/aiTrainMetrics.ts
 var divideOrNull = (num, denom) => {
@@ -312,10 +312,82 @@ var summarizeAiTrainEvaluations = (evaluations) => {
     )
   };
 };
+var getDirectionSortKey = (direction) => {
+  if (direction === "LONG") {
+    return 0;
+  }
+  if (direction === "SHORT") {
+    return 1;
+  }
+  return 2;
+};
+var summarizeAiTrainEvaluationsByDirection = (evaluations) => {
+  const grouped = /* @__PURE__ */ new Map([
+    ["LONG", []],
+    ["SHORT", []]
+  ]);
+  for (const evaluation of evaluations) {
+    const direction = typeof evaluation.direction === "string" && evaluation.direction.trim() ? evaluation.direction : "UNKNOWN";
+    const bucket = grouped.get(direction) ?? [];
+    bucket.push(evaluation);
+    grouped.set(direction, bucket);
+  }
+  return [...grouped.entries()].sort(
+    ([leftDirection], [rightDirection]) => getDirectionSortKey(leftDirection) - getDirectionSortKey(rightDirection) || leftDirection.localeCompare(rightDirection)
+  ).map(([direction, directionEvaluations]) => ({
+    direction,
+    summary: summarizeAiTrainEvaluations(directionEvaluations)
+  }));
+};
 
 // src/lib/aiTrainResearch.ts
 var import_strategies = require("@tradejs/node/strategies");
 var import_types = require("@tradejs/types");
+
+// src/lib/strategyGateFingerprint.ts
+var import_node_crypto = require("crypto");
+var import_promises = __toESM(require("fs/promises"));
+var import_node_path = __toESM(require("path"));
+var gateFingerprintRelativePaths = (strategyName) => [
+  `packages/strategies/src/${strategyName}/adapters/ai.ts`,
+  `packages/strategies/src/${strategyName}/guardrails.ts`,
+  `packages/strategies/src/${strategyName}/pockets.ts`,
+  `packages/strategies/src/${strategyName}/config.ts`,
+  "packages/strategies/src/shared/localAiGate.ts",
+  "packages/node/src/ai.ts",
+  "packages/core/src/utils/strategyHelpers/signalBuilders.ts"
+];
+var resolveStrategyGateFingerprint = async ({
+  projectRoot,
+  strategyName,
+  gitSha
+}) => {
+  const candidates = await Promise.all(
+    gateFingerprintRelativePaths(strategyName).map(async (relativePath) => {
+      const content = await import_promises.default.readFile(import_node_path.default.join(projectRoot, relativePath)).catch(() => null);
+      return content == null ? null : { relativePath, content };
+    })
+  );
+  const sourceEntries = candidates.filter(
+    (entry) => entry != null
+  );
+  const hash = (0, import_node_crypto.createHash)("sha256");
+  hash.update(strategyName);
+  if (sourceEntries.length) {
+    for (const entry of sourceEntries) {
+      hash.update(entry.relativePath);
+      hash.update(entry.content);
+    }
+  } else {
+    hash.update(gitSha ?? "unknown-git-sha");
+  }
+  return {
+    gateFingerprint: hash.digest("hex").slice(0, 16),
+    gateFingerprintFiles: sourceEntries.map((entry) => entry.relativePath)
+  };
+};
+
+// src/lib/aiTrainResearch.ts
 var DAY_MS2 = 24 * 60 * 60 * 1e3;
 var RESEARCH_CONTEXT_ENV_KEYS = [
   "AI_MODE",
@@ -355,9 +427,9 @@ var writeAiTrainResearchSnapshot = async ({
   outputPath,
   result
 }) => {
-  const resolvedPath = import_node_path.default.resolve(outputPath);
-  await import_promises.default.mkdir(import_node_path.default.dirname(resolvedPath), { recursive: true });
-  await import_promises.default.writeFile(
+  const resolvedPath = import_node_path2.default.resolve(outputPath);
+  await import_promises2.default.mkdir(import_node_path2.default.dirname(resolvedPath), { recursive: true });
+  await import_promises2.default.writeFile(
     resolvedPath,
     `${JSON.stringify(result, null, 2)}
 `,
@@ -376,7 +448,7 @@ var normalizeForStableJson = (value) => {
   }
   return value;
 };
-var fingerprintResearchValue = (value) => (0, import_node_crypto.createHash)("sha256").update(JSON.stringify(normalizeForStableJson(value))).digest("hex").slice(0, 16);
+var fingerprintResearchValue = (value) => (0, import_node_crypto2.createHash)("sha256").update(JSON.stringify(normalizeForStableJson(value))).digest("hex").slice(0, 16);
 var getTimestampRange = (evaluations) => {
   let minTimestamp = null;
   let maxTimestamp = null;
@@ -441,17 +513,11 @@ var summarizeAiTrainTerminalWindows = (evaluations, windowDays) => {
       selected: selected.length,
       approvedPerCalendarDay: outcome.approved / coverageDays,
       outcome,
+      byDirection: summarizeAiTrainEvaluationsByDirection(selected),
       topRejectReasons: summarizeAiTrainRejectReasons(selected)
     };
   });
 };
-var readOptionalFile = async (filePath) => {
-  try {
-    return await import_promises.default.readFile(filePath);
-  } catch {
-    return null;
-  }
-};
 var getGitLineage = (projectRoot) => {
   try {
     const gitSha = (0, import_node_child_process.execFileSync)("git", ["rev-parse", "HEAD"], {
@@ -473,53 +539,20 @@ var getGitLineage = (projectRoot) => {
     return { gitSha: null, gitDirty: null };
   }
 };
-var resolveGateFingerprint = async (projectRoot, strategyName, gitSha) => {
-  const relativeCandidates = [
-    `packages/strategies/src/${strategyName}/adapters/ai.ts`,
-    `packages/strategies/src/${strategyName}/guardrails.ts`,
-    `packages/strategies/src/${strategyName}/pockets.ts`,
-    `packages/strategies/src/${strategyName}/config.ts`,
-    "packages/strategies/src/shared/localAiGate.ts",
-    "packages/node/src/ai.ts"
-  ];
-  const optionalSourceEntries = await Promise.all(
-    relativeCandidates.map(async (relativePath) => {
-      const content = await readOptionalFile(
-        import_node_path.default.join(projectRoot, relativePath)
-      );
-      return content == null ? null : { relativePath, content };
-    })
-  );
-  const sourceEntries = [];
-  for (const entry of optionalSourceEntries) {
-    if (entry != null) {
-      sourceEntries.push(entry);
-    }
-  }
-  const hash = (0, import_node_crypto.createHash)("sha256");
-  hash.update(strategyName);
-  if (sourceEntries.length) {
-    for (const entry of sourceEntries) {
-      hash.update(entry.relativePath);
-      hash.update(entry.content);
-    }
-  } else {
-    hash.update(gitSha ?? "unknown-git-sha");
-  }
-  return {
-    gateFingerprint: hash.digest("hex").slice(0, 16),
-    gateFingerprintFiles: sourceEntries.map((entry) => entry.relativePath)
-  };
-};
 var buildAiTrainLineage = async ({
   projectRoot,
   strategyName,
   configIds,
   runContext,
+  sourceSha256s = [],
   env = process.env
 }) => {
   const { gitSha, gitDirty } = getGitLineage(projectRoot);
-  const gate = await resolveGateFingerprint(projectRoot, strategyName, gitSha);
+  const gate = await resolveStrategyGateFingerprint({
+    projectRoot,
+    strategyName,
+    gitSha
+  });
   const normalizedConfigIds = [...new Set(configIds.filter(Boolean))].sort();
   const hyperliquidPerpUniverseFingerprint = typeof import_strategies.getHyperliquidPerpUniverseSnapshot === "function" ? (0, import_strategies.getHyperliquidPerpUniverseSnapshot)().fingerprint : null;
   const hyperliquidWhaleRegistryFingerprint = typeof import_strategies.getHyperliquidWhaleRegistrySnapshot === "function" ? (0, import_strategies.getHyperliquidWhaleRegistrySnapshot)().fingerprint : null;
@@ -539,7 +572,8 @@ var buildAiTrainLineage = async ({
     configIdsFingerprint: fingerprintResearchValue(normalizedConfigIds),
     configIds: normalizedConfigIds,
     contextFingerprint: fingerprintResearchValue(context),
-    context
+    context,
+    sourceSha256s: [...new Set(sourceSha256s.filter(Boolean))].sort()
   };
 };
 // Annotate the CommonJS export names for ESM import in node:

package/dist/lib/binanceMarketContextBackfill.js

@@ -47,7 +47,8 @@ var import_chalk = __toESM(require("chalk"));
 var import_connectors = require("@tradejs/connectors");
 var import_connectors2 = require("@tradejs/node/connectors");
 var import_strategies = require("@tradejs/node/strategies");
-var import_timescale = require("@tradejs/infra/timescale");
+var import_marketContext = require("@tradejs/infra/timescale/marketContext");
+var import_client = require("@tradejs/infra/timescale/client");
 
 // src/lib/binanceMarketData.ts
 var MARKET_FEATURE_INTERVAL_MS = {
@@ -555,7 +556,7 @@ var backfillBinanceMarketContext = async (params, enabled) => {
   if (endMs <= Math.min(breadthStartMs, tradeFlowStartMs)) {
     return skippedBackfillResult();
   }
-  await (0, import_timescale.waitForDbReady)();
+  await (0, import_client.waitForDbReady)();
   const connector = await getBinanceConnector({
     projectRoot: params.projectRoot,
     userName: params.userName
@@ -601,7 +602,7 @@ var backfillBinanceMarketContext = async (params, enabled) => {
     )
   );
   if (includeTradeFlow && referenceSymbols.length) {
-    const coverage = await (0, import_timescale.getMarketTradeFlowCoverage)({
+    const coverage = await (0, import_marketContext.getMarketTradeFlowCoverage)({
       symbols: referenceSymbols,
       interval,
       startMs: tradeFlowStartMs,
@@ -685,7 +686,7 @@ var backfillBinanceMarketContext = async (params, enabled) => {
           const ts = row.ts.getTime();
           return ts >= chunk.startMs && ts <= chunk.endMs;
         });
-        await (0, import_timescale.upsertMarketTradeFlowRows)(boundedRows);
+        await (0, import_marketContext.upsertMarketTradeFlowRows)(boundedRows);
         tradeFlowRows += boundedRows.length;
         chunkBar?.tick(1, {
           rows: tradeFlowRows,
@@ -713,7 +714,7 @@ var backfillBinanceMarketContext = async (params, enabled) => {
     });
     const plans = await Promise.all(
       breadthUniverses.map(async (definition) => {
-        const coverage = await (0, import_timescale.getMarketBreadthCoverage)({
+        const coverage = await (0, import_marketContext.getMarketBreadthCoverage)({
           universe: definition.universe,
           interval,
           startMs: breadthStartMs,
@@ -814,7 +815,7 @@ var backfillBinanceMarketContext = async (params, enabled) => {
           const ts = row.ts.getTime();
           return ts >= chunk.startMs && ts <= chunk.endMs;
         });
-        await (0, import_timescale.upsertMarketBreadthRows)(rows);
+        await (0, import_marketContext.upsertMarketBreadthRows)(rows);
         breadthRows += rows.length;
       }
     }

package/dist/lib/coinMarketCapContextBackfill.js

@@ -49,7 +49,8 @@ __export(coinMarketCapContextBackfill_exports, {
 module.exports = __toCommonJS(coinMarketCapContextBackfill_exports);
 var import_chalk = __toESM(require("chalk"));
 var import_async = require("@tradejs/core/async");
-var import_timescale = require("@tradejs/infra/timescale");
+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;
@@ -313,7 +314,7 @@ var logBackfillSourceDone = (params) => {
     )
   );
 };
-var markBackfillCoverage = (rows) => (0, import_timescale.upsertMarketContextBackfillCoverage)(rows);
+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)) {
@@ -642,7 +643,7 @@ var backfillCoinMarketCapContext = async (params) => {
   if (toMs <= fromMs) return skippedResult();
   const exchangeLiquidityEnabled = isExchangeLiquidityBackfillEnabled();
   const fearGreedEnabled = isFearGreedBackfillEnabled();
-  await (0, import_timescale.waitForDbReady)();
+  await (0, import_client.waitForDbReady)();
   const [
     globalDailyCoverage,
     referenceDailyCoverage,
@@ -655,66 +656,66 @@ var backfillCoinMarketCapContext = async (params) => {
     fearGreedBackfillCoverage,
     indexBackfillCoverage
   ] = await Promise.all([
-    (0, import_timescale.getMarketGlobalContextCoverage)({
+    (0, import_marketContext.getMarketGlobalContextCoverage)({
       source: SOURCE_GLOBAL_DAILY,
       startMs: fromMs,
       endMs: toMs
     }),
-    (0, import_timescale.getMarketReferenceAssetContextCoverage)({
+    (0, import_marketContext.getMarketReferenceAssetContextCoverage)({
       source: SOURCE_REFERENCE,
       symbols: REFERENCE_ASSETS.map((item) => item.symbol),
       interval: "1d",
       startMs: fromMs,
       endMs: toMs
     }),
-    exchangeLiquidityEnabled ? (0, import_timescale.getMarketCmcExchangeLiquidityContextCoverage)({
+    exchangeLiquidityEnabled ? (0, import_marketContext.getMarketCmcExchangeLiquidityContextCoverage)({
       source: SOURCE_EXCHANGE_LIQUIDITY,
       interval: "1d",
       startMs: fromMs,
       endMs: toMs
     }) : Promise.resolve(null),
-    fearGreedEnabled ? (0, import_timescale.getMarketCmcFearGreedContextCoverage)({
+    fearGreedEnabled ? (0, import_marketContext.getMarketCmcFearGreedContextCoverage)({
       source: SOURCE_FEAR_GREED,
       interval: "1d",
       startMs: fromMs,
       endMs: toMs
     }) : Promise.resolve(null),
-    (0, import_timescale.getMarketCmcIndexContextCoverage)({
+    (0, import_marketContext.getMarketCmcIndexContextCoverage)({
       source: SOURCE_INDEX,
       indexSlugs: CMC_INDEXES.map((index) => index.slug),
       interval: "1d",
       startMs: fromMs,
       endMs: toMs
     }),
-    (0, import_timescale.getMarketContextBackfillCoverage)({
+    (0, import_marketContext.getMarketContextBackfillCoverage)({
       source: SOURCE_GLOBAL_DAILY,
       scopes: [COVERAGE_SCOPE_ALL],
       interval: "1d",
       fromMs,
       toMs
     }),
-    (0, import_timescale.getMarketContextBackfillCoverage)({
+    (0, import_marketContext.getMarketContextBackfillCoverage)({
       source: SOURCE_REFERENCE,
       scopes: REFERENCE_ASSETS.map((item) => item.symbol),
       interval: "1d",
       fromMs,
       toMs
     }),
-    exchangeLiquidityEnabled ? (0, import_timescale.getMarketContextBackfillCoverage)({
+    exchangeLiquidityEnabled ? (0, import_marketContext.getMarketContextBackfillCoverage)({
       source: SOURCE_EXCHANGE_LIQUIDITY,
       scopes: [COVERAGE_SCOPE_ALL],
       interval: "1d",
       fromMs,
       toMs
     }) : Promise.resolve([]),
-    fearGreedEnabled ? (0, import_timescale.getMarketContextBackfillCoverage)({
+    fearGreedEnabled ? (0, import_marketContext.getMarketContextBackfillCoverage)({
       source: SOURCE_FEAR_GREED,
       scopes: [COVERAGE_SCOPE_ALL],
       interval: "1d",
       fromMs,
       toMs
     }) : Promise.resolve([]),
-    (0, import_timescale.getMarketContextBackfillCoverage)({
+    (0, import_marketContext.getMarketContextBackfillCoverage)({
       source: SOURCE_INDEX,
       scopes: CMC_INDEXES.map((index) => index.slug),
       interval: "1d",
@@ -905,7 +906,7 @@ var backfillCoinMarketCapContext = async (params) => {
       }
     });
     const rows = coinMarketCapGlobalPayloadToRows(payload, SOURCE_GLOBAL_DAILY);
-    await (0, import_timescale.upsertMarketGlobalContextRows)(rows);
+    await (0, import_marketContext.upsertMarketGlobalContextRows)(rows);
     await markBackfillCoverage([
       {
         source: SOURCE_GLOBAL_DAILY,
@@ -939,7 +940,7 @@ var backfillCoinMarketCapContext = async (params) => {
       }
     });
     const rows = coinMarketCapHistoricalQuotesPayloadToRows(payload, "1d");
-    await (0, import_timescale.upsertMarketReferenceAssetContextRows)(rows);
+    await (0, import_marketContext.upsertMarketReferenceAssetContextRows)(rows);
     await markBackfillCoverage(
       REFERENCE_ASSETS.map((asset) => ({
         source: SOURCE_REFERENCE,
@@ -978,7 +979,7 @@ var backfillCoinMarketCapContext = async (params) => {
       payload,
       "1d"
     );
-    await (0, import_timescale.upsertMarketCmcExchangeLiquidityContextRows)(rows);
+    await (0, import_marketContext.upsertMarketCmcExchangeLiquidityContextRows)(rows);
     await markBackfillCoverage([
       {
         source: SOURCE_EXCHANGE_LIQUIDITY,
@@ -1023,7 +1024,7 @@ var backfillCoinMarketCapContext = async (params) => {
       const oldestPageTs = Math.min(...pageRows.map((row) => row.ts.getTime()));
       if (oldestPageTs < fromMs || pageRows.length < pageSize) break;
     }
-    await (0, import_timescale.upsertMarketCmcFearGreedContextRows)(rows);
+    await (0, import_marketContext.upsertMarketCmcFearGreedContextRows)(rows);
     await markBackfillCoverage([
       {
         source: SOURCE_FEAR_GREED,
@@ -1057,7 +1058,7 @@ var backfillCoinMarketCapContext = async (params) => {
       }))
     );
     const rows = rowsByIndex.flatMap((item) => item.result.rows);
-    await (0, import_timescale.upsertMarketCmcIndexContextRows)(rows);
+    await (0, import_marketContext.upsertMarketCmcIndexContextRows)(rows);
     await markBackfillCoverage(
       rowsByIndex.map(({ index, result }) => ({
         source: SOURCE_INDEX,