@tradejs/strategies 1.0.5 → 1.0.6

package/dist/strategy-LC2FSFVN.mjs

@@ -0,0 +1,470 @@
+import {
+  buildReverseTrendlineStructuralContext,
+  buildReverseTrendlineTimingContext,
+  config,
+  reverseTrendLineManifest,
+  toFiniteNumberOrNull
+} from "./chunk-GNQJ5TVU.mjs";
+import "./chunk-HEBXNMVQ.mjs";
+
+// src/ReverseTrendLine/strategy.ts
+import { createStrategyRuntime } from "@tradejs/node/strategies";
+
+// src/ReverseTrendLine/core.ts
+import { round as round2 } from "@tradejs/core/math";
+import { createTrendlineEngine } from "@tradejs/core/indicators";
+
+// src/ReverseTrendLine/filters.ts
+import { diffRel } from "@tradejs/core/math";
+var MAX_CANDLE_VOLATILITY = 0.025;
+var filterByVeryVolatility = (data) => {
+  const lastCandle = data[data.length - 1];
+  const prevCandle = data[data.length - 2];
+  if (!lastCandle || !prevCandle) {
+    return false;
+  }
+  const isVeryVolatility = diffRel(lastCandle.low, lastCandle.high) > MAX_CANDLE_VOLATILITY || diffRel(prevCandle.low, prevCandle.high) > MAX_CANDLE_VOLATILITY;
+  return !isVeryVolatility;
+};
+
+// src/ReverseTrendLine/figures.ts
+var buildReverseTrendLineFigures = (bestLine) => ({
+  lines: [
+    {
+      id: bestLine.id,
+      kind: "trendline",
+      points: [...bestLine.points ?? []].sort(
+        (left, right) => left.timestamp - right.timestamp
+      ),
+      color: bestLine.mode === "lows" ? "#22c55e" : "#f97316",
+      width: 2,
+      style: "solid"
+    }
+  ],
+  points: [
+    {
+      id: `${bestLine.id}-points`,
+      kind: "trendline_points",
+      points: [...bestLine.points ?? [], ...bestLine.touches ?? []].sort(
+        (left, right) => left.timestamp - right.timestamp
+      ),
+      color: "#ef4444",
+      radius: 4
+    }
+  ]
+});
+
+// src/ReverseTrendLine/risk.ts
+import { round } from "@tradejs/core/math";
+var MIN_STOP_BUFFER_PCT = 0.1;
+var LINE_BUFFER_ATR_FACTOR = 0.25;
+var LINE_BUFFER_BASE_SL_FACTOR = 0.1;
+var ATR_STOP_FLOOR_FACTOR = 0.65;
+var MIN_STOP_LOSS_FACTOR = 0.8;
+var MAX_STOP_LOSS_FACTOR = 2;
+var clampNumber = (value, min, max) => Math.min(Math.max(value, min), max);
+var getTimingStopFactor = (entryTiming) => {
+  if (entryTiming === "ready_follow_through") {
+    return 0.95;
+  }
+  return 1;
+};
+var getTimingTargetRiskRatio = ({
+  direction,
+  entryTiming
+}) => {
+  if (direction === "LONG") {
+    return entryTiming === "ready_follow_through" ? 2.15 : 1.95;
+  }
+  return entryTiming === "ready_follow_through" ? 2.2 : 2;
+};
+var buildReverseTrendlineRiskPlan = ({
+  direction,
+  modeConfig,
+  structuralContext,
+  timingContext
+}) => {
+  const baseStopLossDelta = modeConfig.SL;
+  const atrPct = structuralContext.atrPct ?? baseStopLossDelta;
+  const priceVsLinePctAbs = structuralContext.priceVsLinePctAbs ?? 0;
+  const rejectionStrengthPct = structuralContext.rejectionStrengthPct ?? 0;
+  const touches = structuralContext.touches ?? 0;
+  const distance = structuralContext.distance ?? null;
+  const lineBufferPct = Math.max(
+    atrPct * LINE_BUFFER_ATR_FACTOR,
+    baseStopLossDelta * LINE_BUFFER_BASE_SL_FACTOR,
+    MIN_STOP_BUFFER_PCT
+  );
+  const lineInvalidationPct = priceVsLinePctAbs + lineBufferPct;
+  const volatilityFloorPct = Math.max(
+    atrPct * ATR_STOP_FLOOR_FACTOR,
+    baseStopLossDelta * MIN_STOP_LOSS_FACTOR
+  );
+  let stopLossDelta = Math.max(lineInvalidationPct, volatilityFloorPct);
+  if (touches >= 6) {
+    stopLossDelta *= 0.95;
+  } else if (touches > 0 && touches <= 4) {
+    stopLossDelta *= 1.03;
+  }
+  if (distance != null && distance >= 400) {
+    stopLossDelta *= 1.05;
+  } else if (distance != null && distance <= 120) {
+    stopLossDelta *= 0.95;
+  }
+  if (rejectionStrengthPct >= 0.2) {
+    stopLossDelta *= 0.95;
+  }
+  stopLossDelta *= getTimingStopFactor(timingContext.entryTiming);
+  stopLossDelta = clampNumber(
+    stopLossDelta,
+    baseStopLossDelta * MIN_STOP_LOSS_FACTOR,
+    baseStopLossDelta * MAX_STOP_LOSS_FACTOR
+  );
+  let targetRiskRatio = getTimingTargetRiskRatio({
+    direction,
+    entryTiming: timingContext.entryTiming
+  });
+  if (touches >= 6) {
+    targetRiskRatio += 0.1;
+  }
+  if (distance != null && distance >= 120 && distance <= 350) {
+    targetRiskRatio += 0.05;
+  }
+  if (direction === "SHORT" && distance != null && distance > 500) {
+    targetRiskRatio -= 0.15;
+  }
+  if (direction === "LONG" && distance != null && distance > 500) {
+    targetRiskRatio -= 0.1;
+  }
+  const minTargetRiskRatio = modeConfig.minRiskRatio + 0.05;
+  const maxTargetRiskRatio = Math.max(modeConfig.TP / modeConfig.SL, minTargetRiskRatio) + 0.3;
+  targetRiskRatio = clampNumber(
+    targetRiskRatio,
+    minTargetRiskRatio,
+    maxTargetRiskRatio
+  );
+  return {
+    stopLossDelta: round(stopLossDelta, 3),
+    targetRiskRatio: round(targetRiskRatio, 2),
+    takeProfitDelta: round(stopLossDelta * targetRiskRatio, 3)
+  };
+};
+
+// src/ReverseTrendLine/core.ts
+var BREAK_EVEN_TRIGGER_RISK_MULTIPLIER = 0.5;
+var buildReverseTrendlineSignalSeed = ({
+  direction,
+  currentPrice,
+  indicators,
+  bestLine,
+  currentCandle,
+  reverseTrendlineTiming
+}) => ({
+  direction,
+  prices: { currentPrice },
+  indicators,
+  additionalIndicators: {
+    touches: Array.isArray(bestLine.touches) ? bestLine.touches.length + 2 : 2,
+    distance: bestLine.distance,
+    trendLine: bestLine,
+    ...currentCandle ? { currentCandle } : {},
+    ...reverseTrendlineTiming ? { reverseTrendlineTiming } : {}
+  },
+  figures: {
+    trendLine: bestLine
+  }
+});
+var isOpenPosition = (position) => Boolean(
+  position && typeof position.price === "number" && Number.isFinite(position.price) && typeof position.qty === "number" && Number.isFinite(position.qty) && position.qty > 0 && (position.direction === "LONG" || position.direction === "SHORT")
+);
+var getFavorableMovePct = ({
+  direction,
+  entryPrice,
+  currentPrice
+}) => {
+  if (!Number.isFinite(entryPrice) || !Number.isFinite(currentPrice) || entryPrice <= 0) {
+    return null;
+  }
+  return direction === "LONG" ? (currentPrice - entryPrice) / entryPrice * 100 : (entryPrice - currentPrice) / entryPrice * 100;
+};
+var getPositionStopLossPrice = (position) => {
+  if (!position || typeof position !== "object") {
+    return null;
+  }
+  const slPrice = Number(
+    position.slPrice ?? Number.NaN
+  );
+  if (Number.isFinite(slPrice)) {
+    return slPrice;
+  }
+  const signalStopLossPrice = Number(
+    position.signal?.prices?.stopLossPrice ?? Number.NaN
+  );
+  return Number.isFinite(signalStopLossPrice) ? signalStopLossPrice : null;
+};
+var getPositionRiskPct = ({
+  direction,
+  entryPrice,
+  stopLossPrice
+}) => {
+  if (stopLossPrice == null || !Number.isFinite(entryPrice) || !Number.isFinite(stopLossPrice) || entryPrice <= 0) {
+    return null;
+  }
+  return direction === "LONG" ? (entryPrice - stopLossPrice) / entryPrice * 100 : (stopLossPrice - entryPrice) / entryPrice * 100;
+};
+var isBreakEvenStopAlreadyApplied = ({
+  direction,
+  entryPrice,
+  stopLossPrice
+}) => {
+  if (stopLossPrice == null || !Number.isFinite(entryPrice) || !Number.isFinite(stopLossPrice)) {
+    return false;
+  }
+  return direction === "LONG" ? stopLossPrice >= entryPrice : stopLossPrice <= entryPrice;
+};
+var getLinePriceAtNow = (line, timestamp) => {
+  if (!line || !Array.isArray(line.points) || line.points.length === 0) {
+    return null;
+  }
+  const sortedPoints = [...line.points].sort(
+    (left, right) => left.timestamp - right.timestamp
+  );
+  const first = sortedPoints[0];
+  const last = sortedPoints[sortedPoints.length - 1];
+  if (first.timestamp === last.timestamp) {
+    return last.value;
+  }
+  const slope = (last.value - first.value) / (last.timestamp - first.timestamp);
+  return first.value + slope * (timestamp - first.timestamp);
+};
+var buildReverseTrendlineCandidateContext = ({
+  line,
+  candle,
+  direction
+}) => {
+  const currentLinePrice = getLinePriceAtNow(line, candle.timestamp);
+  const priceVsLinePct = currentLinePrice != null && currentLinePrice !== 0 ? (candle.close - currentLinePrice) / currentLinePrice * 100 : null;
+  const priceVsLinePctAbs = priceVsLinePct == null ? null : Math.abs(priceVsLinePct);
+  const lineTouchedNow = currentLinePrice != null && candle.low <= currentLinePrice && candle.high >= currentLinePrice;
+  const failedBounceBreak = direction === "LONG" ? priceVsLinePct != null && priceVsLinePct <= -0.35 : priceVsLinePct != null && priceVsLinePct >= 0.35;
+  return {
+    currentLinePrice,
+    priceVsLinePctAbs,
+    lineTouchedNow,
+    failedBounceBreak,
+    distance: toFiniteNumberOrNull(line.distance)
+  };
+};
+var pickBestCandidateLine = ({
+  candle,
+  lines
+}) => {
+  const ranked = lines.map(({ line, direction }) => {
+    const candidateContext = buildReverseTrendlineCandidateContext({
+      line,
+      candle,
+      direction
+    });
+    return { line, direction, candidateContext };
+  }).filter(({ candidateContext }) => candidateContext.currentLinePrice != null).sort((left, right) => {
+    const leftTouchRank = left.candidateContext.lineTouchedNow ? 0 : 1;
+    const rightTouchRank = right.candidateContext.lineTouchedNow ? 0 : 1;
+    if (leftTouchRank !== rightTouchRank) {
+      return leftTouchRank - rightTouchRank;
+    }
+    const leftDistance = left.candidateContext.priceVsLinePctAbs ?? Number.POSITIVE_INFINITY;
+    const rightDistance = right.candidateContext.priceVsLinePctAbs ?? Number.POSITIVE_INFINITY;
+    if (leftDistance !== rightDistance) {
+      return leftDistance - rightDistance;
+    }
+    return (left.candidateContext.distance ?? Number.POSITIVE_INFINITY) - (right.candidateContext.distance ?? Number.POSITIVE_INFINITY);
+  });
+  return ranked[0] ?? null;
+};
+var createReverseTrendLineCore = async ({ config: config2, data: cachedData, strategyApi, indicatorsState }) => {
+  const { TRENDLINE, FEE_PERCENT, MAX_LOSS_VALUE, HIGHS, LOWS } = config2;
+  const lastTradeController = strategyApi.createLastTradeController();
+  const trendlineOptions = {
+    bestLines: 1,
+    capture: true,
+    ...TRENDLINE
+  };
+  const getLowsTrendlines = createTrendlineEngine(cachedData, {
+    mode: "lows",
+    ...trendlineOptions
+  });
+  const getHighsTrendlines = createTrendlineEngine(cachedData, {
+    mode: "highs",
+    ...trendlineOptions
+  });
+  return async (candle) => {
+    const lowsTrendlines = getLowsTrendlines.next(candle);
+    const highsTrendlines = getHighsTrendlines.next(candle);
+    indicatorsState.onBar();
+    const currentPosition = await strategyApi.getCurrentPosition();
+    if (isOpenPosition(currentPosition)) {
+      const activeLine = currentPosition.direction === "LONG" ? lowsTrendlines[0] : highsTrendlines[0];
+      const activeModeConfig = currentPosition.direction === "LONG" ? LOWS : HIGHS;
+      const activeLinePrice = getLinePriceAtNow(
+        activeLine ?? null,
+        candle.timestamp
+      );
+      const priceVsLinePct = activeLinePrice != null && activeLinePrice !== 0 ? (candle.close - activeLinePrice) / activeLinePrice * 100 : null;
+      const failedBounceBreak = currentPosition.direction === "LONG" ? priceVsLinePct != null && priceVsLinePct <= -0.35 : priceVsLinePct != null && priceVsLinePct >= 0.35;
+      if (failedBounceBreak) {
+        return strategyApi.exit({
+          code: "REVERSE_TRENDLINE_FAILED_BOUNCE_EXIT",
+          direction: currentPosition.direction
+        });
+      }
+      const favorableMovePct = getFavorableMovePct({
+        direction: currentPosition.direction,
+        entryPrice: currentPosition.price,
+        currentPrice: candle.close
+      });
+      const currentStopLossPrice = getPositionStopLossPrice(currentPosition);
+      const currentPositionRiskPct = getPositionRiskPct({
+        direction: currentPosition.direction,
+        entryPrice: currentPosition.price,
+        stopLossPrice: currentStopLossPrice
+      });
+      if (!isBreakEvenStopAlreadyApplied({
+        direction: currentPosition.direction,
+        entryPrice: currentPosition.price,
+        stopLossPrice: currentStopLossPrice
+      }) && favorableMovePct != null && favorableMovePct >= (currentPositionRiskPct ?? activeModeConfig.SL) * BREAK_EVEN_TRIGGER_RISK_MULTIPLIER) {
+        return strategyApi.protect({
+          code: "REVERSE_TRENDLINE_MOVE_STOP_TO_BREAK_EVEN",
+          protectPlan: {
+            direction: currentPosition.direction,
+            stopLossPrice: currentPosition.price
+          }
+        });
+      }
+      return strategyApi.skip("POSITION_EXISTS");
+    }
+    if (lastTradeController.isInCooldown(candle.timestamp)) {
+      return strategyApi.skip("DEV_TRADE_COOLDOWN");
+    }
+    const candidates = [];
+    if (LOWS.enable && lowsTrendlines.length > 0) {
+      candidates.push({ line: lowsTrendlines[0], direction: LOWS.direction });
+    }
+    if (HIGHS.enable && highsTrendlines.length > 0) {
+      candidates.push({ line: highsTrendlines[0], direction: HIGHS.direction });
+    }
+    if (candidates.length === 0) {
+      return strategyApi.skip("NO_TRENDLINE");
+    }
+    const bestCandidate = pickBestCandidateLine({
+      candle: {
+        timestamp: candle.timestamp,
+        open: candle.open,
+        close: candle.close,
+        high: candle.high,
+        low: candle.low
+      },
+      lines: candidates
+    });
+    if (!bestCandidate) {
+      return strategyApi.skip("NO_TRENDLINE");
+    }
+    const { line: bestLine, direction, candidateContext } = bestCandidate;
+    const modeConfig = direction === "LONG" ? LOWS : HIGHS;
+    const { minRiskRatio } = modeConfig;
+    if (candidateContext.failedBounceBreak) {
+      return strategyApi.skip(
+        "REVERSE_TRENDLINE_STRUCTURE:failed_bounce_break"
+      );
+    }
+    const { fullData, timestamp, currentPrice } = await strategyApi.getMarketData();
+    if (!filterByVeryVolatility(fullData)) {
+      return strategyApi.skip("VERY_VOLATILITY");
+    }
+    const indicators = indicatorsState.snapshot();
+    const signalSeed = buildReverseTrendlineSignalSeed({
+      direction,
+      currentPrice,
+      indicators,
+      bestLine,
+      currentCandle: {
+        timestamp: candle.timestamp,
+        open: candle.open,
+        close: candle.close,
+        high: candle.high,
+        low: candle.low
+      }
+    });
+    const structuralContext = buildReverseTrendlineStructuralContext(signalSeed);
+    const timingContext = buildReverseTrendlineTimingContext({
+      signal: signalSeed,
+      candles: fullData,
+      structuralContext
+    });
+    if (!timingContext.entryReadyNow) {
+      const timingCode = timingContext.entryTiming === "stale_reaction" ? "STALE_REACTION" : timingContext.entryTiming === "wait_reaction_confirmation" ? "WAIT_REACTION_CONFIRMATION" : "WAIT_TOUCH";
+      return strategyApi.skip(`REVERSE_TRENDLINE_TIMING:${timingCode}`);
+    }
+    const riskPlan = buildReverseTrendlineRiskPlan({
+      direction,
+      modeConfig,
+      structuralContext,
+      timingContext
+    });
+    const { stopLossPrice, takeProfitPrice, riskRatio, qty } = strategyApi.getDirectionalTpSlPrices({
+      price: currentPrice,
+      direction,
+      takeProfitDelta: riskPlan.takeProfitDelta,
+      stopLossDelta: riskPlan.stopLossDelta,
+      unit: "percent",
+      maxLossValue: MAX_LOSS_VALUE,
+      feePercent: Number(FEE_PERCENT ?? 0)
+    });
+    if (!qty || !Number.isFinite(qty) || qty <= 0) {
+      return strategyApi.skip("INVALID_QTY");
+    }
+    if (riskRatio <= minRiskRatio) {
+      return strategyApi.skip(`RISK_RATIO:${round2(riskRatio)}`);
+    }
+    lastTradeController.markTrade(timestamp);
+    return strategyApi.entry({
+      code: "REVERSE_TRENDLINE_SIGNAL",
+      figures: {
+        ...buildReverseTrendLineFigures(bestLine)
+      },
+      direction,
+      indicators,
+      additionalIndicators: buildReverseTrendlineSignalSeed({
+        direction,
+        currentPrice,
+        indicators,
+        bestLine,
+        currentCandle: {
+          timestamp: candle.timestamp,
+          open: candle.open,
+          close: candle.close,
+          high: candle.high,
+          low: candle.low
+        },
+        reverseTrendlineTiming: timingContext
+      }).additionalIndicators,
+      orderPlan: {
+        qty,
+        stopLossPrice,
+        takeProfits: [{ rate: 1, price: takeProfitPrice }]
+      }
+    });
+  };
+};
+
+// src/ReverseTrendLine/strategy.ts
+var ReverseTrendLineStrategyCreator = createStrategyRuntime({
+  strategyName: "ReverseTrendLine",
+  defaults: config,
+  createCore: createReverseTrendLineCore,
+  manifest: reverseTrendLineManifest,
+  strategyDirectory: __dirname
+});
+export {
+  ReverseTrendLineStrategyCreator
+};

package/dist/{strategy-UHRWSGZC.mjs → strategy-OI4WRB3S.mjs}

@@ -1,6 +1,6 @@
 import {
   adaptiveMomentumRibbonManifest
-} from "./chunk-RYEPHOGL.mjs";
+} from "./chunk-MOBKL73M.mjs";
 import {
   __commonJS,
   __esm,
@@ -3233,9 +3233,9 @@ var require_buffer_list = __commonJS({
   }
 });
 
-// ../../node_modules/safe-buffer/index.js
+// ../../node_modules/readable-stream/node_modules/safe-buffer/index.js
 var require_safe_buffer = __commonJS({
-  "../../node_modules/safe-buffer/index.js"(exports, module) {
+  "../../node_modules/readable-stream/node_modules/safe-buffer/index.js"(exports, module) {
     "use strict";
     var buffer = __require("buffer");
     var Buffer2 = buffer.Buffer;
@@ -10925,6 +10925,8 @@ var config = {
   ML_ENABLED: false,
   ML_THRESHOLD: 0.1,
   MIN_AI_QUALITY: 3,
+  FEE_PERCENT: 5e-3,
+  MAX_LOSS_VALUE: 10,
   AMR_LOOKBACK_BARS: 400,
   AMR_MOMENTUM_PERIOD: 20,
   AMR_BUTTERWORTH_SMOOTHING: 3,
@@ -10953,9 +10955,8 @@ var config = {
 
 // src/AdaptiveMomentumRibbon/core.ts
 import {
-  asPineBoolean,
-  asFiniteNumber as asFiniteNumber2,
-  getLatestPinePlotValue,
+  getLatestPineBooleanPlotValues,
+  getLatestPineNumberPlotValues,
   runPineScript
 } from "@tradejs/node/pine";
 import { asPositiveInt, asPositiveNumber } from "@tradejs/core/math";
@@ -11001,8 +11002,8 @@ var logger = (0, import_winston.createLogger)({
 
 // src/AdaptiveMomentumRibbon/figures.ts
 import {
-  asFiniteNumber,
-  getPinePlotSeries
+  getPinePlotSeries,
+  toFiniteNumber
 } from "@tradejs/node/pine";
 var DEFAULT_COLORS = ["#2962ff", "#f23645", "#089981", "#f59e0b"];
 var LINE_STYLE_BY_PLOT = {
@@ -11032,8 +11033,8 @@ var toFigurePoints = (series, maxPoints) => {
   const points = [];
   for (let i = start; i < series.length; i += 1) {
     const item = series[i];
-    const timestamp = asFiniteNumber(item?.time);
-    const value = asFiniteNumber(item?.value);
+    const timestamp = toFiniteNumber(item?.time);
+    const value = toFiniteNumber(item?.value);
     if (timestamp == null || value == null) continue;
     points.push({
       timestamp,
@@ -11085,6 +11086,20 @@ var buildAdaptiveMomentumRibbonFigures = ({
 
 // src/AdaptiveMomentumRibbon/core.ts
 var AMR_PINE_FILE_NAME = "adaptiveMomentumRibbon.pine";
+var AMR_BOOLEAN_PLOTS = [
+  "entryLong",
+  "entryShort",
+  "invalidated",
+  "activeBuy",
+  "activeSell"
+];
+var AMR_NUMBER_PLOTS = [
+  "signalOsc",
+  "kcMidline",
+  "kcUpper",
+  "kcLower",
+  "invalidationLevel"
+];
 var asKcMaType = (value) => {
   if (value === "SMA" || value === "EMA" || value === "SMMA (RMA)" || value === "WMA" || value === "VWMA") {
     return value;
@@ -11108,38 +11123,16 @@ var resolveLinePlots = (value) => {
   }
   return value.map((item) => String(item ?? "").trim()).filter((item) => item.length > 0);
 };
-var getLookbackCandles = (candles, lookbackBars) => {
-  if (lookbackBars <= 0) {
-    return candles;
-  }
-  return candles.slice(-lookbackBars);
-};
-var readBooleanPlot = (pineContext, plotName) => asPineBoolean(getLatestPinePlotValue(pineContext, plotName));
-var readNumericPlot = (pineContext, plotName) => asFiniteNumber2(getLatestPinePlotValue(pineContext, plotName)) ?? null;
 var readAmrSnapshot = (pineContext, linePlots) => {
-  const lineValues = Object.fromEntries(
-    linePlots.map((plotName) => [
-      plotName,
-      readNumericPlot(pineContext, plotName)
-    ])
-  );
   return {
-    entryLong: readBooleanPlot(pineContext, "entryLong"),
-    entryShort: readBooleanPlot(pineContext, "entryShort"),
-    invalidated: readBooleanPlot(pineContext, "invalidated"),
-    activeBuy: readBooleanPlot(pineContext, "activeBuy"),
-    activeSell: readBooleanPlot(pineContext, "activeSell"),
-    signalOsc: readNumericPlot(pineContext, "signalOsc"),
-    kcMidline: readNumericPlot(pineContext, "kcMidline"),
-    kcUpper: readNumericPlot(pineContext, "kcUpper"),
-    kcLower: readNumericPlot(pineContext, "kcLower"),
-    invalidationLevel: readNumericPlot(pineContext, "invalidationLevel"),
-    lineValues
+    ...getLatestPineBooleanPlotValues(pineContext, AMR_BOOLEAN_PLOTS),
+    ...getLatestPineNumberPlotValues(pineContext, AMR_NUMBER_PLOTS),
+    lineValues: getLatestPineNumberPlotValues(pineContext, linePlots)
   };
 };
-var createAdaptiveMomentumRibbonCore = async ({ config: config2, symbol, loadPineScript, strategyApi }) => {
-  const script = loadPineScript(AMR_PINE_FILE_NAME);
-  const { LONG, SHORT, AMR_EXIT_ON_INVALIDATION } = config2;
+var createAdaptiveMomentumRibbonCore = async ({ config: config2, symbol, loadPineScriptFile, strategyApi }) => {
+  const script = loadPineScriptFile(AMR_PINE_FILE_NAME);
+  const { LONG, SHORT, AMR_EXIT_ON_INVALIDATION, MAX_LOSS_VALUE, FEE_PERCENT } = config2;
   const linePlots = resolveLinePlots(config2.AMR_LINE_PLOTS);
   const lookbackBars = asPositiveInt(config2.AMR_LOOKBACK_BARS, 0);
   const pineInputs = resolveAmrInputs(config2);
@@ -11156,7 +11149,7 @@ var createAdaptiveMomentumRibbonCore = async ({ config: config2, symbol, loadPin
     const positionExists = Boolean(
       position && typeof position.qty === "number" && position.qty > 0
     );
-    const candles = getLookbackCandles(fullData, lookbackBars);
+    const candles = lookbackBars > 0 ? fullData.slice(-lookbackBars) : fullData;
     let pineContext;
     try {
       pineContext = await runPineScript({
@@ -11217,7 +11210,9 @@ var createAdaptiveMomentumRibbonCore = async ({ config: config2, symbol, loadPin
       direction: modeConfig.direction,
       takeProfitDelta: modeConfig.TP,
       stopLossDelta: modeConfig.SL,
-      unit: "percent"
+      unit: "percent",
+      maxLossValue: MAX_LOSS_VALUE,
+      feePercent: Number(FEE_PERCENT ?? 0)
     });
     if (!qty || !Number.isFinite(qty) || qty <= 0) {
       return strategyApi.skip("INVALID_QTY");
@@ -11233,7 +11228,22 @@ var createAdaptiveMomentumRibbonCore = async ({ config: config2, symbol, loadPin
         entryPrice: currentPrice
       }),
       additionalIndicators: {
-        amr
+        amr,
+        amrSignalTiming: {
+          entryTiming: "zero_cross",
+          waitClose: Boolean(config2.AMR_WAIT_CLOSE),
+          lookbackBars
+        },
+        amrConfigSnapshot: {
+          momentumPeriod: asPositiveInt(config2.AMR_MOMENTUM_PERIOD, 20),
+          butterworthSmoothing: asPositiveInt(
+            config2.AMR_BUTTERWORTH_SMOOTHING,
+            3
+          ),
+          kcLength: asPositiveInt(config2.AMR_KC_LENGTH, 20),
+          atrLength: asPositiveInt(config2.AMR_ATR_LENGTH, 14),
+          atrMultiplier: asPositiveNumber(config2.AMR_ATR_MULTIPLIER, 2)
+        }
       },
       orderPlan: {
         qty,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tradejs/strategies",
-  "version": "1.0.5",
+  "version": "1.0.6",
   "description": "Built-in strategy plugin catalog for the TradeJS open-source framework.",
   "keywords": [
     "tradejs",
@@ -32,10 +32,10 @@
     }
   },
   "dependencies": {
-    "@tradejs/core": "^1.0.5",
-    "@tradejs/indicators": "^1.0.5",
-    "@tradejs/node": "^1.0.5",
-    "@tradejs/types": "^1.0.5"
+    "@tradejs/core": "^1.0.6",
+    "@tradejs/indicators": "^1.0.6",
+    "@tradejs/node": "^1.0.6",
+    "@tradejs/types": "^1.0.6"
   },
   "devDependencies": {
     "tsup": "^8.5.1",