@tradejs/strategies 1.0.5 → 1.0.8

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

@@ -1,6 +1,7 @@
 import {
-  adaptiveMomentumRibbonManifest
-} from "./chunk-RYEPHOGL.mjs";
+  adaptiveMomentumRibbonManifest,
+  config
+} from "./chunk-IMLNXICX.mjs";
 import {
   __commonJS,
   __esm,
@@ -3233,9 +3234,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;
@@ -10914,51 +10915,8 @@ var require_winston = __commonJS({
 // src/AdaptiveMomentumRibbon/strategy.ts
 import { createStrategyRuntime } from "@tradejs/node/strategies";
 
-// src/AdaptiveMomentumRibbon/config.ts
-var config = {
-  ENV: "BACKTEST",
-  INTERVAL: "15",
-  MAKE_ORDERS: true,
-  CLOSE_OPPOSITE_POSITIONS: false,
-  BACKTEST_PRICE_MODE: "mid",
-  AI_ENABLED: false,
-  ML_ENABLED: false,
-  ML_THRESHOLD: 0.1,
-  MIN_AI_QUALITY: 3,
-  AMR_LOOKBACK_BARS: 400,
-  AMR_MOMENTUM_PERIOD: 20,
-  AMR_BUTTERWORTH_SMOOTHING: 3,
-  AMR_WAIT_CLOSE: true,
-  AMR_SHOW_INVALIDATION_LEVELS: true,
-  AMR_SHOW_KELTNER_CHANNEL: true,
-  AMR_KC_LENGTH: 20,
-  AMR_KC_MA_TYPE: "EMA",
-  AMR_ATR_LENGTH: 14,
-  AMR_ATR_MULTIPLIER: 2,
-  AMR_EXIT_ON_INVALIDATION: true,
-  AMR_LINE_PLOTS: ["kcMidline", "kcUpper", "kcLower", "invalidationLevel"],
-  LONG: {
-    enable: true,
-    direction: "LONG",
-    TP: 2,
-    SL: 1
-  },
-  SHORT: {
-    enable: true,
-    direction: "SHORT",
-    TP: 2,
-    SL: 1
-  }
-};
-
 // src/AdaptiveMomentumRibbon/core.ts
-import {
-  asPineBoolean,
-  asFiniteNumber as asFiniteNumber2,
-  getLatestPinePlotValue,
-  runPineScript
-} from "@tradejs/node/pine";
-import { asPositiveInt, asPositiveNumber } from "@tradejs/core/math";
+import { asPositiveInt as asPositiveInt2, asPositiveNumber as asPositiveNumber2 } from "@tradejs/core/math";
 
 // ../infra/src/logger.ts
 var import_winston = __toESM(require_winston());
@@ -10999,11 +10957,437 @@ var logger = (0, import_winston.createLogger)({
   ]
 });
 
+// src/AdaptiveMomentumRibbon/engine.ts
+import { asPositiveInt, asPositiveNumber } from "@tradejs/core/math";
+var PI = 3.14159265359;
+var MAX_PLOT_POINTS = 240;
+var toFinite = (value) => typeof value === "number" && Number.isFinite(value) ? value : null;
+var percentileNearestRank = (values, percent) => {
+  if (!values.length) {
+    return null;
+  }
+  const sorted = [...values].sort((a, b) => a - b);
+  const rank = Math.max(
+    0,
+    Math.min(sorted.length - 1, Math.ceil(percent / 100 * sorted.length) - 1)
+  );
+  return sorted[rank] ?? null;
+};
+var stdev = (values) => {
+  if (!values.length) {
+    return null;
+  }
+  const mean = values.reduce((sum, value) => sum + value, 0) / values.length;
+  const variance = values.reduce((sum, value) => sum + (value - mean) ** 2, 0) / values.length;
+  return Math.sqrt(variance);
+};
+var pushAndTrim = (values, value, limit) => {
+  values.push(value);
+  if (values.length > limit) {
+    values.splice(0, values.length - limit);
+  }
+};
+var createMovingAverageState = (type, length) => {
+  switch (type) {
+    case "SMA":
+      return {
+        type,
+        length,
+        window: [],
+        sum: 0
+      };
+    case "EMA":
+      return {
+        type,
+        length,
+        seedWindow: [],
+        value: null
+      };
+    case "SMMA (RMA)":
+      return {
+        type,
+        length,
+        seedWindow: [],
+        value: null
+      };
+    case "WMA":
+      return {
+        type,
+        length,
+        window: []
+      };
+    case "VWMA":
+      return {
+        type,
+        length,
+        priceWindow: [],
+        volumeWindow: [],
+        weightedSum: 0,
+        volumeSum: 0
+      };
+  }
+};
+var updateMovingAverage = (state, price, volume) => {
+  switch (state.type) {
+    case "SMA": {
+      state.window.push(price);
+      state.sum += price;
+      if (state.window.length > state.length) {
+        state.sum -= state.window.shift() ?? 0;
+      }
+      if (state.window.length < state.length) {
+        return null;
+      }
+      return state.sum / state.length;
+    }
+    case "EMA": {
+      if (state.value == null) {
+        state.seedWindow.push(price);
+        if (state.seedWindow.length < state.length) {
+          return null;
+        }
+        if (state.seedWindow.length === state.length) {
+          state.value = state.seedWindow.reduce((sum, item) => sum + item, 0) / state.length;
+          return state.value;
+        }
+      }
+      const alpha = 2 / (state.length + 1);
+      state.value = price * alpha + (state.value ?? price) * (1 - alpha);
+      return state.value;
+    }
+    case "SMMA (RMA)": {
+      if (state.value == null) {
+        state.seedWindow.push(price);
+        if (state.seedWindow.length < state.length) {
+          return null;
+        }
+        if (state.seedWindow.length === state.length) {
+          state.value = state.seedWindow.reduce((sum, item) => sum + item, 0) / state.length;
+          return state.value;
+        }
+      }
+      state.value = ((state.value ?? price) * (state.length - 1) + price) / state.length;
+      return state.value;
+    }
+    case "WMA": {
+      state.window.push(price);
+      if (state.window.length > state.length) {
+        state.window.shift();
+      }
+      if (state.window.length < state.length) {
+        return null;
+      }
+      let weightedSum = 0;
+      let weightSum = 0;
+      for (let index = 0; index < state.window.length; index += 1) {
+        const weight = index + 1;
+        weightedSum += state.window[index] * weight;
+        weightSum += weight;
+      }
+      return weightSum > 0 ? weightedSum / weightSum : null;
+    }
+    case "VWMA": {
+      state.priceWindow.push(price);
+      state.volumeWindow.push(volume);
+      state.weightedSum += price * volume;
+      state.volumeSum += volume;
+      if (state.priceWindow.length > state.length) {
+        const removedPrice = state.priceWindow.shift() ?? 0;
+        const removedVolume = state.volumeWindow.shift() ?? 0;
+        state.weightedSum -= removedPrice * removedVolume;
+        state.volumeSum -= removedVolume;
+      }
+      if (state.priceWindow.length < state.length || state.volumeSum <= 0) {
+        return null;
+      }
+      return state.weightedSum / state.volumeSum;
+    }
+  }
+};
+var createAtrState = (length) => ({
+  length,
+  previousClose: null,
+  trSeedWindow: [],
+  atrValue: null
+});
+var updateAtr = (state, candle) => {
+  const previousClose = state.previousClose;
+  const tr = previousClose == null ? candle.high - candle.low : Math.max(
+    candle.high - candle.low,
+    Math.abs(candle.high - previousClose),
+    Math.abs(candle.low - previousClose)
+  );
+  state.previousClose = candle.close;
+  if (state.atrValue == null) {
+    state.trSeedWindow.push(tr);
+    if (state.trSeedWindow.length < state.length) {
+      return null;
+    }
+    if (state.trSeedWindow.length === state.length) {
+      state.atrValue = state.trSeedWindow.reduce((sum, value) => sum + value, 0) / state.length;
+      return state.atrValue;
+    }
+  }
+  state.atrValue = ((state.atrValue ?? tr) * (state.length - 1) + tr) / state.length;
+  return state.atrValue;
+};
+var createButterworthState = (length) => ({
+  length,
+  prev1: null,
+  prev2: null
+});
+var updateButterworth = (state, source) => {
+  if (source == null) {
+    return null;
+  }
+  const safeLength = Math.max(state.length, 1);
+  const a = Math.exp(-Math.sqrt(2) * PI / safeLength);
+  const b = 2 * a * Math.cos(Math.sqrt(2) * PI / safeLength);
+  const c2 = b;
+  const c3 = -(a * a);
+  const c1 = 1 - c2 - c3;
+  if (state.prev1 == null || state.prev2 == null) {
+    state.prev1 = source;
+    state.prev2 = source;
+    return source;
+  }
+  const result = c1 * source + c2 * state.prev1 + c3 * state.prev2;
+  state.prev2 = state.prev1;
+  state.prev1 = result;
+  return result;
+};
+var pushPlotPoint = (plotSeries, plotName, candle, value) => {
+  if (value == null) {
+    return;
+  }
+  const points = plotSeries[plotName] ?? [];
+  points.push({
+    time: candle.timestamp,
+    value
+  });
+  if (points.length > MAX_PLOT_POINTS) {
+    points.splice(0, points.length - MAX_PLOT_POINTS);
+  }
+  plotSeries[plotName] = points;
+};
+var evaluateAdaptiveMomentumRibbon = ({
+  candles,
+  config: config2,
+  linePlots
+}) => {
+  const momentumPeriod = asPositiveInt(config2.AMR_MOMENTUM_PERIOD, 20);
+  const smoothingLength = asPositiveInt(config2.AMR_BUTTERWORTH_SMOOTHING, 3);
+  const waitClose = Boolean(config2.AMR_WAIT_CLOSE);
+  const confirmOnNextBar = Boolean(config2.AMR_CONFIRM_ON_NEXT_BAR);
+  const minSignalOscAbs = asPositiveNumber(config2.AMR_MIN_SIGNAL_OSC_ABS, 0.55);
+  const requireKcBias = Boolean(config2.AMR_REQUIRE_KC_BIAS);
+  const minBarsBetweenSignals = asPositiveInt(
+    config2.AMR_MIN_BARS_BETWEEN_SIGNALS,
+    12
+  );
+  const showInvalidationLevels = Boolean(config2.AMR_SHOW_INVALIDATION_LEVELS);
+  const showKeltnerChannel = Boolean(config2.AMR_SHOW_KELTNER_CHANNEL);
+  const kcLength = asPositiveInt(config2.AMR_KC_LENGTH, 20);
+  const kcMaType = config2.AMR_KC_MA_TYPE === "SMA" || config2.AMR_KC_MA_TYPE === "EMA" || config2.AMR_KC_MA_TYPE === "SMMA (RMA)" || config2.AMR_KC_MA_TYPE === "WMA" || config2.AMR_KC_MA_TYPE === "VWMA" ? config2.AMR_KC_MA_TYPE : "EMA";
+  const atrLength = asPositiveInt(config2.AMR_ATR_LENGTH, 14);
+  const atrMultiplier = asPositiveNumber(config2.AMR_ATR_MULTIPLIER, 2);
+  const sourceWindow = [];
+  const deviationWindow = [];
+  const maState = createMovingAverageState(kcMaType, kcLength);
+  const atrState = createAtrState(atrLength);
+  const butterworthState = createButterworthState(smoothingLength);
+  const plotSeries = {};
+  let previousSignalOsc = null;
+  let lastAcceptedSignalIndex = null;
+  let pendingSignal = null;
+  let invalidationLevel = null;
+  let activeBuy = false;
+  let activeSell = false;
+  let lastSnapshot = {
+    entryLong: false,
+    entryShort: false,
+    invalidated: false,
+    activeBuy: false,
+    activeSell: false,
+    signalOsc: null,
+    kcMidline: null,
+    kcUpper: null,
+    kcLower: null,
+    invalidationLevel: null,
+    lineValues: Object.fromEntries(
+      linePlots.map((plotName) => [plotName, null])
+    )
+  };
+  for (let index = 0; index < candles.length; index += 1) {
+    const candle = candles[index];
+    const previousCandle = index > 0 ? candles[index - 1] : null;
+    const kcMidline = updateMovingAverage(
+      maState,
+      candle.close,
+      Number(candle.volume ?? 0)
+    );
+    const atrValue = updateAtr(atrState, candle);
+    const kcUpper = kcMidline != null && atrValue != null ? kcMidline + atrMultiplier * atrValue : null;
+    const kcLower = kcMidline != null && atrValue != null ? kcMidline - atrMultiplier * atrValue : null;
+    const sourceCandle = waitClose ? previousCandle : candle;
+    const sourceClose = sourceCandle?.close ?? null;
+    let signalOsc = null;
+    let entryLong = false;
+    let entryShort = false;
+    if (sourceClose != null) {
+      pushAndTrim(sourceWindow, sourceClose, momentumPeriod);
+      if (sourceWindow.length >= momentumPeriod) {
+        const medianValue = percentileNearestRank(sourceWindow, 50);
+        const deviation = medianValue != null ? sourceClose - medianValue : null;
+        if (deviation != null) {
+          pushAndTrim(deviationWindow, deviation, momentumPeriod);
+        }
+        if (deviation != null && deviationWindow.length >= momentumPeriod) {
+          const absoluteDeviationWindow = deviationWindow.map(
+            (value) => Math.abs(value)
+          );
+          const medDeviation = percentileNearestRank(
+            absoluteDeviationWindow,
+            50
+          );
+          const scale = medDeviation === 0 ? stdev(sourceWindow) : medDeviation != null ? medDeviation * 1.4826 : null;
+          const rawOsc = scale != null && scale !== 0 ? deviation / scale : 0;
+          signalOsc = updateButterworth(butterworthState, rawOsc);
+        }
+      }
+    }
+    if (signalOsc != null && previousSignalOsc != null) {
+      const rawEntryLong = previousSignalOsc <= 0 && signalOsc > 0;
+      const rawEntryShort = previousSignalOsc >= 0 && signalOsc < 0;
+      const strongEnough = Math.abs(signalOsc) >= minSignalOscAbs;
+      const spacingOk = lastAcceptedSignalIndex == null || index - lastAcceptedSignalIndex >= minBarsBetweenSignals;
+      const longKcBiasOk = !requireKcBias || kcMidline != null && candle.close > kcMidline;
+      const shortKcBiasOk = !requireKcBias || kcMidline != null && candle.close < kcMidline;
+      if (confirmOnNextBar) {
+        if (pendingSignal?.direction === "LONG") {
+          const pendingStillValid = pendingSignal.invalidationLevel == null || candle.low >= pendingSignal.invalidationLevel;
+          const confirmed = pendingStillValid && signalOsc > 0 && strongEnough && longKcBiasOk;
+          if (confirmed) {
+            entryLong = true;
+            invalidationLevel = pendingSignal.invalidationLevel;
+            lastAcceptedSignalIndex = index;
+          }
+          pendingSignal = null;
+        } else if (pendingSignal?.direction === "SHORT") {
+          const pendingStillValid = pendingSignal.invalidationLevel == null || candle.high <= pendingSignal.invalidationLevel;
+          const confirmed = pendingStillValid && signalOsc < 0 && strongEnough && shortKcBiasOk;
+          if (confirmed) {
+            entryShort = true;
+            invalidationLevel = pendingSignal.invalidationLevel;
+            lastAcceptedSignalIndex = index;
+          }
+          pendingSignal = null;
+        }
+        if (!entryLong && !entryShort && spacingOk) {
+          if (rawEntryLong && strongEnough && longKcBiasOk && sourceCandle) {
+            pendingSignal = {
+              direction: "LONG",
+              invalidationLevel: sourceCandle.low
+            };
+          } else if (rawEntryShort && strongEnough && shortKcBiasOk && sourceCandle) {
+            pendingSignal = {
+              direction: "SHORT",
+              invalidationLevel: sourceCandle.high
+            };
+          }
+        }
+      } else {
+        entryLong = rawEntryLong && strongEnough && spacingOk && longKcBiasOk;
+        entryShort = rawEntryShort && strongEnough && spacingOk && shortKcBiasOk;
+      }
+    }
+    if (signalOsc != null) {
+      previousSignalOsc = signalOsc;
+    }
+    if (entryLong && sourceCandle) {
+      if (invalidationLevel == null) {
+        invalidationLevel = sourceCandle.low;
+      }
+      activeBuy = true;
+      activeSell = false;
+    }
+    if (entryShort && sourceCandle) {
+      if (invalidationLevel == null) {
+        invalidationLevel = sourceCandle.high;
+      }
+      activeSell = true;
+      activeBuy = false;
+    }
+    const checkCandle = waitClose ? previousCandle : candle;
+    let invalidated = false;
+    if (activeBuy && checkCandle && invalidationLevel != null && checkCandle.low < invalidationLevel) {
+      invalidated = true;
+    }
+    if (activeSell && checkCandle && invalidationLevel != null && checkCandle.high > invalidationLevel) {
+      invalidated = true;
+    }
+    if (invalidated) {
+      activeBuy = false;
+      activeSell = false;
+    }
+    const displayedKcMidline = showKeltnerChannel ? kcMidline : null;
+    const displayedKcUpper = showKeltnerChannel ? kcUpper : null;
+    const displayedKcLower = showKeltnerChannel ? kcLower : null;
+    const displayedInvalidationLevel = showInvalidationLevels ? invalidationLevel : null;
+    pushPlotPoint(plotSeries, "signalOsc", candle, signalOsc);
+    pushPlotPoint(plotSeries, "kcMidline", candle, displayedKcMidline);
+    pushPlotPoint(plotSeries, "kcUpper", candle, displayedKcUpper);
+    pushPlotPoint(plotSeries, "kcLower", candle, displayedKcLower);
+    pushPlotPoint(
+      plotSeries,
+      "invalidationLevel",
+      candle,
+      displayedInvalidationLevel
+    );
+    const currentLineValues = {};
+    for (const plotName of linePlots) {
+      switch (plotName) {
+        case "signalOsc":
+          currentLineValues[plotName] = signalOsc;
+          break;
+        case "kcMidline":
+          currentLineValues[plotName] = displayedKcMidline;
+          break;
+        case "kcUpper":
+          currentLineValues[plotName] = displayedKcUpper;
+          break;
+        case "kcLower":
+          currentLineValues[plotName] = displayedKcLower;
+          break;
+        case "invalidationLevel":
+          currentLineValues[plotName] = displayedInvalidationLevel;
+          break;
+        default:
+          currentLineValues[plotName] = null;
+          break;
+      }
+    }
+    lastSnapshot = {
+      entryLong,
+      entryShort,
+      invalidated,
+      activeBuy,
+      activeSell,
+      signalOsc: toFinite(signalOsc),
+      kcMidline: toFinite(displayedKcMidline),
+      kcUpper: toFinite(displayedKcUpper),
+      kcLower: toFinite(displayedKcLower),
+      invalidationLevel: toFinite(displayedInvalidationLevel),
+      lineValues: currentLineValues
+    };
+  }
+  return {
+    snapshot: lastSnapshot,
+    plotSeries
+  };
+};
+
 // src/AdaptiveMomentumRibbon/figures.ts
-import {
-  asFiniteNumber,
-  getPinePlotSeries
-} from "@tradejs/node/pine";
 var DEFAULT_COLORS = ["#2962ff", "#f23645", "#089981", "#f59e0b"];
 var LINE_STYLE_BY_PLOT = {
   kcMidline: {
@@ -11032,18 +11416,18 @@ 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);
-    if (timestamp == null || value == null) continue;
+    if (!Number.isFinite(item?.time) || !Number.isFinite(item?.value)) {
+      continue;
+    }
     points.push({
-      timestamp,
-      value
+      timestamp: item.time,
+      value: item.value
     });
   }
   return points;
 };
 var buildAdaptiveMomentumRibbonFigures = ({
-  pineContext,
+  plotSeries,
   linePlots,
   direction,
   entryTimestamp,
@@ -11051,7 +11435,7 @@ var buildAdaptiveMomentumRibbonFigures = ({
   maxPoints = 180
 }) => {
   const lines = linePlots.map((plotName, index) => {
-    const series = getPinePlotSeries(pineContext, plotName);
+    const series = plotSeries[plotName] ?? [];
     const points = toFigurePoints(series, maxPoints);
     if (!points.length) {
       return null;
@@ -11084,70 +11468,17 @@ var buildAdaptiveMomentumRibbonFigures = ({
 };
 
 // src/AdaptiveMomentumRibbon/core.ts
-var AMR_PINE_FILE_NAME = "adaptiveMomentumRibbon.pine";
-var asKcMaType = (value) => {
-  if (value === "SMA" || value === "EMA" || value === "SMMA (RMA)" || value === "WMA" || value === "VWMA") {
-    return value;
-  }
-  return "EMA";
-};
-var resolveAmrInputs = (config2) => ({
-  "Momentum Period": asPositiveInt(config2.AMR_MOMENTUM_PERIOD, 20),
-  "Butterworth Smoothing": asPositiveInt(config2.AMR_BUTTERWORTH_SMOOTHING, 3),
-  "Confirm Signals on Bar Close": Boolean(config2.AMR_WAIT_CLOSE),
-  "Show Invalidation Levels": Boolean(config2.AMR_SHOW_INVALIDATION_LEVELS),
-  "Show Keltner Channel": Boolean(config2.AMR_SHOW_KELTNER_CHANNEL),
-  "KC Length": asPositiveInt(config2.AMR_KC_LENGTH, 20),
-  "KC MA Type": asKcMaType(config2.AMR_KC_MA_TYPE),
-  "ATR Length": asPositiveInt(config2.AMR_ATR_LENGTH, 14),
-  "ATR Multiplier": asPositiveNumber(config2.AMR_ATR_MULTIPLIER, 2)
-});
 var resolveLinePlots = (value) => {
   if (!Array.isArray(value)) {
     return [];
   }
   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
-  };
-};
-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, strategyApi }) => {
+  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);
-  const timeframe = String(config2.INTERVAL ?? "15");
+  const lookbackBars = asPositiveInt2(config2.AMR_LOOKBACK_BARS, 0);
   return async () => {
-    if (!script) {
-      return strategyApi.skip("AMR_SCRIPT_EMPTY");
-    }
     const { fullData, currentPrice, timestamp } = await strategyApi.getMarketData();
     if (fullData.length < 2) {
       return strategyApi.skip("WAIT_DATA");
@@ -11156,27 +11487,25 @@ var createAdaptiveMomentumRibbonCore = async ({ config: config2, symbol, loadPin
     const positionExists = Boolean(
       position && typeof position.qty === "number" && position.qty > 0
     );
-    const candles = getLookbackCandles(fullData, lookbackBars);
-    let pineContext;
+    const candles = lookbackBars > 0 ? fullData.slice(-lookbackBars) : fullData;
+    let evaluation;
     try {
-      pineContext = await runPineScript({
+      evaluation = evaluateAdaptiveMomentumRibbon({
         candles,
-        script,
-        symbol,
-        timeframe,
-        inputs: pineInputs
+        config: config2,
+        linePlots
       });
     } catch (error) {
       if (typeof globalThis.setImmediate === "function") {
         logger.warn(
-          "AdaptiveMomentumRibbon pine run failed for %s: %s",
+          "AdaptiveMomentumRibbon evaluation failed for %s: %s",
           symbol,
           String(error)
         );
       }
-      return strategyApi.skip("AMR_SCRIPT_FAILED");
+      return strategyApi.skip("AMR_EVALUATION_FAILED");
     }
-    const amr = readAmrSnapshot(pineContext, linePlots);
+    const { snapshot: amr, plotSeries } = evaluation;
     if (amr.entryLong && amr.entryShort) {
       return strategyApi.skip("AMR_SIGNAL_CONFLICT");
     }
@@ -11217,7 +11546,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");
@@ -11226,14 +11557,39 @@ var createAdaptiveMomentumRibbonCore = async ({ config: config2, symbol, loadPin
       code: amr.entryLong ? "AMR_ENTRY_LONG" : "AMR_ENTRY_SHORT",
       direction: modeConfig.direction,
       figures: buildAdaptiveMomentumRibbonFigures({
-        pineContext,
+        plotSeries,
         linePlots,
         direction: modeConfig.direction,
         entryTimestamp: timestamp,
         entryPrice: currentPrice
       }),
       additionalIndicators: {
-        amr
+        amr,
+        amrSignalTiming: {
+          entryTiming: "zero_cross",
+          waitClose: Boolean(config2.AMR_WAIT_CLOSE),
+          confirmOnNextBar: Boolean(config2.AMR_CONFIRM_ON_NEXT_BAR),
+          lookbackBars
+        },
+        amrConfigSnapshot: {
+          momentumPeriod: asPositiveInt2(config2.AMR_MOMENTUM_PERIOD, 20),
+          butterworthSmoothing: asPositiveInt2(
+            config2.AMR_BUTTERWORTH_SMOOTHING,
+            3
+          ),
+          minSignalOscAbs: asPositiveNumber2(
+            config2.AMR_MIN_SIGNAL_OSC_ABS,
+            0.55
+          ),
+          requireKcBias: Boolean(config2.AMR_REQUIRE_KC_BIAS),
+          minBarsBetweenSignals: asPositiveInt2(
+            config2.AMR_MIN_BARS_BETWEEN_SIGNALS,
+            12
+          ),
+          kcLength: asPositiveInt2(config2.AMR_KC_LENGTH, 20),
+          atrLength: asPositiveInt2(config2.AMR_ATR_LENGTH, 14),
+          atrMultiplier: asPositiveNumber2(config2.AMR_ATR_MULTIPLIER, 2)
+        }
       },
       orderPlan: {
         qty,