@tradejs/cli 1.0.6 → 1.0.9

package/dist/lib/runtimeParity.js

@@ -0,0 +1,234 @@
+"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/lib/runtimeParity.ts
+var runtimeParity_exports = {};
+__export(runtimeParity_exports, {
+  compareTradeParityEntries: () => compareTradeParityEntries,
+  dedupeRuntimeParityEntries: () => dedupeRuntimeParityEntries,
+  extractBacktestEntryParityEntries: () => extractBacktestEntryParityEntries,
+  extractRuntimeParityEntries: () => extractRuntimeParityEntries,
+  findRuntimeDuplicateGroups: () => findRuntimeDuplicateGroups,
+  summarizeMatchedParity: () => summarizeMatchedParity
+});
+module.exports = __toCommonJS(runtimeParity_exports);
+var toFiniteNumberOrNull = (value) => typeof value === "number" && Number.isFinite(value) ? value : null;
+var toGroupKey = (entry) => `${entry.strategy}::${entry.symbol}::${entry.direction}`;
+var toRuntimeDuplicateKey = (entry) => `${toGroupKey(entry)}::${entry.timestamp}`;
+var sortTradeParityEntries = (left, right) => left.timestamp - right.timestamp || left.strategy.localeCompare(right.strategy) || left.symbol.localeCompare(right.symbol) || left.direction.localeCompare(right.direction) || left.id.localeCompare(right.id);
+var buildPriceDeltaPct = (leftPrice, rightPrice) => {
+  if (leftPrice == null || rightPrice == null || !Number.isFinite(leftPrice) || !Number.isFinite(rightPrice) || leftPrice === 0) {
+    return null;
+  }
+  return Math.abs((rightPrice - leftPrice) / leftPrice * 100);
+};
+var extractBacktestEntryParityEntries = (orderLog) => {
+  if (!Array.isArray(orderLog)) {
+    return [];
+  }
+  return orderLog.filter(
+    (item) => (item.type === "OPEN_LONG" || item.type === "OPEN_SHORT") && item.signal && typeof item.signal.strategy === "string" && typeof item.signal.symbol === "string" && (item.signal.direction === "LONG" || item.signal.direction === "SHORT")
+  ).map((item, index) => {
+    const signal = item.signal;
+    const timestamp = typeof signal.timestamp === "number" && Number.isFinite(signal.timestamp) ? signal.timestamp : item.timestamp;
+    return {
+      id: typeof signal.signalId === "string" && signal.signalId.trim() ? signal.signalId : `backtest-${index}-${timestamp}`,
+      source: "backtest",
+      strategy: signal.strategy,
+      symbol: signal.symbol,
+      direction: signal.direction,
+      timestamp,
+      price: toFiniteNumberOrNull(item.price),
+      signalId: typeof signal.signalId === "string" ? signal.signalId : void 0
+    };
+  }).sort((left, right) => left.timestamp - right.timestamp);
+};
+var extractRuntimeParityEntries = (trades) => trades.filter(
+  (trade) => typeof trade.strategy === "string" && typeof trade.symbol === "string" && (trade.direction === "LONG" || trade.direction === "SHORT") && typeof trade.entryTimestamp === "number" && Number.isFinite(trade.entryTimestamp)
+).map((trade) => ({
+  id: trade.orderId,
+  source: "runtime",
+  strategy: trade.strategy,
+  symbol: trade.symbol,
+  direction: trade.direction,
+  timestamp: trade.entryTimestamp,
+  price: toFiniteNumberOrNull(trade.entryPrice),
+  orderId: trade.orderId,
+  signalId: typeof trade.signalId === "string" ? trade.signalId : void 0
+})).sort((left, right) => left.timestamp - right.timestamp);
+var findRuntimeDuplicateGroups = (entries) => {
+  const groups = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    if (entry.source !== "runtime") {
+      continue;
+    }
+    const key = toRuntimeDuplicateKey(entry);
+    const bucket = groups.get(key) ?? [];
+    bucket.push(entry);
+    groups.set(key, bucket);
+  }
+  return [...groups.entries()].filter(([, group]) => group.length > 1).map(([key, group]) => {
+    const sortedGroup = [...group].sort(sortTradeParityEntries);
+    const first = sortedGroup[0];
+    return {
+      key,
+      strategy: first.strategy,
+      symbol: first.symbol,
+      direction: first.direction,
+      timestamp: first.timestamp,
+      entries: sortedGroup
+    };
+  }).sort(
+    (left, right) => left.timestamp - right.timestamp || left.strategy.localeCompare(right.strategy) || left.symbol.localeCompare(right.symbol) || left.direction.localeCompare(right.direction)
+  );
+};
+var dedupeRuntimeParityEntries = (entries) => {
+  const duplicateGroups = findRuntimeDuplicateGroups(entries);
+  const duplicateEntriesSet = /* @__PURE__ */ new Set();
+  for (const group of duplicateGroups) {
+    for (const duplicate of group.entries.slice(1)) {
+      duplicateEntriesSet.add(duplicate);
+    }
+  }
+  const dedupedEntries = entries.filter((entry) => !duplicateEntriesSet.has(entry)).sort(sortTradeParityEntries);
+  const duplicateEntries = duplicateGroups.flatMap((group) => group.entries.slice(1)).sort(sortTradeParityEntries);
+  return {
+    entries: dedupedEntries,
+    duplicateGroups,
+    duplicateEntries
+  };
+};
+var compareTradeParityEntries = ({
+  runtimeEntries,
+  backtestEntries,
+  toleranceMs
+}) => {
+  const matched = [];
+  const runtimeOnly = [];
+  const backtestOnly = [];
+  const groupedRuntime = /* @__PURE__ */ new Map();
+  const groupedBacktest = /* @__PURE__ */ new Map();
+  for (const entry of runtimeEntries) {
+    const key = toGroupKey(entry);
+    const bucket = groupedRuntime.get(key) ?? [];
+    bucket.push(entry);
+    groupedRuntime.set(key, bucket);
+  }
+  for (const entry of backtestEntries) {
+    const key = toGroupKey(entry);
+    const bucket = groupedBacktest.get(key) ?? [];
+    bucket.push(entry);
+    groupedBacktest.set(key, bucket);
+  }
+  const groupKeys = /* @__PURE__ */ new Set([
+    ...groupedRuntime.keys(),
+    ...groupedBacktest.keys()
+  ]);
+  for (const key of groupKeys) {
+    const runtimeGroup = [...groupedRuntime.get(key) ?? []].sort(
+      (left, right) => left.timestamp - right.timestamp
+    );
+    const backtestGroup = [...groupedBacktest.get(key) ?? []].sort(
+      (left, right) => left.timestamp - right.timestamp
+    );
+    const unmatchedBacktest = backtestGroup.map((entry) => ({
+      entry,
+      used: false
+    }));
+    for (const runtimeEntry of runtimeGroup) {
+      let bestIndex = -1;
+      let bestDiff = Number.POSITIVE_INFINITY;
+      for (let index = 0; index < unmatchedBacktest.length; index += 1) {
+        const candidate = unmatchedBacktest[index];
+        if (candidate.used) {
+          continue;
+        }
+        const diff = Math.abs(
+          candidate.entry.timestamp - runtimeEntry.timestamp
+        );
+        if (diff > toleranceMs || diff >= bestDiff) {
+          continue;
+        }
+        bestIndex = index;
+        bestDiff = diff;
+      }
+      if (bestIndex < 0) {
+        runtimeOnly.push(runtimeEntry);
+        continue;
+      }
+      unmatchedBacktest[bestIndex].used = true;
+      const backtestEntry = unmatchedBacktest[bestIndex].entry;
+      matched.push({
+        runtime: runtimeEntry,
+        backtest: backtestEntry,
+        timestampDiffMs: bestDiff,
+        priceDeltaPct: buildPriceDeltaPct(
+          runtimeEntry.price,
+          backtestEntry.price
+        )
+      });
+    }
+    for (const candidate of unmatchedBacktest) {
+      if (!candidate.used) {
+        backtestOnly.push(candidate.entry);
+      }
+    }
+  }
+  matched.sort(
+    (left, right) => left.runtime.timestamp - right.runtime.timestamp
+  );
+  runtimeOnly.sort((left, right) => left.timestamp - right.timestamp);
+  backtestOnly.sort((left, right) => left.timestamp - right.timestamp);
+  return {
+    matched,
+    runtimeOnly,
+    backtestOnly
+  };
+};
+var summarizeMatchedParity = (matched) => {
+  if (!matched.length) {
+    return {
+      avgPriceDeltaPct: null,
+      maxPriceDeltaPct: null,
+      avgTimestampDiffMs: null,
+      maxTimestampDiffMs: null
+    };
+  }
+  const priceDeltas = matched.map((item) => item.priceDeltaPct).filter(
+    (value) => value != null && Number.isFinite(value)
+  );
+  const timestampDiffs = matched.map((item) => item.timestampDiffMs).filter((value) => Number.isFinite(value));
+  const average = (values) => values.length ? values.reduce((sum, value) => sum + value, 0) / values.length : null;
+  const maximum = (values) => values.length ? Math.max(...values) : null;
+  return {
+    avgPriceDeltaPct: average(priceDeltas),
+    maxPriceDeltaPct: maximum(priceDeltas),
+    avgTimestampDiffMs: average(timestampDiffs),
+    maxTimestampDiffMs: maximum(timestampDiffs)
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  compareTradeParityEntries,
+  dedupeRuntimeParityEntries,
+  extractBacktestEntryParityEntries,
+  extractRuntimeParityEntries,
+  findRuntimeDuplicateGroups,
+  summarizeMatchedParity
+});

package/dist/lib/runtimeSignalsLoader.js

@@ -0,0 +1,153 @@
+"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/lib/runtimeSignalsLoader.ts
+var runtimeSignalsLoader_exports = {};
+__export(runtimeSignalsLoader_exports, {
+  isRuntimeSignalEvaluationRecord: () => isRuntimeSignalEvaluationRecord,
+  isSignalRecord: () => isSignalRecord,
+  loadRuntimeSignalEvaluationStatsBuckets: () => loadRuntimeSignalEvaluationStatsBuckets,
+  loadRuntimeSignalEvaluations: () => loadRuntimeSignalEvaluations,
+  loadRuntimeSignals: () => loadRuntimeSignals
+});
+module.exports = __toCommonJS(runtimeSignalsLoader_exports);
+var import_redis = require("@tradejs/infra/redis");
+
+// src/lib/runtimeSignalsStorage.ts
+var RUNTIME_STORAGE_DAY_OFFSET_MS = 5 * 60 * 60 * 1e3;
+var isRuntimeSignalBucketRef = (value) => {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const record = value;
+  return typeof record.signalId === "string" && typeof record.symbol === "string" && typeof record.strategy === "string" && typeof record.timestamp === "number";
+};
+var toCount = (value) => {
+  const parsed = Number.parseInt(String(value ?? "0"), 10);
+  return Number.isFinite(parsed) ? parsed : 0;
+};
+var parseRuntimeSignalStatsBucket = (value) => {
+  const reasonGroups = /* @__PURE__ */ new Map();
+  for (const [field, rawCount] of Object.entries(value)) {
+    if (!field.startsWith("reason:")) {
+      continue;
+    }
+    const [, source, ...reasonParts] = field.split(":");
+    const reason = reasonParts.join(":");
+    if (!source || !reason) {
+      continue;
+    }
+    const reasons = reasonGroups.get(source) ?? /* @__PURE__ */ new Map();
+    reasons.set(reason, toCount(rawCount));
+    reasonGroups.set(source, reasons);
+  }
+  return {
+    evaluated: toCount(value.evaluated),
+    signals: toCount(value.signals),
+    reasonGroups
+  };
+};
+
+// src/lib/runtimeSignalsLoader.ts
+var isSignalRecord = (value) => {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const record = value;
+  return typeof record.signalId === "string" && typeof record.strategy === "string" && typeof record.symbol === "string" && typeof record.timestamp === "number";
+};
+var isRuntimeSignalEvaluationRecord = (value) => {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const record = value;
+  return typeof record.evaluationId === "string" && typeof record.strategy === "string" && typeof record.symbol === "string" && typeof record.timestamp === "number" && (record.status === "signal" || record.status === "skip" || record.status === "error");
+};
+var sortByTimestamp = (records) => [...records].sort((left, right) => left.timestamp - right.timestamp);
+var loadRuntimeSignals = async (userName) => {
+  const bucketKeys = await (0, import_redis.getKeys)(import_redis.redisKeys.runtimeSignalBuckets(userName));
+  const refs = (await Promise.all(bucketKeys.map((key) => (0, import_redis.getHashJsonValues)(key)))).flat().filter(isRuntimeSignalBucketRef);
+  const seen = /* @__PURE__ */ new Set();
+  const payloads = await Promise.all(
+    refs.map(async (ref) => {
+      const dedupeKey = `${ref.symbol}:${ref.signalId}`;
+      if (seen.has(dedupeKey)) {
+        return null;
+      }
+      seen.add(dedupeKey);
+      const signal = await (0, import_redis.getData)(
+        import_redis.redisKeys.storeSignal(ref.symbol, ref.signalId),
+        null
+      );
+      return isSignalRecord(signal) ? signal : null;
+    })
+  );
+  return sortByTimestamp(payloads.filter(isSignalRecord));
+};
+var loadRuntimeSignalEvaluations = async (userName) => {
+  const bucketKeys = await (0, import_redis.getKeys)(
+    import_redis.redisKeys.runtimeSignalEvaluationBuckets(userName)
+  );
+  const evaluations = (await Promise.all(bucketKeys.map((key) => (0, import_redis.getHashJsonValues)(key)))).flat().filter(isRuntimeSignalEvaluationRecord);
+  const deduped = /* @__PURE__ */ new Map();
+  for (const evaluation of evaluations) {
+    deduped.set(evaluation.evaluationId, evaluation);
+  }
+  return sortByTimestamp([...deduped.values()]);
+};
+var parseBucketKey = (prefix, key) => {
+  if (!key.startsWith(prefix)) {
+    return null;
+  }
+  const suffix = key.slice(prefix.length);
+  const firstColon = suffix.indexOf(":");
+  if (firstColon <= 0 || firstColon >= suffix.length - 1) {
+    return null;
+  }
+  return {
+    dayKey: suffix.slice(0, firstColon),
+    strategy: suffix.slice(firstColon + 1)
+  };
+};
+var loadRuntimeSignalEvaluationStatsBuckets = async (userName) => {
+  const prefix = import_redis.redisKeys.runtimeSignalEvaluationStatsBuckets(userName);
+  const keys = await (0, import_redis.getKeys)(prefix);
+  const entries = await Promise.all(
+    keys.map(async (key) => {
+      const parsedKey = parseBucketKey(prefix, key);
+      if (!parsedKey) {
+        return null;
+      }
+      return {
+        key,
+        ...parsedKey,
+        stats: parseRuntimeSignalStatsBucket(await (0, import_redis.getHashData)(key))
+      };
+    })
+  );
+  return entries.filter(Boolean);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isRuntimeSignalEvaluationRecord,
+  isSignalRecord,
+  loadRuntimeSignalEvaluationStatsBuckets,
+  loadRuntimeSignalEvaluations,
+  loadRuntimeSignals
+});

package/dist/lib/runtimeSignalsStorage.js

@@ -0,0 +1,162 @@
+"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/lib/runtimeSignalsStorage.ts
+var runtimeSignalsStorage_exports = {};
+__export(runtimeSignalsStorage_exports, {
+  buildRuntimeSignalStatsIncrements: () => buildRuntimeSignalStatsIncrements,
+  getRuntimeStorageDayKey: () => getRuntimeStorageDayKey,
+  getRuntimeStorageDayKeys: () => getRuntimeStorageDayKeys,
+  isRuntimeSignalBucketRef: () => isRuntimeSignalBucketRef,
+  normalizeRuntimeSignalSkipReason: () => normalizeRuntimeSignalSkipReason,
+  parseRuntimeSignalStatsBucket: () => parseRuntimeSignalStatsBucket,
+  shouldStoreDetailedRuntimeSignalEvaluation: () => shouldStoreDetailedRuntimeSignalEvaluation,
+  toRuntimeSignalBucketRef: () => toRuntimeSignalBucketRef
+});
+module.exports = __toCommonJS(runtimeSignalsStorage_exports);
+var DAY_MS = 864e5;
+var RUNTIME_STORAGE_DAY_OFFSET_MS = 5 * 60 * 60 * 1e3;
+var toIsoDayKey = (timestamp) => new Date(timestamp).toISOString().slice(0, 10);
+var toRuntimeStorageDayTimestamp = (timestamp) => Math.floor((timestamp + RUNTIME_STORAGE_DAY_OFFSET_MS) / DAY_MS) * DAY_MS;
+var getRuntimeStorageDayKey = (timestamp) => toIsoDayKey(toRuntimeStorageDayTimestamp(timestamp));
+var getRuntimeStorageDayKeys = (startTime, endTime) => {
+  if (!Number.isFinite(startTime) || !Number.isFinite(endTime)) {
+    return [];
+  }
+  const start = Math.min(startTime, endTime);
+  const endExclusive = Math.max(startTime, endTime);
+  const normalizedEnd = Math.max(start, endExclusive - 1);
+  const keys = [];
+  const startDay = toRuntimeStorageDayTimestamp(start);
+  const endDay = toRuntimeStorageDayTimestamp(normalizedEnd);
+  for (let current = startDay; current <= endDay; current += DAY_MS) {
+    keys.push(toIsoDayKey(current));
+  }
+  return keys;
+};
+var toRuntimeSignalBucketRef = (signal) => ({
+  signalId: signal.signalId,
+  symbol: signal.symbol,
+  strategy: signal.strategy,
+  timestamp: signal.timestamp
+});
+var isRuntimeSignalBucketRef = (value) => {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const record = value;
+  return typeof record.signalId === "string" && typeof record.symbol === "string" && typeof record.strategy === "string" && typeof record.timestamp === "number";
+};
+var normalizeRuntimeSignalSkipReason = (reason, fallbackSource) => {
+  let source = fallbackSource;
+  let normalizedReason = reason;
+  if (reason.startsWith("AI_QUALITY_BELOW_MIN")) {
+    source = "AI";
+    normalizedReason = "MIN_AI_QUALITY";
+  } else if (reason === "AI_QUALITY_UNAVAILABLE") {
+    source = "AI";
+    normalizedReason = "QUALITY_UNAVAILABLE";
+  } else if (reason === "ML_RESULT_UNAVAILABLE") {
+    source = "ML";
+    normalizedReason = "RESULT_UNAVAILABLE";
+  } else if (reason.startsWith("ML_THRESHOLD_NOT_MET")) {
+    source = "ML";
+    normalizedReason = "ML_THRESHOLD";
+  } else if (reason.startsWith("HOOK_BEFORE_ENTRY_GATE:")) {
+    source = "hook";
+    normalizedReason = `BEFORE_ENTRY_GATE:${reason.slice(
+      "HOOK_BEFORE_ENTRY_GATE:".length
+    )}`;
+  } else if (reason === "HOOK_BEFORE_ENTRY_GATE") {
+    source = "hook";
+    normalizedReason = "BEFORE_ENTRY_GATE";
+  } else if (reason === "MAKE_ORDERS_DISABLED" || reason === "ENTRY_POLICY_BLOCKED") {
+    source = "policy";
+  }
+  return {
+    source: `skip from ${source}`,
+    reason: normalizedReason
+  };
+};
+var buildStatsReasonField = (source, reason) => `reason:${source}:${reason}`;
+var buildRuntimeSignalStatsIncrements = (evaluation) => {
+  const increments = {
+    evaluated: 1
+  };
+  if (evaluation.status === "signal") {
+    increments.signals = 1;
+  }
+  let skipReason = null;
+  let fallbackSource = "core";
+  if (evaluation.status === "skip") {
+    skipReason = evaluation.reason || "NO_SIGNAL";
+    fallbackSource = "core";
+  } else if (evaluation.status === "signal" && (evaluation.orderStatus === "skipped" || evaluation.orderStatus === "canceled")) {
+    skipReason = evaluation.orderSkipReason || evaluation.reason || `orderStatus=${evaluation.orderStatus}`;
+    fallbackSource = "runtime";
+  } else if (evaluation.status === "error") {
+    skipReason = evaluation.reason || "EVALUATION_ERROR";
+    fallbackSource = "runtime";
+  }
+  if (skipReason) {
+    const normalized = normalizeRuntimeSignalSkipReason(
+      skipReason,
+      fallbackSource
+    );
+    increments[buildStatsReasonField(normalized.source, normalized.reason)] = 1;
+  }
+  return increments;
+};
+var shouldStoreDetailedRuntimeSignalEvaluation = (evaluation) => evaluation.status !== "skip";
+var toCount = (value) => {
+  const parsed = Number.parseInt(String(value ?? "0"), 10);
+  return Number.isFinite(parsed) ? parsed : 0;
+};
+var parseRuntimeSignalStatsBucket = (value) => {
+  const reasonGroups = /* @__PURE__ */ new Map();
+  for (const [field, rawCount] of Object.entries(value)) {
+    if (!field.startsWith("reason:")) {
+      continue;
+    }
+    const [, source, ...reasonParts] = field.split(":");
+    const reason = reasonParts.join(":");
+    if (!source || !reason) {
+      continue;
+    }
+    const reasons = reasonGroups.get(source) ?? /* @__PURE__ */ new Map();
+    reasons.set(reason, toCount(rawCount));
+    reasonGroups.set(source, reasons);
+  }
+  return {
+    evaluated: toCount(value.evaluated),
+    signals: toCount(value.signals),
+    reasonGroups
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildRuntimeSignalStatsIncrements,
+  getRuntimeStorageDayKey,
+  getRuntimeStorageDayKeys,
+  isRuntimeSignalBucketRef,
+  normalizeRuntimeSignalSkipReason,
+  parseRuntimeSignalStatsBucket,
+  shouldStoreDetailedRuntimeSignalEvaluation,
+  toRuntimeSignalBucketRef
+});

package/dist/lib/telegramReports.js

@@ -0,0 +1,91 @@
+"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/lib/telegramReports.ts
+var telegramReports_exports = {};
+__export(telegramReports_exports, {
+  TELEGRAM_REPORT_CHUNK_LIMIT: () => TELEGRAM_REPORT_CHUNK_LIMIT,
+  sendTelegramReport: () => sendTelegramReport,
+  splitTelegramReport: () => splitTelegramReport
+});
+module.exports = __toCommonJS(telegramReports_exports);
+var import_cli = require("@tradejs/node/cli");
+var TELEGRAM_REPORT_CHUNK_LIMIT = 3900;
+var buildPartHeader = (index, total) => `\u{1F4E9} <b>Part ${index}/${total}</b>`;
+var splitLongLine = (line, limit) => {
+  const chunks = [];
+  for (let index = 0; index < line.length; index += limit) {
+    chunks.push(line.slice(index, index + limit));
+  }
+  return chunks;
+};
+var splitTelegramReport = (message, limit = TELEGRAM_REPORT_CHUNK_LIMIT) => {
+  const normalizedLimit = Math.max(100, Math.floor(limit));
+  if (message.length <= normalizedLimit) {
+    return [message];
+  }
+  const chunks = [];
+  let current = "";
+  const flush = () => {
+    if (!current) {
+      return;
+    }
+    chunks.push(current);
+    current = "";
+  };
+  for (const line of message.split("\n")) {
+    const next = current ? `${current}
+${line}` : line;
+    if (next.length <= normalizedLimit) {
+      current = next;
+      continue;
+    }
+    flush();
+    if (line.length <= normalizedLimit) {
+      current = line;
+      continue;
+    }
+    chunks.push(...splitLongLine(line, normalizedLimit));
+  }
+  flush();
+  return chunks;
+};
+var sendTelegramReport = async (message, options = {}) => {
+  const chunks = splitTelegramReport(message);
+  if (chunks.length === 1) {
+    await (0, import_cli.sendTextToTG)(chunks[0], options);
+    return chunks.length;
+  }
+  for (const [index, chunk] of chunks.entries()) {
+    const header = buildPartHeader(index + 1, chunks.length);
+    await (0, import_cli.sendTextToTG)(`${header}
+
+${chunk}`, {
+      userName: options.userName,
+      markup: index === chunks.length - 1 ? options.markup : void 0
+    });
+  }
+  return chunks.length;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TELEGRAM_REPORT_CHUNK_LIMIT,
+  sendTelegramReport,
+  splitTelegramReport
+});