@tradejs/node 3.0.1 → 3.1.1

package/dist/runtimeStrategies.mjs

@@ -0,0 +1,264 @@
+import {
+  getStrategyCreator,
+  getStrategyPluginSource
+} from "./chunk-XN7BC7XK.mjs";
+import "./chunk-WS5DYEVZ.mjs";
+import "./chunk-Y6FXYEAI.mjs";
+
+// src/runtimeStrategies.ts
+import { readFile } from "fs/promises";
+import path from "path";
+import { getData, redisKeys } from "@tradejs/infra/redis";
+import { getRuntimeStrategyRelease } from "@tradejs/infra/runtimeStrategyReleases";
+import { loadRuntimeStrategyConfigs } from "@tradejs/infra/runtimeStrategyConfigs";
+import { resolveTradingAccount } from "@tradejs/infra/tradingAccounts";
+var readPackageManifest = async (projectRoot) => {
+  const candidates = [
+    process.env.TRADEJS_RUNTIME_PACKAGE_MANIFEST,
+    path.join(projectRoot, "runtime-package-manifest.json"),
+    "/app/runtime-package-manifest.json"
+  ].filter((candidate) => Boolean(candidate));
+  for (const candidate of candidates) {
+    try {
+      return JSON.parse(
+        await readFile(candidate, "utf8")
+      );
+    } catch {
+    }
+  }
+  return { packages: {} };
+};
+var resolveInstalledPackageVersion = async (projectRoot, packageName, manifest) => {
+  if (!packageName || packageName === "runtime") return null;
+  const manifestVersion = manifest.packages?.[packageName];
+  if (manifestVersion) return manifestVersion;
+  try {
+    const packageJsonPath = path.join(
+      projectRoot,
+      "node_modules",
+      ...packageName.split("/"),
+      "package.json"
+    );
+    const packageJson = JSON.parse(await readFile(packageJsonPath, "utf8"));
+    return packageJson.version ?? null;
+  } catch {
+    return null;
+  }
+};
+var validateReleaseRuntimeCompatibility = async ({
+  release,
+  projectRoot,
+  packageManifest
+}) => {
+  const installedStrategyVersion = await resolveInstalledPackageVersion(
+    projectRoot,
+    release.strategyPackage,
+    packageManifest
+  );
+  if (release.strategyPackageVersion && installedStrategyVersion && release.strategyPackageVersion !== installedStrategyVersion) {
+    throw new Error(
+      `${release.strategyName} v${release.releaseVersion} requires ${release.strategyPackage}@${release.strategyPackageVersion}, image has ${installedStrategyVersion}`
+    );
+  }
+  const installedRuntimeVersion = packageManifest.packages?.["@tradejs/node"];
+  if (release.runtimePackageVersion && installedRuntimeVersion && release.runtimePackageVersion !== installedRuntimeVersion) {
+    throw new Error(
+      `${release.strategyName} v${release.releaseVersion} requires @tradejs/node@${release.runtimePackageVersion}, image has ${installedRuntimeVersion}`
+    );
+  }
+};
+var resolveAccountId = async ({
+  userName,
+  deployment,
+  connectorName,
+  universe,
+  legacyAccountId
+}) => {
+  const requestedAccountId = deployment?.accountId ?? legacyAccountId;
+  const account = await resolveTradingAccount({
+    userName,
+    accountId: requestedAccountId,
+    provider: deployment?.provider ?? connectorName,
+    universe
+  });
+  return account?.id ?? requestedAccountId;
+};
+var loadVersionedRuntimeStrategies = async ({
+  userName,
+  projectRoot,
+  deployment,
+  connectorName
+}) => {
+  const packageManifest = await readPackageManifest(projectRoot);
+  return Promise.all(
+    deployment.strategies.map(async (reference) => {
+      if (!Number.isSafeInteger(reference.releaseVersion) || !reference.releaseVersion) {
+        throw new Error(
+          `Deployment ${deployment.id} strategy ${reference.strategyName} has no releaseVersion`
+        );
+      }
+      if (reference.config && Object.keys(reference.config).length) {
+        throw new Error(
+          `Deployment ${deployment.id} must not embed config for ${reference.strategyName}`
+        );
+      }
+      const release = await getRuntimeStrategyRelease(
+        userName,
+        reference.strategyName,
+        reference.releaseVersion
+      );
+      if (!release) {
+        throw new Error(
+          `Runtime release not found: ${reference.strategyName} v${reference.releaseVersion}`
+        );
+      }
+      await validateReleaseRuntimeCompatibility({
+        release,
+        projectRoot,
+        packageManifest
+      });
+      const strategyCreator = await getStrategyCreator(
+        reference.strategyName,
+        projectRoot
+      );
+      if (!strategyCreator) {
+        throw new Error(`Unknown strategy: ${reference.strategyName}`);
+      }
+      const interval = String(release.config.INTERVAL);
+      const universe = release.config.UNIVERSE;
+      const accountId = await resolveAccountId({
+        userName,
+        deployment,
+        connectorName,
+        universe
+      });
+      return {
+        strategyName: reference.strategyName,
+        releaseVersion: release.releaseVersion,
+        controlState: reference.controlState ?? "active",
+        interval,
+        universe,
+        accountId,
+        strategyPackage: release.strategyPackage,
+        strategyPackageVersion: release.strategyPackageVersion,
+        runtimePackageVersion: release.runtimePackageVersion,
+        strategyCreator,
+        sourceStrategyConfig: release.config,
+        strategyConfig: release.config,
+        // Symbol result configs are mutable legacy overlays and are not read by v2.
+        strategyResults: {}
+      };
+    })
+  );
+};
+var loadLegacyRuntimeStrategies = async ({
+  userName,
+  projectRoot,
+  deployment,
+  connectorName
+}) => {
+  const deploymentStrategies = new Map(
+    (deployment?.strategies ?? []).map((strategy) => [
+      strategy.strategyName,
+      strategy
+    ])
+  );
+  const candidates = await Promise.all(
+    (await loadRuntimeStrategyConfigs(userName)).map(async (record) => {
+      const binding = deploymentStrategies.get(record.strategyName);
+      if (binding?.enabled === false || record.strategyConfig.ENABLE === false) {
+        return null;
+      }
+      const universe = record.strategyConfig.UNIVERSE === "tradfi" ? "tradfi" : "crypto";
+      const interval = String(
+        record.strategyConfig.INTERVAL ?? "15"
+      );
+      const accountId = await resolveAccountId({
+        userName,
+        deployment,
+        connectorName,
+        universe,
+        legacyAccountId: typeof record.strategyConfig.ACCOUNT_ID === "string" ? record.strategyConfig.ACCOUNT_ID : void 0
+      });
+      const [strategyCreator, strategyResults] = await Promise.all([
+        getStrategyCreator(record.strategyName, projectRoot),
+        getData(redisKeys.strategyResults(userName, record.strategyName), {})
+      ]);
+      if (!strategyCreator) return null;
+      return {
+        strategyName: record.strategyName,
+        configId: record.configId,
+        controlState: "active",
+        interval,
+        universe,
+        accountId,
+        strategyCreator,
+        sourceStrategyConfig: record.strategyConfig,
+        strategyConfig: record.strategyConfig,
+        strategyResults: strategyResults ?? {}
+      };
+    })
+  );
+  return candidates.filter(Boolean);
+};
+var loadResolvedRuntimeStrategies = async ({
+  userName,
+  projectRoot,
+  deployment,
+  connectorName = "bybit",
+  universe,
+  accountId,
+  interval
+}) => {
+  const hasVersionedReferences = Boolean(
+    deployment?.strategies.some((strategy) => strategy.releaseVersion != null)
+  );
+  if (hasVersionedReferences && deployment?.strategies.some((strategy) => strategy.releaseVersion == null)) {
+    throw new Error(
+      `Deployment ${deployment.id} mixes legacy configs and versioned releases`
+    );
+  }
+  const strategies = hasVersionedReferences ? await loadVersionedRuntimeStrategies({
+    userName,
+    projectRoot,
+    deployment,
+    connectorName
+  }) : await loadLegacyRuntimeStrategies({
+    userName,
+    projectRoot,
+    deployment,
+    connectorName
+  });
+  const filtered = strategies.filter(
+    (candidate) => (!universe || candidate.universe === universe) && (!interval || String(candidate.interval) === String(interval)) && (!accountId || candidate.accountId === accountId)
+  );
+  const identities = /* @__PURE__ */ new Set();
+  for (const candidate of filtered) {
+    const identity = `${candidate.strategyName}:${candidate.accountId ?? "default"}`;
+    if (identities.has(identity)) {
+      throw new Error(`Runtime strategy conflict: ${identity}`);
+    }
+    identities.add(identity);
+  }
+  return filtered;
+};
+var getRuntimeStrategyPackageMetadata = async ({
+  strategyName,
+  projectRoot
+}) => {
+  const packageManifest = await readPackageManifest(projectRoot);
+  const strategyPackage = await getStrategyPluginSource(strategyName, projectRoot) ?? null;
+  return {
+    strategyPackage,
+    strategyPackageVersion: await resolveInstalledPackageVersion(
+      projectRoot,
+      strategyPackage,
+      packageManifest
+    ),
+    runtimePackageVersion: packageManifest.packages?.["@tradejs/node"] ?? null
+  };
+};
+export {
+  getRuntimeStrategyPackageMetadata,
+  loadResolvedRuntimeStrategies
+};

package/dist/runtimeTrades.d.mts

@@ -0,0 +1,31 @@
+import { ClosedPnlRecord, RuntimeTradeRecord, ExchangeEntryRecord, PositionPnlSnapshot } from '@tradejs/types';
+
+type ClosedPnlRecordWithOrderLinkId = ClosedPnlRecord & {
+    direction?: RuntimeTradeRecord['direction'];
+    entryTimestamp?: number;
+    orderLinkId?: string;
+};
+declare const takeExactClosedPnlMatch: ({ exactByOrderLinkId, exactByOrderId, symbolBuckets, orderLinkId, orderId, }: {
+    exactByOrderLinkId: Map<string, ClosedPnlRecordWithOrderLinkId>;
+    exactByOrderId: Map<string, ClosedPnlRecordWithOrderLinkId>;
+    symbolBuckets: Map<string, ClosedPnlRecordWithOrderLinkId[]>;
+    orderLinkId?: string | null;
+    orderId?: string | null;
+}) => ClosedPnlRecordWithOrderLinkId | null;
+declare const takeClosedPnlMatch: ({ exactByOrderLinkId, exactByOrderId, symbolBuckets, trade, }: {
+    exactByOrderLinkId: Map<string, ClosedPnlRecordWithOrderLinkId>;
+    exactByOrderId?: Map<string, ClosedPnlRecordWithOrderLinkId>;
+    symbolBuckets: Map<string, ClosedPnlRecordWithOrderLinkId[]>;
+    trade: RuntimeTradeRecord;
+}) => ClosedPnlRecordWithOrderLinkId | null;
+
+declare const buildExchangeFallbackRuntimeTrades: ({ entryRows, closedPnlRows, openPositions, strategyNames, existingTrades, endTime, }: {
+    entryRows: ExchangeEntryRecord[];
+    closedPnlRows: ClosedPnlRecordWithOrderLinkId[];
+    openPositions: PositionPnlSnapshot[];
+    strategyNames: string[];
+    existingTrades: RuntimeTradeRecord[];
+    endTime: number;
+}) => RuntimeTradeRecord[];
+
+export { type ClosedPnlRecordWithOrderLinkId, buildExchangeFallbackRuntimeTrades, takeClosedPnlMatch, takeExactClosedPnlMatch };

package/dist/runtimeTrades.d.ts

@@ -0,0 +1,31 @@
+import { ClosedPnlRecord, RuntimeTradeRecord, ExchangeEntryRecord, PositionPnlSnapshot } from '@tradejs/types';
+
+type ClosedPnlRecordWithOrderLinkId = ClosedPnlRecord & {
+    direction?: RuntimeTradeRecord['direction'];
+    entryTimestamp?: number;
+    orderLinkId?: string;
+};
+declare const takeExactClosedPnlMatch: ({ exactByOrderLinkId, exactByOrderId, symbolBuckets, orderLinkId, orderId, }: {
+    exactByOrderLinkId: Map<string, ClosedPnlRecordWithOrderLinkId>;
+    exactByOrderId: Map<string, ClosedPnlRecordWithOrderLinkId>;
+    symbolBuckets: Map<string, ClosedPnlRecordWithOrderLinkId[]>;
+    orderLinkId?: string | null;
+    orderId?: string | null;
+}) => ClosedPnlRecordWithOrderLinkId | null;
+declare const takeClosedPnlMatch: ({ exactByOrderLinkId, exactByOrderId, symbolBuckets, trade, }: {
+    exactByOrderLinkId: Map<string, ClosedPnlRecordWithOrderLinkId>;
+    exactByOrderId?: Map<string, ClosedPnlRecordWithOrderLinkId>;
+    symbolBuckets: Map<string, ClosedPnlRecordWithOrderLinkId[]>;
+    trade: RuntimeTradeRecord;
+}) => ClosedPnlRecordWithOrderLinkId | null;
+
+declare const buildExchangeFallbackRuntimeTrades: ({ entryRows, closedPnlRows, openPositions, strategyNames, existingTrades, endTime, }: {
+    entryRows: ExchangeEntryRecord[];
+    closedPnlRows: ClosedPnlRecordWithOrderLinkId[];
+    openPositions: PositionPnlSnapshot[];
+    strategyNames: string[];
+    existingTrades: RuntimeTradeRecord[];
+    endTime: number;
+}) => RuntimeTradeRecord[];
+
+export { type ClosedPnlRecordWithOrderLinkId, buildExchangeFallbackRuntimeTrades, takeClosedPnlMatch, takeExactClosedPnlMatch };

package/dist/runtimeTrades.js

@@ -0,0 +1,321 @@
+"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/runtimeTrades.ts
+var runtimeTrades_exports = {};
+__export(runtimeTrades_exports, {
+  buildExchangeFallbackRuntimeTrades: () => buildExchangeFallbackRuntimeTrades,
+  takeClosedPnlMatch: () => takeClosedPnlMatch,
+  takeExactClosedPnlMatch: () => takeExactClosedPnlMatch
+});
+module.exports = __toCommonJS(runtimeTrades_exports);
+var import_runtimeTrades = require("@tradejs/core/runtimeTrades");
+
+// src/runtimeTradeReconciliation.ts
+var toNonEmptyString = (value) => typeof value === "string" && value.trim() ? value.trim() : null;
+var removeFromExactMaps = (exactByOrderLinkId, exactByOrderId, row) => {
+  for (const [key, value] of exactByOrderLinkId) {
+    if (value === row) exactByOrderLinkId.delete(key);
+  }
+  for (const [key, value] of exactByOrderId) {
+    if (value === row) exactByOrderId.delete(key);
+  }
+};
+var removeFromSymbolBuckets = (buckets, row) => {
+  const rows = buckets.get(row.symbol);
+  const index = rows?.findIndex((candidate) => candidate === row) ?? -1;
+  if (index >= 0) rows?.splice(index, 1);
+};
+var takeExactClosedPnlMatch = ({
+  exactByOrderLinkId,
+  exactByOrderId,
+  symbolBuckets,
+  orderLinkId,
+  orderId
+}) => {
+  const keys = [
+    [exactByOrderLinkId, orderLinkId],
+    [exactByOrderId, orderId]
+  ];
+  for (const [bucket, key] of keys) {
+    const normalizedKey = toNonEmptyString(key);
+    if (!normalizedKey) continue;
+    const match = bucket.get(normalizedKey);
+    if (!match) continue;
+    removeFromExactMaps(exactByOrderLinkId, exactByOrderId, match);
+    removeFromSymbolBuckets(symbolBuckets, match);
+    return match;
+  }
+  return null;
+};
+var takeClosedPnlMatch = ({
+  exactByOrderLinkId,
+  exactByOrderId = /* @__PURE__ */ new Map(),
+  symbolBuckets,
+  trade
+}) => {
+  const exactMatch = takeExactClosedPnlMatch({
+    exactByOrderLinkId,
+    exactByOrderId,
+    symbolBuckets,
+    orderLinkId: trade.orderId,
+    orderId: trade.orderId
+  });
+  if (exactMatch) return exactMatch;
+  const rows = symbolBuckets.get(trade.symbol);
+  if (!rows?.length) return null;
+  const minimumClosedAt = trade.entryTimestamp - 5 * 6e4;
+  const matchIndex = rows.reduce((bestIndex, row2, index) => {
+    if (!Number.isFinite(row2.closedAt) || row2.closedAt < minimumClosedAt || row2.direction && row2.direction !== trade.direction) {
+      return bestIndex;
+    }
+    if (bestIndex < 0) return index;
+    return row2.closedAt < rows[bestIndex].closedAt ? index : bestIndex;
+  }, -1);
+  if (matchIndex < 0) return null;
+  const [row] = rows.splice(matchIndex, 1);
+  if (row) removeFromExactMaps(exactByOrderLinkId, exactByOrderId, row);
+  return row ?? null;
+};
+
+// src/runtimeTrades.ts
+var toNonEmptyString2 = (value) => typeof value === "string" && value.trim() ? value.trim() : null;
+var roundValue = (value, digits = 2) => {
+  if (!Number.isFinite(value)) return 0;
+  const factor = 10 ** digits;
+  return Math.round(value * factor) / factor;
+};
+var removeExactMatches = (exactByOrderLinkId, exactByOrderId, row) => {
+  if (row.orderLinkId) exactByOrderLinkId.delete(row.orderLinkId);
+  if (row.orderId) exactByOrderId.delete(row.orderId);
+};
+var takeClosedPnlMatchForEntry = ({
+  exactByOrderLinkId,
+  exactByOrderId,
+  symbolBuckets,
+  entry
+}) => {
+  const exactMatch = takeExactClosedPnlMatch({
+    exactByOrderLinkId,
+    exactByOrderId,
+    symbolBuckets,
+    orderLinkId: entry.orderLinkId,
+    orderId: entry.orderId
+  });
+  if (exactMatch) return exactMatch;
+  const rows = symbolBuckets.get(entry.symbol);
+  if (!rows?.length) return null;
+  const minimumClosedAt = entry.entryTimestamp - 5 * 6e4;
+  const matchIndex = rows.reduce((bestIndex, row, index) => {
+    if (!Number.isFinite(row.closedAt) || row.closedAt < minimumClosedAt || row.direction && row.direction !== entry.direction) {
+      return bestIndex;
+    }
+    if (bestIndex < 0) return index;
+    return row.closedAt < rows[bestIndex].closedAt ? index : bestIndex;
+  }, -1);
+  if (matchIndex < 0) return null;
+  const [match] = rows.splice(matchIndex, 1);
+  if (match) removeExactMatches(exactByOrderLinkId, exactByOrderId, match);
+  return match ?? null;
+};
+var aggregateExchangeEntriesByOrder = (entryRows) => {
+  const grouped = /* @__PURE__ */ new Map();
+  entryRows.forEach((entry, index) => {
+    const orderLinkId = toNonEmptyString2(entry.orderLinkId);
+    const orderId = toNonEmptyString2(entry.orderId);
+    const key = orderLinkId || orderId || `${entry.symbol}:${entry.direction}:${entry.entryTimestamp}:${index}`;
+    const existing = grouped.get(key);
+    const hasPrice = Number.isFinite(entry.qty) && typeof entry.entryPrice === "number" && Number.isFinite(entry.entryPrice);
+    if (!existing) {
+      grouped.set(key, {
+        ...entry,
+        qty: Number.isFinite(entry.qty) ? entry.qty : 0,
+        pricingQty: hasPrice ? entry.qty : 0,
+        pricingNotional: hasPrice ? entry.qty * (entry.entryPrice ?? 0) : 0
+      });
+      return;
+    }
+    existing.qty += Number.isFinite(entry.qty) ? entry.qty : 0;
+    existing.entryTimestamp = Math.min(
+      existing.entryTimestamp,
+      entry.entryTimestamp
+    );
+    if (hasPrice) {
+      existing.pricingQty += entry.qty;
+      existing.pricingNotional += entry.qty * (entry.entryPrice ?? 0);
+    }
+  });
+  return [...grouped.values()].map(({ pricingQty, pricingNotional, ...entry }) => ({
+    ...entry,
+    qty: roundValue(entry.qty, 8),
+    entryPrice: pricingQty > 0 ? roundValue(pricingNotional / pricingQty, 8) : null
+  })).sort((left, right) => left.entryTimestamp - right.entryTimestamp);
+};
+var resolveStrategy = ({
+  orderLinkId,
+  orderId,
+  strategyNameByOrderId,
+  strategyNames
+}) => (orderLinkId ? strategyNameByOrderId.get(orderLinkId) : null) ?? (orderId ? strategyNameByOrderId.get(orderId) : null) ?? (0, import_runtimeTrades.resolveStrategyNameByOrderLinkId)({ orderLinkId, strategyNames });
+var buildRiskLevels = (position) => {
+  const takeProfitPrice = position?.takeProfitPrice;
+  const stopLossPrice = position?.stopLossPrice;
+  if ((typeof takeProfitPrice !== "number" || !Number.isFinite(takeProfitPrice)) && (typeof stopLossPrice !== "number" || !Number.isFinite(stopLossPrice))) {
+    return null;
+  }
+  return {
+    ...typeof takeProfitPrice === "number" && Number.isFinite(takeProfitPrice) ? { takeProfitPrice } : {},
+    ...typeof stopLossPrice === "number" && Number.isFinite(stopLossPrice) ? { stopLossPrice } : {}
+  };
+};
+var buildExchangeFallbackRuntimeTrades = ({
+  entryRows,
+  closedPnlRows,
+  openPositions,
+  strategyNames,
+  existingTrades,
+  endTime
+}) => {
+  if (!entryRows.length && !closedPnlRows.length) return [];
+  const strategyNameByOrderId = new Map(
+    existingTrades.filter(
+      (trade) => Boolean(trade.orderId?.trim() && trade.strategy?.trim())
+    ).map((trade) => [trade.orderId, trade.strategy])
+  );
+  const strategyNamesPool = [
+    .../* @__PURE__ */ new Set([
+      ...strategyNames,
+      ...existingTrades.map(({ strategy }) => strategy)
+    ])
+  ];
+  const openPositionBySymbol = new Map(
+    openPositions.map((position) => [position.symbol, position])
+  );
+  const existingOrderIds = new Set(
+    existingTrades.map(({ orderId }) => toNonEmptyString2(orderId)).filter((value) => value != null)
+  );
+  const exactByOrderLinkId = new Map(
+    closedPnlRows.filter((row) => Boolean(row.orderLinkId)).map((row) => [row.orderLinkId, row])
+  );
+  const exactByOrderId = new Map(
+    closedPnlRows.filter((row) => Boolean(row.orderId)).map((row) => [row.orderId, row])
+  );
+  const symbolBuckets = /* @__PURE__ */ new Map();
+  for (const row of closedPnlRows) {
+    const bucket = symbolBuckets.get(row.symbol) ?? [];
+    bucket.push(row);
+    symbolBuckets.set(row.symbol, bucket);
+  }
+  const fallbackTrades = aggregateExchangeEntriesByOrder(entryRows).map((entry) => {
+    const orderLinkId = toNonEmptyString2(entry.orderLinkId);
+    const orderId = toNonEmptyString2(entry.orderId);
+    const runtimeOrderId = orderLinkId ?? orderId;
+    if (!runtimeOrderId || existingOrderIds.has(runtimeOrderId)) return null;
+    const strategy = resolveStrategy({
+      orderLinkId,
+      orderId,
+      strategyNameByOrderId,
+      strategyNames: strategyNamesPool
+    });
+    if (!strategy) return null;
+    const closed = takeClosedPnlMatchForEntry({
+      exactByOrderLinkId,
+      exactByOrderId,
+      symbolBuckets,
+      entry
+    });
+    const position = openPositionBySymbol.get(entry.symbol);
+    const isActive = !closed && position?.direction === entry.direction && Number.isFinite(position.currentPrice) && Number.isFinite(position.unrealizedPnl);
+    const entryPrice = typeof entry.entryPrice === "number" && Number.isFinite(entry.entryPrice) ? entry.entryPrice : typeof closed?.entryPrice === "number" && Number.isFinite(closed.entryPrice) ? closed.entryPrice : null;
+    if (entryPrice == null) return null;
+    return {
+      orderId: runtimeOrderId,
+      strategy,
+      symbol: entry.symbol,
+      direction: entry.direction,
+      qty: entry.qty,
+      entryPrice,
+      actualEntryPrice: closed?.entryPrice ?? entry.entryPrice ?? null,
+      entryTimestamp: entry.entryTimestamp,
+      status: isActive ? "active" : "closed",
+      currentPrice: isActive ? position?.currentPrice ?? null : closed?.exitPrice ?? null,
+      currentPnl: isActive ? position?.unrealizedPnl ?? null : closed?.closedPnl ?? null,
+      closedPnl: isActive ? null : closed?.closedPnl ?? null,
+      exitPrice: isActive ? null : closed?.exitPrice ?? null,
+      actualExitPrice: isActive ? null : closed?.exitPrice ?? null,
+      exitTimestamp: isActive ? null : closed?.closedAt ?? null,
+      aiAnalysis: isActive ? buildRiskLevels(position) : null,
+      openFee: closed?.openFee ?? entry.openFee ?? null,
+      closeFee: closed?.closeFee ?? entry.closeFee ?? null,
+      fundingFee: closed?.fundingFee ?? entry.fundingFee ?? null,
+      totalFee: closed?.totalFee ?? entry.totalFee ?? null,
+      lastSyncedAt: endTime
+    };
+  }).filter((trade) => trade != null);
+  const usedOrderIds = /* @__PURE__ */ new Set([
+    ...existingOrderIds,
+    ...fallbackTrades.map(({ orderId }) => orderId)
+  ]);
+  const remainingClosedTrades = [...symbolBuckets.values()].flat().map((row) => {
+    const orderLinkId = toNonEmptyString2(row.orderLinkId);
+    const orderId = toNonEmptyString2(row.orderId);
+    const runtimeOrderId = orderLinkId ?? orderId;
+    if (!runtimeOrderId || usedOrderIds.has(runtimeOrderId)) return null;
+    const strategy = resolveStrategy({
+      orderLinkId,
+      orderId,
+      strategyNameByOrderId,
+      strategyNames: strategyNamesPool
+    });
+    if (!strategy || row.entryPrice == null || !Number.isFinite(row.entryPrice) || !row.direction) {
+      return null;
+    }
+    return {
+      orderId: runtimeOrderId,
+      strategy,
+      symbol: row.symbol,
+      direction: row.direction,
+      qty: row.qty,
+      entryPrice: row.entryPrice,
+      actualEntryPrice: row.entryPrice,
+      entryTimestamp: typeof row.entryTimestamp === "number" && Number.isFinite(row.entryTimestamp) ? row.entryTimestamp : row.closedAt,
+      status: "closed",
+      currentPrice: row.exitPrice,
+      currentPnl: row.closedPnl,
+      closedPnl: row.closedPnl,
+      exitPrice: row.exitPrice,
+      actualExitPrice: row.exitPrice,
+      exitTimestamp: row.closedAt,
+      openFee: row.openFee ?? null,
+      closeFee: row.closeFee ?? null,
+      fundingFee: row.fundingFee ?? null,
+      totalFee: row.totalFee ?? null,
+      lastSyncedAt: endTime
+    };
+  }).filter((trade) => trade != null);
+  return [...fallbackTrades, ...remainingClosedTrades].sort(
+    (left, right) => left.entryTimestamp - right.entryTimestamp
+  );
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildExchangeFallbackRuntimeTrades,
+  takeClosedPnlMatch,
+  takeExactClosedPnlMatch
+});

package/dist/runtimeTrades.mjs

@@ -0,0 +1,11 @@
+import {
+  buildExchangeFallbackRuntimeTrades,
+  takeClosedPnlMatch,
+  takeExactClosedPnlMatch
+} from "./chunk-FB5NUEOQ.mjs";
+import "./chunk-Y6FXYEAI.mjs";
+export {
+  buildExchangeFallbackRuntimeTrades,
+  takeClosedPnlMatch,
+  takeExactClosedPnlMatch
+};

package/dist/strategies.d.mts

@@ -1,6 +1,6 @@
 export * from '@tradejs/core/strategies';
-export { DEFAULT_AI_MODEL, MAX_AI_SERIES_POINTS, askAI, buildAiHumanPrompt, buildAiPayload, buildAiPrompts, buildAiSystemPrompt, buildCompactAiIndicatorsSnapshot, getDeterministicAiGateContext, getOpenRouterModelKwargs, resetAiRuntimeCache, runAiPrompt, runAiPromptLocal, trimSeriesDeep } from './ai.mjs';
-export { ensureIndicatorPluginsLoaded, ensureStrategyPluginsLoaded, getAvailableStrategyNames, getRegisteredManifests, getRegisteredStrategies, getStrategyCreator, getStrategyManifest, isKnownStrategy, registerStrategyEntries, resetStrategyRegistryCache, strategies } from './registry.mjs';
+export { AiChatMessage, DEFAULT_AI_MODEL, InvokeAiChatOptions, MAX_AI_SERIES_POINTS, askAI, buildAiHumanPrompt, buildAiPayload, buildAiPrompts, buildAiSystemPrompt, buildCompactAiIndicatorsSnapshot, getDeterministicAiGateContext, getOpenRouterModelKwargs, invokeAiChat, resetAiRuntimeCache, runAiPrompt, runAiPromptLocal, trimSeriesDeep } from './ai.mjs';
+export { e as ensureIndicatorPluginsLoaded, a as ensureStrategyPluginsLoaded, g as getAvailableStrategyNames, b as getRegisteredManifests, c as getRegisteredStrategies, d as getStrategyCreator, f as getStrategyDefaults, h as getStrategyManifest, i as getStrategyPluginSource, j as isKnownStrategy, r as registerStrategyEntries, k as resetStrategyRegistryCache, s as strategies } from './registry-DHTLjQcr.mjs';
 import { StrategyConfig, CreateStrategyCore, StrategyManifest, StrategyCreator, RuntimeStrategyConfigSnapshot, Signal, Direction, StrategyRuntimeMlOptions, StrategyRuntimeAiOptions, Connector, Tp, MarketFeatureInterval, StrategyEntrySignalContext } from '@tradejs/types';
 import { TradejsConfigOnBarHook, TradejsConfigBeforeSignalsHook } from '@tradejs/core/config';
 

package/dist/strategies.d.ts

@@ -1,6 +1,6 @@
 export * from '@tradejs/core/strategies';
-export { DEFAULT_AI_MODEL, MAX_AI_SERIES_POINTS, askAI, buildAiHumanPrompt, buildAiPayload, buildAiPrompts, buildAiSystemPrompt, buildCompactAiIndicatorsSnapshot, getDeterministicAiGateContext, getOpenRouterModelKwargs, resetAiRuntimeCache, runAiPrompt, runAiPromptLocal, trimSeriesDeep } from './ai.js';
-export { ensureIndicatorPluginsLoaded, ensureStrategyPluginsLoaded, getAvailableStrategyNames, getRegisteredManifests, getRegisteredStrategies, getStrategyCreator, getStrategyManifest, isKnownStrategy, registerStrategyEntries, resetStrategyRegistryCache, strategies } from './registry.js';
+export { AiChatMessage, DEFAULT_AI_MODEL, InvokeAiChatOptions, MAX_AI_SERIES_POINTS, askAI, buildAiHumanPrompt, buildAiPayload, buildAiPrompts, buildAiSystemPrompt, buildCompactAiIndicatorsSnapshot, getDeterministicAiGateContext, getOpenRouterModelKwargs, invokeAiChat, resetAiRuntimeCache, runAiPrompt, runAiPromptLocal, trimSeriesDeep } from './ai.js';
+export { e as ensureIndicatorPluginsLoaded, a as ensureStrategyPluginsLoaded, g as getAvailableStrategyNames, b as getRegisteredManifests, c as getRegisteredStrategies, d as getStrategyCreator, f as getStrategyDefaults, h as getStrategyManifest, i as getStrategyPluginSource, j as isKnownStrategy, r as registerStrategyEntries, k as resetStrategyRegistryCache, s as strategies } from './registry-DHTLjQcr.js';
 import { StrategyConfig, CreateStrategyCore, StrategyManifest, StrategyCreator, RuntimeStrategyConfigSnapshot, Signal, Direction, StrategyRuntimeMlOptions, StrategyRuntimeAiOptions, Connector, Tp, MarketFeatureInterval, StrategyEntrySignalContext } from '@tradejs/types';
 import { TradejsConfigOnBarHook, TradejsConfigBeforeSignalsHook } from '@tradejs/core/config';