@tradejs/infra 1.0.8 → 1.0.10

package/dist/redis.d.ts

@@ -3,9 +3,11 @@ import Redis from 'ioredis';
 declare global {
     var __redis__: Redis | undefined;
 }
+declare const closeRedisConnection: () => Promise<void>;
 interface Options {
     expire?: number;
 }
+declare const publishData: (channel: string, value: unknown) => Promise<number>;
 interface DelKeyOptions {
     raiseOnMisconf?: boolean;
 }
@@ -17,18 +19,31 @@ declare class RedisWriteBlockedError extends Error {
 }
 declare const delKeyWithOptions: (key: string, options?: DelKeyOptions) => Promise<boolean>;
 declare const setData: <T>(key: string, data: T, options?: Options) => Promise<void>;
+declare const setHashJsonField: <T>(key: string, field: string, data: T, options?: Options) => Promise<void>;
+declare const getHashJsonField: <T>(key: string, field: string, fallback?: T | null) => Promise<T | null>;
+declare const getHashJsonValues: <T>(key: string) => Promise<T[]>;
+declare const incrHashFields: (key: string, increments: Record<string, number>, options?: Options) => Promise<void>;
+declare const getHashData: (key: string) => Promise<Record<string, string>>;
 declare const createScreenshotSessionToken: (userName: string) => Promise<string | null>;
 declare const consumeScreenshotSessionToken: (token: string) => Promise<string | null>;
 declare const redisKeys: {
     users: () => string;
     user: (userName: string) => string;
+    tradingAccounts: (userName: string) => string;
+    tradingAccount: (userName: string, accountId: string) => string;
+    runtimeDeployments: (userName: string) => string;
+    runtimeDeployment: (userName: string, deploymentId: string) => string;
+    runtimeDeploymentHeartbeat: (userName: string, deploymentId: string) => string;
     bots: (userName: string) => string;
     botsPrefix: () => string;
     bot: (userName: string, botId: string) => string;
     backtestConfig: (userName: string, config: string) => string;
     strategies: (userName: string) => string;
-    strategyConfig: (userName: string, strategyName: string) => string;
+    strategyConfig: (userName: string, strategyName: string, configId?: string) => string;
     strategyResults: (userName: string, strategyName: string) => string;
+    strategyCharts: (userName: string, mode: string) => string;
+    strategyChartCards: (userName: string, mode: string) => string;
+    strategyChartCard: (userName: string, mode: string, cardId: string) => string;
     tests: (userName: string, strategyName?: string) => string;
     testOrders: (userName: string, strategyName: string, testName: string) => string;
     testConfig: (userName: string, strategyName: string, testName: string) => string;
@@ -37,21 +52,34 @@ declare const redisKeys: {
     cacheChunk: (userName: string, chunkId: string) => string;
     cacheOrders: (userName: string, orderLogId: string) => string;
     cachePositions: (userName: string, orderLogId: string) => string;
+    tickerUniverse: (userName: string, connectorName: string, universe?: string, accountId?: string) => string;
     signal: (symbol: string, signalId: string) => string;
     signalsBySymbol: (symbol: string) => string;
     storeSignal: (symbol: string, signalId: string) => string;
     runtimeSignals: (userName: string) => string;
     runtimeSignal: (userName: string, signalId: string) => string;
+    runtimeSignalBuckets: (userName: string) => string;
+    runtimeSignalBucket: (userName: string, dayKey: string, strategyName: string) => string;
     runtimeSignalEvaluations: (userName: string) => string;
     runtimeSignalEvaluation: (userName: string, evaluationId: string) => string;
+    runtimeSignalEvaluationBuckets: (userName: string) => string;
+    runtimeSignalEvaluationBucket: (userName: string, dayKey: string, strategyName: string) => string;
+    runtimeSignalEvaluationStatsBuckets: (userName: string) => string;
+    runtimeSignalEvaluationStatsBucket: (userName: string, dayKey: string, strategyName: string) => string;
     runtimeTrades: (userName: string) => string;
     runtimeTrade: (userName: string, orderId: string) => string;
+    runtimeTradeBuckets: (userName: string) => string;
+    runtimeTradeBucket: (userName: string, dayKey: string) => string;
     runtimeActiveTrades: (userName: string) => string;
-    runtimeActiveTrade: (userName: string, symbol: string) => string;
+    runtimeActiveTrade: (userName: string, symbol: string, scopeId?: string) => string;
     aiChatHistory: (userName: string, symbolKey: string) => string;
     analysis: (symbol: string, signalId: string) => string;
     screenshotSessionToken: (token: string) => string;
     backtestResults: (userName: string, config: string, timestamp: string) => string;
+    backtestRuns: (userName: string) => string;
+    backtestRun: (userName: string, runId: string) => string;
+    backtestRunResults: (userName: string, runId: string) => string;
+    backtestLatestRun: (userName: string, config: string) => string;
     researchRuns: (userName: string) => string;
     researchRun: (userName: string, runId: string) => string;
     researchLatestRun: (userName: string, strategyName: string) => string;
@@ -63,4 +91,4 @@ declare const redisKeys: {
     mlResult: (strategyName: string, signalId: string) => string;
 };
 
-export { RedisWriteBlockedError, consumeScreenshotSessionToken, createScreenshotSessionToken, delKey, delKeyWithOptions, getData, getKeys, redisKeys, setData };
+export { RedisWriteBlockedError, closeRedisConnection, consumeScreenshotSessionToken, createScreenshotSessionToken, delKey, delKeyWithOptions, getData, getHashData, getHashJsonField, getHashJsonValues, getKeys, incrHashFields, publishData, redisKeys, setData, setHashJsonField };

package/dist/redis.js

@@ -31,14 +31,21 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var redis_exports = {};
 __export(redis_exports, {
   RedisWriteBlockedError: () => RedisWriteBlockedError,
+  closeRedisConnection: () => closeRedisConnection,
   consumeScreenshotSessionToken: () => consumeScreenshotSessionToken,
   createScreenshotSessionToken: () => createScreenshotSessionToken,
   delKey: () => delKey,
   delKeyWithOptions: () => delKeyWithOptions,
   getData: () => getData,
+  getHashData: () => getHashData,
+  getHashJsonField: () => getHashJsonField,
+  getHashJsonValues: () => getHashJsonValues,
   getKeys: () => getKeys,
+  incrHashFields: () => incrHashFields,
+  publishData: () => publishData,
   redisKeys: () => redisKeys,
-  setData: () => setData
+  setData: () => setData,
+  setHashJsonField: () => setHashJsonField
 });
 module.exports = __toCommonJS(redis_exports);
 var import_crypto = require("crypto");
@@ -54,9 +61,12 @@ var logger = {
 };
 var redisConnectionWarningShown = false;
 var redisUnavailable = false;
-var isRedisConnectivityError = (error) => /ECONNREFUSED|ENOTFOUND|EAI_AGAIN|ETIMEDOUT|MaxRetriesPerRequestError|Connection is closed|Stream isn't writeable/i.test(
-  error.message
-);
+var isRedisConnectivityError = (error) => {
+  const errorText = [error.name, error.message, String(error)].join(" ");
+  return /ECONNREFUSED|ECONNRESET|ECONNABORTED|EPIPE|ENOTFOUND|EAI_AGAIN|ETIMEDOUT|MaxRetriesPerRequestError|Connection is closed|Stream isn't writeable/i.test(
+    errorText
+  );
+};
 var toNonNegativeInt = (value, fallback) => {
   const parsed = Number.parseInt(String(value ?? ""), 10);
   return Number.isFinite(parsed) && parsed >= 0 ? parsed : fallback;
@@ -112,6 +122,16 @@ var getRedis = () => {
   }
   return global.__redis__;
 };
+var closeRedisConnection = async () => {
+  const redis = global.__redis__;
+  if (!redis) {
+    return;
+  }
+  global.__redis__ = void 0;
+  redisUnavailable = false;
+  redisConnectionWarningShown = false;
+  redis.disconnect();
+};
 var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 var getRedisStatus = (redis) => String(redis.status ?? "ready");
 var waitForRedisReady = async (redis) => {
@@ -152,6 +172,11 @@ var toResultString = (result) => {
   if (Buffer.isBuffer(result)) return result.toString("utf8");
   return String(result);
 };
+var publishData = async (channel, value) => {
+  const redis = await getReadyRedis();
+  if (!redis) return 0;
+  return redis.publish(channel, toJson(value));
+};
 var DEFAULT_OPTIONS = {
   expire: TTL_1D
 };
@@ -164,6 +189,31 @@ var parseJsonOrDeleteKey = async (redis, key, raw, fallback) => {
     return fallback;
   }
 };
+var parseHashMap = (value) => {
+  if (!value) {
+    return {};
+  }
+  if (Array.isArray(value)) {
+    const result = {};
+    for (let index = 0; index < value.length; index += 2) {
+      const field = value[index];
+      const fieldValue = value[index + 1];
+      if (field == null || fieldValue == null) {
+        continue;
+      }
+      result[String(field)] = toResultString(fieldValue) ?? "";
+    }
+    return result;
+  }
+  if (typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).map(
+        ([field, fieldValue]) => [field, toResultString(fieldValue) ?? ""]
+      )
+    );
+  }
+  return {};
+};
 var getKeys = async (prefix) => {
   if (redisUnavailable) return [];
   const redis = await getReadyRedis();
@@ -300,6 +350,115 @@ var setData = async (key, data, options = {}) => {
     }
   }
 };
+var setHashJsonField = async (key, field, data, options = {}) => {
+  if (redisUnavailable) return;
+  const { expire } = { ...DEFAULT_OPTIONS, ...options };
+  const redis = await getReadyRedis();
+  if (!redis) return;
+  try {
+    await redis.call("HSET", key, field, toJson(data));
+    if (expire) {
+      await redis.expire(key, expire);
+    }
+  } catch (e) {
+    if (e instanceof Error && isRedisConnectivityError(e)) {
+      markRedisUnavailable(e);
+      return;
+    }
+    logger.log("error", "failed HSET %s[%s]: %s", key, field, String(e));
+  }
+};
+var getHashJsonField = async (key, field, fallback = null) => {
+  if (redisUnavailable) return fallback;
+  const redis = await getReadyRedis();
+  if (!redis) return fallback;
+  try {
+    const value = await redis.call("HGET", key, field);
+    if (typeof value !== "string" || !value) {
+      return fallback;
+    }
+    return JSON.parse(value);
+  } catch (e) {
+    if (e instanceof Error && isRedisConnectivityError(e)) {
+      markRedisUnavailable(e);
+      return fallback;
+    }
+    logger.log("error", "failed HGET %s[%s]: %s", key, field, String(e));
+    return fallback;
+  }
+};
+var getHashJsonValues = async (key) => {
+  if (redisUnavailable) return [];
+  const redis = await getReadyRedis();
+  if (!redis) return [];
+  try {
+    const raw = await redis.call("HGETALL", key);
+    const values = Object.values(parseHashMap(raw));
+    const parsed = [];
+    for (const value of values) {
+      if (!value) {
+        continue;
+      }
+      try {
+        parsed.push(JSON.parse(value));
+      } catch (e) {
+        logger.log(
+          "error",
+          "failed JSON.parse(HGETALL %s value): %s",
+          key,
+          String(e)
+        );
+      }
+    }
+    return parsed;
+  } catch (e) {
+    if (e instanceof Error && isRedisConnectivityError(e)) {
+      markRedisUnavailable(e);
+      return [];
+    }
+    logger.log("error", "failed HGETALL %s: %s", key, String(e));
+    return [];
+  }
+};
+var incrHashFields = async (key, increments, options = {}) => {
+  if (redisUnavailable) return;
+  const { expire } = { ...DEFAULT_OPTIONS, ...options };
+  const redis = await getReadyRedis();
+  if (!redis) return;
+  try {
+    for (const [field, increment] of Object.entries(increments)) {
+      if (!Number.isFinite(increment) || increment === 0) {
+        continue;
+      }
+      await redis.call("HINCRBY", key, field, Math.trunc(increment));
+    }
+    if (expire) {
+      await redis.expire(key, expire);
+    }
+  } catch (e) {
+    if (e instanceof Error && isRedisConnectivityError(e)) {
+      markRedisUnavailable(e);
+      return;
+    }
+    logger.log("error", "failed HINCRBY %s: %s", key, String(e));
+  }
+};
+var getHashData = async (key) => {
+  if (redisUnavailable) return {};
+  const redis = await getReadyRedis();
+  if (!redis) return {};
+  try {
+    const raw = await redis.call("HGETALL", key);
+    return parseHashMap(raw);
+  } catch (e) {
+    if (e instanceof Error && isRedisConnectivityError(e)) {
+      markRedisUnavailable(e);
+      return {};
+    }
+    logger.log("error", "failed HGETALL %s: %s", key, String(e));
+    return {};
+  }
+};
 var createScreenshotSessionToken = async (userName) => {
   const token = (0, import_crypto.randomBytes)(24).toString("hex");
   await setData(
@@ -333,13 +492,21 @@ var consumeScreenshotSessionToken = async (token) => {
 var redisKeys = {
   users: () => "users:index:",
   user: (userName) => `users:index:${userName}`,
+  tradingAccounts: (userName) => `users:${userName}:trading-accounts:`,
+  tradingAccount: (userName, accountId) => `users:${userName}:trading-accounts:${accountId}`,
+  runtimeDeployments: (userName) => `users:${userName}:runtime:deployments:`,
+  runtimeDeployment: (userName, deploymentId) => `users:${userName}:runtime:deployments:${deploymentId}`,
+  runtimeDeploymentHeartbeat: (userName, deploymentId) => `users:${userName}:runtime:deployments:${deploymentId}:heartbeat`,
   bots: (userName) => `users:${userName}:bots`,
   botsPrefix: () => "users:",
   bot: (userName, botId) => `users:${userName}:bots:${botId}`,
   backtestConfig: (userName, config) => `users:${userName}:backtests:configs:${config}`,
   strategies: (userName) => `users:${userName}:strategies`,
-  strategyConfig: (userName, strategyName) => `users:${userName}:strategies:${strategyName}:config`,
+  strategyConfig: (userName, strategyName, configId = "config") => `users:${userName}:strategies:${strategyName}:${configId}`,
   strategyResults: (userName, strategyName) => `users:${userName}:strategies:${strategyName}:results`,
+  strategyCharts: (userName, mode) => `users:${userName}:strategies:charts:${mode}`,
+  strategyChartCards: (userName, mode) => `users:${userName}:strategies:charts:${mode}:cards:`,
+  strategyChartCard: (userName, mode, cardId) => `users:${userName}:strategies:charts:${mode}:cards:${cardId}`,
   tests: (userName, strategyName) => strategyName ? `users:${userName}:tests:${strategyName}` : `users:${userName}:tests:`,
   testOrders: (userName, strategyName, testName) => `users:${userName}:tests:${strategyName}:${testName}:orders`,
   testConfig: (userName, strategyName, testName) => `users:${userName}:tests:${strategyName}:${testName}:config`,
@@ -348,21 +515,34 @@ var redisKeys = {
   cacheChunk: (userName, chunkId) => `users:${userName}:cache:tests:chunks:${chunkId}`,
   cacheOrders: (userName, orderLogId) => `users:${userName}:cache:tests:orders:${orderLogId}`,
   cachePositions: (userName, orderLogId) => `users:${userName}:cache:tests:positions:${orderLogId}`,
+  tickerUniverse: (userName, connectorName, universe, accountId) => universe || accountId ? `users:${userName}:cache:tickers:${connectorName}:${universe ?? "crypto"}:${accountId ?? "default"}` : `users:${userName}:cache:tickers:${connectorName}`,
   signal: (symbol, signalId) => `signals:${symbol}:${signalId}`,
   signalsBySymbol: (symbol) => `signals:${symbol}:`,
   storeSignal: (symbol, signalId) => `store:signals:${symbol}:${signalId}`,
   runtimeSignals: (userName) => `users:${userName}:runtime:signals:`,
   runtimeSignal: (userName, signalId) => `users:${userName}:runtime:signals:${signalId}`,
+  runtimeSignalBuckets: (userName) => `users:${userName}:runtime:signals:days:`,
+  runtimeSignalBucket: (userName, dayKey, strategyName) => `users:${userName}:runtime:signals:days:${dayKey}:${strategyName}`,
   runtimeSignalEvaluations: (userName) => `users:${userName}:runtime:signal-evaluations:`,
   runtimeSignalEvaluation: (userName, evaluationId) => `users:${userName}:runtime:signal-evaluations:${evaluationId}`,
+  runtimeSignalEvaluationBuckets: (userName) => `users:${userName}:runtime:signal-evaluations:days:`,
+  runtimeSignalEvaluationBucket: (userName, dayKey, strategyName) => `users:${userName}:runtime:signal-evaluations:days:${dayKey}:${strategyName}`,
+  runtimeSignalEvaluationStatsBuckets: (userName) => `users:${userName}:runtime:signal-evaluation-stats:days:`,
+  runtimeSignalEvaluationStatsBucket: (userName, dayKey, strategyName) => `users:${userName}:runtime:signal-evaluation-stats:days:${dayKey}:${strategyName}`,
   runtimeTrades: (userName) => `users:${userName}:runtime:trade-records:`,
   runtimeTrade: (userName, orderId) => `users:${userName}:runtime:trade-records:${orderId}`,
+  runtimeTradeBuckets: (userName) => `users:${userName}:runtime:trade-records:days:`,
+  runtimeTradeBucket: (userName, dayKey) => `users:${userName}:runtime:trade-records:days:${dayKey}`,
   runtimeActiveTrades: (userName) => `users:${userName}:runtime:active-trades:`,
-  runtimeActiveTrade: (userName, symbol) => `users:${userName}:runtime:active-trades:${symbol}`,
+  runtimeActiveTrade: (userName, symbol, scopeId) => scopeId ? `users:${userName}:runtime:active-trades:${scopeId}:${symbol}` : `users:${userName}:runtime:active-trades:${symbol}`,
   aiChatHistory: (userName, symbolKey) => `users:${userName}:ai:chats:${symbolKey}`,
   analysis: (symbol, signalId) => `analysis:${symbol}:${signalId}`,
   screenshotSessionToken: (token) => `auth:screenshot:${token}`,
   backtestResults: (userName, config, timestamp) => `users:${userName}:backtests:results:${config}:${timestamp}`,
+  backtestRuns: (userName) => `users:${userName}:backtests:runs:`,
+  backtestRun: (userName, runId) => `users:${userName}:backtests:runs:${runId}`,
+  backtestRunResults: (userName, runId) => `users:${userName}:backtests:runs:${runId}:results`,
+  backtestLatestRun: (userName, config) => `users:${userName}:backtests:latest:${config}`,
   researchRuns: (userName) => `users:${userName}:research:runs:`,
   researchRun: (userName, runId) => `users:${userName}:research:runs:${runId}`,
   researchLatestRun: (userName, strategyName) => `users:${userName}:research:latest:${strategyName}`,
@@ -376,12 +556,19 @@ var redisKeys = {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   RedisWriteBlockedError,
+  closeRedisConnection,
   consumeScreenshotSessionToken,
   createScreenshotSessionToken,
   delKey,
   delKeyWithOptions,
   getData,
+  getHashData,
+  getHashJsonField,
+  getHashJsonValues,
   getKeys,
+  incrHashFields,
+  publishData,
   redisKeys,
-  setData
+  setData,
+  setHashJsonField
 });

package/dist/redis.mjs

@@ -1,22 +1,36 @@
 import {
   RedisWriteBlockedError,
+  closeRedisConnection,
   consumeScreenshotSessionToken,
   createScreenshotSessionToken,
   delKey,
   delKeyWithOptions,
   getData,
+  getHashData,
+  getHashJsonField,
+  getHashJsonValues,
   getKeys,
+  incrHashFields,
+  publishData,
   redisKeys,
-  setData
-} from "./chunk-DSTV67R5.mjs";
+  setData,
+  setHashJsonField
+} from "./chunk-DXG2UDNA.mjs";
 export {
   RedisWriteBlockedError,
+  closeRedisConnection,
   consumeScreenshotSessionToken,
   createScreenshotSessionToken,
   delKey,
   delKeyWithOptions,
   getData,
+  getHashData,
+  getHashJsonField,
+  getHashJsonValues,
   getKeys,
+  incrHashFields,
+  publishData,
   redisKeys,
-  setData
+  setData,
+  setHashJsonField
 };

package/dist/timescale.d.mts

@@ -1,5 +1,5 @@
 import { Pool } from 'pg';
-import { DerivativesInterval, DerivativesRow, KlineChartData, SpreadRow } from '@tradejs/types';
+import { DerivativesInterval, DerivativesRow, MarketFeatureInterval, MarketBreadthRow, MarketCmcExchangeLiquidityContextRow, MarketCmcFearGreedContextRow, MarketCmcIndexContextRow, MarketGlobalContextRow, MarketReferenceAssetContextRow, MarketTradeFlowRow, KlineChartData, SpreadRow } from '@tradejs/types';
 
 declare global {
     var __pgPool__: Pool | undefined;
@@ -15,7 +15,12 @@ type CandleRow = {
     close: number;
     volume?: number | null;
     turnover?: number | null;
+    takerBuyBaseVolume?: number | null;
+    takerBuyQuoteVolume?: number | null;
+    takerSellBaseVolume?: number | null;
+    takerSellQuoteVolume?: number | null;
 };
+declare const closeTimescalePool: () => Promise<void>;
 declare const toRows: (provider: string, symbol: string, interval: number, data: KlineChartData) => CandleRow[];
 declare function upsertCandles(rows: CandleRow[]): Promise<void>;
 declare function upsertDerivatives(rows: DerivativesRow[]): Promise<void>;
@@ -24,18 +29,224 @@ declare function getDerivativesDataEdgesForSymbols(symbols: string[], interval:
     min?: number;
     max?: number;
 }>>;
+declare function getDerivativesBackfillCoverage(params: {
+    source: string;
+    symbols: string[];
+    interval: DerivativesInterval;
+    fromMs: number;
+    toMs: number;
+}): Promise<{
+    symbol: string;
+    interval: DerivativesInterval;
+    fromMs: number;
+    toMs: number;
+    rowsCount: number;
+}[]>;
+declare function upsertDerivativesBackfillCoverage(rows: Array<{
+    source: string;
+    symbol: string;
+    interval: DerivativesInterval;
+    fromMs: number;
+    toMs: number;
+    rowsCount: number;
+}>): Promise<void>;
 declare function getDerivativesWindow(params: {
     symbol: string;
     intervals: DerivativesInterval[];
     endMs: number;
     lookbackMs: number;
 }): Promise<Partial<Record<DerivativesInterval, DerivativesRow[]>>>;
-declare function getDerivativesSummary(hours?: number, limit?: number): Promise<{
-    rows: any[];
-    aggregates: any[];
+declare function getDerivativesSummary(hours?: number, limit?: number, symbols?: string[]): Promise<{
     hours: number;
+    items: {
+        symbol: string;
+        interval: string;
+        points: number;
+        last_ts: string | Date;
+        first_ts: string | Date;
+        latest_open_interest: number | null;
+        first_open_interest: number | null;
+        oi_change: number | null;
+        oi_change_pct: number | null;
+        latest_funding_rate: number | null;
+        first_funding_rate: number | null;
+        funding_change: number | null;
+        sum_liq_long: number | null;
+        sum_liq_short: number | null;
+        sum_liq_total: number | null;
+    }[];
 }>;
 declare function upsertSpreadRows(rows: SpreadRow[]): Promise<void>;
+declare function upsertMarketTradeFlowRows(rows: MarketTradeFlowRow[]): Promise<void>;
+declare function upsertMarketBreadthRows(rows: MarketBreadthRow[]): Promise<void>;
+declare function upsertMarketGlobalContextRows(rows: MarketGlobalContextRow[]): Promise<void>;
+declare function upsertMarketReferenceAssetContextRows(rows: MarketReferenceAssetContextRow[]): Promise<void>;
+declare function upsertMarketCmcExchangeLiquidityContextRows(rows: MarketCmcExchangeLiquidityContextRow[]): Promise<void>;
+declare function upsertMarketCmcFearGreedContextRows(rows: MarketCmcFearGreedContextRow[]): Promise<void>;
+declare function upsertMarketCmcIndexContextRows(rows: MarketCmcIndexContextRow[]): Promise<void>;
+declare function getMarketContextBackfillCoverage(params: {
+    source: string;
+    scopes: string[];
+    interval: string;
+    fromMs: number;
+    toMs: number;
+}): Promise<Array<{
+    source: string;
+    scope: string;
+    interval: string;
+    fromMs: number;
+    toMs: number;
+    rowsCount: number;
+}>>;
+declare function upsertMarketContextBackfillCoverage(rows: Array<{
+    source: string;
+    scope: string;
+    interval: string;
+    fromMs: number;
+    toMs: number;
+    rowsCount: number;
+}>): Promise<void>;
+type MarketFeatureAsOf<T> = T & {
+    ageMs: number | null;
+    stale: boolean;
+};
+declare function getLatestMarketTradeFlow(params: {
+    symbol: string;
+    interval: MarketFeatureInterval;
+    atMs: number;
+    maxAgeMs?: number;
+}): Promise<MarketFeatureAsOf<MarketTradeFlowRow> | null>;
+declare function getLatestMarketBreadth(params: {
+    universe: string;
+    interval: MarketFeatureInterval;
+    atMs: number;
+    maxAgeMs?: number;
+}): Promise<MarketFeatureAsOf<MarketBreadthRow> | null>;
+declare function getLatestMarketGlobalContext(params: {
+    source?: MarketGlobalContextRow['source'];
+    atMs: number;
+    maxAgeMs?: number;
+}): Promise<(MarketFeatureAsOf<MarketGlobalContextRow> & {
+    btcDominanceChange24hPct: number | null;
+    ethDominanceChange24hPct: number | null;
+    altMarketCapChange24hPct: number | null;
+    altVolumeChange24hPct: number | null;
+}) | null>;
+declare function getMarketGlobalContextCoverage(params: {
+    source: MarketGlobalContextRow['source'];
+    startMs: number;
+    endMs: number;
+}): Promise<{
+    firstMs: number;
+    lastMs: number;
+    rows: number;
+} | null>;
+declare function getMarketReferenceAssetContextCoverage(params: {
+    source: MarketReferenceAssetContextRow['source'];
+    symbols: string[];
+    interval: MarketReferenceAssetContextRow['interval'];
+    startMs: number;
+    endMs: number;
+}): Promise<Map<string, {
+    firstMs: number;
+    lastMs: number;
+    rows: number;
+}>>;
+declare function getLatestMarketReferenceAssetContexts(params: {
+    source?: MarketReferenceAssetContextRow['source'];
+    symbols: string[];
+    interval?: MarketReferenceAssetContextRow['interval'];
+    atMs: number;
+    maxAgeMs?: number;
+}): Promise<Map<string, MarketFeatureAsOf<MarketReferenceAssetContextRow>>>;
+declare function getLatestMarketCmcExchangeLiquidityContext(params: {
+    source?: MarketCmcExchangeLiquidityContextRow['source'];
+    interval?: MarketCmcExchangeLiquidityContextRow['interval'];
+    atMs: number;
+    maxAgeMs?: number;
+}): Promise<(MarketFeatureAsOf<MarketCmcExchangeLiquidityContextRow> & {
+    totalVolumeChange24hPct: number | null;
+}) | null>;
+declare function getLatestMarketCmcIndexContexts(params: {
+    source?: MarketCmcIndexContextRow['source'];
+    indexSlugs: MarketCmcIndexContextRow['indexSlug'][];
+    interval?: MarketCmcIndexContextRow['interval'];
+    atMs: number;
+    maxAgeMs?: number;
+}): Promise<Map<MarketCmcIndexContextRow['indexSlug'], MarketFeatureAsOf<MarketCmcIndexContextRow> & {
+    valueChange24hPct: number | null;
+}>>;
+declare function getLatestMarketCmcFearGreedContext(params: {
+    source?: MarketCmcFearGreedContextRow['source'];
+    interval?: MarketCmcFearGreedContextRow['interval'];
+    atMs: number;
+    maxAgeMs?: number;
+}): Promise<(MarketFeatureAsOf<MarketCmcFearGreedContextRow> & {
+    valueChange24h: number | null;
+    valueChange7d: number | null;
+}) | null>;
+declare function getMarketCmcFearGreedContextCoverage(params: {
+    source: MarketCmcFearGreedContextRow['source'];
+    interval: MarketCmcFearGreedContextRow['interval'];
+    startMs: number;
+    endMs: number;
+}): Promise<{
+    firstMs: number;
+    lastMs: number;
+    rows: number;
+} | null>;
+declare function getMarketCmcExchangeLiquidityContextCoverage(params: {
+    source: MarketCmcExchangeLiquidityContextRow['source'];
+    interval: MarketCmcExchangeLiquidityContextRow['interval'];
+    startMs: number;
+    endMs: number;
+}): Promise<{
+    firstMs: number;
+    lastMs: number;
+    rows: number;
+} | null>;
+declare function getMarketCmcIndexContextCoverage(params: {
+    source: MarketCmcIndexContextRow['source'];
+    indexSlugs: MarketCmcIndexContextRow['indexSlug'][];
+    interval: MarketCmcIndexContextRow['interval'];
+    startMs: number;
+    endMs: number;
+}): Promise<Map<MarketCmcIndexContextRow['indexSlug'], {
+    firstMs: number;
+    lastMs: number;
+    rows: number;
+}>>;
+declare function getMarketTradeFlowCoverage(params: {
+    symbols: string[];
+    interval: MarketFeatureInterval;
+    startMs: number;
+    endMs: number;
+}): Promise<Map<string, {
+    firstMs: number;
+    lastMs: number;
+    rows: number;
+}>>;
+type DeprecatedMarketContextCleanupItem = {
+    kind: 'table' | 'rows';
+    name: string;
+    rows: number;
+    action: 'drop_table' | 'delete_rows';
+    applied: boolean;
+};
+declare function cleanupDeprecatedMarketContext(params?: {
+    apply?: boolean;
+}): Promise<DeprecatedMarketContextCleanupItem[]>;
+declare function getMarketBreadthCoverage(params: {
+    universe: string;
+    interval: MarketFeatureInterval;
+    startMs: number;
+    endMs: number;
+}): Promise<{
+    firstMs: number;
+    lastMs: number;
+    rows: number;
+    btcAltMetricsRows: number;
+} | null>;
 declare function getSpreadRangeForSymbols(symbols: string[], interval: DerivativesInterval, startMs: number, endMs: number): Promise<any[]>;
 declare function getSpreadSummary(hours?: number, limit?: number): Promise<{
     rows: any[];
@@ -47,6 +258,10 @@ declare function getDataEdges(provider: string, symbol: string, interval: number
     min: number | undefined;
     max: number | undefined;
 }>;
+declare function getDataEdgesForSymbols(provider: string, symbols: string[], interval: number): Promise<Map<string, {
+    min?: number;
+    max?: number;
+}>>;
 declare function waitForDbReady(attempts?: number, delayMs?: number): Promise<void>;
 declare function deleteCandles(provider: string, symbol: string, interval: number): Promise<void>;
 declare function findContinuityGap(provider: string, symbol: string, interval: number): Promise<{
@@ -55,4 +270,4 @@ declare function findContinuityGap(provider: string, symbol: string, interval: n
     diffSeconds: number;
 } | null>;
 
-export { type CandleRow, deleteCandles, findContinuityGap, getCandlesRange, getDataEdges, getDerivativesDataEdgesForSymbols, getDerivativesRangeForSymbols, getDerivativesSummary, getDerivativesWindow, getSpreadRangeForSymbols, getSpreadSummary, toRows, upsertCandles, upsertDerivatives, upsertSpreadRows, waitForDbReady };
+export { type CandleRow, type DeprecatedMarketContextCleanupItem, type MarketFeatureAsOf, cleanupDeprecatedMarketContext, closeTimescalePool, deleteCandles, findContinuityGap, getCandlesRange, getDataEdges, getDataEdgesForSymbols, getDerivativesBackfillCoverage, getDerivativesDataEdgesForSymbols, getDerivativesRangeForSymbols, getDerivativesSummary, getDerivativesWindow, getLatestMarketBreadth, getLatestMarketCmcExchangeLiquidityContext, getLatestMarketCmcFearGreedContext, getLatestMarketCmcIndexContexts, getLatestMarketGlobalContext, getLatestMarketReferenceAssetContexts, getLatestMarketTradeFlow, getMarketBreadthCoverage, getMarketCmcExchangeLiquidityContextCoverage, getMarketCmcFearGreedContextCoverage, getMarketCmcIndexContextCoverage, getMarketContextBackfillCoverage, getMarketGlobalContextCoverage, getMarketReferenceAssetContextCoverage, getMarketTradeFlowCoverage, getSpreadRangeForSymbols, getSpreadSummary, toRows, upsertCandles, upsertDerivatives, upsertDerivativesBackfillCoverage, upsertMarketBreadthRows, upsertMarketCmcExchangeLiquidityContextRows, upsertMarketCmcFearGreedContextRows, upsertMarketCmcIndexContextRows, upsertMarketContextBackfillCoverage, upsertMarketGlobalContextRows, upsertMarketReferenceAssetContextRows, upsertMarketTradeFlowRows, upsertSpreadRows, waitForDbReady };