@tradejs/infra 2.0.18 → 2.0.19

package/dist/timescale/hyperliquidWhales.js

@@ -0,0 +1,1893 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/timescale/hyperliquidWhales.ts
+var hyperliquidWhales_exports = {};
+__export(hyperliquidWhales_exports, {
+  ensureHyperliquidWhaleSchema: () => ensureHyperliquidWhaleSchema,
+  getHyperliquidWhaleCoverageSeriesRows: () => getHyperliquidWhaleCoverageSeriesRows,
+  getHyperliquidWhaleFlowAggregate: () => getHyperliquidWhaleFlowAggregate,
+  getHyperliquidWhaleFlowSeriesRows: () => getHyperliquidWhaleFlowSeriesRows,
+  getHyperliquidWhaleWalletCoverage: () => getHyperliquidWhaleWalletCoverage,
+  hasHyperliquidWhaleBackfillCoverage: () => hasHyperliquidWhaleBackfillCoverage,
+  rebuildHyperliquidWhaleCoverageRows: () => rebuildHyperliquidWhaleCoverageRows,
+  rebuildHyperliquidWhaleFlowRows: () => rebuildHyperliquidWhaleFlowRows,
+  upsertHyperliquidWhaleCoverageRows: () => upsertHyperliquidWhaleCoverageRows,
+  upsertHyperliquidWhaleFlowRows: () => upsertHyperliquidWhaleFlowRows,
+  upsertHyperliquidWhaleTradeEvents: () => upsertHyperliquidWhaleTradeEvents,
+  upsertHyperliquidWhaleWalletCoverage: () => upsertHyperliquidWhaleWalletCoverage
+});
+module.exports = __toCommonJS(hyperliquidWhales_exports);
+var import_types = require("@tradejs/types");
+
+// src/timescale/pool.ts
+var import_pg = require("pg");
+var getPool = () => {
+  if (!global.__pgPool__) {
+    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: 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
+    });
+  }
+  return global.__pgPool__;
+};
+
+// 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 createQueryError = (name, message) => {
+  const error = new Error(message);
+  error.name = name;
+  return error;
+};
+var queryMarketContext = async (text, values, options = {}) => {
+  const client = await getPool().connect();
+  const timeoutMs = resolveQueryTimeoutMs(options.timeoutMs);
+  let released = false;
+  let rejectCancellation;
+  const release = (error) => {
+    if (released) return;
+    released = true;
+    client.release(error);
+  };
+  const cancellation = new Promise((_resolve, reject) => {
+    rejectCancellation = reject;
+  });
+  const cancel = (error) => {
+    release(error);
+    rejectCancellation?.(error);
+  };
+  const onAbort = () => cancel(
+    createQueryError("AbortError", "Timescale market-context query aborted")
+  );
+  const timer = setTimeout(
+    () => cancel(
+      createQueryError(
+        "TimescaleQueryTimeoutError",
+        `Timescale market-context query exceeded ${timeoutMs}ms`
+      )
+    ),
+    timeoutMs
+  );
+  timer.unref?.();
+  options.signal?.addEventListener("abort", onAbort, { once: true });
+  try {
+    if (options.signal?.aborted) {
+      const error = createQueryError(
+        "AbortError",
+        "Timescale market-context query aborted"
+      );
+      release(error);
+      throw error;
+    }
+    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 getSafeBulkInsertRows = (columnsCount) => Math.max(1, Math.floor(PG_SAFE_MAX_BIND_PARAMS / columnsCount));
+
+// src/timescale/internal.ts
+var derivativesSchemaReady = false;
+var binanceMarketSchemaReady = false;
+var hyperliquidWhaleSchemaReady = false;
+var derivativesSchemaReadyPromise = null;
+var binanceMarketSchemaReadyPromise = null;
+var hyperliquidWhaleSchemaReadyPromise = null;
+var marketContextSchemaMode = "ensure";
+var verifiedMarketContextSchemas = /* @__PURE__ */ new Set();
+var DERIVATIVES_SCHEMA_LOCK_KEY = 610001;
+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]);
+  try {
+    await work();
+  } finally {
+    await pool.query("SELECT pg_advisory_unlock($1)", [lockKey]);
+  }
+};
+var ensureDerivativesSchema = async () => {
+  if (derivativesSchemaReady) return;
+  if (derivativesSchemaReadyPromise) {
+    await derivativesSchemaReadyPromise;
+    return;
+  }
+  const pool = getPool();
+  derivativesSchemaReadyPromise = withSchemaLock(
+    DERIVATIVES_SCHEMA_LOCK_KEY,
+    async () => {
+      if (derivativesSchemaReady) return;
+      await pool.query("CREATE EXTENSION IF NOT EXISTS timescaledb");
+      await pool.query(`
+        CREATE TABLE IF NOT EXISTS derivatives_market (
+          symbol text NOT NULL,
+          interval text NOT NULL,
+          ts timestamptz NOT NULL,
+          open_interest double precision,
+          funding_rate double precision,
+          liq_long double precision,
+          liq_short double precision,
+          liq_total double precision,
+          source text,
+          ingested_at timestamptz NOT NULL DEFAULT now(),
+          PRIMARY KEY (symbol, interval, ts)
+        )
+      `);
+      await pool.query(`
+        SELECT create_hypertable(
+          'derivatives_market',
+          'ts',
+          if_not_exists => TRUE,
+          chunk_time_interval => interval '14 days'
+        )
+      `);
+      await pool.query(`
+        CREATE INDEX IF NOT EXISTS derivatives_market_symbol_tf_ts_idx
+        ON derivatives_market (symbol, interval, ts DESC)
+      `);
+      await pool.query(`
+        CREATE TABLE IF NOT EXISTS derivatives_backfill_coverage (
+          source text NOT NULL,
+          symbol text NOT NULL,
+          interval text NOT NULL,
+          from_ts timestamptz NOT NULL,
+          to_ts timestamptz NOT NULL,
+          rows_count integer NOT NULL DEFAULT 0,
+          checked_at timestamptz NOT NULL DEFAULT now(),
+          PRIMARY KEY (source, symbol, interval, from_ts, to_ts)
+        )
+      `);
+      await pool.query(`
+        CREATE INDEX IF NOT EXISTS derivatives_backfill_coverage_lookup_idx
+        ON derivatives_backfill_coverage (source, symbol, interval, from_ts, to_ts)
+      `);
+      await pool.query(`
+        CREATE TABLE IF NOT EXISTS derivatives_metric_coverage (
+          source text NOT NULL,
+          metric text NOT NULL,
+          symbol text NOT NULL,
+          interval text NOT NULL,
+          from_ts timestamptz NOT NULL,
+          to_ts timestamptz NOT NULL,
+          event_rows_count integer NOT NULL DEFAULT 0,
+          zero_rows_count integer NOT NULL DEFAULT 0,
+          checked_at timestamptz NOT NULL DEFAULT now(),
+          PRIMARY KEY (source, metric, symbol, interval, from_ts, to_ts)
+        )
+      `);
+      await pool.query(`
+        CREATE INDEX IF NOT EXISTS derivatives_metric_coverage_lookup_idx
+        ON derivatives_metric_coverage (
+          source,
+          metric,
+          symbol,
+          interval,
+          from_ts,
+          to_ts
+        )
+      `);
+      derivativesSchemaReady = true;
+    }
+  ).finally(() => {
+    derivativesSchemaReadyPromise = null;
+  });
+  await derivativesSchemaReadyPromise;
+};
+var ensureBinanceMarketSchema = async () => {
+  if (binanceMarketSchemaReady) return;
+  if (binanceMarketSchemaReadyPromise) {
+    await binanceMarketSchemaReadyPromise;
+    return;
+  }
+  const pool = getPool();
+  binanceMarketSchemaReadyPromise = withSchemaLock(
+    BINANCE_MARKET_SCHEMA_LOCK_KEY,
+    async () => {
+      if (binanceMarketSchemaReady) return;
+      await pool.query("CREATE EXTENSION IF NOT EXISTS timescaledb");
+      await pool.query(`
+        CREATE TABLE IF NOT EXISTS market_trade_flow (
+          symbol text NOT NULL,
+          interval text NOT NULL,
+          ts timestamptz NOT NULL,
+          trades integer NOT NULL,
+          buy_base_volume double precision,
+          sell_base_volume double precision,
+          buy_quote_volume double precision,
+          sell_quote_volume double precision,
+          net_base_delta double precision,
+          net_quote_delta double precision,
+          buy_pressure_pct double precision,
+          source text,
+          ingested_at timestamptz NOT NULL DEFAULT now(),
+          PRIMARY KEY (symbol, interval, ts)
+        )
+      `);
+      await pool.query(`
+        SELECT create_hypertable(
+          'market_trade_flow',
+          'ts',
+          if_not_exists => TRUE,
+          chunk_time_interval => interval '7 days'
+        )
+      `);
+      await pool.query(`
+        CREATE INDEX IF NOT EXISTS market_trade_flow_symbol_tf_ts_idx
+        ON market_trade_flow (symbol, interval, ts DESC)
+      `);
+      await pool.query(`
+        CREATE TABLE IF NOT EXISTS market_breadth (
+          universe text NOT NULL,
+          interval text NOT NULL,
+          ts timestamptz NOT NULL,
+          symbols_count integer NOT NULL,
+          advancers integer NOT NULL,
+          decliners integer NOT NULL,
+          unchanged integer NOT NULL,
+          advance_decline_ratio double precision,
+          pct_above_ma20 double precision,
+          pct_above_ma50 double precision,
+          equal_weighted_return double precision,
+          volume_weighted_return double precision,
+          dispersion double precision,
+          btc_return_1h double precision,
+          btc_return_4h double precision,
+          btc_return_24h double precision,
+          alt_basket_return_1h double precision,
+          alt_basket_return_4h double precision,
+          alt_basket_return_24h double precision,
+          btc_vs_alt_return_1h double precision,
+          btc_vs_alt_return_4h double precision,
+          btc_vs_alt_return_24h double precision,
+          btc_turnover_share_1h double precision,
+          btc_turnover_share_24h double precision,
+          btc_turnover_share_change_24h double precision,
+          alt_vol_to_btc_vol_24h double precision,
+          alt_dispersion_24h double precision,
+          btc_alt_regime text,
+          source text,
+          ingested_at timestamptz NOT NULL DEFAULT now(),
+          PRIMARY KEY (universe, interval, ts)
+        )
+      `);
+      await pool.query(`
+        ALTER TABLE market_breadth
+          ADD COLUMN IF NOT EXISTS btc_return_1h double precision,
+          ADD COLUMN IF NOT EXISTS btc_return_4h double precision,
+          ADD COLUMN IF NOT EXISTS btc_return_24h double precision,
+          ADD COLUMN IF NOT EXISTS alt_basket_return_1h double precision,
+          ADD COLUMN IF NOT EXISTS alt_basket_return_4h double precision,
+          ADD COLUMN IF NOT EXISTS alt_basket_return_24h double precision,
+          ADD COLUMN IF NOT EXISTS btc_vs_alt_return_1h double precision,
+          ADD COLUMN IF NOT EXISTS btc_vs_alt_return_4h double precision,
+          ADD COLUMN IF NOT EXISTS btc_vs_alt_return_24h double precision,
+          ADD COLUMN IF NOT EXISTS btc_turnover_share_1h double precision,
+          ADD COLUMN IF NOT EXISTS btc_turnover_share_24h double precision,
+          ADD COLUMN IF NOT EXISTS btc_turnover_share_change_24h double precision,
+          ADD COLUMN IF NOT EXISTS alt_vol_to_btc_vol_24h double precision,
+          ADD COLUMN IF NOT EXISTS alt_dispersion_24h double precision,
+          ADD COLUMN IF NOT EXISTS btc_alt_regime text
+      `);
+      await pool.query(`
+        SELECT create_hypertable(
+          'market_breadth',
+          'ts',
+          if_not_exists => TRUE,
+          chunk_time_interval => interval '14 days'
+        )
+      `);
+      await pool.query(`
+        CREATE INDEX IF NOT EXISTS market_breadth_universe_tf_ts_idx
+        ON market_breadth (universe, interval, ts DESC)
+      `);
+      await pool.query(`
+        CREATE TABLE IF NOT EXISTS market_global_context (
+          source text NOT NULL,
+          ts timestamptz NOT NULL,
+          updated_at_ts timestamptz,
+          active_cryptocurrencies integer,
+          active_exchanges integer,
+          active_market_pairs integer,
+          markets integer,
+          total_market_cap_usd double precision,
+          total_volume_usd double precision,
+          total_volume_reported_usd double precision,
+          btc_dominance_pct double precision,
+          eth_dominance_pct double precision,
+          alt_market_cap_usd double precision,
+          alt_volume_usd double precision,
+          alt_volume_reported_usd double precision,
+          btc_to_alt_market_cap_ratio double precision,
+          market_cap_change_pct_24h_usd double precision,
+          ingested_at timestamptz NOT NULL DEFAULT now(),
+          PRIMARY KEY (source, ts)
+        )
+      `);
+      await pool.query(`
+        SELECT create_hypertable(
+          'market_global_context',
+          'ts',
+          if_not_exists => TRUE,
+          chunk_time_interval => interval '30 days'
+        )
+      `);
+      await pool.query(`
+        CREATE INDEX IF NOT EXISTS market_global_context_source_ts_idx
+        ON market_global_context (source, ts DESC)
+      `);
+      await pool.query(`
+        ALTER TABLE market_global_context
+          ADD COLUMN IF NOT EXISTS active_exchanges integer,
+          ADD COLUMN IF NOT EXISTS active_market_pairs integer,
+          ADD COLUMN IF NOT EXISTS total_volume_reported_usd double precision,
+          ADD COLUMN IF NOT EXISTS alt_volume_usd double precision,
+          ADD COLUMN IF NOT EXISTS alt_volume_reported_usd double precision
+      `);
+      await pool.query(`
+        CREATE TABLE IF NOT EXISTS market_reference_asset_context (
+          source text NOT NULL,
+          symbol text NOT NULL,
+          cmc_id integer NOT NULL,
+          interval text NOT NULL,
+          ts timestamptz NOT NULL,
+          open_usd double precision,
+          high_usd double precision,
+          low_usd double precision,
+          close_usd double precision,
+          volume_usd double precision,
+          market_cap_usd double precision,
+          ingested_at timestamptz NOT NULL DEFAULT now(),
+          PRIMARY KEY (source, symbol, interval, ts)
+        )
+      `);
+      await pool.query(`
+        SELECT create_hypertable(
+          'market_reference_asset_context',
+          'ts',
+          if_not_exists => TRUE,
+          chunk_time_interval => interval '30 days'
+        )
+      `);
+      await pool.query(`
+        CREATE INDEX IF NOT EXISTS market_reference_asset_context_lookup_idx
+        ON market_reference_asset_context (source, symbol, interval, ts DESC)
+      `);
+      await pool.query(`
+        CREATE TABLE IF NOT EXISTS market_cmc_exchange_liquidity_context (
+          source text NOT NULL,
+          interval text NOT NULL,
+          ts timestamptz NOT NULL,
+          exchanges_count integer NOT NULL,
+          total_volume_usd double precision,
+          binance_volume_usd double precision,
+          binance_volume_share double precision,
+          top_exchange_volume_share double precision,
+          liquidity_regime text,
+          ingested_at timestamptz NOT NULL DEFAULT now(),
+          PRIMARY KEY (source, interval, ts)
+        )
+      `);
+      await pool.query(`
+        SELECT create_hypertable(
+          'market_cmc_exchange_liquidity_context',
+          'ts',
+          if_not_exists => TRUE,
+          chunk_time_interval => interval '30 days'
+        )
+      `);
+      await pool.query(`
+        CREATE INDEX IF NOT EXISTS market_cmc_exchange_liquidity_context_lookup_idx
+        ON market_cmc_exchange_liquidity_context (source, interval, ts DESC)
+      `);
+      await pool.query(`
+        CREATE TABLE IF NOT EXISTS market_cmc_fear_greed_context (
+          source text NOT NULL,
+          interval text NOT NULL,
+          ts timestamptz NOT NULL,
+          value integer NOT NULL,
+          classification text NOT NULL,
+          sentiment_regime text NOT NULL,
+          ingested_at timestamptz NOT NULL DEFAULT now(),
+          PRIMARY KEY (source, interval, ts)
+        )
+      `);
+      await pool.query(`
+        SELECT create_hypertable(
+          'market_cmc_fear_greed_context',
+          'ts',
+          if_not_exists => TRUE,
+          chunk_time_interval => interval '30 days'
+        )
+      `);
+      await pool.query(`
+        CREATE INDEX IF NOT EXISTS market_cmc_fear_greed_context_lookup_idx
+        ON market_cmc_fear_greed_context (source, interval, ts DESC)
+      `);
+      await pool.query(`
+        CREATE TABLE IF NOT EXISTS market_cmc_index_context (
+          source text NOT NULL,
+          index_slug text NOT NULL,
+          interval text NOT NULL,
+          ts timestamptz NOT NULL,
+          value double precision NOT NULL,
+          constituents_count integer,
+          top_constituent_symbol text,
+          top_constituent_weight_pct double precision,
+          constituents jsonb,
+          ingested_at timestamptz NOT NULL DEFAULT now(),
+          PRIMARY KEY (source, index_slug, interval, ts)
+        )
+      `);
+      await pool.query(`
+        SELECT create_hypertable(
+          'market_cmc_index_context',
+          'ts',
+          if_not_exists => TRUE,
+          chunk_time_interval => interval '30 days'
+        )
+      `);
+      await pool.query(`
+        CREATE INDEX IF NOT EXISTS market_cmc_index_context_lookup_idx
+        ON market_cmc_index_context (source, index_slug, interval, ts DESC)
+      `);
+      await pool.query(`
+        CREATE TABLE IF NOT EXISTS market_context_backfill_coverage (
+          source text NOT NULL,
+          scope text NOT NULL,
+          interval text NOT NULL,
+          from_ts timestamptz NOT NULL,
+          to_ts timestamptz NOT NULL,
+          rows_count integer NOT NULL DEFAULT 0,
+          checked_at timestamptz NOT NULL DEFAULT now(),
+          PRIMARY KEY (source, scope, interval, from_ts, to_ts)
+        )
+      `);
+      await pool.query(`
+        CREATE INDEX IF NOT EXISTS market_context_backfill_coverage_lookup_idx
+        ON market_context_backfill_coverage (source, scope, interval, from_ts, to_ts)
+      `);
+      binanceMarketSchemaReady = true;
+    }
+  ).finally(() => {
+    binanceMarketSchemaReadyPromise = null;
+  });
+  await binanceMarketSchemaReadyPromise;
+};
+var ensureHyperliquidWhaleSchema = async () => {
+  if (hyperliquidWhaleSchemaReady) return;
+  if (hyperliquidWhaleSchemaReadyPromise) {
+    await hyperliquidWhaleSchemaReadyPromise;
+    return;
+  }
+  hyperliquidWhaleSchemaReadyPromise = withSchemaLock(
+    HYPERLIQUID_WHALE_SCHEMA_LOCK_KEY,
+    async () => {
+      if (hyperliquidWhaleSchemaReady) return;
+      const pool = getPool();
+      await pool.query("CREATE EXTENSION IF NOT EXISTS timescaledb");
+      await pool.query(`
+        CREATE TABLE IF NOT EXISTS hyperliquid_whale_trade_events (
+          symbol text NOT NULL,
+          ts timestamptz NOT NULL,
+          tid text NOT NULL,
+          price double precision NOT NULL,
+          size double precision NOT NULL,
+          notional_usd double precision NOT NULL,
+          buyer_address text,
+          seller_address text,
+          buyer_tracked boolean NOT NULL,
+          seller_tracked boolean NOT NULL,
+          buyer_start_position double precision,
+          buyer_end_position double precision,
+          buyer_position_action text,
+          buyer_closed_pnl double precision,
+          buyer_liquidation boolean,
+          seller_start_position double precision,
+          seller_end_position double precision,
+          seller_position_action text,
+          seller_closed_pnl double precision,
+          seller_liquidation boolean,
+          universe_fingerprint text NOT NULL,
+          whale_registry_fingerprint text NOT NULL,
+          source text,
+          ingested_at timestamptz NOT NULL DEFAULT now(),
+          PRIMARY KEY (
+            universe_fingerprint,
+            whale_registry_fingerprint,
+            symbol,
+            ts,
+            tid
+          )
+        )
+      `);
+      await pool.query(`
+        ALTER TABLE hyperliquid_whale_trade_events
+          ADD COLUMN IF NOT EXISTS buyer_start_position double precision,
+          ADD COLUMN IF NOT EXISTS buyer_end_position double precision,
+          ADD COLUMN IF NOT EXISTS buyer_position_action text,
+          ADD COLUMN IF NOT EXISTS buyer_closed_pnl double precision,
+          ADD COLUMN IF NOT EXISTS buyer_liquidation boolean,
+          ADD COLUMN IF NOT EXISTS seller_start_position double precision,
+          ADD COLUMN IF NOT EXISTS seller_end_position double precision,
+          ADD COLUMN IF NOT EXISTS seller_position_action text,
+          ADD COLUMN IF NOT EXISTS seller_closed_pnl double precision,
+          ADD COLUMN IF NOT EXISTS seller_liquidation boolean
+      `);
+      await pool.query(`
+        SELECT create_hypertable(
+          'hyperliquid_whale_trade_events',
+          'ts',
+          if_not_exists => TRUE,
+          chunk_time_interval => interval '1 day'
+        )
+      `);
+      await pool.query(`
+        CREATE INDEX IF NOT EXISTS hyperliquid_whale_events_lookup_idx
+        ON hyperliquid_whale_trade_events (
+          universe_fingerprint,
+          whale_registry_fingerprint,
+          symbol,
+          ts DESC
+        )
+      `);
+      await pool.query(`
+        CREATE TABLE IF NOT EXISTS hyperliquid_whale_flow (
+          symbol text NOT NULL,
+          interval text NOT NULL,
+          ts timestamptz NOT NULL,
+          trades integer NOT NULL,
+          whale_sides integer NOT NULL,
+          unique_whales integer NOT NULL,
+          whale_addresses text[] NOT NULL DEFAULT '{}',
+          buy_notional_usd double precision NOT NULL,
+          sell_notional_usd double precision NOT NULL,
+          net_notional_usd double precision NOT NULL,
+          buy_share_pct double precision,
+          position_aware_whale_sides integer NOT NULL DEFAULT 0,
+          long_entry_whale_addresses text[] NOT NULL DEFAULT '{}',
+          short_entry_whale_addresses text[] NOT NULL DEFAULT '{}',
+          long_exit_whale_addresses text[] NOT NULL DEFAULT '{}',
+          short_exit_whale_addresses text[] NOT NULL DEFAULT '{}',
+          long_entry_notional_usd double precision NOT NULL DEFAULT 0,
+          short_entry_notional_usd double precision NOT NULL DEFAULT 0,
+          long_exit_notional_usd double precision NOT NULL DEFAULT 0,
+          short_exit_notional_usd double precision NOT NULL DEFAULT 0,
+          entry_net_notional_usd double precision NOT NULL DEFAULT 0,
+          entry_long_share_pct double precision,
+          universe_fingerprint text NOT NULL,
+          whale_registry_fingerprint text NOT NULL,
+          source text,
+          ingested_at timestamptz NOT NULL DEFAULT now(),
+          PRIMARY KEY (
+            universe_fingerprint,
+            whale_registry_fingerprint,
+            symbol,
+            interval,
+            ts
+          )
+        )
+      `);
+      await pool.query(`
+        ALTER TABLE hyperliquid_whale_flow
+          ADD COLUMN IF NOT EXISTS position_aware_whale_sides integer NOT NULL DEFAULT 0,
+          ADD COLUMN IF NOT EXISTS long_entry_whale_addresses text[] NOT NULL DEFAULT '{}',
+          ADD COLUMN IF NOT EXISTS short_entry_whale_addresses text[] NOT NULL DEFAULT '{}',
+          ADD COLUMN IF NOT EXISTS long_exit_whale_addresses text[] NOT NULL DEFAULT '{}',
+          ADD COLUMN IF NOT EXISTS short_exit_whale_addresses text[] NOT NULL DEFAULT '{}',
+          ADD COLUMN IF NOT EXISTS long_entry_notional_usd double precision NOT NULL DEFAULT 0,
+          ADD COLUMN IF NOT EXISTS short_entry_notional_usd double precision NOT NULL DEFAULT 0,
+          ADD COLUMN IF NOT EXISTS long_exit_notional_usd double precision NOT NULL DEFAULT 0,
+          ADD COLUMN IF NOT EXISTS short_exit_notional_usd double precision NOT NULL DEFAULT 0,
+          ADD COLUMN IF NOT EXISTS entry_net_notional_usd double precision NOT NULL DEFAULT 0,
+          ADD COLUMN IF NOT EXISTS entry_long_share_pct double precision
+      `);
+      await pool.query(`
+        SELECT create_hypertable(
+          'hyperliquid_whale_flow',
+          'ts',
+          if_not_exists => TRUE,
+          chunk_time_interval => interval '7 days'
+        )
+      `);
+      await pool.query(`
+        CREATE INDEX IF NOT EXISTS hyperliquid_whale_flow_lookup_idx
+        ON hyperliquid_whale_flow (
+          universe_fingerprint,
+          whale_registry_fingerprint,
+          symbol,
+          interval,
+          ts DESC
+        )
+      `);
+      await pool.query(`
+        CREATE TABLE IF NOT EXISTS hyperliquid_whale_wallet_coverage (
+          universe_fingerprint text NOT NULL,
+          whale_registry_fingerprint text NOT NULL,
+          address text NOT NULL,
+          requested_from_ts timestamptz NOT NULL,
+          requested_to_ts timestamptz NOT NULL,
+          covered_from_ts timestamptz,
+          covered_to_ts timestamptz,
+          status text NOT NULL CHECK (status IN ('complete', 'truncated', 'failed')),
+          fills_count integer NOT NULL DEFAULT 0,
+          error text,
+          data_model_version integer NOT NULL DEFAULT 2,
+          checked_at timestamptz NOT NULL DEFAULT now(),
+          PRIMARY KEY (
+            universe_fingerprint,
+            whale_registry_fingerprint,
+            address,
+            requested_from_ts,
+            requested_to_ts
+          )
+        )
+      `);
+      await pool.query(`
+        ALTER TABLE hyperliquid_whale_wallet_coverage
+          ADD COLUMN IF NOT EXISTS data_model_version integer NOT NULL DEFAULT 2
+      `);
+      await pool.query(`
+        CREATE INDEX IF NOT EXISTS hyperliquid_whale_wallet_coverage_lookup_idx
+        ON hyperliquid_whale_wallet_coverage (
+          universe_fingerprint,
+          whale_registry_fingerprint,
+          address,
+          requested_from_ts,
+          requested_to_ts
+        )
+      `);
+      await pool.query(`
+        CREATE TABLE IF NOT EXISTS hyperliquid_whale_coverage_1m (
+          ts timestamptz NOT NULL,
+          covered_whales integer NOT NULL,
+          expected_whales integer NOT NULL,
+          coverage_pct double precision NOT NULL,
+          universe_fingerprint text NOT NULL,
+          whale_registry_fingerprint text NOT NULL,
+          source text,
+          data_model_version integer NOT NULL DEFAULT 2,
+          ingested_at timestamptz NOT NULL DEFAULT now(),
+          PRIMARY KEY (
+            universe_fingerprint,
+            whale_registry_fingerprint,
+            ts
+          )
+        )
+      `);
+      await pool.query(`
+        ALTER TABLE hyperliquid_whale_coverage_1m
+          ADD COLUMN IF NOT EXISTS data_model_version integer NOT NULL DEFAULT 2
+      `);
+      await pool.query(`
+        SELECT create_hypertable(
+          'hyperliquid_whale_coverage_1m',
+          'ts',
+          if_not_exists => TRUE,
+          chunk_time_interval => interval '7 days'
+        )
+      `);
+      await pool.query(`
+        CREATE INDEX IF NOT EXISTS hyperliquid_whale_coverage_1m_lookup_idx
+        ON hyperliquid_whale_coverage_1m (
+          universe_fingerprint,
+          whale_registry_fingerprint,
+          ts DESC
+        )
+      `);
+      hyperliquidWhaleSchemaReady = true;
+    }
+  ).finally(() => {
+    hyperliquidWhaleSchemaReadyPromise = null;
+  });
+  await hyperliquidWhaleSchemaReadyPromise;
+};
+var ensureCoinMarketCapContextSchema = async () => ensureBinanceMarketSchema();
+var ensureMarketContextSchema = async (source) => {
+  switch (source) {
+    case "binance":
+      return ensureBinanceMarketSchema();
+    case "coinmarketcap":
+      return ensureCoinMarketCapContextSchema();
+    case "derivatives":
+      return ensureDerivativesSchema();
+    case "hyperliquidWhales":
+      return ensureHyperliquidWhaleSchema();
+  }
+};
+var MARKET_CONTEXT_SCHEMA_TABLES = {
+  binance: ["market_trade_flow", "market_breadth"],
+  coinmarketcap: [
+    "market_global_context",
+    "market_reference_asset_context",
+    "market_cmc_exchange_liquidity_context",
+    "market_cmc_fear_greed_context",
+    "market_cmc_index_context"
+  ],
+  derivatives: ["derivatives_market"],
+  hyperliquidWhales: [
+    "hyperliquid_whale_flow",
+    "hyperliquid_whale_coverage_1m"
+  ]
+};
+var verifyMarketContextSchema = async (source) => {
+  if (verifiedMarketContextSchemas.has(source)) return;
+  const tables = MARKET_CONTEXT_SCHEMA_TABLES[source];
+  const result = await queryMarketContext(
+    `
+      SELECT table_name AS "tableName"
+      FROM unnest($1::text[]) AS requested(table_name)
+      WHERE to_regclass(requested.table_name) IS NULL
+    `,
+    [tables]
+  );
+  if (result.rows.length) {
+    throw new Error(
+      `Timescale ${source} schema is not prepared; missing: ${result.rows.map((row) => row.tableName).filter(Boolean).join(", ")}`
+    );
+  }
+  verifiedMarketContextSchemas.add(source);
+};
+var prepareMarketContextSchemaForRead = async (source) => marketContextSchemaMode === "verify" ? verifyMarketContextSchema(source) : ensureMarketContextSchema(source);
+
+// src/timescale/hyperliquidWhales.ts
+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;
+  }
+  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(
+    `
+      INSERT INTO hyperliquid_whale_trade_events (${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"
+  ];
+  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;
+  }
+  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
+  ]);
+  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 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 = getSafeBulkInsertRows(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(
+    `
+      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 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 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
+        $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?.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 {
+    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 = {
+  ensureHyperliquidWhaleSchema,
+  getHyperliquidWhaleCoverageSeriesRows,
+  getHyperliquidWhaleFlowAggregate,
+  getHyperliquidWhaleFlowSeriesRows,
+  getHyperliquidWhaleWalletCoverage,
+  hasHyperliquidWhaleBackfillCoverage,
+  rebuildHyperliquidWhaleCoverageRows,
+  rebuildHyperliquidWhaleFlowRows,
+  upsertHyperliquidWhaleCoverageRows,
+  upsertHyperliquidWhaleFlowRows,
+  upsertHyperliquidWhaleTradeEvents,
+  upsertHyperliquidWhaleWalletCoverage
+});