@tradejs/core 1.0.9 → 1.0.11

package/dist/{time-BMkFD4Kd.d.mts → time-BQ3AXmxo.d.mts}

@@ -7,6 +7,8 @@ declare const getDataTimestamp: (data: KlineChartData) => number | null;
 declare const formatUnix: (dt: number) => string;
 declare const getBacktestPreloadStart: (start: number, preloadDays?: number) => number;
 declare const getTimeline: (start?: number, end?: number, step?: number) => number[];
+declare const getRuntimeStorageDayKey: (timestamp: number) => string;
+declare const getRuntimeStorageDayKeys: (startTime: number, endTime: number) => string[];
 declare const compactOrderLog: (timeline: number[], orderLog: OrderLogData) => SimpleOrderLogData;
 
-export { getBacktestPreloadStart as a, getDataTimestamp as b, compactOrderLog as c, getItemTimestamp as d, getTimestamp as e, formatUnix as f, getTimeline as g, toMs as t };
+export { getBacktestPreloadStart as a, getDataTimestamp as b, compactOrderLog as c, getItemTimestamp as d, getRuntimeStorageDayKey as e, formatUnix as f, getTimeline as g, getRuntimeStorageDayKeys as h, getTimestamp as i, toMs as t };

package/dist/{time-BMkFD4Kd.d.ts → time-BQ3AXmxo.d.ts}

@@ -7,6 +7,8 @@ declare const getDataTimestamp: (data: KlineChartData) => number | null;
 declare const formatUnix: (dt: number) => string;
 declare const getBacktestPreloadStart: (start: number, preloadDays?: number) => number;
 declare const getTimeline: (start?: number, end?: number, step?: number) => number[];
+declare const getRuntimeStorageDayKey: (timestamp: number) => string;
+declare const getRuntimeStorageDayKeys: (startTime: number, endTime: number) => string[];
 declare const compactOrderLog: (timeline: number[], orderLog: OrderLogData) => SimpleOrderLogData;
 
-export { getBacktestPreloadStart as a, getDataTimestamp as b, compactOrderLog as c, getItemTimestamp as d, getTimestamp as e, formatUnix as f, getTimeline as g, toMs as t };
+export { getBacktestPreloadStart as a, getDataTimestamp as b, compactOrderLog as c, getItemTimestamp as d, getRuntimeStorageDayKey as e, formatUnix as f, getTimeline as g, getRuntimeStorageDayKeys as h, getTimestamp as i, toMs as t };

package/dist/time.d.mts

@@ -1,2 +1,2 @@
-export { f as formatUnix, a as getBacktestPreloadStart, b as getDataTimestamp, d as getItemTimestamp, e as getTimestamp, t as toMs } from './time-BMkFD4Kd.mjs';
+export { f as formatUnix, a as getBacktestPreloadStart, b as getDataTimestamp, d as getItemTimestamp, e as getRuntimeStorageDayKey, h as getRuntimeStorageDayKeys, i as getTimestamp, t as toMs } from './time-BQ3AXmxo.mjs';
 import '@tradejs/types';

package/dist/time.d.ts

@@ -1,2 +1,2 @@
-export { f as formatUnix, a as getBacktestPreloadStart, b as getDataTimestamp, d as getItemTimestamp, e as getTimestamp, t as toMs } from './time-BMkFD4Kd.js';
+export { f as formatUnix, a as getBacktestPreloadStart, b as getDataTimestamp, d as getItemTimestamp, e as getRuntimeStorageDayKey, h as getRuntimeStorageDayKeys, i as getTimestamp, t as toMs } from './time-BQ3AXmxo.js';
 import '@tradejs/types';

package/dist/time.js

@@ -24,6 +24,8 @@ __export(time_exports, {
   getBacktestPreloadStart: () => getBacktestPreloadStart,
   getDataTimestamp: () => getDataTimestamp,
   getItemTimestamp: () => getItemTimestamp,
+  getRuntimeStorageDayKey: () => getRuntimeStorageDayKey,
+  getRuntimeStorageDayKeys: () => getRuntimeStorageDayKeys,
   getTimestamp: () => getTimestamp,
   toMs: () => toMs
 });
@@ -34,10 +36,26 @@ var import_date_fns = require("date-fns");
 var import_date_fns2 = require("date-fns");
 
 // src/constants/index.ts
+var BACKTEST_EXECUTION_DELAY_MS = 5 * 6e4;
 var BACKTEST_PRELOAD_DAYS = 60;
+var DERIVATIVES_CONTEXT_BASE_REFERENCE_SYMBOLS = [
+  "BTCUSDT",
+  "ETHUSDT"
+];
+var DERIVATIVES_CONTEXT_DEFAULT_EXTRA_REFERENCE_SYMBOLS = [
+  "BNBUSDT",
+  "SOLUSDT",
+  "TRXUSDT",
+  "XRPUSDT"
+];
+var DERIVATIVES_CONTEXT_REFERENCE_SYMBOLS = [
+  ...DERIVATIVES_CONTEXT_BASE_REFERENCE_SYMBOLS,
+  ...DERIVATIVES_CONTEXT_DEFAULT_EXTRA_REFERENCE_SYMBOLS
+];
 
 // src/utils/timestamp.ts
 var DAY_MS = 864e5;
+var RUNTIME_STORAGE_DAY_OFFSET_MS = 6 * 60 * 60 * 1e3;
 var toMs = (ts) => ts < 1e12 ? ts * 1e3 : ts;
 var getTimestamp = (days = 0) => {
   if (days > 0) {
@@ -56,12 +74,32 @@ var formatUnix = (dt) => {
   return (0, import_date_fns.format)(new Date(dt), "d MMM u HH:mm:ss");
 };
 var getBacktestPreloadStart = (start, preloadDays = BACKTEST_PRELOAD_DAYS) => Math.max(0, Math.trunc(start - preloadDays * DAY_MS));
+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;
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   formatUnix,
   getBacktestPreloadStart,
   getDataTimestamp,
   getItemTimestamp,
+  getRuntimeStorageDayKey,
+  getRuntimeStorageDayKeys,
   getTimestamp,
   toMs
 });

package/dist/time.mjs

@@ -3,15 +3,19 @@ import {
   getBacktestPreloadStart,
   getDataTimestamp,
   getItemTimestamp,
+  getRuntimeStorageDayKey,
+  getRuntimeStorageDayKeys,
   getTimestamp,
   toMs
-} from "./chunk-FNLPYYML.mjs";
-import "./chunk-2ORZC66W.mjs";
+} from "./chunk-BOETNABM.mjs";
+import "./chunk-MKCQSB4H.mjs";
 export {
   formatUnix,
   getBacktestPreloadStart,
   getDataTimestamp,
   getItemTimestamp,
+  getRuntimeStorageDayKey,
+  getRuntimeStorageDayKeys,
   getTimestamp,
   toMs
 };

package/dist/trade.d.mts

@@ -0,0 +1,54 @@
+type ExecutionSlippageStage = 'entry' | 'exit';
+type ExecutionSlippageDirection = 'LONG' | 'SHORT';
+type ExecutionSlippageModelParams = {
+    baseSlippageBps?: number | null;
+    spreadBps?: number | null;
+    spreadMultiplier?: number | null;
+    marketImpactBps?: number | null;
+    delayRiskBps?: number | null;
+};
+type ExecutionSlippageBreakdown = {
+    baseSlippageBps: number;
+    spreadBps: number;
+    spreadMultiplier: number;
+    spreadSlippageBps: number;
+    marketImpactBps: number;
+    delayRiskBps: number;
+    effectiveSlippageBps: number;
+};
+type ExecutionDelayRiskParams = {
+    closes?: unknown[] | null;
+    candles?: unknown[] | null;
+    intervalMs?: number | null;
+    expectedDelayMs?: number | null;
+    lookbackCandles?: number | null;
+    multiplier?: number | null;
+    maxBps?: number | null;
+};
+type ApplyExecutionSlippageParams = ExecutionSlippageModelParams & {
+    price: number;
+    direction: ExecutionSlippageDirection;
+    stage: ExecutionSlippageStage;
+};
+declare const calculateEffectiveSlippageBps: ({ baseSlippageBps, spreadBps, spreadMultiplier, marketImpactBps, delayRiskBps, }?: ExecutionSlippageModelParams) => number;
+declare const calculateExecutionSlippageBreakdown: ({ baseSlippageBps, spreadBps, spreadMultiplier, marketImpactBps, delayRiskBps, }?: ExecutionSlippageModelParams) => ExecutionSlippageBreakdown;
+declare const calculateDelayRiskBps: ({ closes, candles, intervalMs, expectedDelayMs, lookbackCandles, multiplier, maxBps, }?: ExecutionDelayRiskParams) => number | null;
+declare const slippageBpsToRate: (slippageBps: number) => number;
+declare const applyExecutionSlippage: ({ price, direction, stage, ...modelParams }: ApplyExecutionSlippageParams) => number;
+declare const extractExecutionSpreadBps: (signal?: {
+    additionalIndicators?: Record<string, unknown>;
+}) => number | null;
+declare const extractExecutionMarketImpactBps: (signal?: {
+    additionalIndicators?: Record<string, unknown>;
+}) => number | null;
+declare const extractExecutionDelayRiskBps: (signal?: {
+    interval?: unknown;
+    indicators?: Record<string, unknown>;
+    additionalIndicators?: Record<string, unknown>;
+}) => number | null;
+
+declare const normalizeStrategyOrderLinkKey: (strategyName: string | null | undefined) => string | null;
+declare const createRuntimeOrderLinkPrefix: (strategyName: string | null | undefined) => string;
+declare const parseStrategyOrderLinkKey: (orderLinkId: string | null | undefined) => string | null;
+
+export { type ApplyExecutionSlippageParams, type ExecutionDelayRiskParams, type ExecutionSlippageBreakdown, type ExecutionSlippageDirection, type ExecutionSlippageModelParams, type ExecutionSlippageStage, applyExecutionSlippage, calculateDelayRiskBps, calculateEffectiveSlippageBps, calculateExecutionSlippageBreakdown, createRuntimeOrderLinkPrefix, extractExecutionDelayRiskBps, extractExecutionMarketImpactBps, extractExecutionSpreadBps, normalizeStrategyOrderLinkKey, parseStrategyOrderLinkKey, slippageBpsToRate };

package/dist/trade.d.ts

@@ -0,0 +1,54 @@
+type ExecutionSlippageStage = 'entry' | 'exit';
+type ExecutionSlippageDirection = 'LONG' | 'SHORT';
+type ExecutionSlippageModelParams = {
+    baseSlippageBps?: number | null;
+    spreadBps?: number | null;
+    spreadMultiplier?: number | null;
+    marketImpactBps?: number | null;
+    delayRiskBps?: number | null;
+};
+type ExecutionSlippageBreakdown = {
+    baseSlippageBps: number;
+    spreadBps: number;
+    spreadMultiplier: number;
+    spreadSlippageBps: number;
+    marketImpactBps: number;
+    delayRiskBps: number;
+    effectiveSlippageBps: number;
+};
+type ExecutionDelayRiskParams = {
+    closes?: unknown[] | null;
+    candles?: unknown[] | null;
+    intervalMs?: number | null;
+    expectedDelayMs?: number | null;
+    lookbackCandles?: number | null;
+    multiplier?: number | null;
+    maxBps?: number | null;
+};
+type ApplyExecutionSlippageParams = ExecutionSlippageModelParams & {
+    price: number;
+    direction: ExecutionSlippageDirection;
+    stage: ExecutionSlippageStage;
+};
+declare const calculateEffectiveSlippageBps: ({ baseSlippageBps, spreadBps, spreadMultiplier, marketImpactBps, delayRiskBps, }?: ExecutionSlippageModelParams) => number;
+declare const calculateExecutionSlippageBreakdown: ({ baseSlippageBps, spreadBps, spreadMultiplier, marketImpactBps, delayRiskBps, }?: ExecutionSlippageModelParams) => ExecutionSlippageBreakdown;
+declare const calculateDelayRiskBps: ({ closes, candles, intervalMs, expectedDelayMs, lookbackCandles, multiplier, maxBps, }?: ExecutionDelayRiskParams) => number | null;
+declare const slippageBpsToRate: (slippageBps: number) => number;
+declare const applyExecutionSlippage: ({ price, direction, stage, ...modelParams }: ApplyExecutionSlippageParams) => number;
+declare const extractExecutionSpreadBps: (signal?: {
+    additionalIndicators?: Record<string, unknown>;
+}) => number | null;
+declare const extractExecutionMarketImpactBps: (signal?: {
+    additionalIndicators?: Record<string, unknown>;
+}) => number | null;
+declare const extractExecutionDelayRiskBps: (signal?: {
+    interval?: unknown;
+    indicators?: Record<string, unknown>;
+    additionalIndicators?: Record<string, unknown>;
+}) => number | null;
+
+declare const normalizeStrategyOrderLinkKey: (strategyName: string | null | undefined) => string | null;
+declare const createRuntimeOrderLinkPrefix: (strategyName: string | null | undefined) => string;
+declare const parseStrategyOrderLinkKey: (orderLinkId: string | null | undefined) => string | null;
+
+export { type ApplyExecutionSlippageParams, type ExecutionDelayRiskParams, type ExecutionSlippageBreakdown, type ExecutionSlippageDirection, type ExecutionSlippageModelParams, type ExecutionSlippageStage, applyExecutionSlippage, calculateDelayRiskBps, calculateEffectiveSlippageBps, calculateExecutionSlippageBreakdown, createRuntimeOrderLinkPrefix, extractExecutionDelayRiskBps, extractExecutionMarketImpactBps, extractExecutionSpreadBps, normalizeStrategyOrderLinkKey, parseStrategyOrderLinkKey, slippageBpsToRate };

package/dist/trade.js

@@ -0,0 +1,352 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/trade.ts
+var trade_exports = {};
+__export(trade_exports, {
+  applyExecutionSlippage: () => applyExecutionSlippage,
+  calculateDelayRiskBps: () => calculateDelayRiskBps,
+  calculateEffectiveSlippageBps: () => calculateEffectiveSlippageBps,
+  calculateExecutionSlippageBreakdown: () => calculateExecutionSlippageBreakdown,
+  createRuntimeOrderLinkPrefix: () => createRuntimeOrderLinkPrefix,
+  extractExecutionDelayRiskBps: () => extractExecutionDelayRiskBps,
+  extractExecutionMarketImpactBps: () => extractExecutionMarketImpactBps,
+  extractExecutionSpreadBps: () => extractExecutionSpreadBps,
+  normalizeStrategyOrderLinkKey: () => normalizeStrategyOrderLinkKey,
+  parseStrategyOrderLinkKey: () => parseStrategyOrderLinkKey,
+  slippageBpsToRate: () => slippageBpsToRate
+});
+module.exports = __toCommonJS(trade_exports);
+
+// src/constants/index.ts
+var BACKTEST_BASE_SLIPPAGE_BPS = 10;
+var BACKTEST_SPREAD_SLIPPAGE_MULTIPLIER = 1;
+var BACKTEST_MARKET_IMPACT_BPS = 0;
+var BACKTEST_DELAY_RISK_LOOKBACK_CANDLES = 5;
+var BACKTEST_DELAY_RISK_MULTIPLIER = 0;
+var BACKTEST_DELAY_RISK_MAX_BPS = 0;
+var BACKTEST_EXPECTED_DELAY_MS = 0;
+var BACKTEST_EXECUTION_DELAY_MS = 5 * 6e4;
+var DERIVATIVES_CONTEXT_BASE_REFERENCE_SYMBOLS = [
+  "BTCUSDT",
+  "ETHUSDT"
+];
+var DERIVATIVES_CONTEXT_DEFAULT_EXTRA_REFERENCE_SYMBOLS = [
+  "BNBUSDT",
+  "SOLUSDT",
+  "TRXUSDT",
+  "XRPUSDT"
+];
+var DERIVATIVES_CONTEXT_REFERENCE_SYMBOLS = [
+  ...DERIVATIVES_CONTEXT_BASE_REFERENCE_SYMBOLS,
+  ...DERIVATIVES_CONTEXT_DEFAULT_EXTRA_REFERENCE_SYMBOLS
+];
+
+// src/utils/array.ts
+var import_lodash = __toESM(require("lodash"));
+var intervalToMs = (interval) => {
+  const minutes = {
+    "1": 1,
+    "3": 3,
+    "5": 5,
+    "15": 15,
+    "30": 30,
+    "60": 60,
+    "120": 120,
+    "240": 240,
+    "360": 360,
+    "720": 720
+  };
+  if (interval in minutes) {
+    return minutes[interval] * 60 * 1e3;
+  }
+  switch (interval) {
+    case "D":
+      return 24 * 60 * 60 * 1e3;
+    case "W":
+      return 7 * 24 * 60 * 60 * 1e3;
+    case "M":
+      return 30 * 24 * 60 * 60 * 1e3;
+    default:
+      throw new Error(`Unknown interval: ${interval}`);
+  }
+};
+
+// src/utils/executionSlippage.ts
+var toNonNegativeFiniteNumber = (value, fallback = 0) => typeof value === "number" && Number.isFinite(value) && value > 0 ? value : fallback;
+var toFiniteNumberOrNull = (value) => typeof value === "number" && Number.isFinite(value) ? value : null;
+var toRecord = (value) => value && typeof value === "object" ? value : null;
+var getMedian = (values) => {
+  if (!values.length) {
+    return null;
+  }
+  const sorted = [...values].sort((left, right) => left - right);
+  const middle = Math.floor(sorted.length / 2);
+  if (sorted.length % 2 === 0) {
+    const left = sorted[middle - 1];
+    const right = sorted[middle];
+    return left == null || right == null ? null : (left + right) / 2;
+  }
+  return sorted[middle] ?? null;
+};
+var extractCandleClose = (value) => {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value;
+  }
+  const record = toRecord(value);
+  return toFiniteNumberOrNull(record?.close);
+};
+var extractCloseSeries = ({
+  closes,
+  candles
+}) => {
+  const source = Array.isArray(closes) && closes.length ? closes : candles;
+  if (!Array.isArray(source)) {
+    return [];
+  }
+  return source.map(extractCandleClose).filter((value) => value != null && value > 0);
+};
+var getSignalIntervalMs = (interval) => {
+  if (typeof interval !== "string") {
+    return null;
+  }
+  try {
+    return intervalToMs(interval);
+  } catch {
+    return null;
+  }
+};
+var getSignalCandleSeries = (signal) => {
+  const indicators = toRecord(signal?.indicators);
+  if (!indicators) {
+    return null;
+  }
+  const intervalKey = (() => {
+    switch (signal?.interval) {
+      case "15":
+        return "candles15m";
+      case "60":
+        return "candles1h";
+      case "240":
+        return "candles4h";
+      case "D":
+        return "candles1d";
+      default:
+        return null;
+    }
+  })();
+  const keys = [
+    intervalKey,
+    "candles15m",
+    "candles1h",
+    "candles4h",
+    "candles1d"
+  ].filter((key) => Boolean(key));
+  for (const key of keys) {
+    const value = indicators[key];
+    if (Array.isArray(value) && value.length > 1) {
+      return value;
+    }
+  }
+  const candle = indicators.candle;
+  const prevCandle = indicators.prevCandle;
+  return prevCandle && candle ? [prevCandle, candle] : null;
+};
+var calculateEffectiveSlippageBps = ({
+  baseSlippageBps = BACKTEST_BASE_SLIPPAGE_BPS,
+  spreadBps,
+  spreadMultiplier = BACKTEST_SPREAD_SLIPPAGE_MULTIPLIER,
+  marketImpactBps = BACKTEST_MARKET_IMPACT_BPS,
+  delayRiskBps
+} = {}) => {
+  const base = toNonNegativeFiniteNumber(baseSlippageBps);
+  const spread = toNonNegativeFiniteNumber(spreadBps);
+  const multiplier = toNonNegativeFiniteNumber(spreadMultiplier);
+  const marketImpact = toNonNegativeFiniteNumber(marketImpactBps);
+  const delayRisk = toNonNegativeFiniteNumber(delayRiskBps);
+  return base + spread * multiplier + marketImpact + delayRisk;
+};
+var calculateExecutionSlippageBreakdown = ({
+  baseSlippageBps = BACKTEST_BASE_SLIPPAGE_BPS,
+  spreadBps,
+  spreadMultiplier = BACKTEST_SPREAD_SLIPPAGE_MULTIPLIER,
+  marketImpactBps = BACKTEST_MARKET_IMPACT_BPS,
+  delayRiskBps
+} = {}) => {
+  const base = toNonNegativeFiniteNumber(baseSlippageBps);
+  const spread = toNonNegativeFiniteNumber(spreadBps);
+  const multiplier = toNonNegativeFiniteNumber(spreadMultiplier);
+  const spreadSlippage = spread * multiplier;
+  const marketImpact = toNonNegativeFiniteNumber(marketImpactBps);
+  const delayRisk = toNonNegativeFiniteNumber(delayRiskBps);
+  return {
+    baseSlippageBps: base,
+    spreadBps: spread,
+    spreadMultiplier: multiplier,
+    spreadSlippageBps: spreadSlippage,
+    marketImpactBps: marketImpact,
+    delayRiskBps: delayRisk,
+    effectiveSlippageBps: base + spreadSlippage + marketImpact + delayRisk
+  };
+};
+var calculateDelayRiskBps = ({
+  closes,
+  candles,
+  intervalMs,
+  expectedDelayMs = BACKTEST_EXPECTED_DELAY_MS,
+  lookbackCandles = BACKTEST_DELAY_RISK_LOOKBACK_CANDLES,
+  multiplier = BACKTEST_DELAY_RISK_MULTIPLIER,
+  maxBps = BACKTEST_DELAY_RISK_MAX_BPS
+} = {}) => {
+  const normalizedLookback = Math.max(
+    1,
+    Math.trunc(toNonNegativeFiniteNumber(lookbackCandles, 1))
+  );
+  const closeSeries = extractCloseSeries({ closes, candles }).slice(
+    -(normalizedLookback + 1)
+  );
+  if (closeSeries.length < 2) {
+    return null;
+  }
+  const moveBps = [];
+  for (let index = 1; index < closeSeries.length; index += 1) {
+    const previous = closeSeries[index - 1];
+    const current = closeSeries[index];
+    if (previous != null && current != null && previous > 0 && current > 0) {
+      moveBps.push(Math.abs(current / previous - 1) * 1e4);
+    }
+  }
+  const medianMoveBps = getMedian(moveBps);
+  if (medianMoveBps == null) {
+    return null;
+  }
+  const delayScale = typeof intervalMs === "number" && Number.isFinite(intervalMs) && intervalMs > 0 && typeof expectedDelayMs === "number" && Number.isFinite(expectedDelayMs) && expectedDelayMs > 0 ? Math.sqrt(expectedDelayMs / intervalMs) : 1;
+  const rawDelayRisk = medianMoveBps * delayScale * toNonNegativeFiniteNumber(multiplier);
+  const cappedDelayRisk = Math.min(
+    rawDelayRisk,
+    toNonNegativeFiniteNumber(maxBps, Number.POSITIVE_INFINITY)
+  );
+  return Number.isFinite(cappedDelayRisk) ? cappedDelayRisk : null;
+};
+var slippageBpsToRate = (slippageBps) => toNonNegativeFiniteNumber(slippageBps) / 1e4;
+var applyExecutionSlippage = ({
+  price,
+  direction,
+  stage,
+  ...modelParams
+}) => {
+  const slippageRate = slippageBpsToRate(
+    calculateExecutionSlippageBreakdown(modelParams).effectiveSlippageBps
+  );
+  if (!slippageRate) {
+    return price;
+  }
+  const sign = direction === "LONG" ? stage === "entry" ? 1 : -1 : stage === "entry" ? -1 : 1;
+  return price * (1 + sign * slippageRate);
+};
+var extractExecutionSpreadBps = (signal) => {
+  const additionalIndicators = toRecord(signal?.additionalIndicators);
+  const explicitSlippage = toRecord(additionalIndicators?.executionSlippage);
+  return toFiniteNumberOrNull(explicitSlippage?.spreadBps);
+};
+var extractExecutionMarketImpactBps = (signal) => {
+  const additionalIndicators = toRecord(signal?.additionalIndicators);
+  const explicitSlippage = toRecord(additionalIndicators?.executionSlippage);
+  return toFiniteNumberOrNull(explicitSlippage?.marketImpactBps);
+};
+var extractExecutionDelayRiskBps = (signal) => {
+  const additionalIndicators = toRecord(signal?.additionalIndicators);
+  const explicitSlippage = toRecord(additionalIndicators?.executionSlippage);
+  const explicitDelayRisk = toFiniteNumberOrNull(
+    explicitSlippage?.delayRiskBps
+  );
+  if (explicitDelayRisk != null) {
+    return explicitDelayRisk;
+  }
+  return calculateDelayRiskBps({
+    candles: getSignalCandleSeries(signal),
+    intervalMs: getSignalIntervalMs(signal?.interval)
+  });
+};
+
+// src/trade.ts
+var ORDER_LINK_PREFIX = "tjs-";
+var ORDER_LINK_SEPARATOR = "--";
+var STRATEGY_SLUG_LENGTH = 10;
+var STRATEGY_HASH_LENGTH = 5;
+var toBase36Hash = (value) => {
+  let hash = 0;
+  for (let index = 0; index < value.length; index += 1) {
+    hash = hash * 31 + value.charCodeAt(index) >>> 0;
+  }
+  return hash.toString(36).padStart(STRATEGY_HASH_LENGTH, "0");
+};
+var normalizeStrategyOrderLinkKey = (strategyName) => {
+  const normalized = String(strategyName ?? "").trim().toLowerCase();
+  if (!normalized) {
+    return null;
+  }
+  const slug = normalized.replace(/[^a-z0-9]+/g, "").slice(0, STRATEGY_SLUG_LENGTH) || "strategy";
+  const hash = toBase36Hash(normalized).slice(0, STRATEGY_HASH_LENGTH);
+  return `${slug}-${hash}`;
+};
+var createRuntimeOrderLinkPrefix = (strategyName) => {
+  const strategyKey = normalizeStrategyOrderLinkKey(strategyName);
+  return strategyKey ? `${ORDER_LINK_PREFIX}${strategyKey}${ORDER_LINK_SEPARATOR}` : ORDER_LINK_PREFIX;
+};
+var parseStrategyOrderLinkKey = (orderLinkId) => {
+  const normalized = String(orderLinkId ?? "").trim().toLowerCase();
+  if (!normalized.startsWith(ORDER_LINK_PREFIX)) {
+    return null;
+  }
+  const remainder = normalized.slice(ORDER_LINK_PREFIX.length);
+  const separatorIndex = remainder.indexOf(ORDER_LINK_SEPARATOR);
+  if (separatorIndex <= 0) {
+    return null;
+  }
+  const strategyPart = remainder.slice(0, separatorIndex).trim();
+  if (!strategyPart) {
+    return null;
+  }
+  return strategyPart;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  applyExecutionSlippage,
+  calculateDelayRiskBps,
+  calculateEffectiveSlippageBps,
+  calculateExecutionSlippageBreakdown,
+  createRuntimeOrderLinkPrefix,
+  extractExecutionDelayRiskBps,
+  extractExecutionMarketImpactBps,
+  extractExecutionSpreadBps,
+  normalizeStrategyOrderLinkKey,
+  parseStrategyOrderLinkKey,
+  slippageBpsToRate
+});