@tradejs/infra 2.0.18 → 2.0.20

package/dist/strategyReleaseEvidence.mjs

@@ -0,0 +1,90 @@
+// src/strategyReleaseEvidence.ts
+import { createHash } from "crypto";
+import { createReadStream } from "fs";
+import {
+  STRATEGY_EVIDENCE_MARKERS_SCHEMA
+} from "@tradejs/types";
+var SHA256_RE = /^[a-f0-9]{64}$/;
+var LINEAGE_FINGERPRINT_RE = /^[a-f0-9]{16}$/;
+var MARKER_TYPES = /* @__PURE__ */ new Set([
+  "G",
+  "L",
+  "E",
+  "D",
+  "P",
+  "R"
+]);
+var asRecord = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : null;
+var isString = (value) => typeof value === "string" && value.trim().length > 0;
+var isNumber = (value) => typeof value === "number" && Number.isFinite(value);
+var canonicalStrategyEvidenceJson = (value) => {
+  const normalize = (current) => {
+    if (Array.isArray(current)) return current.map(normalize);
+    const record = asRecord(current);
+    if (!record) return current;
+    return Object.fromEntries(
+      Object.entries(record).filter(([, entry]) => entry !== void 0).sort(([left], [right]) => left.localeCompare(right)).map(([key, entry]) => [key, normalize(entry)])
+    );
+  };
+  return JSON.stringify(normalize(value));
+};
+var strategyEvidenceSha256 = (value) => createHash("sha256").update(canonicalStrategyEvidenceJson(value)).digest("hex");
+var strategyEvidenceFingerprint = (value) => strategyEvidenceSha256(value).slice(0, 16);
+var strategyEvidenceFileSha256 = async (filePath) => {
+  const hash = createHash("sha256");
+  for await (const chunk of createReadStream(filePath)) hash.update(chunk);
+  return hash.digest("hex");
+};
+var safeStrategyEvidenceSegment = (value, fallback = "strategy") => {
+  const safe = value.trim().replace(/[^a-zA-Z0-9._-]+/g, "-");
+  return safe && safe !== "." && safe !== ".." ? safe : fallback;
+};
+var compactStrategyEvidenceTimestamp = (timestamp) => new Date(timestamp).toISOString().replace(/[-:]/g, "").replace(/\.000Z$/, "Z");
+var createStrategyEvidenceMarkerEnvelope = (payload) => {
+  const payloadSha256 = strategyEvidenceSha256(payload);
+  return {
+    schema: STRATEGY_EVIDENCE_MARKERS_SCHEMA,
+    artifactId: `${safeStrategyEvidenceSegment(payload.strategy)}_${compactStrategyEvidenceTimestamp(payload.createdAt)}_${payloadSha256.slice(0, 16)}`,
+    payloadSha256,
+    payload
+  };
+};
+var verifyStrategyEvidenceMarkerEnvelope = (value) => {
+  const envelope = asRecord(value);
+  const payload = asRecord(envelope?.payload);
+  if (envelope?.schema !== STRATEGY_EVIDENCE_MARKERS_SCHEMA || !isString(envelope.artifactId) || !isString(envelope.payloadSha256) || !SHA256_RE.test(envelope.payloadSha256) || !payload || !isString(payload.strategy) || !isNumber(payload.createdAt) || !Array.isArray(payload.markers) || !Array.isArray(payload.sourceArtifacts)) {
+    throw new Error("Invalid strategy evidence marker envelope");
+  }
+  for (const value2 of payload.markers) {
+    const marker = asRecord(value2);
+    const coverage = asRecord(marker?.coverage);
+    if (!marker || !isString(marker.id) || !isString(marker.type) || !MARKER_TYPES.has(marker.type) || !isNumber(marker.timestamp) || !isString(marker.label) || !isString(marker.summary) || !isString(marker.artifactId) || !isString(marker.artifactSha256) || !SHA256_RE.test(marker.artifactSha256) || marker.gitSha !== void 0 && !isString(marker.gitSha) || marker.gateFingerprint !== void 0 && (!isString(marker.gateFingerprint) || !LINEAGE_FINGERPRINT_RE.test(marker.gateFingerprint)) || marker.configFingerprint !== void 0 && (!isString(marker.configFingerprint) || !LINEAGE_FINGERPRINT_RE.test(marker.configFingerprint)) || marker.contextFingerprint !== void 0 && (!isString(marker.contextFingerprint) || !LINEAGE_FINGERPRINT_RE.test(marker.contextFingerprint)) || marker.maxLossValue !== void 0 && !isNumber(marker.maxLossValue) || marker.coverage !== void 0 && (!coverage || !isNumber(coverage.startTime) || !isNumber(coverage.endTime) || coverage.startTime > coverage.endTime)) {
+      throw new Error("Invalid strategy evidence marker");
+    }
+  }
+  for (const value2 of payload.sourceArtifacts) {
+    const artifact = asRecord(value2);
+    if (!artifact || !isString(artifact.artifactId) || !isString(artifact.sha256) || !SHA256_RE.test(artifact.sha256) || artifact.path !== void 0 && typeof artifact.path !== "string") {
+      throw new Error("Invalid strategy evidence source artifact");
+    }
+  }
+  const payloadSha256 = strategyEvidenceSha256(payload);
+  if (payloadSha256 !== envelope.payloadSha256) {
+    throw new Error("Strategy evidence marker checksum mismatch");
+  }
+  const expectedId = `${safeStrategyEvidenceSegment(payload.strategy)}_${compactStrategyEvidenceTimestamp(payload.createdAt)}_${payloadSha256.slice(0, 16)}`;
+  if (expectedId !== envelope.artifactId) {
+    throw new Error("Strategy evidence marker artifact identity mismatch");
+  }
+  return value;
+};
+export {
+  canonicalStrategyEvidenceJson,
+  compactStrategyEvidenceTimestamp,
+  createStrategyEvidenceMarkerEnvelope,
+  safeStrategyEvidenceSegment,
+  strategyEvidenceFileSha256,
+  strategyEvidenceFingerprint,
+  strategyEvidenceSha256,
+  verifyStrategyEvidenceMarkerEnvelope
+};

package/dist/timescale/candles.d.mts

@@ -0,0 +1,38 @@
+import { KlineChartData } from '@tradejs/types';
+
+type CandleRow = {
+    provider: string;
+    symbol: string;
+    interval: number;
+    ts: Date;
+    open: number;
+    high: number;
+    low: number;
+    close: number;
+    volume?: number | null;
+    turnover?: number | null;
+    takerBuyBaseVolume?: number | null;
+    takerBuyQuoteVolume?: number | null;
+    takerSellBaseVolume?: number | null;
+    takerSellQuoteVolume?: number | null;
+};
+declare const toRows: (provider: string, symbol: string, interval: number, data: KlineChartData) => CandleRow[];
+declare function upsertCandles(rows: CandleRow[]): Promise<void>;
+declare function getCandlesRange(provider: string, symbol: string, interval: number, startMs: number, endMs: number): Promise<any[]>;
+declare function getDataEdges(provider: string, symbol: string, interval: number): Promise<{
+    min: number | undefined;
+    max: number | undefined;
+}>;
+declare function getDataEdgesForSymbols(provider: string, symbols: string[], interval: number): Promise<Map<string, {
+    min?: number;
+    max?: number;
+}>>;
+declare function waitForDbReady(attempts?: number, delayMs?: number): Promise<void>;
+declare function deleteCandles(provider: string, symbol: string, interval: number): Promise<void>;
+declare function findContinuityGap(provider: string, symbol: string, interval: number): Promise<{
+    ts: number;
+    prevTs: number;
+    diffSeconds: number;
+} | null>;
+
+export { type CandleRow, deleteCandles, findContinuityGap, getCandlesRange, getDataEdges, getDataEdgesForSymbols, toRows, upsertCandles, waitForDbReady };

package/dist/timescale/candles.d.ts

@@ -0,0 +1,38 @@
+import { KlineChartData } from '@tradejs/types';
+
+type CandleRow = {
+    provider: string;
+    symbol: string;
+    interval: number;
+    ts: Date;
+    open: number;
+    high: number;
+    low: number;
+    close: number;
+    volume?: number | null;
+    turnover?: number | null;
+    takerBuyBaseVolume?: number | null;
+    takerBuyQuoteVolume?: number | null;
+    takerSellBaseVolume?: number | null;
+    takerSellQuoteVolume?: number | null;
+};
+declare const toRows: (provider: string, symbol: string, interval: number, data: KlineChartData) => CandleRow[];
+declare function upsertCandles(rows: CandleRow[]): Promise<void>;
+declare function getCandlesRange(provider: string, symbol: string, interval: number, startMs: number, endMs: number): Promise<any[]>;
+declare function getDataEdges(provider: string, symbol: string, interval: number): Promise<{
+    min: number | undefined;
+    max: number | undefined;
+}>;
+declare function getDataEdgesForSymbols(provider: string, symbols: string[], interval: number): Promise<Map<string, {
+    min?: number;
+    max?: number;
+}>>;
+declare function waitForDbReady(attempts?: number, delayMs?: number): Promise<void>;
+declare function deleteCandles(provider: string, symbol: string, interval: number): Promise<void>;
+declare function findContinuityGap(provider: string, symbol: string, interval: number): Promise<{
+    ts: number;
+    prevTs: number;
+    diffSeconds: number;
+} | null>;
+
+export { type CandleRow, deleteCandles, findContinuityGap, getCandlesRange, getDataEdges, getDataEdgesForSymbols, toRows, upsertCandles, waitForDbReady };

package/dist/timescale/candles.js

@@ -0,0 +1,408 @@
+"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/candles.ts
+var candles_exports = {};
+__export(candles_exports, {
+  deleteCandles: () => deleteCandles,
+  findContinuityGap: () => findContinuityGap,
+  getCandlesRange: () => getCandlesRange,
+  getDataEdges: () => getDataEdges,
+  getDataEdgesForSymbols: () => getDataEdgesForSymbols,
+  toRows: () => toRows,
+  upsertCandles: () => upsertCandles,
+  waitForDbReady: () => waitForDbReady
+});
+module.exports = __toCommonJS(candles_exports);
+
+// 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/values.ts
+var normalizeCandleProvider = (provider) => String(provider || "").trim().toLowerCase();
+var normalizeCandleSymbol = (symbol) => String(symbol || "").trim().toUpperCase();
+
+// src/timescale/internal.ts
+var candlesSchemaReady = false;
+var candlesSchemaReadyPromise = null;
+var CANDLES_SCHEMA_LOCK_KEY = 61e4;
+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 ensureCandlesSchema = async () => {
+  if (candlesSchemaReady) return;
+  if (candlesSchemaReadyPromise) {
+    await candlesSchemaReadyPromise;
+    return;
+  }
+  candlesSchemaReadyPromise = withSchemaLock(
+    CANDLES_SCHEMA_LOCK_KEY,
+    async () => {
+      const pool = getPool();
+      await pool.query("CREATE EXTENSION IF NOT EXISTS timescaledb");
+      await pool.query(`
+        CREATE TABLE IF NOT EXISTS candles (
+          provider text NOT NULL DEFAULT 'bybit',
+          symbol text NOT NULL,
+          interval integer NOT NULL,
+          ts timestamptz NOT NULL,
+          open double precision NOT NULL,
+          high double precision NOT NULL,
+          low double precision NOT NULL,
+          close double precision NOT NULL,
+          volume double precision,
+          turnover double precision,
+          taker_buy_base_volume double precision,
+          taker_buy_quote_volume double precision,
+          taker_sell_base_volume double precision,
+          taker_sell_quote_volume double precision,
+          PRIMARY KEY (provider, symbol, interval, ts)
+        )
+      `);
+      await pool.query(`
+        SELECT create_hypertable(
+          'candles',
+          'ts',
+          if_not_exists => TRUE,
+          chunk_time_interval => interval '7 days'
+        )
+      `);
+      await pool.query(`
+        CREATE INDEX IF NOT EXISTS candles_provider_symbol_interval_ts_idx
+        ON candles (provider, symbol, interval, ts DESC)
+      `);
+      await pool.query(`
+      ALTER TABLE candles
+        ADD COLUMN IF NOT EXISTS taker_buy_base_volume double precision,
+        ADD COLUMN IF NOT EXISTS taker_buy_quote_volume double precision,
+        ADD COLUMN IF NOT EXISTS taker_sell_base_volume double precision,
+        ADD COLUMN IF NOT EXISTS taker_sell_quote_volume double precision
+    `);
+      candlesSchemaReady = true;
+    }
+  ).finally(() => {
+    candlesSchemaReadyPromise = null;
+  });
+  await candlesSchemaReadyPromise;
+};
+
+// 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 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();
+  }
+}
+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
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  deleteCandles,
+  findContinuityGap,
+  getCandlesRange,
+  getDataEdges,
+  getDataEdgesForSymbols,
+  toRows,
+  upsertCandles,
+  waitForDbReady
+});

package/dist/timescale/candles.mjs

@@ -0,0 +1,21 @@
+import {
+  deleteCandles,
+  findContinuityGap,
+  getCandlesRange,
+  getDataEdges,
+  getDataEdgesForSymbols,
+  toRows,
+  upsertCandles,
+  waitForDbReady
+} from "../chunk-YVIHTUV5.mjs";
+import "../chunk-I2J6YDBD.mjs";
+export {
+  deleteCandles,
+  findContinuityGap,
+  getCandlesRange,
+  getDataEdges,
+  getDataEdgesForSymbols,
+  toRows,
+  upsertCandles,
+  waitForDbReady
+};

package/dist/timescale/client.d.mts

@@ -0,0 +1,4 @@
+export { T as TimescaleMarketContextQueryOptions, a as TimescaleMarketContextSource, c as closeTimescalePool, b as configureTimescaleMarketContextSchemaMode } from '../internal-2coHaaos.mjs';
+export { waitForDbReady } from './candles.mjs';
+import 'pg';
+import '@tradejs/types';

package/dist/timescale/client.d.ts

@@ -0,0 +1,4 @@
+export { T as TimescaleMarketContextQueryOptions, a as TimescaleMarketContextSource, c as closeTimescalePool, b as configureTimescaleMarketContextSchemaMode } from '../internal-2coHaaos.js';
+export { waitForDbReady } from './candles.js';
+import 'pg';
+import '@tradejs/types';