feat(tuner): Entry/Exit axis — replay closed trades on their tape and search entry and exit fields

assets/param_deps.toml

@@ -215,11 +215,12 @@
 "PriceDownPercent" = "AutoSell=YES;PriceDownTimer<>0"
 "PriceDownRelative" = "AutoSell=YES;PriceDownTimer<>0"
 "PriceDownTimer" = "HODLmode=NO;AutoSell=YES"
+"PriceDownToAllowedDrop" = "AutoSell=YES;PriceDownTimer<>0;PriceDownRelative=YES"
 "SellByCustomEMA" = "AutoSell=YES"
 "SellByFilters" = "AutoSell=YES"
 "SellDelay" = "HODLmode=NO;AutoSell=YES"
-"SellEMACheckEnter" = "AutoSell=YES"
-"SellEMADelay" = "AutoSell=YES"
+"SellEMACheckEnter" = "AutoSell=YES;IgnoreFilters=NO;IgnoreBase=NO;CustomEMA<>"
+"SellEMADelay" = "AutoSell=YES;SellByCustomEMA<>"
 "SellFromAssets" = "AutoSell=YES"
 "SellLevelAdjust" = "AutoSell=YES;SellLevelDelay<>0;SellLevelTime<>0"
 "SellLevelAllowedDrop" = "AutoSell=YES;SellLevelDelay<>0;SellLevelTime<>0"
@@ -395,7 +396,7 @@
 "MShotRepeatWait" = ""
 "MShotReplaceDelay" = ""
 "MShotSellAtLastPrice" = ""
-"MShotSellPriceAdjust" = ""
+"MShotSellPriceAdjust" = "MShotSellAtLastPrice=YES"
 "MShotSortBy" = ""
 "MShotSortDesc" = ""
 "MShotUsePrice" = ""

crates/moon-chart/src/frozen_overlay.rs

@@ -44,6 +44,10 @@ pub struct OverlayTrade {
     pub fill_price: f32,
     /// Exit instant and price; `None` when the position was still open where the tape ends.
     pub exit: Option<(f64, f32)>,
+    /// The sell order's path as the model walked it — `(Unix UTC ms, level)` of each placement
+    /// from the fill, stepped to the exit like the entry path; empty draws the exit line flat at
+    /// the exit price, as a Moonbot line pair does.
+    pub exit_path: Vec<(f64, f32)>,
     /// Whether the position is short, which picks the short styles and the arrows' direction.
     pub is_short: bool,
     /// Pen of the entry path, the exit line and the connector (`SEG_PATTERN_*`) — what tells two
@@ -135,47 +139,19 @@ pub fn build_overlay_geometry(
         } else {
             (&style.buy, &style.sell)
         };
-        // The entry line the model walked, stepped like a repriced order's path, to the fill.
+        // The entry line the model walked, to the fill.
         let entry_color = rgba(entry_style.color, 1.0);
-        for (i, &(t_ms, level)) in trade.path.iter().enumerate() {
-            if !price_ok(level) || t_ms > trade.fill_ms {
-                continue;
-            }
-            let end_ms = trade
-                .path
-                .get(i + 1)
-                .map_or(trade.fill_ms, |(next_ms, _)| *next_ms)
-                .min(trade.fill_ms)
-                .max(t_ms);
-            segs.push(SegInstance {
-                t0_rel: to_rel(t_ms),
-                p0: level,
-                t1_rel: to_rel(end_ms),
-                p1: level,
+        push_stepped(
+            segs,
+            &trade.path,
+            Pen {
+                end_ms: trade.fill_ms,
                 thickness: entry_style.thickness,
                 pattern: trade.pattern,
-                extend: SEG_EXTEND_NONE,
-                clamp: SEG_CLAMP_NONE,
                 color: entry_color,
-            });
-            let riser = trade
-                .path
-                .get(i + 1)
-                .filter(|(next_ms, next)| *next_ms <= trade.fill_ms && price_ok(*next));
-            if let Some(&(next_ms, next)) = riser {
-                segs.push(SegInstance {
-                    t0_rel: to_rel(next_ms),
-                    p0: level,
-                    t1_rel: to_rel(next_ms),
-                    p1: next,
-                    thickness: 1.0,
-                    pattern: trade.pattern,
-                    extend: SEG_EXTEND_NONE,
-                    clamp: SEG_CLAMP_NONE,
-                    color: entry_color,
-                });
-            }
-        }
+                epoch_ms,
+            },
+        );
         // Direction follows the ACTION, as trade history's arrows do: a long enters with a buy.
         markers.push(arrow(
             trade.fill_ms,
@@ -187,19 +163,42 @@ pub fn build_overlay_geometry(
             continue;
         };
         let exit_color = rgba(exit_style.color, 1.0);
-        // The exit line as a Moonbot line pair draws it: at the exit price, from the fill (where
-        // the exit order is placed) to the close.
-        segs.push(SegInstance {
-            t0_rel: to_rel(trade.fill_ms),
-            p0: exit_price,
-            t1_rel: to_rel(exit_ms.max(trade.fill_ms)),
-            p1: exit_price,
-            thickness: exit_style.thickness,
-            pattern: trade.pattern,
-            extend: SEG_EXTEND_NONE,
-            clamp: SEG_CLAMP_NONE,
-            color: exit_color,
-        });
+        let exit_end_ms = exit_ms.max(trade.fill_ms);
+        // A path none of whose levels stood before the close — a stop inside `SellDelay`, before
+        // the sell was ever placed, or on the very ms it was — draws as a path without one would.
+        let path_drawn = trade
+            .exit_path
+            .iter()
+            .any(|&(t_ms, level)| t_ms < exit_end_ms && price_ok(level));
+        if !path_drawn {
+            // The exit line as a Moonbot line pair draws it: at the exit price, from the fill
+            // (where the exit order is placed) to the close.
+            segs.push(SegInstance {
+                t0_rel: to_rel(trade.fill_ms),
+                p0: exit_price,
+                t1_rel: to_rel(exit_end_ms),
+                p1: exit_price,
+                thickness: exit_style.thickness,
+                pattern: trade.pattern,
+                extend: SEG_EXTEND_NONE,
+                clamp: SEG_CLAMP_NONE,
+                color: exit_color,
+            });
+        } else {
+            // The sell order the model walked, from its placement to the close — a stop's exit
+            // lands off it, at the stop's own price.
+            push_stepped(
+                segs,
+                &trade.exit_path,
+                Pen {
+                    end_ms: exit_end_ms,
+                    thickness: exit_style.thickness,
+                    pattern: trade.pattern,
+                    color: exit_color,
+                    epoch_ms,
+                },
+            );
+        }
         segs.push(SegInstance {
             t0_rel: to_rel(trade.fill_ms),
             p0: trade.fill_price,
@@ -215,5 +214,58 @@ pub fn build_overlay_geometry(
     }
 }
 
+/// How [`push_stepped`] draws one path.
+struct Pen {
+    /// Nothing is drawn past this instant, Unix UTC ms.
+    end_ms: f64,
+    thickness: f32,
+    pattern: f32,
+    color: [f32; 4],
+    /// The pane's epoch; every instance is relative to it.
+    epoch_ms: f64,
+}
+
+/// A path the model walked, stepped like a repriced order's: a level per placement to the next
+/// one, a riser at each move, nothing past the pen's end.
+fn push_stepped(segs: &mut Vec<SegInstance>, path: &[(f64, f32)], pen: Pen) {
+    let to_rel = |t_ms: f64| (t_ms - pen.epoch_ms) as f32;
+    let price_ok = |p: f32| p.is_finite() && p > 0.0;
+    for (i, &(t_ms, level)) in path.iter().enumerate() {
+        if !price_ok(level) || t_ms > pen.end_ms {
+            continue;
+        }
+        let next = path.get(i + 1);
+        let to_ms = next
+            .map_or(pen.end_ms, |(next_ms, _)| *next_ms)
+            .min(pen.end_ms)
+            .max(t_ms);
+        segs.push(SegInstance {
+            t0_rel: to_rel(t_ms),
+            p0: level,
+            t1_rel: to_rel(to_ms),
+            p1: level,
+            thickness: pen.thickness,
+            pattern: pen.pattern,
+            extend: SEG_EXTEND_NONE,
+            clamp: SEG_CLAMP_NONE,
+            color: pen.color,
+        });
+        let riser = next.filter(|(next_ms, next)| *next_ms <= pen.end_ms && price_ok(*next));
+        if let Some(&(next_ms, next)) = riser {
+            segs.push(SegInstance {
+                t0_rel: to_rel(next_ms),
+                p0: level,
+                t1_rel: to_rel(next_ms),
+                p1: next,
+                thickness: 1.0,
+                pattern: pen.pattern,
+                extend: SEG_EXTEND_NONE,
+                clamp: SEG_CLAMP_NONE,
+                color: pen.color,
+            });
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests;

crates/moon-chart/src/frozen_overlay/tests.rs

@@ -73,6 +73,7 @@ fn a_modelled_trade_carries_its_pen_and_an_open_one_only_its_entry() {
                 fill_ms: 3_000.0,
                 fill_price: 1.0,
                 exit: Some((6_000.0, 1.05)),
+                exit_path: Vec::new(),
                 is_short: false,
                 pattern: SEG_PATTERN_DASH,
             },
@@ -81,6 +82,7 @@ fn a_modelled_trade_carries_its_pen_and_an_open_one_only_its_entry() {
                 fill_ms: 3_500.0,
                 fill_price: 1.01,
                 exit: None,
+                exit_path: Vec::new(),
                 is_short: true,
                 pattern: SEG_PATTERN_DOT,
             },
@@ -114,6 +116,7 @@ fn a_modelled_entry_path_steps_to_the_fill() {
             fill_ms: 3_000.0,
             fill_price: 0.99,
             exit: None,
+            exit_path: Vec::new(),
             is_short: false,
             pattern: SEG_PATTERN_DASH,
         }],
@@ -135,3 +138,70 @@ fn a_modelled_entry_path_steps_to_the_fill() {
         "one riser: the second move falls after the fill"
     );
 }
+
+/// The model's sell path is stepped from its placement to the close, like the entry path, and
+/// stands in for the flat exit line; the exit arrow keeps the exit's own price.
+#[test]
+fn a_modelled_sell_path_steps_to_the_close() {
+    let (_, segs, markers) = build(&FrozenOverlay {
+        bands: Vec::new(),
+        trades: vec![OverlayTrade {
+            path: Vec::new(),
+            fill_ms: 2_000.0,
+            fill_price: 1.0,
+            exit: Some((5_000.0, 1.02)),
+            exit_path: vec![
+                (2_000.0, 1.05),
+                (3_000.0, 1.03),
+                (4_000.0, 1.02),
+                (6_000.0, 1.01),
+            ],
+            is_short: false,
+            pattern: SEG_PATTERN_DASH,
+        }],
+    });
+    assert_eq!(markers.len(), 2, "the entry and the exit arrow");
+    let levels: Vec<(f32, f32, f32)> = segs
+        .iter()
+        .filter(|s| s.p0 == s.p1)
+        .map(|s| (s.t0_rel, s.t1_rel, s.p0))
+        .collect();
+    assert_eq!(
+        levels,
+        vec![
+            (1_000.0, 2_000.0, 1.05),
+            (2_000.0, 3_000.0, 1.03),
+            (3_000.0, 4_000.0, 1.02),
+        ],
+        "no flat line at the exit price, and nothing past the close"
+    );
+    assert_eq!(
+        segs.iter().filter(|s| s.p0 != s.p1).count(),
+        3,
+        "two risers and the fill-to-exit connector"
+    );
+}
+
+/// A sell path none of whose levels stood by the close — a stop inside `SellDelay`, the sell not
+/// yet placed — draws the flat exit line rather than nothing.
+#[test]
+fn a_sell_path_placed_after_the_close_falls_back_to_the_flat_line() {
+    let (_, segs, _) = build(&FrozenOverlay {
+        bands: Vec::new(),
+        trades: vec![OverlayTrade {
+            path: Vec::new(),
+            fill_ms: 2_000.0,
+            fill_price: 1.0,
+            exit: Some((3_000.0, 0.98)),
+            exit_path: vec![(4_000.0, 1.05)],
+            is_short: false,
+            pattern: SEG_PATTERN_DASH,
+        }],
+    });
+    let levels: Vec<(f32, f32, f32)> = segs
+        .iter()
+        .filter(|s| s.p0 == s.p1)
+        .map(|s| (s.t0_rel, s.t1_rel, s.p0))
+        .collect();
+    assert_eq!(levels, vec![(1_000.0, 2_000.0, 0.98)]);
+}