@tradejs/cli 1.0.8 → 1.0.10

package/dist/lib/runtimeParityDetails.js

@@ -0,0 +1,751 @@
+"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/runtimeParityDetails.ts
+var runtimeParityDetails_exports = {};
+__export(runtimeParityDetails_exports, {
+  buildReplayExchangeComparisonDetails: () => buildReplayExchangeComparisonDetails,
+  buildReplayMismatchDrilldown: () => buildReplayMismatchDrilldown,
+  buildReplayRuntimeComparisonDetails: () => buildReplayRuntimeComparisonDetails,
+  buildStrategyNameByOrderLinkKey: () => buildStrategyNameByOrderLinkKey,
+  resolveReplayStrategyNameFromExchangeEntry: () => resolveReplayStrategyNameFromExchangeEntry
+});
+module.exports = __toCommonJS(runtimeParityDetails_exports);
+var import_trade = require("@tradejs/core/trade");
+
+// src/lib/runtimeParity.ts
+var getBacktestParityComparisonTimestamp = (entry, timestampOffsetMs = 0) => {
+  if (timestampOffsetMs > 0 && entry.signalTimestamp != null && entry.timestamp >= entry.signalTimestamp + timestampOffsetMs) {
+    return entry.timestamp;
+  }
+  return (entry.signalTimestamp ?? entry.timestamp) + timestampOffsetMs;
+};
+
+// src/lib/runtimeParityDetails.ts
+var DEFAULT_REPLAY_PARITY_DETAILS_LIMIT = 500;
+var DEFAULT_REPLAY_PARITY_ARTIFACT_LIMIT = 100;
+var buildStrategyNameByOrderLinkKey = (strategyNames) => new Map(
+  strategyNames.flatMap((strategyName) => {
+    const strategyKey = (0, import_trade.normalizeStrategyOrderLinkKey)(strategyName);
+    return strategyKey ? [[strategyKey, strategyName]] : [];
+  })
+);
+var resolveReplayStrategyNameFromExchangeEntry = ({
+  exchangeEntry,
+  strategyNameByOrderLinkKey
+}) => {
+  const strategyKey = (0, import_trade.parseStrategyOrderLinkKey)(exchangeEntry.orderLinkId);
+  if (!strategyKey) {
+    return null;
+  }
+  return strategyNameByOrderLinkKey.get(strategyKey) ?? null;
+};
+var resolveReplayParityDetailsLimit = () => {
+  const parsed = Number.parseInt(
+    String(process.env.REPLAY_PARITY_DETAILS_LIMIT ?? ""),
+    10
+  );
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_REPLAY_PARITY_DETAILS_LIMIT;
+};
+var resolveReplayParityArtifactLimit = () => {
+  const parsed = Number.parseInt(
+    String(process.env.REPLAY_PARITY_ARTIFACT_LIMIT ?? ""),
+    10
+  );
+  return Number.isFinite(parsed) && parsed >= 0 ? parsed : DEFAULT_REPLAY_PARITY_ARTIFACT_LIMIT;
+};
+var capReplayDetails = (items, limit) => items.slice(0, Math.max(0, limit));
+var buildCostDetail = (entry) => ({
+  entryFee: entry.entryFee ?? null,
+  exitFee: entry.exitFee ?? null,
+  fundingFee: entry.fundingFee ?? null,
+  totalFee: entry.totalFee ?? null
+});
+var toBacktestParityDetail = (entry, timestampOffsetMs = 0) => {
+  const comparisonTimestamp = getBacktestParityComparisonTimestamp(
+    entry,
+    timestampOffsetMs
+  );
+  return {
+    source: "backtest",
+    strategy: entry.strategy,
+    symbol: entry.symbol,
+    direction: entry.direction,
+    qty: entry.qty ?? null,
+    timestamp: entry.timestamp,
+    signalTimestamp: entry.signalTimestamp ?? null,
+    comparisonTimestamp: timestampOffsetMs === 0 ? null : comparisonTimestamp,
+    price: entry.price,
+    exitType: entry.exitType ?? null,
+    exitTimestamp: entry.exitTimestamp ?? null,
+    exitPrice: entry.exitPrice ?? null,
+    pnl: entry.expectedPnl ?? null,
+    costs: buildCostDetail(entry),
+    orderId: entry.orderId,
+    signalId: entry.signalId
+  };
+};
+var toRuntimeParityDetail = (entry) => ({
+  source: "runtime",
+  strategy: entry.strategy,
+  symbol: entry.symbol,
+  direction: entry.direction,
+  qty: entry.qty ?? null,
+  timestamp: entry.timestamp,
+  price: entry.price,
+  exitType: entry.exitType ?? null,
+  exitTimestamp: entry.exitTimestamp ?? null,
+  exitPrice: entry.exitPrice ?? null,
+  pnl: entry.realizedPnl ?? null,
+  costs: buildCostDetail(entry),
+  orderId: entry.orderId,
+  signalId: entry.signalId
+});
+var toExchangeParityDetail = ({
+  entry,
+  inferredStrategy = null
+}) => ({
+  source: "exchange",
+  inferredStrategy,
+  symbol: entry.symbol,
+  direction: entry.direction,
+  qty: entry.qty,
+  timestamp: entry.entryTimestamp,
+  price: entry.entryPrice,
+  exitType: null,
+  exitTimestamp: entry.exitTimestamp ?? null,
+  exitPrice: entry.exitPrice ?? null,
+  pnl: entry.closedPnl ?? null,
+  costs: buildCostDetail({
+    entryFee: entry.openFee,
+    exitFee: entry.closeFee,
+    fundingFee: entry.fundingFee,
+    totalFee: entry.totalFee
+  }),
+  orderId: entry.orderId,
+  orderLinkId: entry.orderLinkId
+});
+var buildTimestampDelta = (left, right) => typeof left === "number" && Number.isFinite(left) && typeof right === "number" && Number.isFinite(right) ? Math.abs(left - right) : null;
+var getComparisonTimestamp = (entry) => typeof entry.comparisonTimestamp === "number" && Number.isFinite(entry.comparisonTimestamp) ? entry.comparisonTimestamp : entry.timestamp;
+var getEntryStrategy = (entry) => entry.strategy ?? entry.inferredStrategy ?? null;
+var findNearestSignal = ({
+  entry,
+  signals,
+  toleranceMs,
+  timestampOffsetMs,
+  entryTimestampOffsetMs = 0
+}) => {
+  const entryStrategy = getEntryStrategy(entry);
+  if (!entryStrategy) {
+    return null;
+  }
+  let bestSignal = null;
+  let bestDiff = Number.POSITIVE_INFINITY;
+  const entryTimestamp = entry.timestamp + entryTimestampOffsetMs;
+  for (const signal of signals) {
+    if (signal.strategy !== entryStrategy || signal.symbol !== entry.symbol || signal.direction !== entry.direction) {
+      continue;
+    }
+    const diff = Math.abs(
+      signal.timestamp + timestampOffsetMs - entryTimestamp
+    );
+    if (diff > toleranceMs || diff >= bestDiff) {
+      continue;
+    }
+    bestSignal = signal;
+    bestDiff = diff;
+  }
+  return bestSignal ? {
+    signal: bestSignal,
+    timestampDiffMs: bestDiff
+  } : null;
+};
+var findNearestEvaluation = ({
+  entry,
+  evaluations,
+  toleranceMs,
+  timestampOffsetMs,
+  entryTimestampOffsetMs = 0
+}) => {
+  const entryStrategy = getEntryStrategy(entry);
+  if (!entryStrategy) {
+    return null;
+  }
+  let bestEvaluation = null;
+  let bestDiff = Number.POSITIVE_INFINITY;
+  const entryTimestamp = entry.timestamp + entryTimestampOffsetMs;
+  for (const evaluation of evaluations) {
+    if (evaluation.strategy !== entryStrategy || evaluation.symbol !== entry.symbol) {
+      continue;
+    }
+    const diff = Math.abs(
+      evaluation.timestamp + timestampOffsetMs - entryTimestamp
+    );
+    if (diff > toleranceMs || diff >= bestDiff) {
+      continue;
+    }
+    bestEvaluation = evaluation;
+    bestDiff = diff;
+  }
+  return bestEvaluation ? {
+    evaluation: bestEvaluation,
+    timestampDiffMs: bestDiff
+  } : null;
+};
+var classifySignalDiagnostic = (signal) => {
+  if (signal.orderStatus === "failed") {
+    return {
+      classification: "order_failed",
+      reason: signal.orderFailureReason || signal.orderSkipReason || "failed"
+    };
+  }
+  if (signal.orderStatus === "skipped" || signal.orderStatus === "canceled" || typeof signal.orderSkipReason === "string" && signal.orderSkipReason.trim() || signal.ml?.passed === false) {
+    return {
+      classification: "gated_or_policy_blocked",
+      reason: signal.orderSkipReason || (signal.ml?.passed === false ? `ml_probability=${signal.ml.probability} threshold=${signal.ml.threshold}` : `orderStatus=${signal.orderStatus ?? "skipped"}`)
+    };
+  }
+  if (signal.orderStatus === "completed") {
+    return {
+      classification: "completed_signal_without_match",
+      reason: "completed_signal_without_matching_trade"
+    };
+  }
+  return {
+    classification: "signal_without_order_status",
+    reason: "signal_found_without_order_status"
+  };
+};
+var classifyEvaluationDiagnostic = (evaluation) => {
+  if (evaluation.status === "skip") {
+    return {
+      classification: "core_skipped",
+      reason: evaluation.reason || "NO_SIGNAL"
+    };
+  }
+  if (evaluation.status === "error") {
+    return {
+      classification: "evaluation_error",
+      reason: evaluation.reason || "runtime_evaluation_error"
+    };
+  }
+  if (evaluation.orderStatus === "failed") {
+    return {
+      classification: "order_failed",
+      reason: evaluation.reason || "orderStatus=failed"
+    };
+  }
+  if (evaluation.orderStatus === "skipped" || evaluation.orderStatus === "canceled" || typeof evaluation.orderSkipReason === "string" && evaluation.orderSkipReason.trim()) {
+    return {
+      classification: "gated_or_policy_blocked",
+      reason: evaluation.orderSkipReason || evaluation.reason || `orderStatus=${evaluation.orderStatus}`
+    };
+  }
+  if (evaluation.orderStatus === "completed") {
+    return {
+      classification: "completed_signal_without_match",
+      reason: "completed_signal_without_matching_trade"
+    };
+  }
+  return {
+    classification: "signal_evaluation_without_order_status",
+    reason: evaluation.reason || "signal_evaluation_without_order_status"
+  };
+};
+var summarizeMismatchDiagnostics = (items) => Object.fromEntries(
+  [
+    ...items.reduce((counts, item) => {
+      counts.set(
+        item.classification,
+        (counts.get(item.classification) ?? 0) + 1
+      );
+      return counts;
+    }, /* @__PURE__ */ new Map()).entries()
+  ].sort(([left], [right]) => left.localeCompare(right))
+);
+var buildPnlDelta = (expectedPnl, realizedPnl) => typeof expectedPnl === "number" && Number.isFinite(expectedPnl) && typeof realizedPnl === "number" && Number.isFinite(realizedPnl) ? realizedPnl - expectedPnl : null;
+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 toFiniteNumberOrNull = (value) => typeof value === "number" && Number.isFinite(value) ? value : null;
+var toAiDiagnostic = (analysis) => {
+  if (!analysis || typeof analysis !== "object") {
+    return null;
+  }
+  return {
+    direction: typeof analysis.direction === "string" ? analysis.direction : null,
+    quality: toFiniteNumberOrNull(analysis.quality),
+    needRetest: typeof analysis.needRetest === "boolean" ? analysis.needRetest : null,
+    gateDecision: typeof analysis.gateDecision === "string" ? analysis.gateDecision : null,
+    llmDecision: typeof analysis.llmDecision === "string" ? analysis.llmDecision : null,
+    qualityReason: typeof analysis.qualityReason === "string" ? analysis.qualityReason : null
+  };
+};
+var toSignalDiagnostic = ({
+  signal,
+  timestampDiffMs
+}) => ({
+  signalId: signal.signalId,
+  timestamp: signal.timestamp,
+  timestampDiffMs,
+  direction: signal.direction,
+  orderStatus: signal.orderStatus,
+  orderSkipReason: signal.orderSkipReason,
+  ai: toAiDiagnostic(signal.aiAnalysis),
+  ml: signal.ml ?? null
+});
+var toEvaluationDiagnostic = ({
+  evaluation,
+  timestampDiffMs
+}) => ({
+  evaluationId: evaluation.evaluationId,
+  timestamp: evaluation.timestamp,
+  timestampDiffMs,
+  status: evaluation.status,
+  reason: evaluation.reason,
+  signalId: evaluation.signalId,
+  direction: evaluation.direction,
+  orderStatus: evaluation.orderStatus,
+  orderSkipReason: evaluation.orderSkipReason,
+  ai: toAiDiagnostic(evaluation.aiAnalysis),
+  ml: evaluation.ml ?? null
+});
+var buildSlippageCost = ({
+  direction,
+  expectedPrice,
+  actualPrice,
+  qty,
+  stage
+}) => {
+  if (typeof expectedPrice !== "number" || !Number.isFinite(expectedPrice) || typeof actualPrice !== "number" || !Number.isFinite(actualPrice) || typeof qty !== "number" || !Number.isFinite(qty)) {
+    return null;
+  }
+  const sideMultiplier = direction === "SHORT" ? -1 : 1;
+  const priceDelta = stage === "entry" ? (actualPrice - expectedPrice) * sideMultiplier : (expectedPrice - actualPrice) * sideMultiplier;
+  return Number((priceDelta * qty).toFixed(12));
+};
+var buildMatchedReplayDetail = ({
+  runtime,
+  backtest,
+  timestampDiffMs,
+  priceDeltaPct
+}) => {
+  const exitPriceDeltaPct = buildPriceDeltaPct(
+    runtime.exitPrice ?? null,
+    backtest.exitPrice ?? null
+  );
+  const qty = runtime.qty ?? backtest.qty ?? null;
+  const entrySlippageCost = buildSlippageCost({
+    direction: runtime.direction,
+    expectedPrice: backtest.price,
+    actualPrice: runtime.price,
+    qty,
+    stage: "entry"
+  });
+  const exitSlippageCost = buildSlippageCost({
+    direction: runtime.direction,
+    expectedPrice: backtest.exitPrice,
+    actualPrice: runtime.exitPrice,
+    qty,
+    stage: "exit"
+  });
+  const totalSlippageCost = entrySlippageCost == null && exitSlippageCost == null ? null : Number(
+    ((entrySlippageCost ?? 0) + (exitSlippageCost ?? 0)).toFixed(12)
+  );
+  return {
+    runtime,
+    backtest,
+    timestampDiffMs,
+    priceDeltaPct,
+    exitTimestampDiffMs: buildTimestampDelta(
+      runtime.exitTimestamp,
+      backtest.exitTimestamp
+    ),
+    exitPriceDeltaPct,
+    exitType: {
+      expected: backtest.exitType ?? null,
+      actual: runtime.exitType ?? null,
+      matches: backtest.exitType && runtime.exitType ? backtest.exitType === runtime.exitType : null
+    },
+    pnl: {
+      expectedPnl: backtest.pnl ?? null,
+      realizedPnl: runtime.pnl ?? null,
+      delta: buildPnlDelta(backtest.pnl, runtime.pnl)
+    },
+    slippage: {
+      entryPriceDeltaPct: priceDeltaPct,
+      exitPriceDeltaPct,
+      entryCost: entrySlippageCost,
+      exitCost: exitSlippageCost,
+      totalCost: totalSlippageCost
+    }
+  };
+};
+var buildNearestCandidates = ({
+  entries,
+  candidates,
+  toleranceMs,
+  requireSameStrategy
+}) => entries.map((entry) => {
+  const comparable = candidates.filter((candidate) => {
+    if (candidate.symbol !== entry.symbol || candidate.direction !== entry.direction) {
+      return false;
+    }
+    if (!requireSameStrategy) {
+      return true;
+    }
+    const entryStrategy = entry.strategy ?? entry.inferredStrategy ?? null;
+    const candidateStrategy = candidate.strategy ?? candidate.inferredStrategy ?? null;
+    return entryStrategy != null && entryStrategy === candidateStrategy;
+  });
+  const nearest = comparable.map((candidate) => ({
+    candidate,
+    timestampDiffMs: Math.abs(
+      getComparisonTimestamp(candidate) - getComparisonTimestamp(entry)
+    )
+  })).sort((left, right) => left.timestampDiffMs - right.timestampDiffMs)[0];
+  if (!nearest) {
+    return {
+      entry,
+      nearest: null,
+      timestampDiffMs: null,
+      priceDeltaPct: null,
+      reason: "no_candidate_same_symbol_direction"
+    };
+  }
+  const priceDeltaPct = buildPriceDeltaPct(
+    entry.price,
+    nearest.candidate.price
+  );
+  return {
+    entry,
+    nearest: nearest.candidate,
+    timestampDiffMs: nearest.timestampDiffMs,
+    priceDeltaPct,
+    reason: nearest.timestampDiffMs > toleranceMs ? "outside_tolerance" : "candidate_already_matched"
+  };
+});
+var buildReplayMismatchDrilldown = ({
+  runtimeOnly,
+  backtestOnly,
+  nearestCandidates,
+  runtimeSignals = [],
+  runtimeSignalEvaluations = [],
+  replaySignals = [],
+  replaySignalEvaluations = [],
+  toleranceMs,
+  backtestTimestampOffsetMs,
+  limit
+}) => {
+  const nearestByEntry = new Map(
+    nearestCandidates.map((candidate) => [candidate.entry, candidate])
+  );
+  const artifactLimit = Math.min(limit, resolveReplayParityArtifactLimit());
+  let runtimeOnlyArtifactsIncluded = 0;
+  let backtestOnlyArtifactsIncluded = 0;
+  const runtimeOnlyDiagnostics = runtimeOnly.map((entry, index) => {
+    const includeArtifacts = index < artifactLimit;
+    const nearestCandidate = nearestByEntry.get(entry);
+    const nearestReplaySignal = findNearestSignal({
+      entry,
+      signals: replaySignals,
+      toleranceMs,
+      timestampOffsetMs: backtestTimestampOffsetMs
+    });
+    const nearestReplayEvaluation = findNearestEvaluation({
+      entry,
+      evaluations: replaySignalEvaluations,
+      toleranceMs,
+      timestampOffsetMs: backtestTimestampOffsetMs
+    });
+    const classification = nearestReplaySignal ? classifySignalDiagnostic(nearestReplaySignal.signal) : nearestReplayEvaluation ? classifyEvaluationDiagnostic(nearestReplayEvaluation.evaluation) : nearestCandidate?.nearest ? {
+      classification: "timing_or_price_drift",
+      reason: nearestCandidate.reason
+    } : {
+      classification: "no_replay_candidate",
+      reason: "no_replay_signal_or_backtest_candidate"
+    };
+    return {
+      entry,
+      ...classification,
+      ...nearestCandidate ? { nearestCandidate } : {},
+      ...nearestReplaySignal ? {
+        replaySignal: toSignalDiagnostic({
+          signal: nearestReplaySignal.signal,
+          timestampDiffMs: nearestReplaySignal.timestampDiffMs
+        }),
+        ...includeArtifacts ? { replaySignalArtifact: nearestReplaySignal.signal } : {}
+      } : {},
+      ...nearestReplayEvaluation ? {
+        replayEvaluation: toEvaluationDiagnostic({
+          evaluation: nearestReplayEvaluation.evaluation,
+          timestampDiffMs: nearestReplayEvaluation.timestampDiffMs
+        }),
+        ...includeArtifacts ? { replayEvaluationArtifact: nearestReplayEvaluation.evaluation } : {}
+      } : {}
+    };
+  });
+  const backtestOnlyDiagnostics = backtestOnly.map((entry, index) => {
+    const includeArtifacts = index < artifactLimit;
+    const nearestCandidate = nearestByEntry.get(entry);
+    const nearestRuntimeSignal = findNearestSignal({
+      entry,
+      signals: runtimeSignals,
+      toleranceMs,
+      timestampOffsetMs: 0
+    });
+    const nearestRuntimeEvaluation = findNearestEvaluation({
+      entry,
+      evaluations: runtimeSignalEvaluations,
+      toleranceMs,
+      timestampOffsetMs: 0
+    });
+    const classification = nearestRuntimeSignal ? classifySignalDiagnostic(nearestRuntimeSignal.signal) : nearestRuntimeEvaluation ? classifyEvaluationDiagnostic(nearestRuntimeEvaluation.evaluation) : nearestCandidate?.nearest ? {
+      classification: "timing_or_price_drift",
+      reason: nearestCandidate.reason
+    } : {
+      classification: "no_runtime_evaluation",
+      reason: "no_runtime_signal_or_evaluation"
+    };
+    return {
+      entry,
+      ...classification,
+      ...nearestCandidate ? { nearestCandidate } : {},
+      ...nearestRuntimeSignal ? {
+        runtimeSignal: toSignalDiagnostic({
+          signal: nearestRuntimeSignal.signal,
+          timestampDiffMs: nearestRuntimeSignal.timestampDiffMs
+        }),
+        ...includeArtifacts ? { runtimeSignalArtifact: nearestRuntimeSignal.signal } : {}
+      } : {},
+      ...nearestRuntimeEvaluation ? {
+        runtimeEvaluation: toEvaluationDiagnostic({
+          evaluation: nearestRuntimeEvaluation.evaluation,
+          timestampDiffMs: nearestRuntimeEvaluation.timestampDiffMs
+        }),
+        ...includeArtifacts ? {
+          runtimeEvaluationArtifact: nearestRuntimeEvaluation.evaluation
+        } : {}
+      } : {}
+    };
+  });
+  for (const diagnostic of runtimeOnlyDiagnostics) {
+    if (diagnostic.replaySignalArtifact || diagnostic.replayEvaluationArtifact) {
+      runtimeOnlyArtifactsIncluded += 1;
+    }
+  }
+  for (const diagnostic of backtestOnlyDiagnostics) {
+    if (diagnostic.runtimeSignalArtifact || diagnostic.runtimeEvaluationArtifact) {
+      backtestOnlyArtifactsIncluded += 1;
+    }
+  }
+  return {
+    runtimeOnly: capReplayDetails(runtimeOnlyDiagnostics, limit),
+    backtestOnly: capReplayDetails(backtestOnlyDiagnostics, limit),
+    summary: {
+      runtimeOnly: summarizeMismatchDiagnostics(runtimeOnlyDiagnostics),
+      backtestOnly: summarizeMismatchDiagnostics(backtestOnlyDiagnostics),
+      artifacts: {
+        limit: artifactLimit,
+        runtimeOnlyIncluded: runtimeOnlyArtifactsIncluded,
+        runtimeOnlyOmitted: Math.max(
+          0,
+          runtimeOnlyDiagnostics.length - runtimeOnlyArtifactsIncluded
+        ),
+        backtestOnlyIncluded: backtestOnlyArtifactsIncluded,
+        backtestOnlyOmitted: Math.max(
+          0,
+          backtestOnlyDiagnostics.length - backtestOnlyArtifactsIncluded
+        )
+      }
+    }
+  };
+};
+var buildReplayRuntimeComparisonDetails = ({
+  matched,
+  runtimeOnly,
+  backtestOnly,
+  runtimeEntries,
+  backtestEntries,
+  toleranceMs,
+  limit = resolveReplayParityDetailsLimit(),
+  backtestTimestampOffsetMs = 0,
+  runtimeSignals,
+  runtimeSignalEvaluations,
+  replaySignals,
+  replaySignalEvaluations
+}) => {
+  const runtimeDetails = runtimeEntries.map(toRuntimeParityDetail);
+  const backtestDetails = backtestEntries.map(
+    (entry) => toBacktestParityDetail(entry, backtestTimestampOffsetMs)
+  );
+  const runtimeOnlyDetails = runtimeOnly.map(toRuntimeParityDetail);
+  const backtestOnlyDetails = backtestOnly.map(
+    (entry) => toBacktestParityDetail(entry, backtestTimestampOffsetMs)
+  );
+  const nearestCandidates = [
+    ...buildNearestCandidates({
+      entries: runtimeOnlyDetails,
+      candidates: backtestDetails,
+      toleranceMs,
+      requireSameStrategy: true
+    }),
+    ...buildNearestCandidates({
+      entries: backtestOnlyDetails,
+      candidates: runtimeDetails,
+      toleranceMs,
+      requireSameStrategy: true
+    })
+  ];
+  const cappedNearestCandidates = capReplayDetails(nearestCandidates, limit);
+  const cappedRuntimeOnlyDetails = capReplayDetails(runtimeOnlyDetails, limit);
+  const cappedBacktestOnlyDetails = capReplayDetails(
+    backtestOnlyDetails,
+    limit
+  );
+  return {
+    capped: matched.length > limit || runtimeOnlyDetails.length > limit || backtestOnlyDetails.length > limit || nearestCandidates.length > limit,
+    limit,
+    matched: capReplayDetails(
+      matched.map(
+        (item) => buildMatchedReplayDetail({
+          runtime: toRuntimeParityDetail(item.runtime),
+          backtest: toBacktestParityDetail(
+            item.backtest,
+            backtestTimestampOffsetMs
+          ),
+          timestampDiffMs: item.timestampDiffMs,
+          priceDeltaPct: item.priceDeltaPct
+        })
+      ),
+      limit
+    ),
+    runtimeOnly: cappedRuntimeOnlyDetails,
+    backtestOnly: cappedBacktestOnlyDetails,
+    nearestCandidates: cappedNearestCandidates,
+    mismatchDrilldown: buildReplayMismatchDrilldown({
+      runtimeOnly: runtimeOnlyDetails,
+      backtestOnly: backtestOnlyDetails,
+      nearestCandidates,
+      runtimeSignals,
+      runtimeSignalEvaluations,
+      replaySignals,
+      replaySignalEvaluations,
+      toleranceMs,
+      backtestTimestampOffsetMs,
+      limit
+    })
+  };
+};
+var buildReplayExchangeComparisonDetails = ({
+  matched,
+  exchangeOnly,
+  backtestOnly,
+  exchangeEntries,
+  backtestEntries,
+  strategyNameByOrderLinkKey,
+  toleranceMs,
+  limit = resolveReplayParityDetailsLimit(),
+  backtestTimestampOffsetMs = 0,
+  runtimeSignals,
+  runtimeSignalEvaluations,
+  replaySignals,
+  replaySignalEvaluations
+}) => {
+  const toExchangeDetail = (entry) => toExchangeParityDetail({
+    entry,
+    inferredStrategy: resolveReplayStrategyNameFromExchangeEntry({
+      exchangeEntry: entry,
+      strategyNameByOrderLinkKey
+    })
+  });
+  const exchangeDetails = exchangeEntries.map(toExchangeDetail);
+  const backtestDetails = backtestEntries.map(
+    (entry) => toBacktestParityDetail(entry, backtestTimestampOffsetMs)
+  );
+  const exchangeOnlyDetails = exchangeOnly.map(toExchangeDetail);
+  const backtestOnlyDetails = backtestOnly.map(
+    (entry) => toBacktestParityDetail(entry, backtestTimestampOffsetMs)
+  );
+  const nearestCandidates = [
+    ...buildNearestCandidates({
+      entries: exchangeOnlyDetails,
+      candidates: backtestDetails,
+      toleranceMs
+    }),
+    ...buildNearestCandidates({
+      entries: backtestOnlyDetails,
+      candidates: exchangeDetails,
+      toleranceMs
+    })
+  ];
+  const cappedNearestCandidates = capReplayDetails(nearestCandidates, limit);
+  const cappedExchangeOnlyDetails = capReplayDetails(
+    exchangeOnlyDetails,
+    limit
+  );
+  const cappedBacktestOnlyDetails = capReplayDetails(
+    backtestOnlyDetails,
+    limit
+  );
+  return {
+    capped: matched.length > limit || exchangeOnlyDetails.length > limit || backtestOnlyDetails.length > limit || nearestCandidates.length > limit,
+    limit,
+    matched: capReplayDetails(
+      matched.map(
+        (item) => buildMatchedReplayDetail({
+          runtime: toExchangeDetail(item.exchange),
+          backtest: toBacktestParityDetail(
+            item.backtest,
+            backtestTimestampOffsetMs
+          ),
+          timestampDiffMs: item.timestampDiffMs,
+          priceDeltaPct: item.priceDeltaPct
+        })
+      ),
+      limit
+    ),
+    runtimeOnly: cappedExchangeOnlyDetails,
+    backtestOnly: cappedBacktestOnlyDetails,
+    nearestCandidates: cappedNearestCandidates,
+    mismatchDrilldown: buildReplayMismatchDrilldown({
+      runtimeOnly: exchangeOnlyDetails,
+      backtestOnly: backtestOnlyDetails,
+      nearestCandidates,
+      runtimeSignals,
+      runtimeSignalEvaluations,
+      replaySignals,
+      replaySignalEvaluations,
+      toleranceMs,
+      backtestTimestampOffsetMs,
+      limit
+    })
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildReplayExchangeComparisonDetails,
+  buildReplayMismatchDrilldown,
+  buildReplayRuntimeComparisonDetails,
+  buildStrategyNameByOrderLinkKey,
+  resolveReplayStrategyNameFromExchangeEntry
+});