@tradejs/infra 2.0.18 → 2.0.20

package/dist/timescale.js

@@ -84,25 +84,21 @@ __export(timescale_exports, {
   waitForDbReady: () => waitForDbReady
 });
 module.exports = __toCommonJS(timescale_exports);
+
+// src/timescale/pool.ts
 var import_pg = require("pg");
-var import_types = require("@tradejs/types");
 var getPool = () => {
   if (!global.__pgPool__) {
-    const host = process.env.PG_HOST || "127.0.0.1";
-    const port = Number(process.env.PG_PORT ?? 5432);
-    const user = process.env.PG_USER || "app";
-    const password = String(process.env.PG_PASSWORD ?? "app");
-    const database = process.env.PG_DATABASE || process.env.PG_DB || "app";
     const max = Number(process.env.PG_POOL_MAX ?? 10);
     const connectionTimeoutMillis = Number(
       process.env.PG_CONNECTION_TIMEOUT_MS ?? 3e4
     );
     global.__pgPool__ = new import_pg.Pool({
-      host,
-      port,
-      user,
-      password,
-      database,
+      host: process.env.PG_HOST || "127.0.0.1",
+      port: Number(process.env.PG_PORT ?? 5432),
+      user: process.env.PG_USER || "app",
+      password: String(process.env.PG_PASSWORD ?? "app"),
+      database: process.env.PG_DATABASE || process.env.PG_DB || "app",
       max: Number.isFinite(max) && max > 0 ? Math.floor(max) : 10,
       idleTimeoutMillis: 3e4,
       connectionTimeoutMillis: Number.isFinite(connectionTimeoutMillis) && connectionTimeoutMillis > 0 ? Math.floor(connectionTimeoutMillis) : 3e4
@@ -110,63 +106,29 @@ var getPool = () => {
   }
   return global.__pgPool__;
 };
-var candlesSchemaReady = false;
-var derivativesSchemaReady = false;
-var spreadSchemaReady = false;
-var binanceMarketSchemaReady = false;
-var hyperliquidWhaleSchemaReady = false;
-var candlesSchemaReadyPromise = null;
-var derivativesSchemaReadyPromise = null;
-var spreadSchemaReadyPromise = null;
-var binanceMarketSchemaReadyPromise = null;
-var hyperliquidWhaleSchemaReadyPromise = null;
-var marketContextSchemaMode = "ensure";
-var verifiedMarketContextSchemas = /* @__PURE__ */ new Set();
-var configureTimescaleMarketContextSchemaMode = (mode) => {
-  marketContextSchemaMode = mode;
-  verifiedMarketContextSchemas.clear();
-};
-var closeTimescalePool = async () => {
+var closePool = async () => {
   const pool = global.__pgPool__;
-  if (!pool) {
-    return;
-  }
+  if (!pool) return;
   global.__pgPool__ = void 0;
-  candlesSchemaReady = false;
-  derivativesSchemaReady = false;
-  spreadSchemaReady = false;
-  binanceMarketSchemaReady = false;
-  hyperliquidWhaleSchemaReady = false;
-  candlesSchemaReadyPromise = null;
-  derivativesSchemaReadyPromise = null;
-  spreadSchemaReadyPromise = null;
-  binanceMarketSchemaReadyPromise = null;
-  hyperliquidWhaleSchemaReadyPromise = null;
-  verifiedMarketContextSchemas.clear();
   await pool.end();
 };
-var CANDLES_SCHEMA_LOCK_KEY = 61e4;
-var DERIVATIVES_SCHEMA_LOCK_KEY = 610001;
-var SPREAD_SCHEMA_LOCK_KEY = 610002;
-var BINANCE_MARKET_SCHEMA_LOCK_KEY = 610003;
-var HYPERLIQUID_WHALE_SCHEMA_LOCK_KEY = 610004;
-var PG_SAFE_MAX_BIND_PARAMS = 3e4;
-var resolveMarketContextQueryTimeoutMs = (override) => {
+
+// src/timescale/query.ts
+var resolveQueryTimeoutMs = (override) => {
   if (Number.isFinite(override) && Number(override) > 0) {
     return Math.floor(Number(override));
   }
   const configured = Number(process.env.MARKET_CONTEXT_SQL_TIMEOUT_MS);
   return Number.isFinite(configured) && configured > 0 ? Math.floor(configured) : 3e4;
 };
-var createMarketContextQueryError = (name, message) => {
+var createQueryError = (name, message) => {
   const error = new Error(message);
   error.name = name;
   return error;
 };
 var queryMarketContext = async (text, values, options = {}) => {
-  const pool = getPool();
-  const client = await pool.connect();
-  const timeoutMs = resolveMarketContextQueryTimeoutMs(options.timeoutMs);
+  const client = await getPool().connect();
+  const timeoutMs = resolveQueryTimeoutMs(options.timeoutMs);
   let released = false;
   let rejectCancellation;
   const release = (error) => {
@@ -182,14 +144,11 @@ var queryMarketContext = async (text, values, options = {}) => {
     rejectCancellation?.(error);
   };
   const onAbort = () => cancel(
-    createMarketContextQueryError(
-      "AbortError",
-      "Timescale market-context query aborted"
-    )
+    createQueryError("AbortError", "Timescale market-context query aborted")
   );
   const timer = setTimeout(
     () => cancel(
-      createMarketContextQueryError(
+      createQueryError(
         "TimescaleQueryTimeoutError",
         `Timescale market-context query exceeded ${timeoutMs}ms`
       )
@@ -200,24 +159,67 @@ var queryMarketContext = async (text, values, options = {}) => {
   options.signal?.addEventListener("abort", onAbort, { once: true });
   try {
     if (options.signal?.aborted) {
-      const error = createMarketContextQueryError(
+      const error = createQueryError(
         "AbortError",
         "Timescale market-context query aborted"
       );
       release(error);
       throw error;
     }
-    const query = client.query(text, values);
-    return await Promise.race([query, cancellation]);
+    return await Promise.race([client.query(text, values), cancellation]);
   } finally {
     clearTimeout(timer);
     options.signal?.removeEventListener("abort", onAbort);
     release();
   }
 };
+
+// src/timescale/values.ts
+var PG_SAFE_MAX_BIND_PARAMS = 3e4;
 var normalizeCandleProvider = (provider) => String(provider || "").trim().toLowerCase();
 var normalizeCandleSymbol = (symbol) => String(symbol || "").trim().toUpperCase();
 var getSafeBulkInsertRows = (columnsCount) => Math.max(1, Math.floor(PG_SAFE_MAX_BIND_PARAMS / columnsCount));
+var toMarketFeatureAge = (rowTs, atMs) => {
+  const ageMs = atMs - rowTs.getTime();
+  return Number.isFinite(ageMs) ? ageMs : null;
+};
+
+// src/timescale/internal.ts
+var candlesSchemaReady = false;
+var derivativesSchemaReady = false;
+var spreadSchemaReady = false;
+var binanceMarketSchemaReady = false;
+var hyperliquidWhaleSchemaReady = false;
+var candlesSchemaReadyPromise = null;
+var derivativesSchemaReadyPromise = null;
+var spreadSchemaReadyPromise = null;
+var binanceMarketSchemaReadyPromise = null;
+var hyperliquidWhaleSchemaReadyPromise = null;
+var marketContextSchemaMode = "ensure";
+var verifiedMarketContextSchemas = /* @__PURE__ */ new Set();
+var configureTimescaleMarketContextSchemaMode = (mode) => {
+  marketContextSchemaMode = mode;
+  verifiedMarketContextSchemas.clear();
+};
+var closeTimescalePool = async () => {
+  candlesSchemaReady = false;
+  derivativesSchemaReady = false;
+  spreadSchemaReady = false;
+  binanceMarketSchemaReady = false;
+  hyperliquidWhaleSchemaReady = false;
+  candlesSchemaReadyPromise = null;
+  derivativesSchemaReadyPromise = null;
+  spreadSchemaReadyPromise = null;
+  binanceMarketSchemaReadyPromise = null;
+  hyperliquidWhaleSchemaReadyPromise = null;
+  verifiedMarketContextSchemas.clear();
+  await closePool();
+};
+var CANDLES_SCHEMA_LOCK_KEY = 61e4;
+var DERIVATIVES_SCHEMA_LOCK_KEY = 610001;
+var SPREAD_SCHEMA_LOCK_KEY = 610002;
+var BINANCE_MARKET_SCHEMA_LOCK_KEY = 610003;
+var HYPERLIQUID_WHALE_SCHEMA_LOCK_KEY = 610004;
 var withSchemaLock = async (lockKey, work) => {
   const pool = getPool();
   await pool.query("SELECT pg_advisory_lock($1)", [lockKey]);
@@ -283,103 +285,6 @@ var ensureCandlesSchema = async () => {
   });
   await candlesSchemaReadyPromise;
 };
-var toRows = (provider, symbol, interval, data) => {
-  const normalizedProvider = normalizeCandleProvider(provider);
-  if (!normalizedProvider) {
-    throw new Error("Candle provider is required");
-  }
-  const normalizedSymbol = normalizeCandleSymbol(symbol);
-  return data.map((i) => ({
-    provider: normalizedProvider,
-    symbol: normalizedSymbol,
-    interval,
-    ts: new Date(i.timestamp),
-    // ms -> Date
-    open: i.open,
-    high: i.high,
-    low: i.low,
-    close: i.close,
-    volume: i.volume ?? null,
-    turnover: i.turnover ?? null,
-    takerBuyBaseVolume: i.takerBuyBaseVolume ?? null,
-    takerBuyQuoteVolume: i.takerBuyQuoteVolume ?? null,
-    takerSellBaseVolume: i.takerSellBaseVolume ?? null,
-    takerSellQuoteVolume: i.takerSellQuoteVolume ?? null
-  }));
-};
-async function upsertCandles(rows) {
-  if (!rows.length) return;
-  await ensureCandlesSchema();
-  const pool = getPool();
-  const cols = [
-    "provider",
-    "symbol",
-    "interval",
-    "ts",
-    "open",
-    "high",
-    "low",
-    "close",
-    "volume",
-    "turnover",
-    "taker_buy_base_volume",
-    "taker_buy_quote_volume",
-    "taker_sell_base_volume",
-    "taker_sell_quote_volume"
-  ];
-  const maxRows = Math.floor(65535 / cols.length);
-  if (rows.length > maxRows) {
-    for (let i = 0; i < rows.length; i += maxRows) {
-      await upsertCandles(rows.slice(i, i + maxRows));
-    }
-    return;
-  }
-  const valuesSql = rows.map(
-    (_, i) => `(${cols.map((__, j) => `$${i * cols.length + j + 1}`).join(",")})`
-  ).join(",");
-  const flat = rows.flatMap((r) => [
-    normalizeCandleProvider(r.provider),
-    normalizeCandleSymbol(r.symbol),
-    r.interval,
-    r.ts,
-    r.open,
-    r.high,
-    r.low,
-    r.close,
-    r.volume ?? null,
-    r.turnover ?? null,
-    r.takerBuyBaseVolume ?? null,
-    r.takerBuyQuoteVolume ?? null,
-    r.takerSellBaseVolume ?? null,
-    r.takerSellQuoteVolume ?? null
-  ]);
-  const sql = `
-    INSERT INTO candles (${cols.join(",")})
-    VALUES ${valuesSql}
-    ON CONFLICT (provider, symbol, interval, ts) DO UPDATE SET
-      open = EXCLUDED.open,
-      high = EXCLUDED.high,
-      low  = EXCLUDED.low,
-      close = EXCLUDED.close,
-      volume = COALESCE(EXCLUDED.volume, candles.volume),
-      turnover = COALESCE(EXCLUDED.turnover, candles.turnover),
-      taker_buy_base_volume = COALESCE(EXCLUDED.taker_buy_base_volume, candles.taker_buy_base_volume),
-      taker_buy_quote_volume = COALESCE(EXCLUDED.taker_buy_quote_volume, candles.taker_buy_quote_volume),
-      taker_sell_base_volume = COALESCE(EXCLUDED.taker_sell_base_volume, candles.taker_sell_base_volume),
-      taker_sell_quote_volume = COALESCE(EXCLUDED.taker_sell_quote_volume, candles.taker_sell_quote_volume)
-  `;
-  const client = await pool.connect();
-  try {
-    await client.query("BEGIN");
-    await client.query(sql, flat);
-    await client.query("COMMIT");
-  } catch (e) {
-    await client.query("ROLLBACK");
-    throw e;
-  } finally {
-    client.release();
-  }
-}
 var ensureDerivativesSchema = async () => {
   if (derivativesSchemaReady) return;
   if (derivativesSchemaReadyPromise) {
@@ -1071,44 +976,315 @@ var ensureMarketContextSchemas = async (sources) => {
     await ensureMarketContextSchema(source);
   }
 };
-async function upsertDerivatives(rows) {
+
+// src/timescale/candles.ts
+var toRows = (provider, symbol, interval, data) => {
+  const normalizedProvider = normalizeCandleProvider(provider);
+  if (!normalizedProvider) {
+    throw new Error("Candle provider is required");
+  }
+  const normalizedSymbol = normalizeCandleSymbol(symbol);
+  return data.map((i) => ({
+    provider: normalizedProvider,
+    symbol: normalizedSymbol,
+    interval,
+    ts: new Date(i.timestamp),
+    // ms -> Date
+    open: i.open,
+    high: i.high,
+    low: i.low,
+    close: i.close,
+    volume: i.volume ?? null,
+    turnover: i.turnover ?? null,
+    takerBuyBaseVolume: i.takerBuyBaseVolume ?? null,
+    takerBuyQuoteVolume: i.takerBuyQuoteVolume ?? null,
+    takerSellBaseVolume: i.takerSellBaseVolume ?? null,
+    takerSellQuoteVolume: i.takerSellQuoteVolume ?? null
+  }));
+};
+async function upsertCandles(rows) {
   if (!rows.length) return;
-  await ensureDerivativesSchema();
+  await ensureCandlesSchema();
   const pool = getPool();
   const cols = [
+    "provider",
     "symbol",
     "interval",
     "ts",
-    "open_interest",
-    "funding_rate",
-    "liq_long",
-    "liq_short",
-    "liq_total",
-    "source"
+    "open",
+    "high",
+    "low",
+    "close",
+    "volume",
+    "turnover",
+    "taker_buy_base_volume",
+    "taker_buy_quote_volume",
+    "taker_sell_base_volume",
+    "taker_sell_quote_volume"
   ];
   const maxRows = Math.floor(65535 / cols.length);
   if (rows.length > maxRows) {
     for (let i = 0; i < rows.length; i += maxRows) {
-      await upsertDerivatives(rows.slice(i, i + maxRows));
+      await upsertCandles(rows.slice(i, i + maxRows));
     }
     return;
   }
   const valuesSql = rows.map(
     (_, i) => `(${cols.map((__, j) => `$${i * cols.length + j + 1}`).join(",")})`
   ).join(",");
-  const flat = rows.flatMap((row) => [
-    row.symbol,
-    row.interval,
-    row.ts,
-    row.openInterest ?? null,
-    row.fundingRate ?? null,
-    row.liqLong ?? null,
-    row.liqShort ?? null,
-    row.liqTotal ?? null,
-    row.source ?? null
+  const flat = rows.flatMap((r) => [
+    normalizeCandleProvider(r.provider),
+    normalizeCandleSymbol(r.symbol),
+    r.interval,
+    r.ts,
+    r.open,
+    r.high,
+    r.low,
+    r.close,
+    r.volume ?? null,
+    r.turnover ?? null,
+    r.takerBuyBaseVolume ?? null,
+    r.takerBuyQuoteVolume ?? null,
+    r.takerSellBaseVolume ?? null,
+    r.takerSellQuoteVolume ?? null
   ]);
   const sql = `
-    INSERT INTO derivatives_market (${cols.join(",")})
+    INSERT INTO candles (${cols.join(",")})
+    VALUES ${valuesSql}
+    ON CONFLICT (provider, symbol, interval, ts) DO UPDATE SET
+      open = EXCLUDED.open,
+      high = EXCLUDED.high,
+      low  = EXCLUDED.low,
+      close = EXCLUDED.close,
+      volume = COALESCE(EXCLUDED.volume, candles.volume),
+      turnover = COALESCE(EXCLUDED.turnover, candles.turnover),
+      taker_buy_base_volume = COALESCE(EXCLUDED.taker_buy_base_volume, candles.taker_buy_base_volume),
+      taker_buy_quote_volume = COALESCE(EXCLUDED.taker_buy_quote_volume, candles.taker_buy_quote_volume),
+      taker_sell_base_volume = COALESCE(EXCLUDED.taker_sell_base_volume, candles.taker_sell_base_volume),
+      taker_sell_quote_volume = COALESCE(EXCLUDED.taker_sell_quote_volume, candles.taker_sell_quote_volume)
+  `;
+  const client = await pool.connect();
+  try {
+    await client.query("BEGIN");
+    await client.query(sql, flat);
+    await client.query("COMMIT");
+  } catch (e) {
+    await client.query("ROLLBACK");
+    throw e;
+  } finally {
+    client.release();
+  }
+}
+async function getCandlesRange(provider, symbol, interval, startMs, endMs) {
+  await ensureCandlesSchema();
+  const pool = getPool();
+  const normalizedProvider = normalizeCandleProvider(provider);
+  const normalizedSymbol = normalizeCandleSymbol(symbol);
+  const sql = `
+    SELECT symbol, interval, ts,
+           open, high, low, close, volume, turnover,
+           taker_buy_base_volume AS "takerBuyBaseVolume",
+           taker_buy_quote_volume AS "takerBuyQuoteVolume",
+           taker_sell_base_volume AS "takerSellBaseVolume",
+           taker_sell_quote_volume AS "takerSellQuoteVolume"
+    FROM candles
+    WHERE provider = $1 AND symbol = $2 AND interval = $3
+      AND ts >= to_timestamp($4/1000.0)
+      AND ts <= to_timestamp($5/1000.0)
+    ORDER BY ts ASC
+  `;
+  const res = await pool.query(sql, [
+    normalizedProvider,
+    normalizedSymbol,
+    interval,
+    startMs,
+    endMs
+  ]);
+  return res.rows;
+}
+async function getDataEdges(provider, symbol, interval) {
+  await ensureCandlesSchema();
+  const pool = getPool();
+  const normalizedProvider = normalizeCandleProvider(provider);
+  const normalizedSymbol = normalizeCandleSymbol(symbol);
+  const sqlMin = `
+    SELECT extract(epoch from ts)*1000 AS ms
+    FROM candles
+    WHERE provider=$1 AND symbol=$2 AND interval=$3
+    ORDER BY ts ASC
+    LIMIT 1
+  `;
+  const sqlMax = `
+    SELECT extract(epoch from ts)*1000 AS ms
+    FROM candles
+    WHERE provider=$1 AND symbol=$2 AND interval=$3
+    ORDER BY ts DESC
+    LIMIT 1
+  `;
+  const [minQ, maxQ] = await Promise.all([
+    pool.query(sqlMin, [normalizedProvider, normalizedSymbol, interval]),
+    pool.query(sqlMax, [normalizedProvider, normalizedSymbol, interval])
+  ]);
+  const minRaw = minQ.rows[0]?.ms;
+  const maxRaw = maxQ.rows[0]?.ms;
+  const min = Number.isFinite(Number(minRaw)) ? Number(minRaw) : void 0;
+  const max = Number.isFinite(Number(maxRaw)) ? Number(maxRaw) : void 0;
+  return { min, max };
+}
+async function getDataEdgesForSymbols(provider, symbols, interval) {
+  const normalizedSymbols = [
+    ...new Set(symbols.map(normalizeCandleSymbol).filter(Boolean))
+  ];
+  const result = /* @__PURE__ */ new Map();
+  for (const symbol of normalizedSymbols) {
+    result.set(symbol, {});
+  }
+  if (!normalizedSymbols.length) {
+    return result;
+  }
+  await ensureCandlesSchema();
+  const pool = getPool();
+  const normalizedProvider = normalizeCandleProvider(provider);
+  const sql = `
+    WITH requested(symbol) AS (
+      SELECT unnest($2::text[])
+    )
+    SELECT
+      r.symbol,
+      (
+        SELECT extract(epoch from c.ts)*1000
+        FROM candles c
+        WHERE c.provider = $1 AND c.symbol = r.symbol AND c.interval = $3
+        ORDER BY c.ts ASC
+        LIMIT 1
+      ) AS min_ms,
+      (
+        SELECT extract(epoch from c.ts)*1000
+        FROM candles c
+        WHERE c.provider = $1 AND c.symbol = r.symbol AND c.interval = $3
+        ORDER BY c.ts DESC
+        LIMIT 1
+      ) AS max_ms
+    FROM requested r
+  `;
+  const response = await pool.query(sql, [
+    normalizedProvider,
+    normalizedSymbols,
+    interval
+  ]);
+  for (const row of response.rows) {
+    const symbol = normalizeCandleSymbol(String(row.symbol || ""));
+    if (!symbol) continue;
+    const min = row.min_ms == null ? NaN : Number(row.min_ms);
+    const max = row.max_ms == null ? NaN : Number(row.max_ms);
+    result.set(symbol, {
+      ...Number.isFinite(min) ? { min } : {},
+      ...Number.isFinite(max) ? { max } : {}
+    });
+  }
+  return result;
+}
+async function waitForDbReady(attempts = 20, delayMs = 1e3) {
+  const pool = getPool();
+  let lastError;
+  for (let i = 0; i < attempts; i++) {
+    try {
+      await pool.query("SELECT 1");
+      return;
+    } catch (e) {
+      lastError = e;
+      await new Promise((r) => setTimeout(r, delayMs));
+    }
+  }
+  throw lastError;
+}
+async function deleteCandles(provider, symbol, interval) {
+  const pool = getPool();
+  const normalizedProvider = normalizeCandleProvider(provider);
+  const normalizedSymbol = normalizeCandleSymbol(symbol);
+  const sql = `
+    DELETE FROM candles
+    WHERE provider = $1 AND symbol = $2 AND interval = $3
+  `;
+  await pool.query(sql, [normalizedProvider, normalizedSymbol, interval]);
+}
+async function findContinuityGap(provider, symbol, interval) {
+  const pool = getPool();
+  const normalizedProvider = normalizeCandleProvider(provider);
+  const normalizedSymbol = normalizeCandleSymbol(symbol);
+  const expectedSeconds = interval * 60;
+  const sql = `
+    WITH ordered AS (
+      SELECT
+        ts,
+        LAG(ts) OVER (ORDER BY ts) AS prev_ts
+      FROM candles
+      WHERE provider = $1 AND symbol = $2 AND interval = $3
+    )
+    SELECT
+      ts,
+      prev_ts,
+      EXTRACT(EPOCH FROM (ts - prev_ts))::int AS diff_seconds
+    FROM ordered
+    WHERE prev_ts IS NOT NULL
+      AND EXTRACT(EPOCH FROM (ts - prev_ts))::int <> $4
+    ORDER BY ts ASC
+    LIMIT 1
+  `;
+  const res = await pool.query(sql, [
+    normalizedProvider,
+    normalizedSymbol,
+    interval,
+    expectedSeconds
+  ]);
+  const row = res.rows[0];
+  if (!row) return null;
+  return {
+    ts: new Date(row.ts).getTime(),
+    prevTs: new Date(row.prev_ts).getTime(),
+    diffSeconds: row.diff_seconds
+  };
+}
+
+// src/timescale/derivatives.ts
+async function upsertDerivatives(rows) {
+  if (!rows.length) return;
+  await ensureDerivativesSchema();
+  const pool = getPool();
+  const cols = [
+    "symbol",
+    "interval",
+    "ts",
+    "open_interest",
+    "funding_rate",
+    "liq_long",
+    "liq_short",
+    "liq_total",
+    "source"
+  ];
+  const maxRows = Math.floor(65535 / cols.length);
+  if (rows.length > maxRows) {
+    for (let i = 0; i < rows.length; i += maxRows) {
+      await upsertDerivatives(rows.slice(i, i + maxRows));
+    }
+    return;
+  }
+  const valuesSql = rows.map(
+    (_, i) => `(${cols.map((__, j) => `$${i * cols.length + j + 1}`).join(",")})`
+  ).join(",");
+  const flat = rows.flatMap((row) => [
+    row.symbol,
+    row.interval,
+    row.ts,
+    row.openInterest ?? null,
+    row.fundingRate ?? null,
+    row.liqLong ?? null,
+    row.liqShort ?? null,
+    row.liqTotal ?? null,
+    row.source ?? null
+  ]);
+  const sql = `
+    INSERT INTO derivatives_market (${cols.join(",")})
     VALUES ${valuesSql}
     ON CONFLICT (symbol, interval, ts) DO UPDATE SET
       open_interest = COALESCE(EXCLUDED.open_interest, derivatives_market.open_interest),
@@ -1542,6 +1718,8 @@ async function getDerivativesSummary(hours = 24, limit = 500, symbols) {
     items
   };
 }
+
+// src/timescale/spread.ts
 async function upsertSpreadRows(rows) {
   if (!rows.length) return;
   await ensureSpreadSchema();
@@ -1586,23 +1764,81 @@ async function upsertSpreadRows(rows) {
   `;
   await pool.query(sql, flat);
 }
-async function upsertMarketTradeFlowRows(rows) {
-  if (!rows.length) return;
-  await ensureBinanceMarketSchema();
+async function getSpreadRangeForSymbols(symbols, interval, startMs, endMs) {
+  if (!symbols.length) {
+    return [];
+  }
+  await ensureSpreadSchema();
   const pool = getPool();
-  const cols = [
-    "symbol",
-    "interval",
-    "ts",
-    "trades",
-    "buy_base_volume",
-    "sell_base_volume",
-    "buy_quote_volume",
-    "sell_quote_volume",
-    "net_base_delta",
-    "net_quote_delta",
-    "buy_pressure_pct",
-    "source"
+  const sql = `
+    SELECT symbol, interval, ts, binance_price, coinbase_price, spread
+    FROM market_spread
+    WHERE symbol = ANY($1)
+      AND interval = $2
+      AND ts >= to_timestamp($3/1000.0)
+      AND ts <= to_timestamp($4/1000.0)
+    ORDER BY symbol ASC, ts ASC
+  `;
+  const res = await pool.query(sql, [symbols, interval, startMs, endMs]);
+  return res.rows;
+}
+async function getSpreadSummary(hours = 24, limit = 500) {
+  await ensureSpreadSchema();
+  const pool = getPool();
+  const cappedHours = Math.max(1, Math.min(24 * 30, hours));
+  const cappedLimit = Math.max(50, Math.min(5e3, limit));
+  const rowsQ = await pool.query(
+    `
+      SELECT symbol, interval, ts, binance_price, coinbase_price, spread
+      FROM market_spread
+      WHERE ts >= now() - ($1 || ' hours')::interval
+      ORDER BY ts DESC
+      LIMIT $2
+    `,
+    [String(cappedHours), cappedLimit]
+  );
+  const aggQ = await pool.query(
+    `
+      SELECT
+        symbol,
+        interval,
+        COUNT(*)::int AS points,
+        MAX(ts) AS last_ts,
+        AVG(spread) AS avg_spread,
+        STDDEV_POP(spread) AS std_spread
+      FROM market_spread
+      WHERE ts >= now() - ($1 || ' hours')::interval
+      GROUP BY symbol, interval
+      ORDER BY points DESC, symbol ASC
+      LIMIT 500
+    `,
+    [String(cappedHours)]
+  );
+  return {
+    rows: rowsQ.rows,
+    aggregates: aggQ.rows,
+    hours: cappedHours
+  };
+}
+
+// src/timescale/marketContext.ts
+async function upsertMarketTradeFlowRows(rows) {
+  if (!rows.length) return;
+  await ensureBinanceMarketSchema();
+  const pool = getPool();
+  const cols = [
+    "symbol",
+    "interval",
+    "ts",
+    "trades",
+    "buy_base_volume",
+    "sell_base_volume",
+    "buy_quote_volume",
+    "sell_quote_volume",
+    "net_base_delta",
+    "net_quote_delta",
+    "buy_pressure_pct",
+    "source"
   ];
   const maxRows = getSafeBulkInsertRows(cols.length);
   if (rows.length > maxRows) {
@@ -1647,530 +1883,273 @@ async function upsertMarketTradeFlowRows(rows) {
     flat
   );
 }
-async function upsertHyperliquidWhaleTradeEvents(rows) {
+async function upsertMarketBreadthRows(rows) {
   if (!rows.length) return;
-  await ensureHyperliquidWhaleSchema();
+  await ensureBinanceMarketSchema();
+  const pool = getPool();
   const cols = [
-    "symbol",
+    "universe",
+    "interval",
     "ts",
-    "tid",
-    "price",
-    "size",
-    "notional_usd",
-    "buyer_address",
-    "seller_address",
-    "buyer_tracked",
-    "seller_tracked",
-    "buyer_start_position",
-    "buyer_end_position",
-    "buyer_position_action",
-    "buyer_closed_pnl",
-    "buyer_liquidation",
-    "seller_start_position",
-    "seller_end_position",
-    "seller_position_action",
-    "seller_closed_pnl",
-    "seller_liquidation",
-    "universe_fingerprint",
-    "whale_registry_fingerprint",
+    "symbols_count",
+    "advancers",
+    "decliners",
+    "unchanged",
+    "advance_decline_ratio",
+    "pct_above_ma20",
+    "pct_above_ma50",
+    "equal_weighted_return",
+    "volume_weighted_return",
+    "dispersion",
+    "btc_return_1h",
+    "btc_return_4h",
+    "btc_return_24h",
+    "alt_basket_return_1h",
+    "alt_basket_return_4h",
+    "alt_basket_return_24h",
+    "btc_vs_alt_return_1h",
+    "btc_vs_alt_return_4h",
+    "btc_vs_alt_return_24h",
+    "btc_turnover_share_1h",
+    "btc_turnover_share_24h",
+    "btc_turnover_share_change_24h",
+    "alt_vol_to_btc_vol_24h",
+    "alt_dispersion_24h",
+    "btc_alt_regime",
     "source"
   ];
   const maxRows = getSafeBulkInsertRows(cols.length);
   if (rows.length > maxRows) {
-    for (let index = 0; index < rows.length; index += maxRows) {
-      await upsertHyperliquidWhaleTradeEvents(
-        rows.slice(index, index + maxRows)
-      );
+    for (let i = 0; i < rows.length; i += maxRows) {
+      await upsertMarketBreadthRows(rows.slice(i, i + maxRows));
     }
     return;
   }
   const valuesSql = rows.map(
-    (_, rowIndex) => `(${cols.map((__, colIndex) => `$${rowIndex * cols.length + colIndex + 1}`).join(",")})`
+    (_, i) => `(${cols.map((__, j) => `$${i * cols.length + j + 1}`).join(",")})`
   ).join(",");
   const flat = rows.flatMap((row) => [
-    row.symbol,
+    row.universe,
+    row.interval,
     row.ts,
-    row.tid,
-    row.price,
-    row.size,
-    row.notionalUsd,
-    row.buyerAddress ?? null,
-    row.sellerAddress ?? null,
-    row.buyerTracked,
-    row.sellerTracked,
-    row.buyerStartPosition ?? null,
-    row.buyerEndPosition ?? null,
-    row.buyerPositionAction ?? null,
-    row.buyerClosedPnl ?? null,
-    row.buyerLiquidation ?? null,
-    row.sellerStartPosition ?? null,
-    row.sellerEndPosition ?? null,
-    row.sellerPositionAction ?? null,
-    row.sellerClosedPnl ?? null,
-    row.sellerLiquidation ?? null,
-    row.universeFingerprint,
-    row.whaleRegistryFingerprint,
+    row.symbolsCount,
+    row.advancers,
+    row.decliners,
+    row.unchanged,
+    row.advanceDeclineRatio ?? null,
+    row.pctAboveMa20 ?? null,
+    row.pctAboveMa50 ?? null,
+    row.equalWeightedReturn ?? null,
+    row.volumeWeightedReturn ?? null,
+    row.dispersion ?? null,
+    row.btcReturn1h ?? null,
+    row.btcReturn4h ?? null,
+    row.btcReturn24h ?? null,
+    row.altBasketReturn1h ?? null,
+    row.altBasketReturn4h ?? null,
+    row.altBasketReturn24h ?? null,
+    row.btcVsAltReturn1h ?? null,
+    row.btcVsAltReturn4h ?? null,
+    row.btcVsAltReturn24h ?? null,
+    row.btcTurnoverShare1h ?? null,
+    row.btcTurnoverShare24h ?? null,
+    row.btcTurnoverShareChange24h ?? null,
+    row.altVolToBtcVol24h ?? null,
+    row.altDispersion24h ?? null,
+    row.btcAltRegime ?? null,
     row.source ?? null
   ]);
-  await getPool().query(
+  await pool.query(
     `
-      INSERT INTO hyperliquid_whale_trade_events (${cols.join(",")})
+      INSERT INTO market_breadth (${cols.join(",")})
       VALUES ${valuesSql}
-      ON CONFLICT (
-        universe_fingerprint,
-        whale_registry_fingerprint,
-        symbol,
-        ts,
-        tid
-      ) DO UPDATE SET
-        buyer_address = COALESCE(
-          hyperliquid_whale_trade_events.buyer_address,
-          EXCLUDED.buyer_address
-        ),
-        seller_address = COALESCE(
-          hyperliquid_whale_trade_events.seller_address,
-          EXCLUDED.seller_address
-        ),
-        buyer_tracked = hyperliquid_whale_trade_events.buyer_tracked OR EXCLUDED.buyer_tracked,
-        seller_tracked = hyperliquid_whale_trade_events.seller_tracked OR EXCLUDED.seller_tracked,
-        buyer_start_position = COALESCE(
-          hyperliquid_whale_trade_events.buyer_start_position,
-          EXCLUDED.buyer_start_position
-        ),
-        buyer_end_position = COALESCE(
-          hyperliquid_whale_trade_events.buyer_end_position,
-          EXCLUDED.buyer_end_position
-        ),
-        buyer_position_action = COALESCE(
-          hyperliquid_whale_trade_events.buyer_position_action,
-          EXCLUDED.buyer_position_action
-        ),
-        buyer_closed_pnl = COALESCE(
-          hyperliquid_whale_trade_events.buyer_closed_pnl,
-          EXCLUDED.buyer_closed_pnl
-        ),
-        buyer_liquidation = COALESCE(
-          hyperliquid_whale_trade_events.buyer_liquidation,
-          EXCLUDED.buyer_liquidation
-        ),
-        seller_start_position = COALESCE(
-          hyperliquid_whale_trade_events.seller_start_position,
-          EXCLUDED.seller_start_position
-        ),
-        seller_end_position = COALESCE(
-          hyperliquid_whale_trade_events.seller_end_position,
-          EXCLUDED.seller_end_position
-        ),
-        seller_position_action = COALESCE(
-          hyperliquid_whale_trade_events.seller_position_action,
-          EXCLUDED.seller_position_action
-        ),
-        seller_closed_pnl = COALESCE(
-          hyperliquid_whale_trade_events.seller_closed_pnl,
-          EXCLUDED.seller_closed_pnl
-        ),
-        seller_liquidation = COALESCE(
-          hyperliquid_whale_trade_events.seller_liquidation,
-          EXCLUDED.seller_liquidation
-        ),
-        source = EXCLUDED.source,
-        ingested_at = now()
-    `,
-    flat
-  );
-}
-async function upsertHyperliquidWhaleFlowRows(rows) {
-  if (!rows.length) return;
-  await ensureHyperliquidWhaleSchema();
-  const cols = [
-    "symbol",
-    "interval",
-    "ts",
-    "trades",
-    "whale_sides",
-    "unique_whales",
-    "whale_addresses",
-    "buy_notional_usd",
-    "sell_notional_usd",
-    "net_notional_usd",
-    "buy_share_pct",
-    "position_aware_whale_sides",
-    "long_entry_whale_addresses",
-    "short_entry_whale_addresses",
-    "long_exit_whale_addresses",
-    "short_exit_whale_addresses",
-    "long_entry_notional_usd",
-    "short_entry_notional_usd",
-    "long_exit_notional_usd",
-    "short_exit_notional_usd",
-    "entry_net_notional_usd",
-    "entry_long_share_pct",
-    "universe_fingerprint",
-    "whale_registry_fingerprint",
-    "source"
+      ON CONFLICT (universe, interval, ts) DO UPDATE SET
+        symbols_count = EXCLUDED.symbols_count,
+        advancers = EXCLUDED.advancers,
+        decliners = EXCLUDED.decliners,
+        unchanged = EXCLUDED.unchanged,
+        advance_decline_ratio = COALESCE(EXCLUDED.advance_decline_ratio, market_breadth.advance_decline_ratio),
+        pct_above_ma20 = COALESCE(EXCLUDED.pct_above_ma20, market_breadth.pct_above_ma20),
+        pct_above_ma50 = COALESCE(EXCLUDED.pct_above_ma50, market_breadth.pct_above_ma50),
+        equal_weighted_return = COALESCE(EXCLUDED.equal_weighted_return, market_breadth.equal_weighted_return),
+        volume_weighted_return = COALESCE(EXCLUDED.volume_weighted_return, market_breadth.volume_weighted_return),
+        dispersion = COALESCE(EXCLUDED.dispersion, market_breadth.dispersion),
+        btc_return_1h = COALESCE(EXCLUDED.btc_return_1h, market_breadth.btc_return_1h),
+        btc_return_4h = COALESCE(EXCLUDED.btc_return_4h, market_breadth.btc_return_4h),
+        btc_return_24h = COALESCE(EXCLUDED.btc_return_24h, market_breadth.btc_return_24h),
+        alt_basket_return_1h = COALESCE(EXCLUDED.alt_basket_return_1h, market_breadth.alt_basket_return_1h),
+        alt_basket_return_4h = COALESCE(EXCLUDED.alt_basket_return_4h, market_breadth.alt_basket_return_4h),
+        alt_basket_return_24h = COALESCE(EXCLUDED.alt_basket_return_24h, market_breadth.alt_basket_return_24h),
+        btc_vs_alt_return_1h = COALESCE(EXCLUDED.btc_vs_alt_return_1h, market_breadth.btc_vs_alt_return_1h),
+        btc_vs_alt_return_4h = COALESCE(EXCLUDED.btc_vs_alt_return_4h, market_breadth.btc_vs_alt_return_4h),
+        btc_vs_alt_return_24h = COALESCE(EXCLUDED.btc_vs_alt_return_24h, market_breadth.btc_vs_alt_return_24h),
+        btc_turnover_share_1h = COALESCE(EXCLUDED.btc_turnover_share_1h, market_breadth.btc_turnover_share_1h),
+        btc_turnover_share_24h = COALESCE(EXCLUDED.btc_turnover_share_24h, market_breadth.btc_turnover_share_24h),
+        btc_turnover_share_change_24h = COALESCE(EXCLUDED.btc_turnover_share_change_24h, market_breadth.btc_turnover_share_change_24h),
+        alt_vol_to_btc_vol_24h = COALESCE(EXCLUDED.alt_vol_to_btc_vol_24h, market_breadth.alt_vol_to_btc_vol_24h),
+        alt_dispersion_24h = COALESCE(EXCLUDED.alt_dispersion_24h, market_breadth.alt_dispersion_24h),
+        btc_alt_regime = COALESCE(EXCLUDED.btc_alt_regime, market_breadth.btc_alt_regime),
+        source = COALESCE(EXCLUDED.source, market_breadth.source),
+        ingested_at = now()
+    `,
+    flat
+  );
+}
+async function upsertMarketGlobalContextRows(rows) {
+  if (!rows.length) return;
+  await ensureBinanceMarketSchema();
+  const pool = getPool();
+  const cols = [
+    "source",
+    "ts",
+    "updated_at_ts",
+    "active_cryptocurrencies",
+    "active_exchanges",
+    "active_market_pairs",
+    "markets",
+    "total_market_cap_usd",
+    "total_volume_usd",
+    "total_volume_reported_usd",
+    "btc_dominance_pct",
+    "eth_dominance_pct",
+    "alt_market_cap_usd",
+    "alt_volume_usd",
+    "alt_volume_reported_usd",
+    "btc_to_alt_market_cap_ratio",
+    "market_cap_change_pct_24h_usd"
   ];
   const maxRows = getSafeBulkInsertRows(cols.length);
   if (rows.length > maxRows) {
-    for (let index = 0; index < rows.length; index += maxRows) {
-      await upsertHyperliquidWhaleFlowRows(rows.slice(index, index + maxRows));
+    for (let i = 0; i < rows.length; i += maxRows) {
+      await upsertMarketGlobalContextRows(rows.slice(i, i + maxRows));
     }
     return;
   }
   const valuesSql = rows.map(
-    (_, rowIndex) => `(${cols.map((__, colIndex) => `$${rowIndex * cols.length + colIndex + 1}`).join(",")})`
+    (_, i) => `(${cols.map((__, j) => `$${i * cols.length + j + 1}`).join(",")})`
   ).join(",");
   const flat = rows.flatMap((row) => [
-    row.symbol,
+    row.source,
+    row.ts,
+    row.updatedAt ?? null,
+    row.activeCryptocurrencies ?? null,
+    row.activeExchanges ?? null,
+    row.activeMarketPairs ?? null,
+    row.markets ?? null,
+    row.totalMarketCapUsd ?? null,
+    row.totalVolumeUsd ?? null,
+    row.totalVolumeReportedUsd ?? null,
+    row.btcDominancePct ?? null,
+    row.ethDominancePct ?? null,
+    row.altMarketCapUsd ?? null,
+    row.altVolumeUsd ?? null,
+    row.altVolumeReportedUsd ?? null,
+    row.btcToAltMarketCapRatio ?? null,
+    row.marketCapChangePct24hUsd ?? null
+  ]);
+  await pool.query(
+    `
+      INSERT INTO market_global_context (${cols.join(",")})
+      VALUES ${valuesSql}
+      ON CONFLICT (source, ts) DO UPDATE SET
+        updated_at_ts = COALESCE(EXCLUDED.updated_at_ts, market_global_context.updated_at_ts),
+        active_cryptocurrencies = COALESCE(EXCLUDED.active_cryptocurrencies, market_global_context.active_cryptocurrencies),
+        active_exchanges = COALESCE(EXCLUDED.active_exchanges, market_global_context.active_exchanges),
+        active_market_pairs = COALESCE(EXCLUDED.active_market_pairs, market_global_context.active_market_pairs),
+        markets = COALESCE(EXCLUDED.markets, market_global_context.markets),
+        total_market_cap_usd = COALESCE(EXCLUDED.total_market_cap_usd, market_global_context.total_market_cap_usd),
+        total_volume_usd = COALESCE(EXCLUDED.total_volume_usd, market_global_context.total_volume_usd),
+        total_volume_reported_usd = COALESCE(EXCLUDED.total_volume_reported_usd, market_global_context.total_volume_reported_usd),
+        btc_dominance_pct = COALESCE(EXCLUDED.btc_dominance_pct, market_global_context.btc_dominance_pct),
+        eth_dominance_pct = COALESCE(EXCLUDED.eth_dominance_pct, market_global_context.eth_dominance_pct),
+        alt_market_cap_usd = COALESCE(EXCLUDED.alt_market_cap_usd, market_global_context.alt_market_cap_usd),
+        alt_volume_usd = COALESCE(EXCLUDED.alt_volume_usd, market_global_context.alt_volume_usd),
+        alt_volume_reported_usd = COALESCE(EXCLUDED.alt_volume_reported_usd, market_global_context.alt_volume_reported_usd),
+        btc_to_alt_market_cap_ratio = COALESCE(EXCLUDED.btc_to_alt_market_cap_ratio, market_global_context.btc_to_alt_market_cap_ratio),
+        market_cap_change_pct_24h_usd = COALESCE(EXCLUDED.market_cap_change_pct_24h_usd, market_global_context.market_cap_change_pct_24h_usd),
+        ingested_at = now()
+    `,
+    flat
+  );
+}
+async function upsertMarketReferenceAssetContextRows(rows) {
+  if (!rows.length) return;
+  await ensureBinanceMarketSchema();
+  const pool = getPool();
+  const cols = [
+    "source",
+    "symbol",
+    "cmc_id",
+    "interval",
+    "ts",
+    "open_usd",
+    "high_usd",
+    "low_usd",
+    "close_usd",
+    "volume_usd",
+    "market_cap_usd"
+  ];
+  const maxRows = getSafeBulkInsertRows(cols.length);
+  if (rows.length > maxRows) {
+    for (let i = 0; i < rows.length; i += maxRows) {
+      await upsertMarketReferenceAssetContextRows(rows.slice(i, i + maxRows));
+    }
+    return;
+  }
+  const valuesSql = rows.map(
+    (_, i) => `(${cols.map((__, j) => `$${i * cols.length + j + 1}`).join(",")})`
+  ).join(",");
+  const flat = rows.flatMap((row) => [
+    row.source,
+    row.symbol.trim().toUpperCase(),
+    Math.trunc(row.cmcId),
     row.interval,
     row.ts,
-    row.trades,
-    row.whaleSides,
-    row.uniqueWhales,
-    row.whaleAddresses ?? [],
-    row.buyNotionalUsd,
-    row.sellNotionalUsd,
-    row.netNotionalUsd,
-    row.buySharePct ?? null,
-    row.positionAwareWhaleSides,
-    row.longEntryWhaleAddresses ?? [],
-    row.shortEntryWhaleAddresses ?? [],
-    row.longExitWhaleAddresses ?? [],
-    row.shortExitWhaleAddresses ?? [],
-    row.longEntryNotionalUsd,
-    row.shortEntryNotionalUsd,
-    row.longExitNotionalUsd,
-    row.shortExitNotionalUsd,
-    row.entryNetNotionalUsd,
-    row.entryLongSharePct ?? null,
-    row.universeFingerprint,
-    row.whaleRegistryFingerprint,
-    row.source ?? null
+    row.openUsd ?? null,
+    row.highUsd ?? null,
+    row.lowUsd ?? null,
+    row.closeUsd ?? null,
+    row.volumeUsd ?? null,
+    row.marketCapUsd ?? null
   ]);
-  await getPool().query(
+  await pool.query(
     `
-      INSERT INTO hyperliquid_whale_flow (${cols.join(",")})
+      INSERT INTO market_reference_asset_context (${cols.join(",")})
       VALUES ${valuesSql}
-      ON CONFLICT (
-        universe_fingerprint,
-        whale_registry_fingerprint,
-        symbol,
-        interval,
-        ts
-      ) DO UPDATE SET
-        trades = EXCLUDED.trades,
-        whale_sides = EXCLUDED.whale_sides,
-        unique_whales = EXCLUDED.unique_whales,
-        whale_addresses = EXCLUDED.whale_addresses,
-        buy_notional_usd = EXCLUDED.buy_notional_usd,
-        sell_notional_usd = EXCLUDED.sell_notional_usd,
-        net_notional_usd = EXCLUDED.net_notional_usd,
-        buy_share_pct = EXCLUDED.buy_share_pct,
-        position_aware_whale_sides = EXCLUDED.position_aware_whale_sides,
-        long_entry_whale_addresses = EXCLUDED.long_entry_whale_addresses,
-        short_entry_whale_addresses = EXCLUDED.short_entry_whale_addresses,
-        long_exit_whale_addresses = EXCLUDED.long_exit_whale_addresses,
-        short_exit_whale_addresses = EXCLUDED.short_exit_whale_addresses,
-        long_entry_notional_usd = EXCLUDED.long_entry_notional_usd,
-        short_entry_notional_usd = EXCLUDED.short_entry_notional_usd,
-        long_exit_notional_usd = EXCLUDED.long_exit_notional_usd,
-        short_exit_notional_usd = EXCLUDED.short_exit_notional_usd,
-        entry_net_notional_usd = EXCLUDED.entry_net_notional_usd,
-        entry_long_share_pct = EXCLUDED.entry_long_share_pct,
-        source = EXCLUDED.source,
+      ON CONFLICT (source, symbol, interval, ts) DO UPDATE SET
+        cmc_id = EXCLUDED.cmc_id,
+        open_usd = COALESCE(EXCLUDED.open_usd, market_reference_asset_context.open_usd),
+        high_usd = COALESCE(EXCLUDED.high_usd, market_reference_asset_context.high_usd),
+        low_usd = COALESCE(EXCLUDED.low_usd, market_reference_asset_context.low_usd),
+        close_usd = COALESCE(EXCLUDED.close_usd, market_reference_asset_context.close_usd),
+        volume_usd = COALESCE(EXCLUDED.volume_usd, market_reference_asset_context.volume_usd),
+        market_cap_usd = COALESCE(EXCLUDED.market_cap_usd, market_reference_asset_context.market_cap_usd),
         ingested_at = now()
     `,
     flat
   );
 }
-async function rebuildHyperliquidWhaleFlowRows(params) {
-  await ensureHyperliquidWhaleSchema();
-  const client = await getPool().connect();
-  try {
-    await client.query("BEGIN");
-    const result = await client.query(
-      `
-        WITH source_events AS (
-          SELECT *
-          FROM hyperliquid_whale_trade_events
-          WHERE universe_fingerprint = $1
-            AND whale_registry_fingerprint = $2
-            AND ts >= to_timestamp($3/1000.0)
-            AND ts < to_timestamp($4/1000.0)
-        ), metrics AS (
-          SELECT
-            symbol,
-            date_trunc('minute', ts) AS bucket_ts,
-            COUNT(*)::int AS trades,
-            SUM(buyer_tracked::int + seller_tracked::int)::int AS whale_sides,
-            SUM(CASE WHEN buyer_tracked THEN notional_usd ELSE 0 END) AS buy_notional_usd,
-            SUM(CASE WHEN seller_tracked THEN notional_usd ELSE 0 END) AS sell_notional_usd
-          FROM source_events
-          GROUP BY symbol, date_trunc('minute', ts)
-        ), position_legs AS (
-          SELECT
-            symbol,
-            ts,
-            price,
-            buyer_address AS whale_address,
-            buyer_start_position AS start_position,
-            buyer_end_position AS end_position
-          FROM source_events
-          WHERE buyer_tracked
-            AND buyer_address IS NOT NULL
-            AND buyer_start_position IS NOT NULL
-            AND buyer_end_position IS NOT NULL
-          UNION ALL
-          SELECT
-            symbol,
-            ts,
-            price,
-            seller_address AS whale_address,
-            seller_start_position AS start_position,
-            seller_end_position AS end_position
-          FROM source_events
-          WHERE seller_tracked
-            AND seller_address IS NOT NULL
-            AND seller_start_position IS NOT NULL
-            AND seller_end_position IS NOT NULL
-        ), classified_legs AS (
-          SELECT
-            *,
-            GREATEST(
-              GREATEST(end_position, 0) - GREATEST(start_position, 0),
-              0
-            ) AS long_entry_size,
-            GREATEST(
-              GREATEST(-end_position, 0) - GREATEST(-start_position, 0),
-              0
-            ) AS short_entry_size,
-            GREATEST(
-              GREATEST(start_position, 0) - GREATEST(end_position, 0),
-              0
-            ) AS long_exit_size,
-            GREATEST(
-              GREATEST(-start_position, 0) - GREATEST(-end_position, 0),
-              0
-            ) AS short_exit_size
-          FROM position_legs
-        ), position_metrics AS (
-          SELECT
-            symbol,
-            date_trunc('minute', ts) AS bucket_ts,
-            COUNT(*)::int AS position_aware_whale_sides,
-            SUM(long_entry_size * price) AS long_entry_notional_usd,
-            SUM(short_entry_size * price) AS short_entry_notional_usd,
-            SUM(long_exit_size * price) AS long_exit_notional_usd,
-            SUM(short_exit_size * price) AS short_exit_notional_usd,
-            COALESCE(
-              ARRAY_AGG(DISTINCT whale_address ORDER BY whale_address)
-                FILTER (WHERE long_entry_size > 0),
-              '{}'
-            ) AS long_entry_whale_addresses,
-            COALESCE(
-              ARRAY_AGG(DISTINCT whale_address ORDER BY whale_address)
-                FILTER (WHERE short_entry_size > 0),
-              '{}'
-            ) AS short_entry_whale_addresses,
-            COALESCE(
-              ARRAY_AGG(DISTINCT whale_address ORDER BY whale_address)
-                FILTER (WHERE long_exit_size > 0),
-              '{}'
-            ) AS long_exit_whale_addresses,
-            COALESCE(
-              ARRAY_AGG(DISTINCT whale_address ORDER BY whale_address)
-                FILTER (WHERE short_exit_size > 0),
-              '{}'
-            ) AS short_exit_whale_addresses
-          FROM classified_legs
-          GROUP BY symbol, date_trunc('minute', ts)
-        ), addresses AS (
-          SELECT
-            symbol,
-            date_trunc('minute', ts) AS bucket_ts,
-            ARRAY_AGG(DISTINCT whale_address ORDER BY whale_address) AS whale_addresses
-          FROM source_events
-          CROSS JOIN LATERAL UNNEST(ARRAY[
-            CASE WHEN buyer_tracked THEN buyer_address END,
-            CASE WHEN seller_tracked THEN seller_address END
-          ]) AS expanded(whale_address)
-          WHERE whale_address IS NOT NULL
-          GROUP BY symbol, date_trunc('minute', ts)
-        )
-        INSERT INTO hyperliquid_whale_flow (
-          symbol,
-          interval,
-          ts,
-          trades,
-          whale_sides,
-          unique_whales,
-          whale_addresses,
-          buy_notional_usd,
-          sell_notional_usd,
-          net_notional_usd,
-          buy_share_pct,
-          position_aware_whale_sides,
-          long_entry_whale_addresses,
-          short_entry_whale_addresses,
-          long_exit_whale_addresses,
-          short_exit_whale_addresses,
-          long_entry_notional_usd,
-          short_entry_notional_usd,
-          long_exit_notional_usd,
-          short_exit_notional_usd,
-          entry_net_notional_usd,
-          entry_long_share_pct,
-          universe_fingerprint,
-          whale_registry_fingerprint,
-          source
-        )
-        SELECT
-          metrics.symbol,
-          '1m',
-          metrics.bucket_ts,
-          metrics.trades,
-          metrics.whale_sides,
-          COALESCE(CARDINALITY(addresses.whale_addresses), 0),
-          COALESCE(addresses.whale_addresses, '{}'),
-          metrics.buy_notional_usd,
-          metrics.sell_notional_usd,
-          metrics.buy_notional_usd - metrics.sell_notional_usd,
-          CASE
-            WHEN metrics.buy_notional_usd + metrics.sell_notional_usd > 0
-            THEN metrics.buy_notional_usd /
-              (metrics.buy_notional_usd + metrics.sell_notional_usd)
-            ELSE NULL
-          END,
-          COALESCE(position_metrics.position_aware_whale_sides, 0),
-          COALESCE(position_metrics.long_entry_whale_addresses, '{}'),
-          COALESCE(position_metrics.short_entry_whale_addresses, '{}'),
-          COALESCE(position_metrics.long_exit_whale_addresses, '{}'),
-          COALESCE(position_metrics.short_exit_whale_addresses, '{}'),
-          COALESCE(position_metrics.long_entry_notional_usd, 0),
-          COALESCE(position_metrics.short_entry_notional_usd, 0),
-          COALESCE(position_metrics.long_exit_notional_usd, 0),
-          COALESCE(position_metrics.short_exit_notional_usd, 0),
-          COALESCE(position_metrics.long_entry_notional_usd, 0) -
-            COALESCE(position_metrics.short_entry_notional_usd, 0),
-          CASE
-            WHEN COALESCE(position_metrics.long_entry_notional_usd, 0) +
-              COALESCE(position_metrics.short_entry_notional_usd, 0) > 0
-            THEN COALESCE(position_metrics.long_entry_notional_usd, 0) /
-              (
-                COALESCE(position_metrics.long_entry_notional_usd, 0) +
-                COALESCE(position_metrics.short_entry_notional_usd, 0)
-              )
-            ELSE NULL
-          END,
-          $1,
-          $2,
-          CASE
-            WHEN COALESCE(position_metrics.position_aware_whale_sides, 0) > 0
-            THEN 'hyperliquid_user_fills'
-            ELSE 'hyperliquid_trades'
-          END
-        FROM metrics
-        LEFT JOIN addresses USING (symbol, bucket_ts)
-        LEFT JOIN position_metrics USING (symbol, bucket_ts)
-        ON CONFLICT (
-          universe_fingerprint,
-          whale_registry_fingerprint,
-          symbol,
-          interval,
-          ts
-        ) DO UPDATE SET
-          trades = EXCLUDED.trades,
-          whale_sides = EXCLUDED.whale_sides,
-          unique_whales = EXCLUDED.unique_whales,
-          whale_addresses = EXCLUDED.whale_addresses,
-          buy_notional_usd = EXCLUDED.buy_notional_usd,
-          sell_notional_usd = EXCLUDED.sell_notional_usd,
-          net_notional_usd = EXCLUDED.net_notional_usd,
-          buy_share_pct = EXCLUDED.buy_share_pct,
-          position_aware_whale_sides = EXCLUDED.position_aware_whale_sides,
-          long_entry_whale_addresses = EXCLUDED.long_entry_whale_addresses,
-          short_entry_whale_addresses = EXCLUDED.short_entry_whale_addresses,
-          long_exit_whale_addresses = EXCLUDED.long_exit_whale_addresses,
-          short_exit_whale_addresses = EXCLUDED.short_exit_whale_addresses,
-          long_entry_notional_usd = EXCLUDED.long_entry_notional_usd,
-          short_entry_notional_usd = EXCLUDED.short_entry_notional_usd,
-          long_exit_notional_usd = EXCLUDED.long_exit_notional_usd,
-          short_exit_notional_usd = EXCLUDED.short_exit_notional_usd,
-          entry_net_notional_usd = EXCLUDED.entry_net_notional_usd,
-          entry_long_share_pct = EXCLUDED.entry_long_share_pct,
-          source = EXCLUDED.source,
-          ingested_at = now()
-        RETURNING 1
-      `,
-      [
-        params.universeFingerprint,
-        params.whaleRegistryFingerprint,
-        params.fromMs,
-        params.toMs
-      ]
-    );
-    if (params.deleteEventsBeforeMs != null) {
-      await client.query(
-        `
-          DELETE FROM hyperliquid_whale_trade_events
-          WHERE universe_fingerprint = $1
-            AND whale_registry_fingerprint = $2
-            AND ts < to_timestamp($3/1000.0)
-        `,
-        [
-          params.universeFingerprint,
-          params.whaleRegistryFingerprint,
-          params.deleteEventsBeforeMs
-        ]
-      );
-    }
-    await client.query("COMMIT");
-    return result.rowCount ?? 0;
-  } catch (error) {
-    await client.query("ROLLBACK");
-    throw error;
-  } finally {
-    client.release();
-  }
-}
-async function upsertMarketBreadthRows(rows) {
+async function upsertMarketCmcExchangeLiquidityContextRows(rows) {
   if (!rows.length) return;
   await ensureBinanceMarketSchema();
   const pool = getPool();
   const cols = [
-    "universe",
+    "source",
     "interval",
     "ts",
-    "symbols_count",
-    "advancers",
-    "decliners",
-    "unchanged",
-    "advance_decline_ratio",
-    "pct_above_ma20",
-    "pct_above_ma50",
-    "equal_weighted_return",
-    "volume_weighted_return",
-    "dispersion",
-    "btc_return_1h",
-    "btc_return_4h",
-    "btc_return_24h",
-    "alt_basket_return_1h",
-    "alt_basket_return_4h",
-    "alt_basket_return_24h",
-    "btc_vs_alt_return_1h",
-    "btc_vs_alt_return_4h",
-    "btc_vs_alt_return_24h",
-    "btc_turnover_share_1h",
-    "btc_turnover_share_24h",
-    "btc_turnover_share_change_24h",
-    "alt_vol_to_btc_vol_24h",
-    "alt_dispersion_24h",
-    "btc_alt_regime",
-    "source"
+    "exchanges_count",
+    "total_volume_usd",
+    "binance_volume_usd",
+    "binance_volume_share",
+    "top_exchange_volume_share",
+    "liquidity_regime"
   ];
   const maxRows = getSafeBulkInsertRows(cols.length);
   if (rows.length > maxRows) {
     for (let i = 0; i < rows.length; i += maxRows) {
-      await upsertMarketBreadthRows(rows.slice(i, i + maxRows));
+      await upsertMarketCmcExchangeLiquidityContextRows(
+        rows.slice(i, i + maxRows)
+      );
     }
     return;
   }
@@ -2178,235 +2157,7 @@ async function upsertMarketBreadthRows(rows) {
     (_, i) => `(${cols.map((__, j) => `$${i * cols.length + j + 1}`).join(",")})`
   ).join(",");
   const flat = rows.flatMap((row) => [
-    row.universe,
-    row.interval,
-    row.ts,
-    row.symbolsCount,
-    row.advancers,
-    row.decliners,
-    row.unchanged,
-    row.advanceDeclineRatio ?? null,
-    row.pctAboveMa20 ?? null,
-    row.pctAboveMa50 ?? null,
-    row.equalWeightedReturn ?? null,
-    row.volumeWeightedReturn ?? null,
-    row.dispersion ?? null,
-    row.btcReturn1h ?? null,
-    row.btcReturn4h ?? null,
-    row.btcReturn24h ?? null,
-    row.altBasketReturn1h ?? null,
-    row.altBasketReturn4h ?? null,
-    row.altBasketReturn24h ?? null,
-    row.btcVsAltReturn1h ?? null,
-    row.btcVsAltReturn4h ?? null,
-    row.btcVsAltReturn24h ?? null,
-    row.btcTurnoverShare1h ?? null,
-    row.btcTurnoverShare24h ?? null,
-    row.btcTurnoverShareChange24h ?? null,
-    row.altVolToBtcVol24h ?? null,
-    row.altDispersion24h ?? null,
-    row.btcAltRegime ?? null,
-    row.source ?? null
-  ]);
-  await pool.query(
-    `
-      INSERT INTO market_breadth (${cols.join(",")})
-      VALUES ${valuesSql}
-      ON CONFLICT (universe, interval, ts) DO UPDATE SET
-        symbols_count = EXCLUDED.symbols_count,
-        advancers = EXCLUDED.advancers,
-        decliners = EXCLUDED.decliners,
-        unchanged = EXCLUDED.unchanged,
-        advance_decline_ratio = COALESCE(EXCLUDED.advance_decline_ratio, market_breadth.advance_decline_ratio),
-        pct_above_ma20 = COALESCE(EXCLUDED.pct_above_ma20, market_breadth.pct_above_ma20),
-        pct_above_ma50 = COALESCE(EXCLUDED.pct_above_ma50, market_breadth.pct_above_ma50),
-        equal_weighted_return = COALESCE(EXCLUDED.equal_weighted_return, market_breadth.equal_weighted_return),
-        volume_weighted_return = COALESCE(EXCLUDED.volume_weighted_return, market_breadth.volume_weighted_return),
-        dispersion = COALESCE(EXCLUDED.dispersion, market_breadth.dispersion),
-        btc_return_1h = COALESCE(EXCLUDED.btc_return_1h, market_breadth.btc_return_1h),
-        btc_return_4h = COALESCE(EXCLUDED.btc_return_4h, market_breadth.btc_return_4h),
-        btc_return_24h = COALESCE(EXCLUDED.btc_return_24h, market_breadth.btc_return_24h),
-        alt_basket_return_1h = COALESCE(EXCLUDED.alt_basket_return_1h, market_breadth.alt_basket_return_1h),
-        alt_basket_return_4h = COALESCE(EXCLUDED.alt_basket_return_4h, market_breadth.alt_basket_return_4h),
-        alt_basket_return_24h = COALESCE(EXCLUDED.alt_basket_return_24h, market_breadth.alt_basket_return_24h),
-        btc_vs_alt_return_1h = COALESCE(EXCLUDED.btc_vs_alt_return_1h, market_breadth.btc_vs_alt_return_1h),
-        btc_vs_alt_return_4h = COALESCE(EXCLUDED.btc_vs_alt_return_4h, market_breadth.btc_vs_alt_return_4h),
-        btc_vs_alt_return_24h = COALESCE(EXCLUDED.btc_vs_alt_return_24h, market_breadth.btc_vs_alt_return_24h),
-        btc_turnover_share_1h = COALESCE(EXCLUDED.btc_turnover_share_1h, market_breadth.btc_turnover_share_1h),
-        btc_turnover_share_24h = COALESCE(EXCLUDED.btc_turnover_share_24h, market_breadth.btc_turnover_share_24h),
-        btc_turnover_share_change_24h = COALESCE(EXCLUDED.btc_turnover_share_change_24h, market_breadth.btc_turnover_share_change_24h),
-        alt_vol_to_btc_vol_24h = COALESCE(EXCLUDED.alt_vol_to_btc_vol_24h, market_breadth.alt_vol_to_btc_vol_24h),
-        alt_dispersion_24h = COALESCE(EXCLUDED.alt_dispersion_24h, market_breadth.alt_dispersion_24h),
-        btc_alt_regime = COALESCE(EXCLUDED.btc_alt_regime, market_breadth.btc_alt_regime),
-        source = COALESCE(EXCLUDED.source, market_breadth.source),
-        ingested_at = now()
-    `,
-    flat
-  );
-}
-async function upsertMarketGlobalContextRows(rows) {
-  if (!rows.length) return;
-  await ensureBinanceMarketSchema();
-  const pool = getPool();
-  const cols = [
-    "source",
-    "ts",
-    "updated_at_ts",
-    "active_cryptocurrencies",
-    "active_exchanges",
-    "active_market_pairs",
-    "markets",
-    "total_market_cap_usd",
-    "total_volume_usd",
-    "total_volume_reported_usd",
-    "btc_dominance_pct",
-    "eth_dominance_pct",
-    "alt_market_cap_usd",
-    "alt_volume_usd",
-    "alt_volume_reported_usd",
-    "btc_to_alt_market_cap_ratio",
-    "market_cap_change_pct_24h_usd"
-  ];
-  const maxRows = getSafeBulkInsertRows(cols.length);
-  if (rows.length > maxRows) {
-    for (let i = 0; i < rows.length; i += maxRows) {
-      await upsertMarketGlobalContextRows(rows.slice(i, i + maxRows));
-    }
-    return;
-  }
-  const valuesSql = rows.map(
-    (_, i) => `(${cols.map((__, j) => `$${i * cols.length + j + 1}`).join(",")})`
-  ).join(",");
-  const flat = rows.flatMap((row) => [
-    row.source,
-    row.ts,
-    row.updatedAt ?? null,
-    row.activeCryptocurrencies ?? null,
-    row.activeExchanges ?? null,
-    row.activeMarketPairs ?? null,
-    row.markets ?? null,
-    row.totalMarketCapUsd ?? null,
-    row.totalVolumeUsd ?? null,
-    row.totalVolumeReportedUsd ?? null,
-    row.btcDominancePct ?? null,
-    row.ethDominancePct ?? null,
-    row.altMarketCapUsd ?? null,
-    row.altVolumeUsd ?? null,
-    row.altVolumeReportedUsd ?? null,
-    row.btcToAltMarketCapRatio ?? null,
-    row.marketCapChangePct24hUsd ?? null
-  ]);
-  await pool.query(
-    `
-      INSERT INTO market_global_context (${cols.join(",")})
-      VALUES ${valuesSql}
-      ON CONFLICT (source, ts) DO UPDATE SET
-        updated_at_ts = COALESCE(EXCLUDED.updated_at_ts, market_global_context.updated_at_ts),
-        active_cryptocurrencies = COALESCE(EXCLUDED.active_cryptocurrencies, market_global_context.active_cryptocurrencies),
-        active_exchanges = COALESCE(EXCLUDED.active_exchanges, market_global_context.active_exchanges),
-        active_market_pairs = COALESCE(EXCLUDED.active_market_pairs, market_global_context.active_market_pairs),
-        markets = COALESCE(EXCLUDED.markets, market_global_context.markets),
-        total_market_cap_usd = COALESCE(EXCLUDED.total_market_cap_usd, market_global_context.total_market_cap_usd),
-        total_volume_usd = COALESCE(EXCLUDED.total_volume_usd, market_global_context.total_volume_usd),
-        total_volume_reported_usd = COALESCE(EXCLUDED.total_volume_reported_usd, market_global_context.total_volume_reported_usd),
-        btc_dominance_pct = COALESCE(EXCLUDED.btc_dominance_pct, market_global_context.btc_dominance_pct),
-        eth_dominance_pct = COALESCE(EXCLUDED.eth_dominance_pct, market_global_context.eth_dominance_pct),
-        alt_market_cap_usd = COALESCE(EXCLUDED.alt_market_cap_usd, market_global_context.alt_market_cap_usd),
-        alt_volume_usd = COALESCE(EXCLUDED.alt_volume_usd, market_global_context.alt_volume_usd),
-        alt_volume_reported_usd = COALESCE(EXCLUDED.alt_volume_reported_usd, market_global_context.alt_volume_reported_usd),
-        btc_to_alt_market_cap_ratio = COALESCE(EXCLUDED.btc_to_alt_market_cap_ratio, market_global_context.btc_to_alt_market_cap_ratio),
-        market_cap_change_pct_24h_usd = COALESCE(EXCLUDED.market_cap_change_pct_24h_usd, market_global_context.market_cap_change_pct_24h_usd),
-        ingested_at = now()
-    `,
-    flat
-  );
-}
-async function upsertMarketReferenceAssetContextRows(rows) {
-  if (!rows.length) return;
-  await ensureBinanceMarketSchema();
-  const pool = getPool();
-  const cols = [
-    "source",
-    "symbol",
-    "cmc_id",
-    "interval",
-    "ts",
-    "open_usd",
-    "high_usd",
-    "low_usd",
-    "close_usd",
-    "volume_usd",
-    "market_cap_usd"
-  ];
-  const maxRows = getSafeBulkInsertRows(cols.length);
-  if (rows.length > maxRows) {
-    for (let i = 0; i < rows.length; i += maxRows) {
-      await upsertMarketReferenceAssetContextRows(rows.slice(i, i + maxRows));
-    }
-    return;
-  }
-  const valuesSql = rows.map(
-    (_, i) => `(${cols.map((__, j) => `$${i * cols.length + j + 1}`).join(",")})`
-  ).join(",");
-  const flat = rows.flatMap((row) => [
-    row.source,
-    row.symbol.trim().toUpperCase(),
-    Math.trunc(row.cmcId),
-    row.interval,
-    row.ts,
-    row.openUsd ?? null,
-    row.highUsd ?? null,
-    row.lowUsd ?? null,
-    row.closeUsd ?? null,
-    row.volumeUsd ?? null,
-    row.marketCapUsd ?? null
-  ]);
-  await pool.query(
-    `
-      INSERT INTO market_reference_asset_context (${cols.join(",")})
-      VALUES ${valuesSql}
-      ON CONFLICT (source, symbol, interval, ts) DO UPDATE SET
-        cmc_id = EXCLUDED.cmc_id,
-        open_usd = COALESCE(EXCLUDED.open_usd, market_reference_asset_context.open_usd),
-        high_usd = COALESCE(EXCLUDED.high_usd, market_reference_asset_context.high_usd),
-        low_usd = COALESCE(EXCLUDED.low_usd, market_reference_asset_context.low_usd),
-        close_usd = COALESCE(EXCLUDED.close_usd, market_reference_asset_context.close_usd),
-        volume_usd = COALESCE(EXCLUDED.volume_usd, market_reference_asset_context.volume_usd),
-        market_cap_usd = COALESCE(EXCLUDED.market_cap_usd, market_reference_asset_context.market_cap_usd),
-        ingested_at = now()
-    `,
-    flat
-  );
-}
-async function upsertMarketCmcExchangeLiquidityContextRows(rows) {
-  if (!rows.length) return;
-  await ensureBinanceMarketSchema();
-  const pool = getPool();
-  const cols = [
-    "source",
-    "interval",
-    "ts",
-    "exchanges_count",
-    "total_volume_usd",
-    "binance_volume_usd",
-    "binance_volume_share",
-    "top_exchange_volume_share",
-    "liquidity_regime"
-  ];
-  const maxRows = getSafeBulkInsertRows(cols.length);
-  if (rows.length > maxRows) {
-    for (let i = 0; i < rows.length; i += maxRows) {
-      await upsertMarketCmcExchangeLiquidityContextRows(
-        rows.slice(i, i + maxRows)
-      );
-    }
-    return;
-  }
-  const valuesSql = rows.map(
-    (_, i) => `(${cols.map((__, j) => `$${i * cols.length + j + 1}`).join(",")})`
-  ).join(",");
-  const flat = rows.flatMap((row) => [
-    row.source,
+    row.source,
     row.interval,
     row.ts,
     Math.trunc(row.exchangesCount),
@@ -2615,10 +2366,6 @@ async function upsertMarketContextBackfillCoverage(rows) {
     flat
   );
 }
-var toMarketFeatureAge = (rowTs, atMs) => {
-  const ageMs = atMs - rowTs.getTime();
-  return Number.isFinite(ageMs) ? ageMs : null;
-};
 async function getLatestMarketTradeFlow(params) {
   await prepareMarketContextSchemaForRead("binance");
   const res = await queryMarketContext(
@@ -2655,695 +2402,388 @@ async function getLatestMarketTradeFlow(params) {
     stale: ageMs == null || params.maxAgeMs != null && ageMs > params.maxAgeMs
   };
 }
-var HYPERLIQUID_CONTEXT_INTERVAL_MS = {
-  "1m": 6e4,
-  "5m": 5 * 6e4,
-  "15m": 15 * 6e4,
-  "1h": 60 * 6e4
-};
-async function getHyperliquidWhaleWalletCoverage(params) {
-  await ensureHyperliquidWhaleSchema();
-  const result = await getPool().query(
+async function getLatestMarketBreadth(params) {
+  await prepareMarketContextSchemaForRead("binance");
+  const res = await queryMarketContext(
     `
       SELECT
-        status,
-        covered_from_ts,
-        covered_to_ts,
-        fills_count,
-        error,
-        checked_at
-      FROM hyperliquid_whale_wallet_coverage
-      WHERE universe_fingerprint = $1
-        AND whale_registry_fingerprint = $2
-        AND address = $3
-        AND data_model_version = $6
-        AND (
-          (
-            covered_from_ts <= to_timestamp($4/1000.0)
-            AND covered_to_ts >= to_timestamp($5/1000.0)
-          )
-          OR (
-            requested_from_ts = to_timestamp($4/1000.0)
-            AND requested_to_ts = to_timestamp($5/1000.0)
-          )
-        )
-      ORDER BY checked_at DESC
+        universe,
+        interval,
+        ts,
+        symbols_count::int AS "symbolsCount",
+        advancers::int AS advancers,
+        decliners::int AS decliners,
+        unchanged::int AS unchanged,
+        advance_decline_ratio AS "advanceDeclineRatio",
+        pct_above_ma20 AS "pctAboveMa20",
+        pct_above_ma50 AS "pctAboveMa50",
+        equal_weighted_return AS "equalWeightedReturn",
+        volume_weighted_return AS "volumeWeightedReturn",
+        dispersion,
+        btc_return_1h AS "btcReturn1h",
+        btc_return_4h AS "btcReturn4h",
+        btc_return_24h AS "btcReturn24h",
+        alt_basket_return_1h AS "altBasketReturn1h",
+        alt_basket_return_4h AS "altBasketReturn4h",
+        alt_basket_return_24h AS "altBasketReturn24h",
+        btc_vs_alt_return_1h AS "btcVsAltReturn1h",
+        btc_vs_alt_return_4h AS "btcVsAltReturn4h",
+        btc_vs_alt_return_24h AS "btcVsAltReturn24h",
+        btc_turnover_share_1h AS "btcTurnoverShare1h",
+        btc_turnover_share_24h AS "btcTurnoverShare24h",
+        btc_turnover_share_change_24h AS "btcTurnoverShareChange24h",
+        alt_vol_to_btc_vol_24h AS "altVolToBtcVol24h",
+        alt_dispersion_24h AS "altDispersion24h",
+        btc_alt_regime AS "btcAltRegime",
+        source
+      FROM market_breadth
+      WHERE universe = $1
+        AND interval = $2
+        AND ts <= to_timestamp($3/1000.0)
+      ORDER BY ts DESC
       LIMIT 1
     `,
-    [
-      params.universeFingerprint,
-      params.whaleRegistryFingerprint,
-      params.address.toLowerCase(),
-      params.fromMs,
-      params.toMs,
-      import_types.HYPERLIQUID_WHALE_DATA_MODEL_VERSION
-    ]
+    [params.universe, params.interval, params.atMs],
+    params
   );
-  const row = result.rows[0];
+  const row = res.rows[0];
   if (!row) return null;
+  const ageMs = toMarketFeatureAge(row.ts, params.atMs);
   return {
-    status: row.covered_from_ts != null && row.covered_to_ts != null && new Date(row.covered_from_ts).getTime() <= params.fromMs && new Date(row.covered_to_ts).getTime() >= params.toMs ? "complete" : String(row.status),
-    coveredFromMs: row.covered_from_ts == null ? null : new Date(row.covered_from_ts).getTime(),
-    coveredToMs: row.covered_to_ts == null ? null : new Date(row.covered_to_ts).getTime(),
-    fillsCount: Number(row.fills_count) || 0,
-    error: row.error == null ? null : String(row.error),
-    checkedAt: new Date(row.checked_at)
+    ...row,
+    ageMs,
+    stale: ageMs == null || params.maxAgeMs != null && ageMs > params.maxAgeMs
   };
 }
-async function upsertHyperliquidWhaleWalletCoverage(params) {
-  await ensureHyperliquidWhaleSchema();
-  await getPool().query(
+async function getLatestMarketGlobalContext(params) {
+  await prepareMarketContextSchemaForRead("coinmarketcap");
+  const source = params.source ?? "coinmarketcap_global";
+  const res = await queryMarketContext(
     `
-      INSERT INTO hyperliquid_whale_wallet_coverage (
-        universe_fingerprint,
-        whale_registry_fingerprint,
-        address,
-        requested_from_ts,
-        requested_to_ts,
-        covered_from_ts,
-        covered_to_ts,
-        status,
-        fills_count,
-        error,
-        data_model_version
-      ) VALUES (
-        $1,
-        $2,
-        $3,
-        to_timestamp($4/1000.0),
-        to_timestamp($5/1000.0),
-        CASE WHEN $6::double precision IS NULL THEN NULL ELSE to_timestamp($6/1000.0) END,
-        CASE WHEN $7::double precision IS NULL THEN NULL ELSE to_timestamp($7/1000.0) END,
-        $8,
-        $9,
-        $10,
-        $11
-      )
-      ON CONFLICT (
-        universe_fingerprint,
-        whale_registry_fingerprint,
-        address,
-        requested_from_ts,
-        requested_to_ts
-      ) DO UPDATE SET
-        covered_from_ts = EXCLUDED.covered_from_ts,
-        covered_to_ts = EXCLUDED.covered_to_ts,
-        status = EXCLUDED.status,
-        fills_count = EXCLUDED.fills_count,
-        error = EXCLUDED.error,
-        data_model_version = EXCLUDED.data_model_version,
-        checked_at = now()
+      SELECT
+        source,
+        ts,
+        updated_at_ts AS "updatedAt",
+        active_cryptocurrencies::int AS "activeCryptocurrencies",
+        active_exchanges::int AS "activeExchanges",
+        active_market_pairs::int AS "activeMarketPairs",
+        markets::int AS markets,
+        total_market_cap_usd AS "totalMarketCapUsd",
+        total_volume_usd AS "totalVolumeUsd",
+        total_volume_reported_usd AS "totalVolumeReportedUsd",
+        btc_dominance_pct AS "btcDominancePct",
+        eth_dominance_pct AS "ethDominancePct",
+        alt_market_cap_usd AS "altMarketCapUsd",
+        alt_volume_usd AS "altVolumeUsd",
+        alt_volume_reported_usd AS "altVolumeReportedUsd",
+        btc_to_alt_market_cap_ratio AS "btcToAltMarketCapRatio",
+        market_cap_change_pct_24h_usd AS "marketCapChangePct24hUsd"
+      FROM market_global_context
+      WHERE source = $1
+        AND ts + CASE
+          WHEN source = 'coinmarketcap_global' THEN interval '1 day'
+          ELSE interval '0 seconds'
+        END <= to_timestamp($2/1000.0)
+      ORDER BY ts DESC
+      LIMIT 1
     `,
-    [
-      params.universeFingerprint,
-      params.whaleRegistryFingerprint,
-      params.address.toLowerCase(),
-      params.fromMs,
-      params.toMs,
-      params.coveredFromMs,
-      params.coveredToMs,
-      params.status,
-      params.fillsCount,
-      params.error ?? null,
-      import_types.HYPERLIQUID_WHALE_DATA_MODEL_VERSION
-    ]
+    [source, params.atMs],
+    params
+  );
+  const row = res.rows[0];
+  if (!row) return null;
+  const previousRes = await queryMarketContext(
+    `
+      SELECT
+        btc_dominance_pct AS "btcDominancePct",
+        eth_dominance_pct AS "ethDominancePct",
+        alt_market_cap_usd AS "altMarketCapUsd",
+        alt_volume_usd AS "altVolumeUsd"
+      FROM market_global_context
+      WHERE source = $1
+        AND ts <= $2::timestamptz - interval '24 hours'
+      ORDER BY ts DESC
+      LIMIT 1
+    `,
+    [source, row.ts],
+    params
   );
+  const previousDominance = previousRes.rows[0]?.btcDominancePct == null ? null : Number(previousRes.rows[0].btcDominancePct);
+  const previousEthDominance = previousRes.rows[0]?.ethDominancePct == null ? null : Number(previousRes.rows[0].ethDominancePct);
+  const previousAltMarketCap = previousRes.rows[0]?.altMarketCapUsd == null ? null : Number(previousRes.rows[0].altMarketCapUsd);
+  const previousAltVolume = previousRes.rows[0]?.altVolumeUsd == null ? null : Number(previousRes.rows[0].altVolumeUsd);
+  const currentDominance = row.btcDominancePct == null ? null : Number(row.btcDominancePct);
+  const currentEthDominance = row.ethDominancePct == null ? null : Number(row.ethDominancePct);
+  const currentAltMarketCap = row.altMarketCapUsd == null ? null : Number(row.altMarketCapUsd);
+  const currentAltVolume = row.altVolumeUsd == null ? null : Number(row.altVolumeUsd);
+  const ageMs = toMarketFeatureAge(row.ts, params.atMs);
+  return {
+    ...row,
+    ageMs,
+    stale: ageMs == null || params.maxAgeMs != null && ageMs > params.maxAgeMs,
+    btcDominanceChange24hPct: currentDominance != null && previousDominance != null ? currentDominance - previousDominance : null,
+    ethDominanceChange24hPct: currentEthDominance != null && previousEthDominance != null ? currentEthDominance - previousEthDominance : null,
+    altMarketCapChange24hPct: currentAltMarketCap != null && previousAltMarketCap != null && previousAltMarketCap > 0 ? (currentAltMarketCap - previousAltMarketCap) / previousAltMarketCap : null,
+    altVolumeChange24hPct: currentAltVolume != null && previousAltVolume != null && previousAltVolume > 0 ? (currentAltVolume - previousAltVolume) / previousAltVolume : null
+  };
 }
-async function rebuildHyperliquidWhaleCoverageRows(params) {
-  await ensureHyperliquidWhaleSchema();
-  if (params.toMs <= params.fromMs) return 0;
-  const minuteMs = 6e4;
-  const defaultChunkMinutes = 7 * 24 * 60;
-  const chunkMinutes = Number.isFinite(params.chunkMinutes) && Number(params.chunkMinutes) > 0 ? Math.floor(Number(params.chunkMinutes)) : defaultChunkMinutes;
-  const chunkMs = chunkMinutes * minuteMs;
-  const totalBuckets = Math.ceil((params.toMs - params.fromMs) / minuteMs);
-  const totalChunks = Math.ceil((params.toMs - params.fromMs) / chunkMs);
-  let completedBuckets = 0;
-  let rows = 0;
-  for (let chunkIndex = 0, chunkFromMs = params.fromMs; chunkFromMs < params.toMs; chunkIndex += 1, chunkFromMs += chunkMs) {
-    const chunkToMs = Math.min(params.toMs, chunkFromMs + chunkMs);
-    const result = await getPool().query(
-      `
-        WITH normalized_ranges AS (
-          SELECT
-            address,
-            GREATEST(
-              to_timestamp($3/1000.0),
-              date_trunc('minute', covered_from_ts) +
-                CASE
-                  WHEN covered_from_ts = date_trunc('minute', covered_from_ts)
-                  THEN interval '0 minutes'
-                  ELSE interval '1 minute'
-                END
-            ) AS range_start,
-            LEAST(
-              to_timestamp($4/1000.0),
-              date_trunc('minute', covered_to_ts)
-            ) AS range_end
-          FROM hyperliquid_whale_wallet_coverage
-          WHERE universe_fingerprint = $1
-            AND whale_registry_fingerprint = $2
-            AND data_model_version = $6
-            AND status IN ('complete', 'truncated')
-            AND covered_from_ts < to_timestamp($4/1000.0)
-            AND covered_to_ts > to_timestamp($3/1000.0)
-        ), eligible_ranges AS (
-          SELECT *
-          FROM normalized_ranges
-          WHERE range_start < range_end
-        ), ordered_ranges AS (
-          SELECT
-            *,
-            MAX(range_end) OVER (
-              PARTITION BY address
-              ORDER BY range_start, range_end
-              ROWS BETWEEN UNBOUNDED PRECEDING AND 1 PRECEDING
-            ) AS previous_max_end
-          FROM eligible_ranges
-        ), marked_ranges AS (
-          SELECT
-            *,
-            SUM(
-              CASE
-                WHEN previous_max_end IS NULL OR range_start > previous_max_end
-                THEN 1
-                ELSE 0
-              END
-            ) OVER (
-              PARTITION BY address
-              ORDER BY range_start, range_end
-            ) AS range_group
-          FROM ordered_ranges
-        ), merged_ranges AS (
-          SELECT
-            address,
-            MIN(range_start) AS range_start,
-            MAX(range_end) AS range_end
-          FROM marked_ranges
-          GROUP BY address, range_group
-        ), deltas AS (
-          SELECT range_start AS ts, 1 AS delta
-          FROM merged_ranges
-          UNION ALL
-          SELECT range_end AS ts, -1 AS delta
-          FROM merged_ranges
-        ), bucket_deltas AS (
-          SELECT ts, SUM(delta)::int AS delta
-          FROM deltas
-          GROUP BY ts
-        ), buckets AS (
-          SELECT generate_series(
-            to_timestamp($3/1000.0),
-            to_timestamp($4/1000.0) - interval '1 minute',
-            interval '1 minute'
-          ) AS ts
-        ), coverage AS (
-          SELECT
-            buckets.ts,
-            SUM(COALESCE(bucket_deltas.delta, 0)) OVER (
-              ORDER BY buckets.ts
-              ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW
-            )::int AS covered_whales
-          FROM buckets
-          LEFT JOIN bucket_deltas USING (ts)
-        )
-        INSERT INTO hyperliquid_whale_coverage_1m (
-          ts,
-          covered_whales,
-          expected_whales,
-          coverage_pct,
-          universe_fingerprint,
-          whale_registry_fingerprint,
-          source,
-          data_model_version
-        )
-        SELECT
-          ts,
-          covered_whales,
-          $5,
-          CASE WHEN $5 > 0 THEN covered_whales::double precision / $5 ELSE 0 END,
-          $1,
-          $2,
-          'hyperliquid_user_fills',
-          $6
-        FROM coverage
-        ON CONFLICT (
-          universe_fingerprint,
-          whale_registry_fingerprint,
-          ts
-        ) DO UPDATE SET
-          covered_whales = EXCLUDED.covered_whales,
-          expected_whales = EXCLUDED.expected_whales,
-          coverage_pct = EXCLUDED.coverage_pct,
-          source = EXCLUDED.source,
-          data_model_version = EXCLUDED.data_model_version,
-          ingested_at = now()
-      `,
-      [
-        params.universeFingerprint,
-        params.whaleRegistryFingerprint,
-        chunkFromMs,
-        chunkToMs,
-        params.expectedWhales,
-        import_types.HYPERLIQUID_WHALE_DATA_MODEL_VERSION
-      ]
-    );
-    const chunkBuckets = Math.ceil((chunkToMs - chunkFromMs) / minuteMs);
-    completedBuckets = Math.min(totalBuckets, completedBuckets + chunkBuckets);
-    rows += result.rowCount ?? 0;
-    params.onProgress?.({
-      chunkIndex: chunkIndex + 1,
-      totalChunks,
-      completedBuckets,
-      totalBuckets,
-      rows
-    });
-  }
-  return rows;
-}
-async function upsertHyperliquidWhaleCoverageRows(rows) {
-  if (!rows.length) return;
-  await ensureHyperliquidWhaleSchema();
-  const cols = [
-    "ts",
-    "covered_whales",
-    "expected_whales",
-    "coverage_pct",
-    "universe_fingerprint",
-    "whale_registry_fingerprint",
-    "source",
-    "data_model_version"
-  ];
-  const maxRows = Math.floor(PG_SAFE_MAX_BIND_PARAMS / cols.length);
-  if (rows.length > maxRows) {
-    for (let index = 0; index < rows.length; index += maxRows) {
-      await upsertHyperliquidWhaleCoverageRows(
-        rows.slice(index, index + maxRows)
-      );
-    }
-    return;
-  }
-  const values = [];
-  const tuples = rows.map((row, rowIndex) => {
-    const offset = rowIndex * cols.length;
-    values.push(
-      row.ts,
-      row.coveredWhales,
-      row.expectedWhales,
-      row.coveragePct,
-      row.universeFingerprint,
-      row.whaleRegistryFingerprint,
-      row.source ?? null,
-      row.dataModelVersion ?? import_types.HYPERLIQUID_WHALE_DATA_MODEL_VERSION
-    );
-    return `(${cols.map((_, colIndex) => `$${offset + colIndex + 1}`).join(",")})`;
-  });
-  await getPool().query(
+async function getMarketGlobalContextCoverage(params) {
+  await ensureBinanceMarketSchema();
+  const pool = getPool();
+  const res = await pool.query(
     `
-      INSERT INTO hyperliquid_whale_coverage_1m (${cols.join(",")})
-      VALUES ${tuples.join(",")}
-      ON CONFLICT (
-        universe_fingerprint,
-        whale_registry_fingerprint,
-        ts
-      ) DO UPDATE SET
-        covered_whales = EXCLUDED.covered_whales,
-        expected_whales = EXCLUDED.expected_whales,
-        coverage_pct = EXCLUDED.coverage_pct,
-        source = EXCLUDED.source,
-        data_model_version = EXCLUDED.data_model_version,
-        ingested_at = now()
+      SELECT
+        extract(epoch from MIN(ts))*1000 AS first_ms,
+        extract(epoch from MAX(ts))*1000 AS last_ms,
+        COUNT(*)::int AS rows
+      FROM market_global_context
+      WHERE source = $1
+        AND ts >= to_timestamp($2/1000.0)
+        AND ts <= to_timestamp($3/1000.0)
     `,
-    values
+    [params.source, params.startMs, params.endMs]
   );
+  const row = res.rows[0];
+  const rows = Number(row?.rows ?? 0);
+  const firstMs = Number(row?.first_ms);
+  const lastMs = Number(row?.last_ms);
+  if (!rows || !Number.isFinite(firstMs) || !Number.isFinite(lastMs)) {
+    return null;
+  }
+  return { firstMs, lastMs, rows };
 }
-async function getHyperliquidWhaleCoverageSeriesRows(params) {
-  await prepareMarketContextSchemaForRead("hyperliquidWhales");
-  const result = await queryMarketContext(
+async function getMarketReferenceAssetContextCoverage(params) {
+  const symbols = [
+    ...new Set(
+      params.symbols.map((symbol) => symbol.trim().toUpperCase()).filter(Boolean)
+    )
+  ];
+  const coverage = /* @__PURE__ */ new Map();
+  if (!symbols.length) return coverage;
+  await ensureBinanceMarketSchema();
+  const pool = getPool();
+  const res = await pool.query(
     `
       SELECT
-        ts,
-        covered_whales,
-        expected_whales,
-        coverage_pct
-      FROM hyperliquid_whale_coverage_1m
-      WHERE universe_fingerprint = $1
-        AND whale_registry_fingerprint = $2
-        AND data_model_version = $3
+        symbol,
+        extract(epoch from MIN(ts))*1000 AS first_ms,
+        extract(epoch from MAX(ts))*1000 AS last_ms,
+        COUNT(*)::int AS rows
+      FROM market_reference_asset_context
+      WHERE source = $1
+        AND symbol = ANY($2)
+        AND interval = $3
         AND ts >= to_timestamp($4/1000.0)
-        AND ts < to_timestamp($5/1000.0)
-      ORDER BY ts
+        AND ts <= to_timestamp($5/1000.0)
+      GROUP BY symbol
     `,
-    [
-      params.universeFingerprint,
-      params.whaleRegistryFingerprint,
-      import_types.HYPERLIQUID_WHALE_DATA_MODEL_VERSION,
-      params.fromMs,
-      params.toMs
-    ],
-    params
+    [params.source, symbols, params.interval, params.startMs, params.endMs]
   );
-  return result.rows.map((row) => ({
-    ts: new Date(row.ts),
-    coveredWhales: Number(row.covered_whales) || 0,
-    expectedWhales: Number(row.expected_whales) || 0,
-    coveragePct: Number(row.coverage_pct) || 0
-  }));
+  for (const row of res.rows) {
+    const firstMs = Number(row.first_ms);
+    const lastMs = Number(row.last_ms);
+    const rows = Number(row.rows);
+    if (Number.isFinite(firstMs) && Number.isFinite(lastMs) && rows > 0) {
+      coverage.set(row.symbol.toUpperCase(), { firstMs, lastMs, rows });
+    }
+  }
+  return coverage;
 }
-async function getHyperliquidWhaleFlowSeriesRows(params) {
-  await prepareMarketContextSchemaForRead("hyperliquidWhales");
-  const result = await queryMarketContext(
+async function getLatestMarketReferenceAssetContexts(params) {
+  const source = params.source ?? "coinmarketcap_reference_asset";
+  const interval = params.interval ?? "1d";
+  const symbols = [
+    ...new Set(
+      params.symbols.map((symbol) => symbol.trim().toUpperCase()).filter(Boolean)
+    )
+  ];
+  const rows = /* @__PURE__ */ new Map();
+  if (!symbols.length) return rows;
+  await prepareMarketContextSchemaForRead("coinmarketcap");
+  const res = await queryMarketContext(
     `
-      SELECT
+      SELECT DISTINCT ON (symbol)
+        source,
+        symbol,
+        cmc_id AS "cmcId",
+        interval,
         ts,
-        trades,
-        whale_sides,
-        whale_addresses,
-        buy_notional_usd,
-        sell_notional_usd,
-        position_aware_whale_sides,
-        long_entry_whale_addresses,
-        short_entry_whale_addresses,
-        long_exit_whale_addresses,
-        short_exit_whale_addresses,
-        long_entry_notional_usd,
-        short_entry_notional_usd,
-        long_exit_notional_usd,
-        short_exit_notional_usd
-      FROM hyperliquid_whale_flow
-      WHERE symbol = $1
-        AND interval = '1m'
-        AND universe_fingerprint = $2
-        AND whale_registry_fingerprint = $3
-        AND ts >= to_timestamp($4/1000.0)
-        AND ts < to_timestamp($5/1000.0)
-      ORDER BY ts
+        open_usd AS "openUsd",
+        high_usd AS "highUsd",
+        low_usd AS "lowUsd",
+        close_usd AS "closeUsd",
+        volume_usd AS "volumeUsd",
+        market_cap_usd AS "marketCapUsd"
+      FROM market_reference_asset_context
+      WHERE source = $1
+        AND symbol = ANY($2)
+        AND interval = $3
+        AND ts + CASE interval
+          WHEN '1d' THEN interval '1 day'
+          WHEN '1h' THEN interval '1 hour'
+          ELSE interval '0 seconds'
+        END <= to_timestamp($4/1000.0)
+      ORDER BY symbol ASC, ts DESC
     `,
-    [
-      params.symbol,
-      params.universeFingerprint,
-      params.whaleRegistryFingerprint,
-      params.fromMs,
-      params.toMs
-    ],
+    [source, symbols, interval, params.atMs],
     params
   );
-  return result.rows.map((row) => ({
-    ts: new Date(row.ts),
-    trades: Number(row.trades) || 0,
-    whaleSides: Number(row.whale_sides) || 0,
-    whaleAddresses: Array.isArray(row.whale_addresses) ? row.whale_addresses.map(String) : [],
-    buyNotionalUsd: Number(row.buy_notional_usd) || 0,
-    sellNotionalUsd: Number(row.sell_notional_usd) || 0,
-    positionAwareWhaleSides: Number(row.position_aware_whale_sides) || 0,
-    longEntryWhaleAddresses: Array.isArray(row.long_entry_whale_addresses) ? row.long_entry_whale_addresses.map(String) : [],
-    shortEntryWhaleAddresses: Array.isArray(row.short_entry_whale_addresses) ? row.short_entry_whale_addresses.map(String) : [],
-    longExitWhaleAddresses: Array.isArray(row.long_exit_whale_addresses) ? row.long_exit_whale_addresses.map(String) : [],
-    shortExitWhaleAddresses: Array.isArray(row.short_exit_whale_addresses) ? row.short_exit_whale_addresses.map(String) : [],
-    longEntryNotionalUsd: Number(row.long_entry_notional_usd) || 0,
-    shortEntryNotionalUsd: Number(row.short_entry_notional_usd) || 0,
-    longExitNotionalUsd: Number(row.long_exit_notional_usd) || 0,
-    shortExitNotionalUsd: Number(row.short_exit_notional_usd) || 0
-  }));
+  for (const row of res.rows) {
+    const ageMs = toMarketFeatureAge(row.ts, params.atMs);
+    rows.set(row.symbol.toUpperCase(), {
+      ...row,
+      ageMs,
+      stale: ageMs == null || params.maxAgeMs != null && ageMs > params.maxAgeMs
+    });
+  }
+  return rows;
 }
-async function getHyperliquidWhaleFlowAggregate(params) {
-  await prepareMarketContextSchemaForRead("hyperliquidWhales");
-  const intervalMs = HYPERLIQUID_CONTEXT_INTERVAL_MS[params.interval];
-  const expectedBuckets = Math.ceil(intervalMs / 6e4);
+async function getLatestMarketCmcExchangeLiquidityContext(params) {
+  await prepareMarketContextSchemaForRead("coinmarketcap");
+  const source = params.source ?? "coinmarketcap_exchange_liquidity";
+  const interval = params.interval ?? "1d";
   const res = await queryMarketContext(
     `
-      WITH coverage_rows AS (
-        SELECT *
-        FROM hyperliquid_whale_coverage_1m
-        WHERE universe_fingerprint = $2
-          AND whale_registry_fingerprint = $3
-          AND data_model_version = $6
-          AND ts >= to_timestamp(
-            ($4::double precision - $5::double precision) / 1000.0
-          )
-          AND ts < to_timestamp($4/1000.0)
-      ), coverage_summary AS (
-        SELECT
-          COUNT(*)::int AS coverage_buckets,
-          MAX(ts) AS coverage_as_of_ts,
-          MIN(covered_whales)::int AS covered_whales,
-          MAX(expected_whales)::int AS expected_whales,
-          MIN(coverage_pct) AS coverage_pct
-        FROM coverage_rows
-      ), window_rows AS (
-        SELECT *
-        FROM hyperliquid_whale_flow
-        WHERE symbol = $1
-          AND interval = '1m'
-          AND universe_fingerprint = $2
-          AND whale_registry_fingerprint = $3
-          AND ts >= to_timestamp(
-            ($4::double precision - $5::double precision) / 1000.0
-          )
-          AND ts < to_timestamp($4/1000.0)
-      ), unique_addresses AS (
-        SELECT COUNT(DISTINCT address)::int AS unique_whales
-        FROM window_rows
-        CROSS JOIN LATERAL UNNEST(whale_addresses) AS expanded(address)
-      ), directional_counts AS (
-        SELECT
-          (
-            SELECT COUNT(DISTINCT address)::int
-            FROM window_rows
-            CROSS JOIN LATERAL UNNEST(long_entry_whale_addresses) AS expanded(address)
-          ) AS long_entry_whales,
-          (
-            SELECT COUNT(DISTINCT address)::int
-            FROM window_rows
-            CROSS JOIN LATERAL UNNEST(short_entry_whale_addresses) AS expanded(address)
-          ) AS short_entry_whales,
-          (
-            SELECT COUNT(DISTINCT address)::int
-            FROM window_rows
-            CROSS JOIN LATERAL UNNEST(long_exit_whale_addresses) AS expanded(address)
-          ) AS long_exit_whales,
-          (
-            SELECT COUNT(DISTINCT address)::int
-            FROM window_rows
-            CROSS JOIN LATERAL UNNEST(short_exit_whale_addresses) AS expanded(address)
-          ) AS short_exit_whales
-      )
       SELECT
-        $1::text AS symbol,
-        coverage_summary.coverage_as_of_ts AS as_of_ts,
-        coverage_summary.coverage_buckets,
-        coverage_summary.covered_whales,
-        coverage_summary.expected_whales,
-        coverage_summary.coverage_pct,
-        COALESCE((SELECT SUM(trades) FROM window_rows), 0)::int AS trades,
-        COALESCE((SELECT SUM(whale_sides) FROM window_rows), 0)::int AS whale_sides,
-        COALESCE((SELECT unique_whales FROM unique_addresses), 0)::int AS unique_whales,
-        COALESCE((SELECT SUM(buy_notional_usd) FROM window_rows), 0) AS buy_notional_usd,
-        COALESCE((SELECT SUM(sell_notional_usd) FROM window_rows), 0) AS sell_notional_usd,
-        COALESCE((SELECT SUM(net_notional_usd) FROM window_rows), 0) AS net_notional_usd,
-        CASE
-          WHEN COALESCE((SELECT SUM(buy_notional_usd + sell_notional_usd) FROM window_rows), 0) > 0
-          THEN (SELECT SUM(buy_notional_usd) FROM window_rows) /
-            (SELECT SUM(buy_notional_usd + sell_notional_usd) FROM window_rows)
-          ELSE NULL
-        END AS buy_share_pct,
-        COALESCE((SELECT SUM(position_aware_whale_sides) FROM window_rows), 0)::int
-          AS position_aware_whale_sides,
-        CASE
-          WHEN COALESCE((SELECT SUM(whale_sides) FROM window_rows), 0) > 0
-          THEN COALESCE((SELECT SUM(position_aware_whale_sides) FROM window_rows), 0)::double precision /
-            (SELECT SUM(whale_sides) FROM window_rows)
-          ELSE 0
-        END AS position_aware_pct,
-        COALESCE((SELECT long_entry_whales FROM directional_counts), 0)::int AS long_entry_whales,
-        COALESCE((SELECT short_entry_whales FROM directional_counts), 0)::int AS short_entry_whales,
-        COALESCE((SELECT long_exit_whales FROM directional_counts), 0)::int AS long_exit_whales,
-        COALESCE((SELECT short_exit_whales FROM directional_counts), 0)::int AS short_exit_whales,
-        COALESCE((SELECT SUM(long_entry_notional_usd) FROM window_rows), 0)
-          AS long_entry_notional_usd,
-        COALESCE((SELECT SUM(short_entry_notional_usd) FROM window_rows), 0)
-          AS short_entry_notional_usd,
-        COALESCE((SELECT SUM(long_exit_notional_usd) FROM window_rows), 0)
-          AS long_exit_notional_usd,
-        COALESCE((SELECT SUM(short_exit_notional_usd) FROM window_rows), 0)
-          AS short_exit_notional_usd,
-        COALESCE((SELECT SUM(entry_net_notional_usd) FROM window_rows), 0)
-          AS entry_net_notional_usd,
-        CASE
-          WHEN COALESCE((SELECT SUM(long_entry_notional_usd + short_entry_notional_usd) FROM window_rows), 0) > 0
-          THEN (SELECT SUM(long_entry_notional_usd) FROM window_rows) /
-            (SELECT SUM(long_entry_notional_usd + short_entry_notional_usd) FROM window_rows)
-          ELSE NULL
-        END AS entry_long_share_pct,
-        (SELECT MAX(source) FROM window_rows) AS source
-      FROM coverage_summary
+        source,
+        interval,
+        ts,
+        exchanges_count::int AS "exchangesCount",
+        total_volume_usd AS "totalVolumeUsd",
+        binance_volume_usd AS "binanceVolumeUsd",
+        binance_volume_share AS "binanceVolumeShare",
+        top_exchange_volume_share AS "topExchangeVolumeShare",
+        liquidity_regime AS "liquidityRegime"
+      FROM market_cmc_exchange_liquidity_context
+      WHERE source = $1
+        AND interval = $2
+        AND ts + CASE interval
+          WHEN '1d' THEN interval '1 day'
+          WHEN '1h' THEN interval '1 hour'
+          ELSE interval '0 seconds'
+        END <= to_timestamp($3/1000.0)
+      ORDER BY ts DESC
+      LIMIT 1
     `,
-    [
-      params.symbol,
-      params.universeFingerprint,
-      params.whaleRegistryFingerprint,
-      params.decisionTimeMs,
-      intervalMs,
-      import_types.HYPERLIQUID_WHALE_DATA_MODEL_VERSION
-    ],
+    [source, interval, params.atMs],
     params
   );
   const row = res.rows[0];
-  if (!row?.as_of_ts || Number(row.coverage_buckets) !== expectedBuckets || Number(row.covered_whales) <= 0) {
-    return null;
-  }
-  const asOfTs = new Date(row.as_of_ts);
-  const ageMs = params.decisionTimeMs - (asOfTs.getTime() + 6e4);
+  if (!row) return null;
+  const previousRes = await queryMarketContext(
+    `
+      SELECT total_volume_usd AS "totalVolumeUsd"
+      FROM market_cmc_exchange_liquidity_context
+      WHERE source = $1
+        AND interval = $2
+        AND ts <= $3::timestamptz - interval '24 hours'
+      ORDER BY ts DESC
+      LIMIT 1
+    `,
+    [source, interval, row.ts],
+    params
+  );
+  const currentTotal = row.totalVolumeUsd == null ? null : Number(row.totalVolumeUsd);
+  const previousTotal = previousRes.rows[0]?.totalVolumeUsd == null ? null : Number(previousRes.rows[0].totalVolumeUsd);
+  const ageMs = toMarketFeatureAge(row.ts, params.atMs);
   return {
-    symbol: params.symbol,
-    interval: params.interval,
-    asOfTs,
-    windowEndTs: new Date(params.decisionTimeMs),
-    trades: Number(row.trades) || 0,
-    whaleSides: Number(row.whale_sides) || 0,
-    uniqueWhales: Number(row.unique_whales) || 0,
-    coveredWhales: Number(row.covered_whales) || 0,
-    expectedWhales: Number(row.expected_whales) || 0,
-    coveragePct: Number(row.coverage_pct) || 0,
-    buyNotionalUsd: Number(row.buy_notional_usd) || 0,
-    sellNotionalUsd: Number(row.sell_notional_usd) || 0,
-    netNotionalUsd: Number(row.net_notional_usd) || 0,
-    buySharePct: row.buy_share_pct == null ? null : Number(row.buy_share_pct) || 0,
-    positionAwareWhaleSides: Number(row.position_aware_whale_sides) || 0,
-    positionAwarePct: Number(row.position_aware_pct) || 0,
-    longEntryWhales: Number(row.long_entry_whales) || 0,
-    shortEntryWhales: Number(row.short_entry_whales) || 0,
-    longExitWhales: Number(row.long_exit_whales) || 0,
-    shortExitWhales: Number(row.short_exit_whales) || 0,
-    longEntryNotionalUsd: Number(row.long_entry_notional_usd) || 0,
-    shortEntryNotionalUsd: Number(row.short_entry_notional_usd) || 0,
-    longExitNotionalUsd: Number(row.long_exit_notional_usd) || 0,
-    shortExitNotionalUsd: Number(row.short_exit_notional_usd) || 0,
-    entryNetNotionalUsd: Number(row.entry_net_notional_usd) || 0,
-    entryLongSharePct: row.entry_long_share_pct == null ? null : Number(row.entry_long_share_pct) || 0,
-    universeFingerprint: params.universeFingerprint,
-    whaleRegistryFingerprint: params.whaleRegistryFingerprint,
-    source: row.source == null ? null : String(row.source),
+    ...row,
     ageMs,
-    stale: ageMs < 0 || (params.maxAgeMs != null && Number.isFinite(params.maxAgeMs) ? ageMs > params.maxAgeMs : false)
+    stale: ageMs == null || params.maxAgeMs != null && ageMs > params.maxAgeMs,
+    totalVolumeChange24hPct: currentTotal != null && previousTotal != null && previousTotal > 0 ? (currentTotal - previousTotal) / previousTotal : null
   };
 }
-async function hasHyperliquidWhaleBackfillCoverage(params) {
-  await ensureHyperliquidWhaleSchema();
-  const expectedBuckets = Math.max(
-    0,
-    Math.ceil((params.toMs - params.fromMs) / 6e4)
-  );
-  const result = await getPool().query(
-    `
-      SELECT
-        COUNT(*)::int AS buckets,
-        COUNT(*) FILTER (
-          WHERE covered_whales = expected_whales
-        )::int AS complete_buckets
-      FROM hyperliquid_whale_coverage_1m
-      WHERE universe_fingerprint = $1
-        AND whale_registry_fingerprint = $2
-        AND data_model_version = $5
-        AND ts >= to_timestamp($3/1000.0)
-        AND ts < to_timestamp($4/1000.0)
-    `,
-    [
-      params.universeFingerprint,
-      params.whaleRegistryFingerprint,
-      params.fromMs,
-      params.toMs,
-      import_types.HYPERLIQUID_WHALE_DATA_MODEL_VERSION
-    ]
-  );
-  return Number(result.rows[0]?.buckets) === expectedBuckets && Number(result.rows[0]?.complete_buckets) === expectedBuckets;
-}
-async function getLatestMarketBreadth(params) {
-  await prepareMarketContextSchemaForRead("binance");
+async function getLatestMarketCmcIndexContexts(params) {
+  const source = params.source ?? "coinmarketcap_index";
+  const interval = params.interval ?? "1d";
+  const indexSlugs = [
+    ...new Set(
+      params.indexSlugs.map((slug) => slug.trim().toLowerCase()).filter(
+        (slug) => ["cmc100", "cmc20"].includes(slug)
+      )
+    )
+  ];
+  const rows = /* @__PURE__ */ new Map();
+  if (!indexSlugs.length) return rows;
+  await prepareMarketContextSchemaForRead("coinmarketcap");
   const res = await queryMarketContext(
     `
-      SELECT
-        universe,
+      SELECT DISTINCT ON (index_slug)
+        source,
+        index_slug AS "indexSlug",
         interval,
         ts,
-        symbols_count::int AS "symbolsCount",
-        advancers::int AS advancers,
-        decliners::int AS decliners,
-        unchanged::int AS unchanged,
-        advance_decline_ratio AS "advanceDeclineRatio",
-        pct_above_ma20 AS "pctAboveMa20",
-        pct_above_ma50 AS "pctAboveMa50",
-        equal_weighted_return AS "equalWeightedReturn",
-        volume_weighted_return AS "volumeWeightedReturn",
-        dispersion,
-        btc_return_1h AS "btcReturn1h",
-        btc_return_4h AS "btcReturn4h",
-        btc_return_24h AS "btcReturn24h",
-        alt_basket_return_1h AS "altBasketReturn1h",
-        alt_basket_return_4h AS "altBasketReturn4h",
-        alt_basket_return_24h AS "altBasketReturn24h",
-        btc_vs_alt_return_1h AS "btcVsAltReturn1h",
-        btc_vs_alt_return_4h AS "btcVsAltReturn4h",
-        btc_vs_alt_return_24h AS "btcVsAltReturn24h",
-        btc_turnover_share_1h AS "btcTurnoverShare1h",
-        btc_turnover_share_24h AS "btcTurnoverShare24h",
-        btc_turnover_share_change_24h AS "btcTurnoverShareChange24h",
-        alt_vol_to_btc_vol_24h AS "altVolToBtcVol24h",
-        alt_dispersion_24h AS "altDispersion24h",
-        btc_alt_regime AS "btcAltRegime",
-        source
-      FROM market_breadth
-      WHERE universe = $1
-        AND interval = $2
-        AND ts <= to_timestamp($3/1000.0)
-      ORDER BY ts DESC
-      LIMIT 1
+        value,
+        constituents_count::int AS "constituentsCount",
+        top_constituent_symbol AS "topConstituentSymbol",
+        top_constituent_weight_pct AS "topConstituentWeightPct",
+        constituents
+      FROM market_cmc_index_context
+      WHERE source = $1
+        AND index_slug = ANY($2)
+        AND interval = $3
+        AND ts + CASE interval
+          WHEN '1d' THEN interval '1 day'
+          WHEN '1h' THEN interval '1 hour'
+          ELSE interval '0 seconds'
+        END <= to_timestamp($4/1000.0)
+      ORDER BY index_slug ASC, ts DESC
     `,
-    [params.universe, params.interval, params.atMs],
+    [source, indexSlugs, interval, params.atMs],
     params
   );
-  const row = res.rows[0];
-  if (!row) return null;
-  const ageMs = toMarketFeatureAge(row.ts, params.atMs);
-  return {
-    ...row,
-    ageMs,
-    stale: ageMs == null || params.maxAgeMs != null && ageMs > params.maxAgeMs
-  };
+  for (const row of res.rows) {
+    const previousRes = await queryMarketContext(
+      `
+        SELECT value
+        FROM market_cmc_index_context
+        WHERE source = $1
+          AND index_slug = $2
+          AND interval = $3
+          AND ts <= $4::timestamptz - interval '24 hours'
+        ORDER BY ts DESC
+        LIMIT 1
+      `,
+      [source, row.indexSlug, interval, row.ts],
+      params
+    );
+    const currentValue = row.value == null ? null : Number(row.value);
+    const previousValue = previousRes.rows[0]?.value == null ? null : Number(previousRes.rows[0].value);
+    const ageMs = toMarketFeatureAge(row.ts, params.atMs);
+    rows.set(row.indexSlug, {
+      ...row,
+      ageMs,
+      stale: ageMs == null || params.maxAgeMs != null && ageMs > params.maxAgeMs,
+      valueChange24hPct: currentValue != null && previousValue != null && previousValue > 0 ? (currentValue - previousValue) / previousValue : null
+    });
+  }
+  return rows;
 }
-async function getLatestMarketGlobalContext(params) {
+async function getLatestMarketCmcFearGreedContext(params) {
   await prepareMarketContextSchemaForRead("coinmarketcap");
-  const source = params.source ?? "coinmarketcap_global";
+  const source = params.source ?? "coinmarketcap_fear_greed";
+  const interval = params.interval ?? "1d";
   const res = await queryMarketContext(
     `
       SELECT
         source,
+        interval,
         ts,
-        updated_at_ts AS "updatedAt",
-        active_cryptocurrencies::int AS "activeCryptocurrencies",
-        active_exchanges::int AS "activeExchanges",
-        active_market_pairs::int AS "activeMarketPairs",
-        markets::int AS markets,
-        total_market_cap_usd AS "totalMarketCapUsd",
-        total_volume_usd AS "totalVolumeUsd",
-        total_volume_reported_usd AS "totalVolumeReportedUsd",
-        btc_dominance_pct AS "btcDominancePct",
-        eth_dominance_pct AS "ethDominancePct",
-        alt_market_cap_usd AS "altMarketCapUsd",
-        alt_volume_usd AS "altVolumeUsd",
-        alt_volume_reported_usd AS "altVolumeReportedUsd",
-        btc_to_alt_market_cap_ratio AS "btcToAltMarketCapRatio",
-        market_cap_change_pct_24h_usd AS "marketCapChangePct24hUsd"
-      FROM market_global_context
+        value::int AS value,
+        classification,
+        sentiment_regime AS "sentimentRegime"
+      FROM market_cmc_fear_greed_context
       WHERE source = $1
-        AND ts + CASE
-          WHEN source = 'coinmarketcap_global' THEN interval '1 day'
+        AND interval = $2
+        AND ts + CASE interval
+          WHEN '1d' THEN interval '1 day'
+          WHEN '1h' THEN interval '1 hour'
           ELSE interval '0 seconds'
-        END <= to_timestamp($2/1000.0)
+        END <= to_timestamp($3/1000.0)
       ORDER BY ts DESC
       LIMIT 1
     `,
-    [source, params.atMs],
+    [source, interval, params.atMs],
     params
   );
   const row = res.rows[0];
@@ -3351,39 +2791,43 @@ async function getLatestMarketGlobalContext(params) {
   const previousRes = await queryMarketContext(
     `
       SELECT
-        btc_dominance_pct AS "btcDominancePct",
-        eth_dominance_pct AS "ethDominancePct",
-        alt_market_cap_usd AS "altMarketCapUsd",
-        alt_volume_usd AS "altVolumeUsd"
-      FROM market_global_context
+        value::int AS value,
+        '24h' AS bucket
+      FROM market_cmc_fear_greed_context
       WHERE source = $1
-        AND ts <= $2::timestamptz - interval '24 hours'
+        AND interval = $2
+        AND ts <= $3::timestamptz - interval '24 hours'
       ORDER BY ts DESC
       LIMIT 1
     `,
-    [source, row.ts],
+    [source, interval, row.ts],
     params
   );
-  const previousDominance = previousRes.rows[0]?.btcDominancePct == null ? null : Number(previousRes.rows[0].btcDominancePct);
-  const previousEthDominance = previousRes.rows[0]?.ethDominancePct == null ? null : Number(previousRes.rows[0].ethDominancePct);
-  const previousAltMarketCap = previousRes.rows[0]?.altMarketCapUsd == null ? null : Number(previousRes.rows[0].altMarketCapUsd);
-  const previousAltVolume = previousRes.rows[0]?.altVolumeUsd == null ? null : Number(previousRes.rows[0].altVolumeUsd);
-  const currentDominance = row.btcDominancePct == null ? null : Number(row.btcDominancePct);
-  const currentEthDominance = row.ethDominancePct == null ? null : Number(row.ethDominancePct);
-  const currentAltMarketCap = row.altMarketCapUsd == null ? null : Number(row.altMarketCapUsd);
-  const currentAltVolume = row.altVolumeUsd == null ? null : Number(row.altVolumeUsd);
+  const previous7dRes = await queryMarketContext(
+    `
+      SELECT value::int AS value
+      FROM market_cmc_fear_greed_context
+      WHERE source = $1
+        AND interval = $2
+        AND ts <= $3::timestamptz - interval '7 days'
+      ORDER BY ts DESC
+      LIMIT 1
+    `,
+    [source, interval, row.ts],
+    params
+  );
+  const previousValue = previousRes.rows[0]?.value == null ? null : Number(previousRes.rows[0].value);
+  const previous7dValue = previous7dRes.rows[0]?.value == null ? null : Number(previous7dRes.rows[0].value);
   const ageMs = toMarketFeatureAge(row.ts, params.atMs);
   return {
     ...row,
     ageMs,
     stale: ageMs == null || params.maxAgeMs != null && ageMs > params.maxAgeMs,
-    btcDominanceChange24hPct: currentDominance != null && previousDominance != null ? currentDominance - previousDominance : null,
-    ethDominanceChange24hPct: currentEthDominance != null && previousEthDominance != null ? currentEthDominance - previousEthDominance : null,
-    altMarketCapChange24hPct: currentAltMarketCap != null && previousAltMarketCap != null && previousAltMarketCap > 0 ? (currentAltMarketCap - previousAltMarketCap) / previousAltMarketCap : null,
-    altVolumeChange24hPct: currentAltVolume != null && previousAltVolume != null && previousAltVolume > 0 ? (currentAltVolume - previousAltVolume) / previousAltVolume : null
+    valueChange24h: previousValue == null ? null : row.value - previousValue,
+    valueChange7d: previous7dValue == null ? null : row.value - previous7dValue
   };
 }
-async function getMarketGlobalContextCoverage(params) {
+async function getMarketCmcFearGreedContextCoverage(params) {
   await ensureBinanceMarketSchema();
   const pool = getPool();
   const res = await pool.query(
@@ -3392,166 +2836,48 @@ async function getMarketGlobalContextCoverage(params) {
         extract(epoch from MIN(ts))*1000 AS first_ms,
         extract(epoch from MAX(ts))*1000 AS last_ms,
         COUNT(*)::int AS rows
-      FROM market_global_context
+      FROM market_cmc_fear_greed_context
       WHERE source = $1
-        AND ts >= to_timestamp($2/1000.0)
-        AND ts <= to_timestamp($3/1000.0)
+        AND interval = $2
+        AND ts >= to_timestamp($3/1000.0)
+        AND ts <= to_timestamp($4/1000.0)
     `,
-    [params.source, params.startMs, params.endMs]
+    [params.source, params.interval, params.startMs, params.endMs]
   );
-  const row = res.rows[0];
-  const rows = Number(row?.rows ?? 0);
-  const firstMs = Number(row?.first_ms);
-  const lastMs = Number(row?.last_ms);
+  const rows = Number(res.rows[0]?.rows ?? 0);
+  const firstMs = Number(res.rows[0]?.first_ms);
+  const lastMs = Number(res.rows[0]?.last_ms);
   if (!rows || !Number.isFinite(firstMs) || !Number.isFinite(lastMs)) {
     return null;
   }
   return { firstMs, lastMs, rows };
 }
-async function getMarketReferenceAssetContextCoverage(params) {
-  const symbols = [
-    ...new Set(
-      params.symbols.map((symbol) => symbol.trim().toUpperCase()).filter(Boolean)
-    )
-  ];
-  const coverage = /* @__PURE__ */ new Map();
-  if (!symbols.length) return coverage;
+async function getMarketCmcExchangeLiquidityContextCoverage(params) {
   await ensureBinanceMarketSchema();
   const pool = getPool();
   const res = await pool.query(
     `
       SELECT
-        symbol,
         extract(epoch from MIN(ts))*1000 AS first_ms,
         extract(epoch from MAX(ts))*1000 AS last_ms,
         COUNT(*)::int AS rows
-      FROM market_reference_asset_context
+      FROM market_cmc_exchange_liquidity_context
       WHERE source = $1
-        AND symbol = ANY($2)
-        AND interval = $3
-        AND ts >= to_timestamp($4/1000.0)
-        AND ts <= to_timestamp($5/1000.0)
-      GROUP BY symbol
+        AND interval = $2
+        AND ts >= to_timestamp($3/1000.0)
+        AND ts <= to_timestamp($4/1000.0)
     `,
-    [params.source, symbols, params.interval, params.startMs, params.endMs]
+    [params.source, params.interval, params.startMs, params.endMs]
   );
-  for (const row of res.rows) {
-    const firstMs = Number(row.first_ms);
-    const lastMs = Number(row.last_ms);
-    const rows = Number(row.rows);
-    if (Number.isFinite(firstMs) && Number.isFinite(lastMs) && rows > 0) {
-      coverage.set(row.symbol.toUpperCase(), { firstMs, lastMs, rows });
-    }
+  const rows = Number(res.rows[0]?.rows ?? 0);
+  const firstMs = Number(res.rows[0]?.first_ms);
+  const lastMs = Number(res.rows[0]?.last_ms);
+  if (!rows || !Number.isFinite(firstMs) || !Number.isFinite(lastMs)) {
+    return null;
   }
-  return coverage;
+  return { firstMs, lastMs, rows };
 }
-async function getLatestMarketReferenceAssetContexts(params) {
-  const source = params.source ?? "coinmarketcap_reference_asset";
-  const interval = params.interval ?? "1d";
-  const symbols = [
-    ...new Set(
-      params.symbols.map((symbol) => symbol.trim().toUpperCase()).filter(Boolean)
-    )
-  ];
-  const rows = /* @__PURE__ */ new Map();
-  if (!symbols.length) return rows;
-  await prepareMarketContextSchemaForRead("coinmarketcap");
-  const res = await queryMarketContext(
-    `
-      SELECT DISTINCT ON (symbol)
-        source,
-        symbol,
-        cmc_id AS "cmcId",
-        interval,
-        ts,
-        open_usd AS "openUsd",
-        high_usd AS "highUsd",
-        low_usd AS "lowUsd",
-        close_usd AS "closeUsd",
-        volume_usd AS "volumeUsd",
-        market_cap_usd AS "marketCapUsd"
-      FROM market_reference_asset_context
-      WHERE source = $1
-        AND symbol = ANY($2)
-        AND interval = $3
-        AND ts + CASE interval
-          WHEN '1d' THEN interval '1 day'
-          WHEN '1h' THEN interval '1 hour'
-          ELSE interval '0 seconds'
-        END <= to_timestamp($4/1000.0)
-      ORDER BY symbol ASC, ts DESC
-    `,
-    [source, symbols, interval, params.atMs],
-    params
-  );
-  for (const row of res.rows) {
-    const ageMs = toMarketFeatureAge(row.ts, params.atMs);
-    rows.set(row.symbol.toUpperCase(), {
-      ...row,
-      ageMs,
-      stale: ageMs == null || params.maxAgeMs != null && ageMs > params.maxAgeMs
-    });
-  }
-  return rows;
-}
-async function getLatestMarketCmcExchangeLiquidityContext(params) {
-  await prepareMarketContextSchemaForRead("coinmarketcap");
-  const source = params.source ?? "coinmarketcap_exchange_liquidity";
-  const interval = params.interval ?? "1d";
-  const res = await queryMarketContext(
-    `
-      SELECT
-        source,
-        interval,
-        ts,
-        exchanges_count::int AS "exchangesCount",
-        total_volume_usd AS "totalVolumeUsd",
-        binance_volume_usd AS "binanceVolumeUsd",
-        binance_volume_share AS "binanceVolumeShare",
-        top_exchange_volume_share AS "topExchangeVolumeShare",
-        liquidity_regime AS "liquidityRegime"
-      FROM market_cmc_exchange_liquidity_context
-      WHERE source = $1
-        AND interval = $2
-        AND ts + CASE interval
-          WHEN '1d' THEN interval '1 day'
-          WHEN '1h' THEN interval '1 hour'
-          ELSE interval '0 seconds'
-        END <= to_timestamp($3/1000.0)
-      ORDER BY ts DESC
-      LIMIT 1
-    `,
-    [source, interval, params.atMs],
-    params
-  );
-  const row = res.rows[0];
-  if (!row) return null;
-  const previousRes = await queryMarketContext(
-    `
-      SELECT total_volume_usd AS "totalVolumeUsd"
-      FROM market_cmc_exchange_liquidity_context
-      WHERE source = $1
-        AND interval = $2
-        AND ts <= $3::timestamptz - interval '24 hours'
-      ORDER BY ts DESC
-      LIMIT 1
-    `,
-    [source, interval, row.ts],
-    params
-  );
-  const currentTotal = row.totalVolumeUsd == null ? null : Number(row.totalVolumeUsd);
-  const previousTotal = previousRes.rows[0]?.totalVolumeUsd == null ? null : Number(previousRes.rows[0].totalVolumeUsd);
-  const ageMs = toMarketFeatureAge(row.ts, params.atMs);
-  return {
-    ...row,
-    ageMs,
-    stale: ageMs == null || params.maxAgeMs != null && ageMs > params.maxAgeMs,
-    totalVolumeChange24hPct: currentTotal != null && previousTotal != null && previousTotal > 0 ? (currentTotal - previousTotal) / previousTotal : null
-  };
-}
-async function getLatestMarketCmcIndexContexts(params) {
-  const source = params.source ?? "coinmarketcap_index";
-  const interval = params.interval ?? "1d";
+async function getMarketCmcIndexContextCoverage(params) {
   const indexSlugs = [
     ...new Set(
       params.indexSlugs.map((slug) => slug.trim().toLowerCase()).filter(
@@ -3559,233 +2885,51 @@ async function getLatestMarketCmcIndexContexts(params) {
       )
     )
   ];
-  const rows = /* @__PURE__ */ new Map();
-  if (!indexSlugs.length) return rows;
-  await prepareMarketContextSchemaForRead("coinmarketcap");
-  const res = await queryMarketContext(
+  const coverage = /* @__PURE__ */ new Map();
+  if (!indexSlugs.length) return coverage;
+  await ensureBinanceMarketSchema();
+  const pool = getPool();
+  const res = await pool.query(
     `
-      SELECT DISTINCT ON (index_slug)
-        source,
-        index_slug AS "indexSlug",
-        interval,
-        ts,
-        value,
-        constituents_count::int AS "constituentsCount",
-        top_constituent_symbol AS "topConstituentSymbol",
-        top_constituent_weight_pct AS "topConstituentWeightPct",
-        constituents
+      SELECT
+        index_slug,
+        extract(epoch from MIN(ts))*1000 AS first_ms,
+        extract(epoch from MAX(ts))*1000 AS last_ms,
+        COUNT(*)::int AS rows
       FROM market_cmc_index_context
       WHERE source = $1
         AND index_slug = ANY($2)
         AND interval = $3
-        AND ts + CASE interval
-          WHEN '1d' THEN interval '1 day'
-          WHEN '1h' THEN interval '1 hour'
-          ELSE interval '0 seconds'
-        END <= to_timestamp($4/1000.0)
-      ORDER BY index_slug ASC, ts DESC
+        AND ts >= to_timestamp($4/1000.0)
+        AND ts <= to_timestamp($5/1000.0)
+      GROUP BY index_slug
     `,
-    [source, indexSlugs, interval, params.atMs],
-    params
+    [params.source, indexSlugs, params.interval, params.startMs, params.endMs]
   );
   for (const row of res.rows) {
-    const previousRes = await queryMarketContext(
-      `
-        SELECT value
-        FROM market_cmc_index_context
-        WHERE source = $1
-          AND index_slug = $2
-          AND interval = $3
-          AND ts <= $4::timestamptz - interval '24 hours'
-        ORDER BY ts DESC
-        LIMIT 1
-      `,
-      [source, row.indexSlug, interval, row.ts],
-      params
-    );
-    const currentValue = row.value == null ? null : Number(row.value);
-    const previousValue = previousRes.rows[0]?.value == null ? null : Number(previousRes.rows[0].value);
-    const ageMs = toMarketFeatureAge(row.ts, params.atMs);
-    rows.set(row.indexSlug, {
-      ...row,
-      ageMs,
-      stale: ageMs == null || params.maxAgeMs != null && ageMs > params.maxAgeMs,
-      valueChange24hPct: currentValue != null && previousValue != null && previousValue > 0 ? (currentValue - previousValue) / previousValue : null
-    });
+    const indexSlug = row.index_slug;
+    const firstMs = Number(row.first_ms);
+    const lastMs = Number(row.last_ms);
+    const rows = Number(row.rows);
+    if (Number.isFinite(firstMs) && Number.isFinite(lastMs) && rows > 0) {
+      coverage.set(indexSlug, { firstMs, lastMs, rows });
+    }
   }
-  return rows;
-}
-async function getLatestMarketCmcFearGreedContext(params) {
-  await prepareMarketContextSchemaForRead("coinmarketcap");
-  const source = params.source ?? "coinmarketcap_fear_greed";
-  const interval = params.interval ?? "1d";
-  const res = await queryMarketContext(
-    `
-      SELECT
-        source,
-        interval,
-        ts,
-        value::int AS value,
-        classification,
-        sentiment_regime AS "sentimentRegime"
-      FROM market_cmc_fear_greed_context
-      WHERE source = $1
-        AND interval = $2
-        AND ts + CASE interval
-          WHEN '1d' THEN interval '1 day'
-          WHEN '1h' THEN interval '1 hour'
-          ELSE interval '0 seconds'
-        END <= to_timestamp($3/1000.0)
-      ORDER BY ts DESC
-      LIMIT 1
-    `,
-    [source, interval, params.atMs],
-    params
-  );
-  const row = res.rows[0];
-  if (!row) return null;
-  const previousRes = await queryMarketContext(
-    `
-      SELECT
-        value::int AS value,
-        '24h' AS bucket
-      FROM market_cmc_fear_greed_context
-      WHERE source = $1
-        AND interval = $2
-        AND ts <= $3::timestamptz - interval '24 hours'
-      ORDER BY ts DESC
-      LIMIT 1
-    `,
-    [source, interval, row.ts],
-    params
-  );
-  const previous7dRes = await queryMarketContext(
-    `
-      SELECT value::int AS value
-      FROM market_cmc_fear_greed_context
-      WHERE source = $1
-        AND interval = $2
-        AND ts <= $3::timestamptz - interval '7 days'
-      ORDER BY ts DESC
-      LIMIT 1
-    `,
-    [source, interval, row.ts],
-    params
-  );
-  const previousValue = previousRes.rows[0]?.value == null ? null : Number(previousRes.rows[0].value);
-  const previous7dValue = previous7dRes.rows[0]?.value == null ? null : Number(previous7dRes.rows[0].value);
-  const ageMs = toMarketFeatureAge(row.ts, params.atMs);
-  return {
-    ...row,
-    ageMs,
-    stale: ageMs == null || params.maxAgeMs != null && ageMs > params.maxAgeMs,
-    valueChange24h: previousValue == null ? null : row.value - previousValue,
-    valueChange7d: previous7dValue == null ? null : row.value - previous7dValue
-  };
+  return coverage;
 }
-async function getMarketCmcFearGreedContextCoverage(params) {
+async function getMarketTradeFlowCoverage(params) {
+  const symbols = [
+    ...new Set(params.symbols.map((item) => item.toUpperCase()))
+  ];
+  if (!symbols.length) return /* @__PURE__ */ new Map();
   await ensureBinanceMarketSchema();
   const pool = getPool();
   const res = await pool.query(
     `
       SELECT
-        extract(epoch from MIN(ts))*1000 AS first_ms,
-        extract(epoch from MAX(ts))*1000 AS last_ms,
-        COUNT(*)::int AS rows
-      FROM market_cmc_fear_greed_context
-      WHERE source = $1
-        AND interval = $2
-        AND ts >= to_timestamp($3/1000.0)
-        AND ts <= to_timestamp($4/1000.0)
-    `,
-    [params.source, params.interval, params.startMs, params.endMs]
-  );
-  const rows = Number(res.rows[0]?.rows ?? 0);
-  const firstMs = Number(res.rows[0]?.first_ms);
-  const lastMs = Number(res.rows[0]?.last_ms);
-  if (!rows || !Number.isFinite(firstMs) || !Number.isFinite(lastMs)) {
-    return null;
-  }
-  return { firstMs, lastMs, rows };
-}
-async function getMarketCmcExchangeLiquidityContextCoverage(params) {
-  await ensureBinanceMarketSchema();
-  const pool = getPool();
-  const res = await pool.query(
-    `
-      SELECT
-        extract(epoch from MIN(ts))*1000 AS first_ms,
-        extract(epoch from MAX(ts))*1000 AS last_ms,
-        COUNT(*)::int AS rows
-      FROM market_cmc_exchange_liquidity_context
-      WHERE source = $1
-        AND interval = $2
-        AND ts >= to_timestamp($3/1000.0)
-        AND ts <= to_timestamp($4/1000.0)
-    `,
-    [params.source, params.interval, params.startMs, params.endMs]
-  );
-  const rows = Number(res.rows[0]?.rows ?? 0);
-  const firstMs = Number(res.rows[0]?.first_ms);
-  const lastMs = Number(res.rows[0]?.last_ms);
-  if (!rows || !Number.isFinite(firstMs) || !Number.isFinite(lastMs)) {
-    return null;
-  }
-  return { firstMs, lastMs, rows };
-}
-async function getMarketCmcIndexContextCoverage(params) {
-  const indexSlugs = [
-    ...new Set(
-      params.indexSlugs.map((slug) => slug.trim().toLowerCase()).filter(
-        (slug) => ["cmc100", "cmc20"].includes(slug)
-      )
-    )
-  ];
-  const coverage = /* @__PURE__ */ new Map();
-  if (!indexSlugs.length) return coverage;
-  await ensureBinanceMarketSchema();
-  const pool = getPool();
-  const res = await pool.query(
-    `
-      SELECT
-        index_slug,
-        extract(epoch from MIN(ts))*1000 AS first_ms,
-        extract(epoch from MAX(ts))*1000 AS last_ms,
-        COUNT(*)::int AS rows
-      FROM market_cmc_index_context
-      WHERE source = $1
-        AND index_slug = ANY($2)
-        AND interval = $3
-        AND ts >= to_timestamp($4/1000.0)
-        AND ts <= to_timestamp($5/1000.0)
-      GROUP BY index_slug
-    `,
-    [params.source, indexSlugs, params.interval, params.startMs, params.endMs]
-  );
-  for (const row of res.rows) {
-    const indexSlug = row.index_slug;
-    const firstMs = Number(row.first_ms);
-    const lastMs = Number(row.last_ms);
-    const rows = Number(row.rows);
-    if (Number.isFinite(firstMs) && Number.isFinite(lastMs) && rows > 0) {
-      coverage.set(indexSlug, { firstMs, lastMs, rows });
-    }
-  }
-  return coverage;
-}
-async function getMarketTradeFlowCoverage(params) {
-  const symbols = [
-    ...new Set(params.symbols.map((item) => item.toUpperCase()))
-  ];
-  if (!symbols.length) return /* @__PURE__ */ new Map();
-  await ensureBinanceMarketSchema();
-  const pool = getPool();
-  const res = await pool.query(
-    `
-      SELECT
-        symbol,
-        MIN(ts) AS first_ts,
-        MAX(ts) AS last_ts,
+        symbol,
+        MIN(ts) AS first_ts,
+        MAX(ts) AS last_ts,
         COUNT(*)::int AS rows
       FROM market_trade_flow
       WHERE symbol = ANY($1)
@@ -3926,232 +3070,1097 @@ async function getMarketBreadthCoverage(params) {
     btcAltMetricsRows: Number(row.btc_alt_metrics_rows) || 0
   };
 }
-async function getSpreadRangeForSymbols(symbols, interval, startMs, endMs) {
-  if (!symbols.length) {
-    return [];
+
+// src/timescale/hyperliquidWhales.ts
+var import_types = require("@tradejs/types");
+var HYPERLIQUID_CONTEXT_INTERVAL_MS = {
+  "1m": 6e4,
+  "5m": 5 * 6e4,
+  "15m": 15 * 6e4,
+  "1h": 60 * 6e4
+};
+async function upsertHyperliquidWhaleTradeEvents(rows) {
+  if (!rows.length) return;
+  await ensureHyperliquidWhaleSchema();
+  const cols = [
+    "symbol",
+    "ts",
+    "tid",
+    "price",
+    "size",
+    "notional_usd",
+    "buyer_address",
+    "seller_address",
+    "buyer_tracked",
+    "seller_tracked",
+    "buyer_start_position",
+    "buyer_end_position",
+    "buyer_position_action",
+    "buyer_closed_pnl",
+    "buyer_liquidation",
+    "seller_start_position",
+    "seller_end_position",
+    "seller_position_action",
+    "seller_closed_pnl",
+    "seller_liquidation",
+    "universe_fingerprint",
+    "whale_registry_fingerprint",
+    "source"
+  ];
+  const maxRows = getSafeBulkInsertRows(cols.length);
+  if (rows.length > maxRows) {
+    for (let index = 0; index < rows.length; index += maxRows) {
+      await upsertHyperliquidWhaleTradeEvents(
+        rows.slice(index, index + maxRows)
+      );
+    }
+    return;
   }
-  await ensureSpreadSchema();
-  const pool = getPool();
-  const sql = `
-    SELECT symbol, interval, ts, binance_price, coinbase_price, spread
-    FROM market_spread
-    WHERE symbol = ANY($1)
-      AND interval = $2
-      AND ts >= to_timestamp($3/1000.0)
-      AND ts <= to_timestamp($4/1000.0)
-    ORDER BY symbol ASC, ts ASC
-  `;
-  const res = await pool.query(sql, [symbols, interval, startMs, endMs]);
-  return res.rows;
-}
-async function getSpreadSummary(hours = 24, limit = 500) {
-  await ensureSpreadSchema();
-  const pool = getPool();
-  const cappedHours = Math.max(1, Math.min(24 * 30, hours));
-  const cappedLimit = Math.max(50, Math.min(5e3, limit));
-  const rowsQ = await pool.query(
-    `
-      SELECT symbol, interval, ts, binance_price, coinbase_price, spread
-      FROM market_spread
-      WHERE ts >= now() - ($1 || ' hours')::interval
-      ORDER BY ts DESC
-      LIMIT $2
-    `,
-    [String(cappedHours), cappedLimit]
-  );
-  const aggQ = await pool.query(
+  const valuesSql = rows.map(
+    (_, rowIndex) => `(${cols.map((__, colIndex) => `$${rowIndex * cols.length + colIndex + 1}`).join(",")})`
+  ).join(",");
+  const flat = rows.flatMap((row) => [
+    row.symbol,
+    row.ts,
+    row.tid,
+    row.price,
+    row.size,
+    row.notionalUsd,
+    row.buyerAddress ?? null,
+    row.sellerAddress ?? null,
+    row.buyerTracked,
+    row.sellerTracked,
+    row.buyerStartPosition ?? null,
+    row.buyerEndPosition ?? null,
+    row.buyerPositionAction ?? null,
+    row.buyerClosedPnl ?? null,
+    row.buyerLiquidation ?? null,
+    row.sellerStartPosition ?? null,
+    row.sellerEndPosition ?? null,
+    row.sellerPositionAction ?? null,
+    row.sellerClosedPnl ?? null,
+    row.sellerLiquidation ?? null,
+    row.universeFingerprint,
+    row.whaleRegistryFingerprint,
+    row.source ?? null
+  ]);
+  await getPool().query(
     `
-      SELECT
+      INSERT INTO hyperliquid_whale_trade_events (${cols.join(",")})
+      VALUES ${valuesSql}
+      ON CONFLICT (
+        universe_fingerprint,
+        whale_registry_fingerprint,
         symbol,
-        interval,
-        COUNT(*)::int AS points,
-        MAX(ts) AS last_ts,
-        AVG(spread) AS avg_spread,
-        STDDEV_POP(spread) AS std_spread
-      FROM market_spread
-      WHERE ts >= now() - ($1 || ' hours')::interval
-      GROUP BY symbol, interval
-      ORDER BY points DESC, symbol ASC
-      LIMIT 500
-    `,
-    [String(cappedHours)]
-  );
-  return {
-    rows: rowsQ.rows,
-    aggregates: aggQ.rows,
-    hours: cappedHours
-  };
-}
-async function getCandlesRange(provider, symbol, interval, startMs, endMs) {
-  await ensureCandlesSchema();
-  const pool = getPool();
-  const normalizedProvider = normalizeCandleProvider(provider);
-  const normalizedSymbol = normalizeCandleSymbol(symbol);
-  const sql = `
-    SELECT symbol, interval, ts,
-           open, high, low, close, volume, turnover,
-           taker_buy_base_volume AS "takerBuyBaseVolume",
-           taker_buy_quote_volume AS "takerBuyQuoteVolume",
-           taker_sell_base_volume AS "takerSellBaseVolume",
-           taker_sell_quote_volume AS "takerSellQuoteVolume"
-    FROM candles
-    WHERE provider = $1 AND symbol = $2 AND interval = $3
-      AND ts >= to_timestamp($4/1000.0)
-      AND ts <= to_timestamp($5/1000.0)
-    ORDER BY ts ASC
-  `;
-  const res = await pool.query(sql, [
-    normalizedProvider,
-    normalizedSymbol,
-    interval,
-    startMs,
-    endMs
-  ]);
-  return res.rows;
-}
-async function getDataEdges(provider, symbol, interval) {
-  await ensureCandlesSchema();
-  const pool = getPool();
-  const normalizedProvider = normalizeCandleProvider(provider);
-  const normalizedSymbol = normalizeCandleSymbol(symbol);
-  const sqlMin = `
-    SELECT extract(epoch from ts)*1000 AS ms
-    FROM candles
-    WHERE provider=$1 AND symbol=$2 AND interval=$3
-    ORDER BY ts ASC
-    LIMIT 1
-  `;
-  const sqlMax = `
-    SELECT extract(epoch from ts)*1000 AS ms
-    FROM candles
-    WHERE provider=$1 AND symbol=$2 AND interval=$3
-    ORDER BY ts DESC
-    LIMIT 1
-  `;
-  const [minQ, maxQ] = await Promise.all([
-    pool.query(sqlMin, [normalizedProvider, normalizedSymbol, interval]),
-    pool.query(sqlMax, [normalizedProvider, normalizedSymbol, interval])
-  ]);
-  const minRaw = minQ.rows[0]?.ms;
-  const maxRaw = maxQ.rows[0]?.ms;
-  const min = Number.isFinite(Number(minRaw)) ? Number(minRaw) : void 0;
-  const max = Number.isFinite(Number(maxRaw)) ? Number(maxRaw) : void 0;
-  return { min, max };
+        ts,
+        tid
+      ) DO UPDATE SET
+        buyer_address = COALESCE(
+          hyperliquid_whale_trade_events.buyer_address,
+          EXCLUDED.buyer_address
+        ),
+        seller_address = COALESCE(
+          hyperliquid_whale_trade_events.seller_address,
+          EXCLUDED.seller_address
+        ),
+        buyer_tracked = hyperliquid_whale_trade_events.buyer_tracked OR EXCLUDED.buyer_tracked,
+        seller_tracked = hyperliquid_whale_trade_events.seller_tracked OR EXCLUDED.seller_tracked,
+        buyer_start_position = COALESCE(
+          hyperliquid_whale_trade_events.buyer_start_position,
+          EXCLUDED.buyer_start_position
+        ),
+        buyer_end_position = COALESCE(
+          hyperliquid_whale_trade_events.buyer_end_position,
+          EXCLUDED.buyer_end_position
+        ),
+        buyer_position_action = COALESCE(
+          hyperliquid_whale_trade_events.buyer_position_action,
+          EXCLUDED.buyer_position_action
+        ),
+        buyer_closed_pnl = COALESCE(
+          hyperliquid_whale_trade_events.buyer_closed_pnl,
+          EXCLUDED.buyer_closed_pnl
+        ),
+        buyer_liquidation = COALESCE(
+          hyperliquid_whale_trade_events.buyer_liquidation,
+          EXCLUDED.buyer_liquidation
+        ),
+        seller_start_position = COALESCE(
+          hyperliquid_whale_trade_events.seller_start_position,
+          EXCLUDED.seller_start_position
+        ),
+        seller_end_position = COALESCE(
+          hyperliquid_whale_trade_events.seller_end_position,
+          EXCLUDED.seller_end_position
+        ),
+        seller_position_action = COALESCE(
+          hyperliquid_whale_trade_events.seller_position_action,
+          EXCLUDED.seller_position_action
+        ),
+        seller_closed_pnl = COALESCE(
+          hyperliquid_whale_trade_events.seller_closed_pnl,
+          EXCLUDED.seller_closed_pnl
+        ),
+        seller_liquidation = COALESCE(
+          hyperliquid_whale_trade_events.seller_liquidation,
+          EXCLUDED.seller_liquidation
+        ),
+        source = EXCLUDED.source,
+        ingested_at = now()
+    `,
+    flat
+  );
 }
-async function getDataEdgesForSymbols(provider, symbols, interval) {
-  const normalizedSymbols = [
-    ...new Set(symbols.map(normalizeCandleSymbol).filter(Boolean))
+async function upsertHyperliquidWhaleFlowRows(rows) {
+  if (!rows.length) return;
+  await ensureHyperliquidWhaleSchema();
+  const cols = [
+    "symbol",
+    "interval",
+    "ts",
+    "trades",
+    "whale_sides",
+    "unique_whales",
+    "whale_addresses",
+    "buy_notional_usd",
+    "sell_notional_usd",
+    "net_notional_usd",
+    "buy_share_pct",
+    "position_aware_whale_sides",
+    "long_entry_whale_addresses",
+    "short_entry_whale_addresses",
+    "long_exit_whale_addresses",
+    "short_exit_whale_addresses",
+    "long_entry_notional_usd",
+    "short_entry_notional_usd",
+    "long_exit_notional_usd",
+    "short_exit_notional_usd",
+    "entry_net_notional_usd",
+    "entry_long_share_pct",
+    "universe_fingerprint",
+    "whale_registry_fingerprint",
+    "source"
   ];
-  const result = /* @__PURE__ */ new Map();
-  for (const symbol of normalizedSymbols) {
-    result.set(symbol, {});
-  }
-  if (!normalizedSymbols.length) {
-    return result;
+  const maxRows = getSafeBulkInsertRows(cols.length);
+  if (rows.length > maxRows) {
+    for (let index = 0; index < rows.length; index += maxRows) {
+      await upsertHyperliquidWhaleFlowRows(rows.slice(index, index + maxRows));
+    }
+    return;
   }
-  await ensureCandlesSchema();
-  const pool = getPool();
-  const normalizedProvider = normalizeCandleProvider(provider);
-  const sql = `
-    WITH requested(symbol) AS (
-      SELECT unnest($2::text[])
-    )
-    SELECT
-      r.symbol,
-      (
-        SELECT extract(epoch from c.ts)*1000
-        FROM candles c
-        WHERE c.provider = $1 AND c.symbol = r.symbol AND c.interval = $3
-        ORDER BY c.ts ASC
-        LIMIT 1
-      ) AS min_ms,
-      (
-        SELECT extract(epoch from c.ts)*1000
-        FROM candles c
-        WHERE c.provider = $1 AND c.symbol = r.symbol AND c.interval = $3
-        ORDER BY c.ts DESC
-        LIMIT 1
-      ) AS max_ms
-    FROM requested r
-  `;
-  const response = await pool.query(sql, [
-    normalizedProvider,
-    normalizedSymbols,
-    interval
+  const valuesSql = rows.map(
+    (_, rowIndex) => `(${cols.map((__, colIndex) => `$${rowIndex * cols.length + colIndex + 1}`).join(",")})`
+  ).join(",");
+  const flat = rows.flatMap((row) => [
+    row.symbol,
+    row.interval,
+    row.ts,
+    row.trades,
+    row.whaleSides,
+    row.uniqueWhales,
+    row.whaleAddresses ?? [],
+    row.buyNotionalUsd,
+    row.sellNotionalUsd,
+    row.netNotionalUsd,
+    row.buySharePct ?? null,
+    row.positionAwareWhaleSides,
+    row.longEntryWhaleAddresses ?? [],
+    row.shortEntryWhaleAddresses ?? [],
+    row.longExitWhaleAddresses ?? [],
+    row.shortExitWhaleAddresses ?? [],
+    row.longEntryNotionalUsd,
+    row.shortEntryNotionalUsd,
+    row.longExitNotionalUsd,
+    row.shortExitNotionalUsd,
+    row.entryNetNotionalUsd,
+    row.entryLongSharePct ?? null,
+    row.universeFingerprint,
+    row.whaleRegistryFingerprint,
+    row.source ?? null
   ]);
-  for (const row of response.rows) {
-    const symbol = normalizeCandleSymbol(String(row.symbol || ""));
-    if (!symbol) continue;
-    const min = row.min_ms == null ? NaN : Number(row.min_ms);
-    const max = row.max_ms == null ? NaN : Number(row.max_ms);
-    result.set(symbol, {
-      ...Number.isFinite(min) ? { min } : {},
-      ...Number.isFinite(max) ? { max } : {}
+  await getPool().query(
+    `
+      INSERT INTO hyperliquid_whale_flow (${cols.join(",")})
+      VALUES ${valuesSql}
+      ON CONFLICT (
+        universe_fingerprint,
+        whale_registry_fingerprint,
+        symbol,
+        interval,
+        ts
+      ) DO UPDATE SET
+        trades = EXCLUDED.trades,
+        whale_sides = EXCLUDED.whale_sides,
+        unique_whales = EXCLUDED.unique_whales,
+        whale_addresses = EXCLUDED.whale_addresses,
+        buy_notional_usd = EXCLUDED.buy_notional_usd,
+        sell_notional_usd = EXCLUDED.sell_notional_usd,
+        net_notional_usd = EXCLUDED.net_notional_usd,
+        buy_share_pct = EXCLUDED.buy_share_pct,
+        position_aware_whale_sides = EXCLUDED.position_aware_whale_sides,
+        long_entry_whale_addresses = EXCLUDED.long_entry_whale_addresses,
+        short_entry_whale_addresses = EXCLUDED.short_entry_whale_addresses,
+        long_exit_whale_addresses = EXCLUDED.long_exit_whale_addresses,
+        short_exit_whale_addresses = EXCLUDED.short_exit_whale_addresses,
+        long_entry_notional_usd = EXCLUDED.long_entry_notional_usd,
+        short_entry_notional_usd = EXCLUDED.short_entry_notional_usd,
+        long_exit_notional_usd = EXCLUDED.long_exit_notional_usd,
+        short_exit_notional_usd = EXCLUDED.short_exit_notional_usd,
+        entry_net_notional_usd = EXCLUDED.entry_net_notional_usd,
+        entry_long_share_pct = EXCLUDED.entry_long_share_pct,
+        source = EXCLUDED.source,
+        ingested_at = now()
+    `,
+    flat
+  );
+}
+async function rebuildHyperliquidWhaleFlowRows(params) {
+  await ensureHyperliquidWhaleSchema();
+  const client = await getPool().connect();
+  try {
+    await client.query("BEGIN");
+    const result = await client.query(
+      `
+        WITH source_events AS (
+          SELECT *
+          FROM hyperliquid_whale_trade_events
+          WHERE universe_fingerprint = $1
+            AND whale_registry_fingerprint = $2
+            AND ts >= to_timestamp($3/1000.0)
+            AND ts < to_timestamp($4/1000.0)
+        ), metrics AS (
+          SELECT
+            symbol,
+            date_trunc('minute', ts) AS bucket_ts,
+            COUNT(*)::int AS trades,
+            SUM(buyer_tracked::int + seller_tracked::int)::int AS whale_sides,
+            SUM(CASE WHEN buyer_tracked THEN notional_usd ELSE 0 END) AS buy_notional_usd,
+            SUM(CASE WHEN seller_tracked THEN notional_usd ELSE 0 END) AS sell_notional_usd
+          FROM source_events
+          GROUP BY symbol, date_trunc('minute', ts)
+        ), position_legs AS (
+          SELECT
+            symbol,
+            ts,
+            price,
+            buyer_address AS whale_address,
+            buyer_start_position AS start_position,
+            buyer_end_position AS end_position
+          FROM source_events
+          WHERE buyer_tracked
+            AND buyer_address IS NOT NULL
+            AND buyer_start_position IS NOT NULL
+            AND buyer_end_position IS NOT NULL
+          UNION ALL
+          SELECT
+            symbol,
+            ts,
+            price,
+            seller_address AS whale_address,
+            seller_start_position AS start_position,
+            seller_end_position AS end_position
+          FROM source_events
+          WHERE seller_tracked
+            AND seller_address IS NOT NULL
+            AND seller_start_position IS NOT NULL
+            AND seller_end_position IS NOT NULL
+        ), classified_legs AS (
+          SELECT
+            *,
+            GREATEST(
+              GREATEST(end_position, 0) - GREATEST(start_position, 0),
+              0
+            ) AS long_entry_size,
+            GREATEST(
+              GREATEST(-end_position, 0) - GREATEST(-start_position, 0),
+              0
+            ) AS short_entry_size,
+            GREATEST(
+              GREATEST(start_position, 0) - GREATEST(end_position, 0),
+              0
+            ) AS long_exit_size,
+            GREATEST(
+              GREATEST(-start_position, 0) - GREATEST(-end_position, 0),
+              0
+            ) AS short_exit_size
+          FROM position_legs
+        ), position_metrics AS (
+          SELECT
+            symbol,
+            date_trunc('minute', ts) AS bucket_ts,
+            COUNT(*)::int AS position_aware_whale_sides,
+            SUM(long_entry_size * price) AS long_entry_notional_usd,
+            SUM(short_entry_size * price) AS short_entry_notional_usd,
+            SUM(long_exit_size * price) AS long_exit_notional_usd,
+            SUM(short_exit_size * price) AS short_exit_notional_usd,
+            COALESCE(
+              ARRAY_AGG(DISTINCT whale_address ORDER BY whale_address)
+                FILTER (WHERE long_entry_size > 0),
+              '{}'
+            ) AS long_entry_whale_addresses,
+            COALESCE(
+              ARRAY_AGG(DISTINCT whale_address ORDER BY whale_address)
+                FILTER (WHERE short_entry_size > 0),
+              '{}'
+            ) AS short_entry_whale_addresses,
+            COALESCE(
+              ARRAY_AGG(DISTINCT whale_address ORDER BY whale_address)
+                FILTER (WHERE long_exit_size > 0),
+              '{}'
+            ) AS long_exit_whale_addresses,
+            COALESCE(
+              ARRAY_AGG(DISTINCT whale_address ORDER BY whale_address)
+                FILTER (WHERE short_exit_size > 0),
+              '{}'
+            ) AS short_exit_whale_addresses
+          FROM classified_legs
+          GROUP BY symbol, date_trunc('minute', ts)
+        ), addresses AS (
+          SELECT
+            symbol,
+            date_trunc('minute', ts) AS bucket_ts,
+            ARRAY_AGG(DISTINCT whale_address ORDER BY whale_address) AS whale_addresses
+          FROM source_events
+          CROSS JOIN LATERAL UNNEST(ARRAY[
+            CASE WHEN buyer_tracked THEN buyer_address END,
+            CASE WHEN seller_tracked THEN seller_address END
+          ]) AS expanded(whale_address)
+          WHERE whale_address IS NOT NULL
+          GROUP BY symbol, date_trunc('minute', ts)
+        )
+        INSERT INTO hyperliquid_whale_flow (
+          symbol,
+          interval,
+          ts,
+          trades,
+          whale_sides,
+          unique_whales,
+          whale_addresses,
+          buy_notional_usd,
+          sell_notional_usd,
+          net_notional_usd,
+          buy_share_pct,
+          position_aware_whale_sides,
+          long_entry_whale_addresses,
+          short_entry_whale_addresses,
+          long_exit_whale_addresses,
+          short_exit_whale_addresses,
+          long_entry_notional_usd,
+          short_entry_notional_usd,
+          long_exit_notional_usd,
+          short_exit_notional_usd,
+          entry_net_notional_usd,
+          entry_long_share_pct,
+          universe_fingerprint,
+          whale_registry_fingerprint,
+          source
+        )
+        SELECT
+          metrics.symbol,
+          '1m',
+          metrics.bucket_ts,
+          metrics.trades,
+          metrics.whale_sides,
+          COALESCE(CARDINALITY(addresses.whale_addresses), 0),
+          COALESCE(addresses.whale_addresses, '{}'),
+          metrics.buy_notional_usd,
+          metrics.sell_notional_usd,
+          metrics.buy_notional_usd - metrics.sell_notional_usd,
+          CASE
+            WHEN metrics.buy_notional_usd + metrics.sell_notional_usd > 0
+            THEN metrics.buy_notional_usd /
+              (metrics.buy_notional_usd + metrics.sell_notional_usd)
+            ELSE NULL
+          END,
+          COALESCE(position_metrics.position_aware_whale_sides, 0),
+          COALESCE(position_metrics.long_entry_whale_addresses, '{}'),
+          COALESCE(position_metrics.short_entry_whale_addresses, '{}'),
+          COALESCE(position_metrics.long_exit_whale_addresses, '{}'),
+          COALESCE(position_metrics.short_exit_whale_addresses, '{}'),
+          COALESCE(position_metrics.long_entry_notional_usd, 0),
+          COALESCE(position_metrics.short_entry_notional_usd, 0),
+          COALESCE(position_metrics.long_exit_notional_usd, 0),
+          COALESCE(position_metrics.short_exit_notional_usd, 0),
+          COALESCE(position_metrics.long_entry_notional_usd, 0) -
+            COALESCE(position_metrics.short_entry_notional_usd, 0),
+          CASE
+            WHEN COALESCE(position_metrics.long_entry_notional_usd, 0) +
+              COALESCE(position_metrics.short_entry_notional_usd, 0) > 0
+            THEN COALESCE(position_metrics.long_entry_notional_usd, 0) /
+              (
+                COALESCE(position_metrics.long_entry_notional_usd, 0) +
+                COALESCE(position_metrics.short_entry_notional_usd, 0)
+              )
+            ELSE NULL
+          END,
+          $1,
+          $2,
+          CASE
+            WHEN COALESCE(position_metrics.position_aware_whale_sides, 0) > 0
+            THEN 'hyperliquid_user_fills'
+            ELSE 'hyperliquid_trades'
+          END
+        FROM metrics
+        LEFT JOIN addresses USING (symbol, bucket_ts)
+        LEFT JOIN position_metrics USING (symbol, bucket_ts)
+        ON CONFLICT (
+          universe_fingerprint,
+          whale_registry_fingerprint,
+          symbol,
+          interval,
+          ts
+        ) DO UPDATE SET
+          trades = EXCLUDED.trades,
+          whale_sides = EXCLUDED.whale_sides,
+          unique_whales = EXCLUDED.unique_whales,
+          whale_addresses = EXCLUDED.whale_addresses,
+          buy_notional_usd = EXCLUDED.buy_notional_usd,
+          sell_notional_usd = EXCLUDED.sell_notional_usd,
+          net_notional_usd = EXCLUDED.net_notional_usd,
+          buy_share_pct = EXCLUDED.buy_share_pct,
+          position_aware_whale_sides = EXCLUDED.position_aware_whale_sides,
+          long_entry_whale_addresses = EXCLUDED.long_entry_whale_addresses,
+          short_entry_whale_addresses = EXCLUDED.short_entry_whale_addresses,
+          long_exit_whale_addresses = EXCLUDED.long_exit_whale_addresses,
+          short_exit_whale_addresses = EXCLUDED.short_exit_whale_addresses,
+          long_entry_notional_usd = EXCLUDED.long_entry_notional_usd,
+          short_entry_notional_usd = EXCLUDED.short_entry_notional_usd,
+          long_exit_notional_usd = EXCLUDED.long_exit_notional_usd,
+          short_exit_notional_usd = EXCLUDED.short_exit_notional_usd,
+          entry_net_notional_usd = EXCLUDED.entry_net_notional_usd,
+          entry_long_share_pct = EXCLUDED.entry_long_share_pct,
+          source = EXCLUDED.source,
+          ingested_at = now()
+        RETURNING 1
+      `,
+      [
+        params.universeFingerprint,
+        params.whaleRegistryFingerprint,
+        params.fromMs,
+        params.toMs
+      ]
+    );
+    if (params.deleteEventsBeforeMs != null) {
+      await client.query(
+        `
+          DELETE FROM hyperliquid_whale_trade_events
+          WHERE universe_fingerprint = $1
+            AND whale_registry_fingerprint = $2
+            AND ts < to_timestamp($3/1000.0)
+        `,
+        [
+          params.universeFingerprint,
+          params.whaleRegistryFingerprint,
+          params.deleteEventsBeforeMs
+        ]
+      );
+    }
+    await client.query("COMMIT");
+    return result.rowCount ?? 0;
+  } catch (error) {
+    await client.query("ROLLBACK");
+    throw error;
+  } finally {
+    client.release();
+  }
+}
+async function getHyperliquidWhaleWalletCoverage(params) {
+  await ensureHyperliquidWhaleSchema();
+  const result = await getPool().query(
+    `
+      SELECT
+        status,
+        covered_from_ts,
+        covered_to_ts,
+        fills_count,
+        error,
+        checked_at
+      FROM hyperliquid_whale_wallet_coverage
+      WHERE universe_fingerprint = $1
+        AND whale_registry_fingerprint = $2
+        AND address = $3
+        AND data_model_version = $6
+        AND (
+          (
+            covered_from_ts <= to_timestamp($4/1000.0)
+            AND covered_to_ts >= to_timestamp($5/1000.0)
+          )
+          OR (
+            requested_from_ts = to_timestamp($4/1000.0)
+            AND requested_to_ts = to_timestamp($5/1000.0)
+          )
+        )
+      ORDER BY checked_at DESC
+      LIMIT 1
+    `,
+    [
+      params.universeFingerprint,
+      params.whaleRegistryFingerprint,
+      params.address.toLowerCase(),
+      params.fromMs,
+      params.toMs,
+      import_types.HYPERLIQUID_WHALE_DATA_MODEL_VERSION
+    ]
+  );
+  const row = result.rows[0];
+  if (!row) return null;
+  return {
+    status: row.covered_from_ts != null && row.covered_to_ts != null && new Date(row.covered_from_ts).getTime() <= params.fromMs && new Date(row.covered_to_ts).getTime() >= params.toMs ? "complete" : String(row.status),
+    coveredFromMs: row.covered_from_ts == null ? null : new Date(row.covered_from_ts).getTime(),
+    coveredToMs: row.covered_to_ts == null ? null : new Date(row.covered_to_ts).getTime(),
+    fillsCount: Number(row.fills_count) || 0,
+    error: row.error == null ? null : String(row.error),
+    checkedAt: new Date(row.checked_at)
+  };
+}
+async function upsertHyperliquidWhaleWalletCoverage(params) {
+  await ensureHyperliquidWhaleSchema();
+  await getPool().query(
+    `
+      INSERT INTO hyperliquid_whale_wallet_coverage (
+        universe_fingerprint,
+        whale_registry_fingerprint,
+        address,
+        requested_from_ts,
+        requested_to_ts,
+        covered_from_ts,
+        covered_to_ts,
+        status,
+        fills_count,
+        error,
+        data_model_version
+      ) VALUES (
+        $1,
+        $2,
+        $3,
+        to_timestamp($4/1000.0),
+        to_timestamp($5/1000.0),
+        CASE WHEN $6::double precision IS NULL THEN NULL ELSE to_timestamp($6/1000.0) END,
+        CASE WHEN $7::double precision IS NULL THEN NULL ELSE to_timestamp($7/1000.0) END,
+        $8,
+        $9,
+        $10,
+        $11
+      )
+      ON CONFLICT (
+        universe_fingerprint,
+        whale_registry_fingerprint,
+        address,
+        requested_from_ts,
+        requested_to_ts
+      ) DO UPDATE SET
+        covered_from_ts = EXCLUDED.covered_from_ts,
+        covered_to_ts = EXCLUDED.covered_to_ts,
+        status = EXCLUDED.status,
+        fills_count = EXCLUDED.fills_count,
+        error = EXCLUDED.error,
+        data_model_version = EXCLUDED.data_model_version,
+        checked_at = now()
+    `,
+    [
+      params.universeFingerprint,
+      params.whaleRegistryFingerprint,
+      params.address.toLowerCase(),
+      params.fromMs,
+      params.toMs,
+      params.coveredFromMs,
+      params.coveredToMs,
+      params.status,
+      params.fillsCount,
+      params.error ?? null,
+      import_types.HYPERLIQUID_WHALE_DATA_MODEL_VERSION
+    ]
+  );
+}
+async function rebuildHyperliquidWhaleCoverageRows(params) {
+  await ensureHyperliquidWhaleSchema();
+  if (params.toMs <= params.fromMs) return 0;
+  const minuteMs = 6e4;
+  const defaultChunkMinutes = 7 * 24 * 60;
+  const chunkMinutes = Number.isFinite(params.chunkMinutes) && Number(params.chunkMinutes) > 0 ? Math.floor(Number(params.chunkMinutes)) : defaultChunkMinutes;
+  const chunkMs = chunkMinutes * minuteMs;
+  const totalBuckets = Math.ceil((params.toMs - params.fromMs) / minuteMs);
+  const totalChunks = Math.ceil((params.toMs - params.fromMs) / chunkMs);
+  let completedBuckets = 0;
+  let rows = 0;
+  for (let chunkIndex = 0, chunkFromMs = params.fromMs; chunkFromMs < params.toMs; chunkIndex += 1, chunkFromMs += chunkMs) {
+    const chunkToMs = Math.min(params.toMs, chunkFromMs + chunkMs);
+    const result = await getPool().query(
+      `
+        WITH normalized_ranges AS (
+          SELECT
+            address,
+            GREATEST(
+              to_timestamp($3/1000.0),
+              date_trunc('minute', covered_from_ts) +
+                CASE
+                  WHEN covered_from_ts = date_trunc('minute', covered_from_ts)
+                  THEN interval '0 minutes'
+                  ELSE interval '1 minute'
+                END
+            ) AS range_start,
+            LEAST(
+              to_timestamp($4/1000.0),
+              date_trunc('minute', covered_to_ts)
+            ) AS range_end
+          FROM hyperliquid_whale_wallet_coverage
+          WHERE universe_fingerprint = $1
+            AND whale_registry_fingerprint = $2
+            AND data_model_version = $6
+            AND status IN ('complete', 'truncated')
+            AND covered_from_ts < to_timestamp($4/1000.0)
+            AND covered_to_ts > to_timestamp($3/1000.0)
+        ), eligible_ranges AS (
+          SELECT *
+          FROM normalized_ranges
+          WHERE range_start < range_end
+        ), ordered_ranges AS (
+          SELECT
+            *,
+            MAX(range_end) OVER (
+              PARTITION BY address
+              ORDER BY range_start, range_end
+              ROWS BETWEEN UNBOUNDED PRECEDING AND 1 PRECEDING
+            ) AS previous_max_end
+          FROM eligible_ranges
+        ), marked_ranges AS (
+          SELECT
+            *,
+            SUM(
+              CASE
+                WHEN previous_max_end IS NULL OR range_start > previous_max_end
+                THEN 1
+                ELSE 0
+              END
+            ) OVER (
+              PARTITION BY address
+              ORDER BY range_start, range_end
+            ) AS range_group
+          FROM ordered_ranges
+        ), merged_ranges AS (
+          SELECT
+            address,
+            MIN(range_start) AS range_start,
+            MAX(range_end) AS range_end
+          FROM marked_ranges
+          GROUP BY address, range_group
+        ), deltas AS (
+          SELECT range_start AS ts, 1 AS delta
+          FROM merged_ranges
+          UNION ALL
+          SELECT range_end AS ts, -1 AS delta
+          FROM merged_ranges
+        ), bucket_deltas AS (
+          SELECT ts, SUM(delta)::int AS delta
+          FROM deltas
+          GROUP BY ts
+        ), buckets AS (
+          SELECT generate_series(
+            to_timestamp($3/1000.0),
+            to_timestamp($4/1000.0) - interval '1 minute',
+            interval '1 minute'
+          ) AS ts
+        ), coverage AS (
+          SELECT
+            buckets.ts,
+            SUM(COALESCE(bucket_deltas.delta, 0)) OVER (
+              ORDER BY buckets.ts
+              ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW
+            )::int AS covered_whales
+          FROM buckets
+          LEFT JOIN bucket_deltas USING (ts)
+        )
+        INSERT INTO hyperliquid_whale_coverage_1m (
+          ts,
+          covered_whales,
+          expected_whales,
+          coverage_pct,
+          universe_fingerprint,
+          whale_registry_fingerprint,
+          source,
+          data_model_version
+        )
+        SELECT
+          ts,
+          covered_whales,
+          $5,
+          CASE WHEN $5 > 0 THEN covered_whales::double precision / $5 ELSE 0 END,
+          $1,
+          $2,
+          'hyperliquid_user_fills',
+          $6
+        FROM coverage
+        ON CONFLICT (
+          universe_fingerprint,
+          whale_registry_fingerprint,
+          ts
+        ) DO UPDATE SET
+          covered_whales = EXCLUDED.covered_whales,
+          expected_whales = EXCLUDED.expected_whales,
+          coverage_pct = EXCLUDED.coverage_pct,
+          source = EXCLUDED.source,
+          data_model_version = EXCLUDED.data_model_version,
+          ingested_at = now()
+      `,
+      [
+        params.universeFingerprint,
+        params.whaleRegistryFingerprint,
+        chunkFromMs,
+        chunkToMs,
+        params.expectedWhales,
+        import_types.HYPERLIQUID_WHALE_DATA_MODEL_VERSION
+      ]
+    );
+    const chunkBuckets = Math.ceil((chunkToMs - chunkFromMs) / minuteMs);
+    completedBuckets = Math.min(totalBuckets, completedBuckets + chunkBuckets);
+    rows += result.rowCount ?? 0;
+    params.onProgress?.({
+      chunkIndex: chunkIndex + 1,
+      totalChunks,
+      completedBuckets,
+      totalBuckets,
+      rows
     });
   }
-  return result;
+  return rows;
 }
-async function waitForDbReady(attempts = 20, delayMs = 1e3) {
-  const pool = getPool();
-  let lastError;
-  for (let i = 0; i < attempts; i++) {
-    try {
-      await pool.query("SELECT 1");
-      return;
-    } catch (e) {
-      lastError = e;
-      await new Promise((r) => setTimeout(r, delayMs));
+async function upsertHyperliquidWhaleCoverageRows(rows) {
+  if (!rows.length) return;
+  await ensureHyperliquidWhaleSchema();
+  const cols = [
+    "ts",
+    "covered_whales",
+    "expected_whales",
+    "coverage_pct",
+    "universe_fingerprint",
+    "whale_registry_fingerprint",
+    "source",
+    "data_model_version"
+  ];
+  const maxRows = getSafeBulkInsertRows(cols.length);
+  if (rows.length > maxRows) {
+    for (let index = 0; index < rows.length; index += maxRows) {
+      await upsertHyperliquidWhaleCoverageRows(
+        rows.slice(index, index + maxRows)
+      );
     }
+    return;
   }
-  throw lastError;
+  const values = [];
+  const tuples = rows.map((row, rowIndex) => {
+    const offset = rowIndex * cols.length;
+    values.push(
+      row.ts,
+      row.coveredWhales,
+      row.expectedWhales,
+      row.coveragePct,
+      row.universeFingerprint,
+      row.whaleRegistryFingerprint,
+      row.source ?? null,
+      row.dataModelVersion ?? import_types.HYPERLIQUID_WHALE_DATA_MODEL_VERSION
+    );
+    return `(${cols.map((_, colIndex) => `$${offset + colIndex + 1}`).join(",")})`;
+  });
+  await getPool().query(
+    `
+      INSERT INTO hyperliquid_whale_coverage_1m (${cols.join(",")})
+      VALUES ${tuples.join(",")}
+      ON CONFLICT (
+        universe_fingerprint,
+        whale_registry_fingerprint,
+        ts
+      ) DO UPDATE SET
+        covered_whales = EXCLUDED.covered_whales,
+        expected_whales = EXCLUDED.expected_whales,
+        coverage_pct = EXCLUDED.coverage_pct,
+        source = EXCLUDED.source,
+        data_model_version = EXCLUDED.data_model_version,
+        ingested_at = now()
+    `,
+    values
+  );
 }
-async function deleteCandles(provider, symbol, interval) {
-  const pool = getPool();
-  const normalizedProvider = normalizeCandleProvider(provider);
-  const normalizedSymbol = normalizeCandleSymbol(symbol);
-  const sql = `
-    DELETE FROM candles
-    WHERE provider = $1 AND symbol = $2 AND interval = $3
-  `;
-  await pool.query(sql, [normalizedProvider, normalizedSymbol, interval]);
+async function getHyperliquidWhaleCoverageSeriesRows(params) {
+  await prepareMarketContextSchemaForRead("hyperliquidWhales");
+  const result = await queryMarketContext(
+    `
+      SELECT
+        ts,
+        covered_whales,
+        expected_whales,
+        coverage_pct
+      FROM hyperliquid_whale_coverage_1m
+      WHERE universe_fingerprint = $1
+        AND whale_registry_fingerprint = $2
+        AND data_model_version = $3
+        AND ts >= to_timestamp($4/1000.0)
+        AND ts < to_timestamp($5/1000.0)
+      ORDER BY ts
+    `,
+    [
+      params.universeFingerprint,
+      params.whaleRegistryFingerprint,
+      import_types.HYPERLIQUID_WHALE_DATA_MODEL_VERSION,
+      params.fromMs,
+      params.toMs
+    ],
+    params
+  );
+  return result.rows.map((row) => ({
+    ts: new Date(row.ts),
+    coveredWhales: Number(row.covered_whales) || 0,
+    expectedWhales: Number(row.expected_whales) || 0,
+    coveragePct: Number(row.coverage_pct) || 0
+  }));
+}
+async function getHyperliquidWhaleFlowSeriesRows(params) {
+  await prepareMarketContextSchemaForRead("hyperliquidWhales");
+  const result = await queryMarketContext(
+    `
+      SELECT
+        ts,
+        trades,
+        whale_sides,
+        whale_addresses,
+        buy_notional_usd,
+        sell_notional_usd,
+        position_aware_whale_sides,
+        long_entry_whale_addresses,
+        short_entry_whale_addresses,
+        long_exit_whale_addresses,
+        short_exit_whale_addresses,
+        long_entry_notional_usd,
+        short_entry_notional_usd,
+        long_exit_notional_usd,
+        short_exit_notional_usd
+      FROM hyperliquid_whale_flow
+      WHERE symbol = $1
+        AND interval = '1m'
+        AND universe_fingerprint = $2
+        AND whale_registry_fingerprint = $3
+        AND ts >= to_timestamp($4/1000.0)
+        AND ts < to_timestamp($5/1000.0)
+      ORDER BY ts
+    `,
+    [
+      params.symbol,
+      params.universeFingerprint,
+      params.whaleRegistryFingerprint,
+      params.fromMs,
+      params.toMs
+    ],
+    params
+  );
+  return result.rows.map((row) => ({
+    ts: new Date(row.ts),
+    trades: Number(row.trades) || 0,
+    whaleSides: Number(row.whale_sides) || 0,
+    whaleAddresses: Array.isArray(row.whale_addresses) ? row.whale_addresses.map(String) : [],
+    buyNotionalUsd: Number(row.buy_notional_usd) || 0,
+    sellNotionalUsd: Number(row.sell_notional_usd) || 0,
+    positionAwareWhaleSides: Number(row.position_aware_whale_sides) || 0,
+    longEntryWhaleAddresses: Array.isArray(row.long_entry_whale_addresses) ? row.long_entry_whale_addresses.map(String) : [],
+    shortEntryWhaleAddresses: Array.isArray(row.short_entry_whale_addresses) ? row.short_entry_whale_addresses.map(String) : [],
+    longExitWhaleAddresses: Array.isArray(row.long_exit_whale_addresses) ? row.long_exit_whale_addresses.map(String) : [],
+    shortExitWhaleAddresses: Array.isArray(row.short_exit_whale_addresses) ? row.short_exit_whale_addresses.map(String) : [],
+    longEntryNotionalUsd: Number(row.long_entry_notional_usd) || 0,
+    shortEntryNotionalUsd: Number(row.short_entry_notional_usd) || 0,
+    longExitNotionalUsd: Number(row.long_exit_notional_usd) || 0,
+    shortExitNotionalUsd: Number(row.short_exit_notional_usd) || 0
+  }));
 }
-async function findContinuityGap(provider, symbol, interval) {
-  const pool = getPool();
-  const normalizedProvider = normalizeCandleProvider(provider);
-  const normalizedSymbol = normalizeCandleSymbol(symbol);
-  const expectedSeconds = interval * 60;
-  const sql = `
-    WITH ordered AS (
+async function getHyperliquidWhaleFlowAggregate(params) {
+  await prepareMarketContextSchemaForRead("hyperliquidWhales");
+  const intervalMs = HYPERLIQUID_CONTEXT_INTERVAL_MS[params.interval];
+  const expectedBuckets = Math.ceil(intervalMs / 6e4);
+  const res = await queryMarketContext(
+    `
+      WITH coverage_rows AS (
+        SELECT *
+        FROM hyperliquid_whale_coverage_1m
+        WHERE universe_fingerprint = $2
+          AND whale_registry_fingerprint = $3
+          AND data_model_version = $6
+          AND ts >= to_timestamp(
+            ($4::double precision - $5::double precision) / 1000.0
+          )
+          AND ts < to_timestamp($4/1000.0)
+      ), coverage_summary AS (
+        SELECT
+          COUNT(*)::int AS coverage_buckets,
+          MAX(ts) AS coverage_as_of_ts,
+          MIN(covered_whales)::int AS covered_whales,
+          MAX(expected_whales)::int AS expected_whales,
+          MIN(coverage_pct) AS coverage_pct
+        FROM coverage_rows
+      ), window_rows AS (
+        SELECT *
+        FROM hyperliquid_whale_flow
+        WHERE symbol = $1
+          AND interval = '1m'
+          AND universe_fingerprint = $2
+          AND whale_registry_fingerprint = $3
+          AND ts >= to_timestamp(
+            ($4::double precision - $5::double precision) / 1000.0
+          )
+          AND ts < to_timestamp($4/1000.0)
+      ), unique_addresses AS (
+        SELECT COUNT(DISTINCT address)::int AS unique_whales
+        FROM window_rows
+        CROSS JOIN LATERAL UNNEST(whale_addresses) AS expanded(address)
+      ), directional_counts AS (
+        SELECT
+          (
+            SELECT COUNT(DISTINCT address)::int
+            FROM window_rows
+            CROSS JOIN LATERAL UNNEST(long_entry_whale_addresses) AS expanded(address)
+          ) AS long_entry_whales,
+          (
+            SELECT COUNT(DISTINCT address)::int
+            FROM window_rows
+            CROSS JOIN LATERAL UNNEST(short_entry_whale_addresses) AS expanded(address)
+          ) AS short_entry_whales,
+          (
+            SELECT COUNT(DISTINCT address)::int
+            FROM window_rows
+            CROSS JOIN LATERAL UNNEST(long_exit_whale_addresses) AS expanded(address)
+          ) AS long_exit_whales,
+          (
+            SELECT COUNT(DISTINCT address)::int
+            FROM window_rows
+            CROSS JOIN LATERAL UNNEST(short_exit_whale_addresses) AS expanded(address)
+          ) AS short_exit_whales
+      )
       SELECT
-        ts,
-        LAG(ts) OVER (ORDER BY ts) AS prev_ts
-      FROM candles
-      WHERE provider = $1 AND symbol = $2 AND interval = $3
-    )
-    SELECT
-      ts,
-      prev_ts,
-      EXTRACT(EPOCH FROM (ts - prev_ts))::int AS diff_seconds
-    FROM ordered
-    WHERE prev_ts IS NOT NULL
-      AND EXTRACT(EPOCH FROM (ts - prev_ts))::int <> $4
-    ORDER BY ts ASC
-    LIMIT 1
-  `;
-  const res = await pool.query(sql, [
-    normalizedProvider,
-    normalizedSymbol,
-    interval,
-    expectedSeconds
-  ]);
+        $1::text AS symbol,
+        coverage_summary.coverage_as_of_ts AS as_of_ts,
+        coverage_summary.coverage_buckets,
+        coverage_summary.covered_whales,
+        coverage_summary.expected_whales,
+        coverage_summary.coverage_pct,
+        COALESCE((SELECT SUM(trades) FROM window_rows), 0)::int AS trades,
+        COALESCE((SELECT SUM(whale_sides) FROM window_rows), 0)::int AS whale_sides,
+        COALESCE((SELECT unique_whales FROM unique_addresses), 0)::int AS unique_whales,
+        COALESCE((SELECT SUM(buy_notional_usd) FROM window_rows), 0) AS buy_notional_usd,
+        COALESCE((SELECT SUM(sell_notional_usd) FROM window_rows), 0) AS sell_notional_usd,
+        COALESCE((SELECT SUM(net_notional_usd) FROM window_rows), 0) AS net_notional_usd,
+        CASE
+          WHEN COALESCE((SELECT SUM(buy_notional_usd + sell_notional_usd) FROM window_rows), 0) > 0
+          THEN (SELECT SUM(buy_notional_usd) FROM window_rows) /
+            (SELECT SUM(buy_notional_usd + sell_notional_usd) FROM window_rows)
+          ELSE NULL
+        END AS buy_share_pct,
+        COALESCE((SELECT SUM(position_aware_whale_sides) FROM window_rows), 0)::int
+          AS position_aware_whale_sides,
+        CASE
+          WHEN COALESCE((SELECT SUM(whale_sides) FROM window_rows), 0) > 0
+          THEN COALESCE((SELECT SUM(position_aware_whale_sides) FROM window_rows), 0)::double precision /
+            (SELECT SUM(whale_sides) FROM window_rows)
+          ELSE 0
+        END AS position_aware_pct,
+        COALESCE((SELECT long_entry_whales FROM directional_counts), 0)::int AS long_entry_whales,
+        COALESCE((SELECT short_entry_whales FROM directional_counts), 0)::int AS short_entry_whales,
+        COALESCE((SELECT long_exit_whales FROM directional_counts), 0)::int AS long_exit_whales,
+        COALESCE((SELECT short_exit_whales FROM directional_counts), 0)::int AS short_exit_whales,
+        COALESCE((SELECT SUM(long_entry_notional_usd) FROM window_rows), 0)
+          AS long_entry_notional_usd,
+        COALESCE((SELECT SUM(short_entry_notional_usd) FROM window_rows), 0)
+          AS short_entry_notional_usd,
+        COALESCE((SELECT SUM(long_exit_notional_usd) FROM window_rows), 0)
+          AS long_exit_notional_usd,
+        COALESCE((SELECT SUM(short_exit_notional_usd) FROM window_rows), 0)
+          AS short_exit_notional_usd,
+        COALESCE((SELECT SUM(entry_net_notional_usd) FROM window_rows), 0)
+          AS entry_net_notional_usd,
+        CASE
+          WHEN COALESCE((SELECT SUM(long_entry_notional_usd + short_entry_notional_usd) FROM window_rows), 0) > 0
+          THEN (SELECT SUM(long_entry_notional_usd) FROM window_rows) /
+            (SELECT SUM(long_entry_notional_usd + short_entry_notional_usd) FROM window_rows)
+          ELSE NULL
+        END AS entry_long_share_pct,
+        (SELECT MAX(source) FROM window_rows) AS source
+      FROM coverage_summary
+    `,
+    [
+      params.symbol,
+      params.universeFingerprint,
+      params.whaleRegistryFingerprint,
+      params.decisionTimeMs,
+      intervalMs,
+      import_types.HYPERLIQUID_WHALE_DATA_MODEL_VERSION
+    ],
+    params
+  );
   const row = res.rows[0];
-  if (!row) return null;
+  if (!row?.as_of_ts || Number(row.coverage_buckets) !== expectedBuckets || Number(row.covered_whales) <= 0) {
+    return null;
+  }
+  const asOfTs = new Date(row.as_of_ts);
+  const ageMs = params.decisionTimeMs - (asOfTs.getTime() + 6e4);
   return {
-    ts: new Date(row.ts).getTime(),
-    prevTs: new Date(row.prev_ts).getTime(),
-    diffSeconds: row.diff_seconds
+    symbol: params.symbol,
+    interval: params.interval,
+    asOfTs,
+    windowEndTs: new Date(params.decisionTimeMs),
+    trades: Number(row.trades) || 0,
+    whaleSides: Number(row.whale_sides) || 0,
+    uniqueWhales: Number(row.unique_whales) || 0,
+    coveredWhales: Number(row.covered_whales) || 0,
+    expectedWhales: Number(row.expected_whales) || 0,
+    coveragePct: Number(row.coverage_pct) || 0,
+    buyNotionalUsd: Number(row.buy_notional_usd) || 0,
+    sellNotionalUsd: Number(row.sell_notional_usd) || 0,
+    netNotionalUsd: Number(row.net_notional_usd) || 0,
+    buySharePct: row.buy_share_pct == null ? null : Number(row.buy_share_pct) || 0,
+    positionAwareWhaleSides: Number(row.position_aware_whale_sides) || 0,
+    positionAwarePct: Number(row.position_aware_pct) || 0,
+    longEntryWhales: Number(row.long_entry_whales) || 0,
+    shortEntryWhales: Number(row.short_entry_whales) || 0,
+    longExitWhales: Number(row.long_exit_whales) || 0,
+    shortExitWhales: Number(row.short_exit_whales) || 0,
+    longEntryNotionalUsd: Number(row.long_entry_notional_usd) || 0,
+    shortEntryNotionalUsd: Number(row.short_entry_notional_usd) || 0,
+    longExitNotionalUsd: Number(row.long_exit_notional_usd) || 0,
+    shortExitNotionalUsd: Number(row.short_exit_notional_usd) || 0,
+    entryNetNotionalUsd: Number(row.entry_net_notional_usd) || 0,
+    entryLongSharePct: row.entry_long_share_pct == null ? null : Number(row.entry_long_share_pct) || 0,
+    universeFingerprint: params.universeFingerprint,
+    whaleRegistryFingerprint: params.whaleRegistryFingerprint,
+    source: row.source == null ? null : String(row.source),
+    ageMs,
+    stale: ageMs < 0 || (params.maxAgeMs != null && Number.isFinite(params.maxAgeMs) ? ageMs > params.maxAgeMs : false)
   };
 }
+async function hasHyperliquidWhaleBackfillCoverage(params) {
+  await ensureHyperliquidWhaleSchema();
+  const expectedBuckets = Math.max(
+    0,
+    Math.ceil((params.toMs - params.fromMs) / 6e4)
+  );
+  const result = await getPool().query(
+    `
+      SELECT
+        COUNT(*)::int AS buckets,
+        COUNT(*) FILTER (
+          WHERE covered_whales = expected_whales
+        )::int AS complete_buckets
+      FROM hyperliquid_whale_coverage_1m
+      WHERE universe_fingerprint = $1
+        AND whale_registry_fingerprint = $2
+        AND data_model_version = $5
+        AND ts >= to_timestamp($3/1000.0)
+        AND ts < to_timestamp($4/1000.0)
+    `,
+    [
+      params.universeFingerprint,
+      params.whaleRegistryFingerprint,
+      params.fromMs,
+      params.toMs,
+      import_types.HYPERLIQUID_WHALE_DATA_MODEL_VERSION
+    ]
+  );
+  return Number(result.rows[0]?.buckets) === expectedBuckets && Number(result.rows[0]?.complete_buckets) === expectedBuckets;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   applyDerivativesMetricCoverage,