portfolio_analyzer/strategy/

book.rs

//! # Book: trading a full month or a full year, the way a person would
//!
//! `sim.rs` grades strategies one trade at a time.  That answers "is this
//! trade a good bet?", but not "what would my account have looked like if I
//! had run this for all of 2022?".  This file answers the second question.
//!
//! ## What "trade a full period" means here
//!
//! 1. **Start flat**: cash only, `capital` dollars, at the close of the last
//!    trading day *before* the period.
//! 2. **Every close, decide**: SD is read from bars up to and including that
//!    close, and nothing later.  The strategy says what it wants to hold.
//! 3. **Fill at the next open** (stocks) or **at that close** (options, the
//!    option simulator's rule, since option prices come from the close).
//!    Every fill pays costs.
//! 4. **Mark to market every close**: the equity curve is cash plus what
//!    every open position is worth that day.
//! 5. **End flat**: everything still open is closed at the period's last
//!    close, at marked value minus closing costs.
//!
//! Nothing in the period can see the period's future: SD's models for
//! year `Y` are refitted on bars whose outcomes were known before `Y` began
//! (see `sd_year`).
//!
//! ## Two kinds of strategy
//!
//! * [`Allocator`]: stock strategies.  Each close they return target
//!   weights (negative = short); the book trades the difference.
//! * Option strategies from `strategy/mod.rs`: each symbol's trades come
//!   from [`super::sim::run_window`], and the book sizes each one at a fixed
//!   fraction of equity ("risk 2% of the account per trade").

use super::sim::Trade;
use crate::sd2::engine::Sd2Reading;
use chrono::NaiveDate;
use std::collections::HashMap;

/// One symbol, lined up on the shared calendar.
pub struct Lane {
    pub symbol: String,
    /// `None` on calendar days the symbol did not trade (not yet listed, halted).
    pub open: Vec<Option<f64>>,
    pub close: Vec<Option<f64>>,
    pub sd: Vec<Option<Sd2Reading>>,
}

/// What an allocator may look at on one close.
pub struct DayView<'a> {
    pub day: usize,
    pub date: NaiveDate,
    pub lanes: &'a [Lane],
}

impl DayView<'_> {
    /// Symbols with a usable SD reading and price today.
    pub fn live(&self) -> impl Iterator<Item = (usize, &Sd2Reading)> + '_ {
        self.lanes.iter().enumerate().filter_map(move |(k, l)| {
            let r = l.sd[self.day].as_ref()?;
            l.close[self.day]?;
            Some((k, r))
        })
    }
}

/// A stock strategy: target weights each close.
pub trait Allocator: Sync {
    fn name(&self) -> &'static str;
    /// One line for the book: what it believes.
    fn thesis(&self) -> &'static str;
    /// Target weights (fraction of equity; negative = short).  `None` keeps
    /// the current holdings unchanged (no trading today).
    fn targets(&self, v: &DayView, days_in: usize) -> Option<Vec<(usize, f64)>>;
}

/// Buy one symbol on day one, hold to the end.
pub struct HoldOne(pub &'static str);
impl Allocator for HoldOne {
    fn name(&self) -> &'static str {
        "SPY buy & hold"
    }
    fn thesis(&self) -> &'static str {
        "The benchmark: own the market, do nothing."
    }
    fn targets(&self, v: &DayView, days_in: usize) -> Option<Vec<(usize, f64)>> {
        (days_in == 0).then(|| v.lanes.iter().position(|l| l.symbol == self.0).map(|k| vec![(k, 1.0)]).unwrap_or_default())
    }
}

/// Equal weight in every symbol that trades on day one, held.
pub struct EqualHold;
impl Allocator for EqualHold {
    fn name(&self) -> &'static str {
        "Equal-weight hold"
    }
    fn thesis(&self) -> &'static str {
        "The universe benchmark: 1/N of every name, never rebalanced."
    }
    fn targets(&self, v: &DayView, days_in: usize) -> Option<Vec<(usize, f64)>> {
        if days_in > 0 {
            return None;
        }
        let k: Vec<usize> = v.live().map(|(k, _)| k).collect();
        let w = 1.0 / k.len().max(1) as f64;
        Some(k.into_iter().map(|k| (k, w)).collect())
    }
}

/// Hold every name SD puts above 0.5, equal weight, rebalanced weekly.
pub struct SdSide;
impl Allocator for SdSide {
    fn name(&self) -> &'static str {
        "SD side"
    }
    fn thesis(&self) -> &'static str {
        "Own what SD calls up, hold cash (or nothing) for what it calls down."
    }
    fn targets(&self, v: &DayView, days_in: usize) -> Option<Vec<(usize, f64)>> {
        if days_in % 5 != 0 {
            return None;
        }
        let k: Vec<usize> = v.live().filter(|(_, r)| r.sd > 0.5).map(|(k, _)| k).collect();
        let w = 1.0 / k.len().max(1) as f64;
        Some(k.into_iter().map(|k| (k, w)).collect())
    }
}

/// Trade fresh squeeze fires in the direction of momentum.
pub struct FireMomentum {
    pub min_lean: f64,
    pub shorts: bool,
    pub slot: f64,
    pub max_names: usize,
}
impl Allocator for FireMomentum {
    fn name(&self) -> &'static str {
        if self.shorts { "SD fire long/short" } else { "SD fire long" }
    }
    fn thesis(&self) -> &'static str {
        "The classic squeeze trade: when a coil fires, ride momentum while the fire is alive."
    }
    fn targets(&self, v: &DayView, _days_in: usize) -> Option<Vec<(usize, f64)>> {
        let mut longs: Vec<(usize, f64)> = Vec::new();
        let mut shorts: Vec<(usize, f64)> = Vec::new();
        for (k, r) in v.live() {
            if !r.is_active_fire {
                continue;
            }
            if r.lean >= self.min_lean {
                longs.push((k, r.lean));
            } else if self.shorts && r.lean <= -self.min_lean {
                shorts.push((k, r.lean));
            }
        }
        longs.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap());
        shorts.sort_by(|a, b| a.1.partial_cmp(&b.1).unwrap());
        let mut out: Vec<(usize, f64)> = longs.into_iter().take(self.max_names).map(|(k, _)| (k, self.slot)).collect();
        out.extend(shorts.into_iter().take(self.max_names).map(|(k, _)| (k, -self.slot)));
        Some(out)
    }
}

/// Rank by SD's expected move and hold the top (or bottom) names, weekly.
pub struct MoveTilt {
    pub biggest: bool,
    pub names: usize,
}
impl Allocator for MoveTilt {
    fn name(&self) -> &'static str {
        if self.biggest { "SD big-move tilt" } else { "SD calm tilt" }
    }
    fn thesis(&self) -> &'static str {
        if self.biggest {
            "Own the names SD expects to move most (on the side SD calls)."
        } else {
            "Own the names SD expects to move least: the low-volatility effect."
        }
    }
    fn targets(&self, v: &DayView, days_in: usize) -> Option<Vec<(usize, f64)>> {
        if days_in % 5 != 0 {
            return None;
        }
        let mut c: Vec<(usize, f64)> =
            v.live().filter(|(_, r)| r.side > 0.0).map(|(k, r)| (k, r.expected_move_sigma * r.vol20)).collect();
        c.sort_by(|a, b| a.1.partial_cmp(&b.1).unwrap());
        if self.biggest {
            c.reverse();
        }
        let n = c.len().min(self.names);
        Some(c.into_iter().take(n).map(|(k, _)| (k, 1.0 / n.max(1) as f64)).collect())
    }
}

/// Few-day swing: buy fresh fires (first half of their expected life) with
/// a clear upward lean; sell as soon as the fire is no longer fresh.
pub struct SwingFire;
impl Allocator for SwingFire {
    fn name(&self) -> &'static str {
        "SD swing long"
    }
    fn thesis(&self) -> &'static str {
        "A squeeze that has just fired, with momentum up: hold for a few days while the fire is young."
    }
    fn targets(&self, v: &DayView, _days_in: usize) -> Option<Vec<(usize, f64)>> {
        let mut c: Vec<(usize, f64)> = v
            .live()
            .filter(|(_, r)| r.is_active_fire && r.phase.is_some_and(|p| p <= 0.5) && r.lean >= 0.3)
            .map(|(k, r)| (k, r.lean))
            .collect();
        c.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap());
        Some(c.into_iter().take(10).map(|(k, _)| (k, 0.1)).collect())
    }
}

/// Few-day mean reversion: own the names stretched furthest *below* their
/// 21-bar average (on the side SD calls up), re-picked every 5 days.
pub struct StretchReversion;
impl Allocator for StretchReversion {
    fn name(&self) -> &'static str {
        "SD stretch reversion"
    }
    fn thesis(&self) -> &'static str {
        "Short-term overreactions tend to partly undo themselves: buy the most stretched-down names, hold about a week."
    }
    fn targets(&self, v: &DayView, days_in: usize) -> Option<Vec<(usize, f64)>> {
        if days_in % 5 != 0 {
            return None;
        }
        let mut c: Vec<(usize, f64)> = v.live().filter(|(_, r)| r.side > 0.0 && r.stretch < 0.0).map(|(k, r)| (k, r.stretch)).collect();
        c.sort_by(|a, b| a.1.partial_cmp(&b.1).unwrap());
        let n = c.len().min(10);
        Some(c.into_iter().take(n).map(|(k, _)| (k, 1.0 / n.max(1) as f64)).collect())
    }
}

/// Every stock strategy the year runs include, in report order.
pub fn allocators() -> Vec<Box<dyn Allocator>> {
    vec![
        Box::new(HoldOne("SPY")),
        Box::new(EqualHold),
        Box::new(SdSide),
        Box::new(FireMomentum { min_lean: 0.3, shorts: false, slot: 0.05, max_names: 20 }),
        Box::new(FireMomentum { min_lean: 0.3, shorts: true, slot: 0.05, max_names: 10 }),
        Box::new(MoveTilt { biggest: true, names: 20 }),
        Box::new(MoveTilt { biggest: false, names: 20 }),
        Box::new(SwingFire),
        Box::new(StretchReversion),
    ]
}

/// One finished position, for win ratio and expectancy.
#[derive(Debug, Clone, serde::Serialize)]
pub struct Closed {
    pub symbol: String,
    pub entry: NaiveDate,
    pub exit: NaiveDate,
    pub days: usize,
    /// Profit as a fraction of the capital committed to the position.
    pub ret: f64,
    pub pnl: f64,
    pub side: &'static str,
}

/// An event a live runner would announce.
#[derive(Debug, Clone, serde::Serialize)]
pub struct Event {
    pub date: NaiveDate,
    pub action: &'static str,
    pub symbol: String,
    pub price: f64,
    pub dollars: f64,
}

/// The result of trading one strategy over one period.
pub struct Run {
    pub name: String,
    pub dates: Vec<NaiveDate>,
    pub equity: Vec<f64>,
    pub exposure: Vec<f64>,
    pub closed: Vec<Closed>,
    pub events: Vec<Event>,
    /// Option trades skipped because one contract's max loss was more than
    /// the per-trade budget (account too small for that underlying).
    pub unaffordable: usize,
}

/// Stock costs: half-spread + slippage per side, as a fraction of notional.
pub const STOCK_COST: f64 = 0.0005;

/// Trade an allocator over calendar days `start..=end` (`start` = the close
/// before the period, where the first decision is made).
pub fn run_allocator(a: &dyn Allocator, lanes: &[Lane], calendar: &[NaiveDate], start: usize, end: usize, capital: f64) -> Run {
    let mut cash = capital;
    let mut pos: HashMap<usize, f64> = HashMap::new();
    // symbol -> (entry date, entry day, committed dollars, running pnl, side)
    let mut book: HashMap<usize, (NaiveDate, usize, f64, f64, &'static str)> = HashMap::new();
    let mut closed = Vec::new();
    let mut events = Vec::new();
    let mut eq_curve = vec![capital];
    let mut exposure = vec![0.0];
    let mut dates = vec![calendar[start]];
    let mut pending = a.targets(&DayView { day: start, date: calendar[start], lanes }, 0);
    for day in start + 1..=end {
        // Overnight: positions move from yesterday's close to today's open.
        for (&k, p) in pos.iter_mut() {
            let l = &lanes[k];
            if let (Some(o), Some(c0)) = (l.open[day], last_close(l, day - 1)) {
                let move_ = *p * (o / c0 - 1.0);
                *p += move_;
                if let Some(b) = book.get_mut(&k) {
                    b.3 += move_;
                }
            }
        }
        // At the open: trade towards yesterday's targets.
        if let Some(t) = pending.take() {
            let equity = cash + pos.values().sum::<f64>();
            let target: HashMap<usize, f64> = t.into_iter().filter(|(k, _)| lanes[*k].open[day].is_some()).collect();
            let mut keys: Vec<usize> = pos.keys().chain(target.keys()).copied().collect();
            keys.sort_unstable();
            keys.dedup();
            for k in keys {
                let Some(price) = lanes[k].open[day] else { continue };
                let cur = pos.get(&k).copied().unwrap_or(0.0);
                let want = target.get(&k).copied().unwrap_or(0.0) * equity;
                // Ignore tiny drifts: rebalance only if off by more than 10% of the target or fully exiting.
                if (want - cur).abs() < 1e-9 || (want != 0.0 && cur != 0.0 && want.signum() == cur.signum() && (want - cur).abs() < 0.1 * want.abs()) {
                    continue;
                }
                let cost = (want - cur).abs() * STOCK_COST;
                cash -= want - cur + cost;
                let date = calendar[day];
                if cur == 0.0 {
                    book.insert(k, (date, day, want.abs(), -cost, if want > 0.0 { "long" } else { "short" }));
                    events.push(Event { date, action: "open", symbol: lanes[k].symbol.clone(), price, dollars: want });
                } else if let Some(b) = book.get_mut(&k) {
                    b.3 -= cost;
                    b.2 = b.2.max(want.abs());
                }
                if cur != 0.0 && (want == 0.0 || want.signum() != cur.signum()) {
                    if let Some((entry, d0, committed, pnl, side)) = book.remove(&k) {
                        closed.push(Closed { symbol: lanes[k].symbol.clone(), entry, exit: date, days: day - d0, ret: pnl / committed, pnl, side });
                        events.push(Event { date, action: "close", symbol: lanes[k].symbol.clone(), price, dollars: cur });
                    }
                    if want != 0.0 {
                        book.insert(k, (date, day, want.abs(), 0.0, if want > 0.0 { "long" } else { "short" }));
                        events.push(Event { date, action: "open", symbol: lanes[k].symbol.clone(), price, dollars: want });
                    }
                }
                if want == 0.0 {
                    pos.remove(&k);
                } else {
                    pos.insert(k, want);
                }
            }
        }
        // During the day: open to close.
        for (&k, p) in pos.iter_mut() {
            let l = &lanes[k];
            if let (Some(o), Some(c)) = (l.open[day], l.close[day]) {
                let move_ = *p * (c / o - 1.0);
                *p += move_;
                if let Some(b) = book.get_mut(&k) {
                    b.3 += move_;
                }
            }
        }
        if day == end {
            // End flat at the last close.
            let mut keys: Vec<usize> = pos.keys().copied().collect();
            keys.sort_unstable();
            for k in keys {
                let p = pos.remove(&k).unwrap();
                let cost = p.abs() * STOCK_COST;
                cash += p - cost;
                if let Some((entry, d0, committed, pnl, side)) = book.remove(&k) {
                    closed.push(Closed { symbol: lanes[k].symbol.clone(), entry, exit: calendar[day], days: day - d0, ret: (pnl - cost) / committed, pnl: pnl - cost, side });
                }
                events.push(Event { date: calendar[day], action: "close", symbol: lanes[k].symbol.clone(), price: last_close(&lanes[k], day).unwrap_or(0.0), dollars: p });
            }
        } else {
            pending = a.targets(&DayView { day, date: calendar[day], lanes }, day - start);
        }
        let gross: f64 = pos.values().map(|p| p.abs()).sum();
        let equity = cash + pos.values().sum::<f64>();
        eq_curve.push(equity);
        exposure.push(gross / equity.max(1e-9));
        dates.push(calendar[day]);
    }
    Run { name: a.name().to_string(), dates, equity: eq_curve, exposure, closed, events, unaffordable: 0 }
}

fn last_close(l: &Lane, day: usize) -> Option<f64> {
    (0..=day).rev().find_map(|d| l.close[d])
}

/// Size option trades into an account: each trade may lose at most
/// `risk_frac` of equity at entry, at most `max_open` at once (later ones
/// are skipped).
///
/// `contract_loss`, when given, is the real-dollar maximum loss of **one
/// contract** (100 shares at the price actually printed that day).  Then
/// the book buys whole contracts only: `floor(budget / contract_loss)`,
/// and a trade it cannot afford a single contract of is skipped.  This is
/// what makes a $5,000 account different from a $1,000,000 one.
#[allow(clippy::too_many_arguments)]
pub fn run_options(
    name: &str,
    trades: &[Trade],
    calendar: &[NaiveDate],
    start: usize,
    end: usize,
    capital: f64,
    risk_frac: f64,
    max_open: usize,
    contract_loss: Option<&(dyn Fn(&Trade) -> f64 + Sync)>,
) -> Run {
    let mut unaffordable = 0;
    let mut order: Vec<&Trade> = trades.iter().collect();
    order.sort_by(|a, b| (a.entry, &a.symbol).cmp(&(b.entry, &b.symbol)));
    let mut next = 0;
    let mut cash = capital;
    // (trade, committed dollars, path cursor, last mark)
    let mut open: Vec<(&Trade, f64, usize, f64)> = Vec::new();
    let mut closed = Vec::new();
    let mut events = Vec::new();
    let mut equity = vec![capital];
    let mut exposure = vec![0.0];
    let mut dates = vec![calendar[start]];
    for day in start..=end {
        let d = calendar[day];
        // Marks first (so today's entries are sized off yesterday's equity).
        let eq_before = cash + open.iter().map(|o| o.1 * (1.0 + o.3)).sum::<f64>();
        while next < order.len() && order[next].entry <= d {
            let t = order[next];
            next += 1;
            if t.entry < d || open.len() >= max_open {
                continue;
            }
            let budget = risk_frac * eq_before;
            let alloc = match contract_loss {
                Some(f) => {
                    let per = f(t);
                    let n = if per.is_finite() && per > 0.0 { (budget / per).floor() } else { 0.0 };
                    if n < 1.0 {
                        unaffordable += 1;
                        continue;
                    }
                    n * per
                }
                None => budget,
            };
            cash -= alloc;
            open.push((t, alloc, 0, 0.0));
            events.push(Event { date: d, action: "open", symbol: format!("{} {}", t.symbol, t.label), price: t.risk, dollars: alloc });
        }
        for o in open.iter_mut() {
            while o.2 < o.0.path.len() && o.0.path[o.2].0 <= d {
                o.3 = o.0.path[o.2].1;
                o.2 += 1;
            }
        }
        let mut still = Vec::new();
        for o in open.drain(..) {
            if o.0.exit <= d {
                let value = o.1 * (1.0 + o.0.ret);
                cash += value;
                closed.push(Closed { symbol: format!("{} {}", o.0.symbol, o.0.label), entry: o.0.entry, exit: o.0.exit, days: o.0.days, ret: o.0.ret, pnl: value - o.1, side: "option" });
                events.push(Event { date: d, action: "close", symbol: format!("{} {}", o.0.symbol, o.0.label), price: o.0.ret, dollars: value });
            } else {
                still.push(o);
            }
        }
        open = still;
        if day > start {
            let committed: f64 = open.iter().map(|o| o.1).sum();
            let eq = cash + open.iter().map(|o| o.1 * (1.0 + o.3)).sum::<f64>();
            equity.push(eq);
            exposure.push(committed / eq.max(1e-9));
            dates.push(d);
        }
    }
    Run { name: name.to_string(), dates, equity, exposure, closed, events, unaffordable }
}

/// The standard scorecard.
#[derive(Debug, Clone, Default, serde::Serialize)]
pub struct Metrics {
    pub strategy: String,
    pub period: String,
    pub total_return: f64,
    pub cagr: f64,
    pub vol: f64,
    pub sharpe: f64,
    pub sortino: f64,
    pub max_drawdown: f64,
    pub calmar: f64,
    pub exposure: f64,
    pub trades: usize,
    pub win_ratio: f64,
    pub avg_win: f64,
    pub avg_loss: f64,
    pub ev_per_trade: f64,
    pub profit_factor: f64,
    pub avg_days: f64,
    pub best_trade: f64,
    pub worst_trade: f64,
}

/// Annual risk-free rate subtracted in Sharpe and Sortino.
pub const RISK_FREE: f64 = 0.0;

pub fn metrics(r: &Run, period: &str) -> Metrics {
    let e = &r.equity;
    let n = e.len().saturating_sub(1).max(1) as f64;
    let rets: Vec<f64> = e.windows(2).map(|w| w[1] / w[0] - 1.0).collect();
    let mean = rets.iter().sum::<f64>() / n;
    let sd = (rets.iter().map(|x| (x - mean).powi(2)).sum::<f64>() / n).sqrt();
    let rf = RISK_FREE / 252.0;
    let down = (rets.iter().map(|x| (x - rf).min(0.0).powi(2)).sum::<f64>() / n).sqrt();
    let (mut peak, mut dd) = (e[0], 0.0f64);
    for &v in e {
        peak = peak.max(v);
        dd = dd.max(1.0 - v / peak);
    }
    let total = e[e.len() - 1] / e[0] - 1.0;
    let cagr = (1.0 + total).powf(252.0 / n) - 1.0;
    let wins: Vec<f64> = r.closed.iter().filter(|c| c.pnl > 0.0).map(|c| c.ret).collect();
    let losses: Vec<f64> = r.closed.iter().filter(|c| c.pnl <= 0.0).map(|c| c.ret).collect();
    let gp: f64 = r.closed.iter().filter(|c| c.pnl > 0.0).map(|c| c.pnl).sum();
    let gl: f64 = -r.closed.iter().filter(|c| c.pnl <= 0.0).map(|c| c.pnl).sum::<f64>();
    let nt = r.closed.len();
    let avg = |v: &[f64]| if v.is_empty() { 0.0 } else { v.iter().sum::<f64>() / v.len() as f64 };
    Metrics {
        strategy: r.name.clone(),
        period: period.to_string(),
        total_return: total,
        cagr,
        vol: sd * 252f64.sqrt(),
        sharpe: if sd > 0.0 { (mean - rf) / sd * 252f64.sqrt() } else { 0.0 },
        sortino: if down > 0.0 { (mean - rf) / down * 252f64.sqrt() } else { 0.0 },
        max_drawdown: dd,
        calmar: if dd > 0.0 { cagr / dd } else { 0.0 },
        exposure: avg(&r.exposure[1..]),
        trades: nt,
        win_ratio: if nt > 0 { wins.len() as f64 / nt as f64 } else { 0.0 },
        avg_win: avg(&wins),
        avg_loss: avg(&losses),
        ev_per_trade: avg(&r.closed.iter().map(|c| c.ret).collect::<Vec<_>>()),
        profit_factor: if gl > 0.0 { gp / gl } else if gp > 0.0 { f64::INFINITY } else { 0.0 },
        avg_days: avg(&r.closed.iter().map(|c| c.days as f64).collect::<Vec<_>>()),
        best_trade: r.closed.iter().map(|c| c.ret).fold(f64::NAN, f64::max),
        worst_trade: r.closed.iter().map(|c| c.ret).fold(f64::NAN, f64::min),
    }
}

// ───────────────────────── charts (plain SVG, no dependencies) ─────────────────────────

/// A colour per series that reads on light and dark pages.
pub const PALETTE: &[&str] = &[
    "#6b7280", "#9ca3af", "#2563eb", "#16a34a", "#0d9488", "#d97706", "#7c3aed", "#dc2626", "#db2777", "#0891b2", "#65a30d", "#ea580c", "#4f46e5", "#a16207",
];

/// Charts are shown as `<img>`, which cannot inherit the page's text colour,
/// so each SVG carries its own light/dark text colour.
const SVG_STYLE: &str = "<style>svg{color:#1f2937}@media (prefers-color-scheme:dark){svg{color:#e5e7eb}}</style>";

fn esc(s: &str) -> String {
    s.replace('&', "&amp;").replace('<', "&lt;").replace('>', "&gt;")
}

/// Line chart of equity curves, each starting at 100.
pub fn svg_equity(title: &str, runs: &[&Run]) -> String {
    let (w, h, l, r, t, b) = (960.0, 460.0, 56.0, 270.0, 36.0, 34.0);
    let log = runs.iter().any(|x| x.equity.iter().any(|v| v / x.equity[0] > 4.0));
    let series: Vec<Vec<f64>> = runs
        .iter()
        .map(|x| x.equity.iter().map(|v| { let v = 100.0 * v / x.equity[0]; if log { v.max(1.0).log10() } else { v } }).collect())
        .collect();
    let base = if log { 2.0 } else { 100.0 };
    let n = series.iter().map(|s| s.len()).max().unwrap_or(2).max(2);
    let lo = series.iter().flatten().cloned().fold(f64::INFINITY, f64::min).min(base);
    let hi = series.iter().flatten().cloned().fold(f64::NEG_INFINITY, f64::max).max(base);
    let pad = (hi - lo).max(1.0) * 0.06;
    let (lo, hi) = (lo - pad, hi + pad);
    let x = |i: usize| l + (w - l - r) * i as f64 / (n - 1) as f64;
    let y = |v: f64| t + (h - t - b) * (1.0 - (v - lo) / (hi - lo));
    let mut s = format!(r#"<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 {w} {h}" role="img" aria-label="{}" font-family="system-ui,sans-serif" font-size="12">"#, esc(title)) + SVG_STYLE;
    s += &format!(r#"<text x="{l}" y="20" font-size="15" font-weight="600" fill="currentColor">{}</text>"#, esc(title));
    for k in 0..=5 {
        let v = lo + (hi - lo) * k as f64 / 5.0;
        let shown = if log { 10f64.powf(v) } else { v };
        s += &format!(r#"<line x1="{l}" x2="{}" y1="{y:.1}" y2="{y:.1}" stroke="currentColor" stroke-opacity="0.12"/><text x="{}" y="{:.1}" text-anchor="end" fill="currentColor" fill-opacity="0.7">{shown:.0}</text>"#, w - r, l - 6.0, y(v) + 4.0, y = y(v));
    }
    s += &format!(r#"<line x1="{l}" x2="{}" y1="{y:.1}" y2="{y:.1}" stroke="currentColor" stroke-opacity="0.45" stroke-dasharray="4 3"/>"#, w - r, y = y(base));
    if let Some(first) = runs.first() {
        let ds = &first.dates;
        // Month ticks for a year or less, year ticks (every other year) for longer spans.
        let long = ds.len() > 400;
        for (i, d) in ds.iter().enumerate() {
            let (key, prev) = if long { ("%Y", ds.get(i.wrapping_sub(1))) } else { ("%m", ds.get(i.wrapping_sub(1))) };
            let new = i == 0 || prev.is_some_and(|p| p.format(key).to_string() != d.format(key).to_string());
            if new && (!long || d.format("%Y").to_string().parse::<i32>().unwrap_or(0) % 2 == 0) {
                let label = if long { d.format("%Y").to_string() } else { d.format("%b").to_string() };
                s += &format!(r#"<text x="{:.1}" y="{}" text-anchor="middle" fill="currentColor" fill-opacity="0.7">{}</text>"#, x(i), h - 12.0, label);
            }
        }
    }
    for (j, (ser, run)) in series.iter().zip(runs).enumerate() {
        let c = PALETTE[j % PALETTE.len()];
        let pts: Vec<String> = ser.iter().enumerate().map(|(i, v)| format!("{:.1},{:.1}", x(i), y(*v))).collect();
        let dash = if j < 2 { r#" stroke-dasharray="5 3""# } else { "" };
        s += &format!(r#"<polyline fill="none" stroke="{c}" stroke-width="1.8"{dash} points="{}"/>"#, pts.join(" "));
        let last = ser.last().map(|v| if log { 10f64.powf(*v) } else { *v }).unwrap_or(100.0);
        s += &format!(r#"<rect x="{}" y="{}" width="12" height="3" fill="{c}"/><text x="{}" y="{}" fill="currentColor">{} ({:+.1}%)</text>"#, w - r + 12.0, t + 6.0 + 18.0 * j as f64, w - r + 30.0, t + 11.0 + 18.0 * j as f64, esc(&run.name), last - 100.0);
    }
    s + "</svg>\n"
}

/// Grouped bars: one group per bucket label, one bar per series (values 0..1).
pub fn svg_bars(title: &str, labels: &[String], series: &[(String, Vec<Option<f64>>)], note: &str) -> String {
    let (w, h, l, t, b) = (760.0, 340.0, 50.0, 44.0, 56.0);
    let gw = (w - l - 20.0) / labels.len().max(1) as f64;
    let bw = gw * 0.8 / series.len().max(1) as f64;
    let y = |v: f64| t + (h - t - b) * (1.0 - v);
    let mut s = format!(r#"<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 {w} {h}" role="img" aria-label="{}" font-family="system-ui,sans-serif" font-size="12">"#, esc(title)) + SVG_STYLE;
    s += &format!(r#"<text x="{l}" y="20" font-size="15" font-weight="600" fill="currentColor">{}</text>"#, esc(title));
    for k in 0..=4 {
        let v = k as f64 / 4.0;
        s += &format!(r#"<line x1="{l}" x2="{}" y1="{yy:.1}" y2="{yy:.1}" stroke="currentColor" stroke-opacity="0.12"/><text x="{}" y="{:.1}" text-anchor="end" fill="currentColor" fill-opacity="0.7">{:.0}%</text>"#, w - 20.0, l - 6.0, y(v) + 4.0, 100.0 * v, yy = y(v));
    }
    s += &format!(r#"<line x1="{l}" x2="{}" y1="{yy:.1}" y2="{yy:.1}" stroke="currentColor" stroke-opacity="0.45" stroke-dasharray="4 3"/>"#, w - 20.0, yy = y(0.5));
    for (i, lab) in labels.iter().enumerate() {
        let gx = l + gw * i as f64 + gw * 0.1;
        for (j, (_, vals)) in series.iter().enumerate() {
            if let Some(Some(v)) = vals.get(i) {
                let c = PALETTE[(j + 2) % PALETTE.len()];
                s += &format!(r#"<rect x="{:.1}" y="{:.1}" width="{:.1}" height="{:.1}" fill="{c}"/><text x="{:.1}" y="{:.1}" text-anchor="middle" fill="currentColor" font-size="10">{:.0}</text>"#, gx + bw * j as f64, y(*v), bw - 2.0, y(0.0) - y(*v), gx + bw * (j as f64 + 0.5), y(*v) - 3.0, 100.0 * v);
            }
        }
        s += &format!(r#"<text x="{:.1}" y="{}" text-anchor="middle" fill="currentColor" fill-opacity="0.8">{}</text>"#, gx + gw * 0.4, h - b + 16.0, esc(lab));
    }
    for (j, (name, _)) in series.iter().enumerate() {
        let c = PALETTE[(j + 2) % PALETTE.len()];
        s += &format!(r#"<rect x="{}" y="{}" width="12" height="10" fill="{c}"/><text x="{}" y="{}" fill="currentColor">{}</text>"#, l + 220.0 * j as f64, h - 22.0, l + 16.0 + 220.0 * j as f64, h - 13.0, esc(name));
    }
    s += &format!(r#"<text x="{l}" y="{}" fill="currentColor" fill-opacity="0.7" font-size="11">{}</text>"#, h - 2.0, esc(note));
    s + "</svg>\n"
}

/// Heat map: one row per strategy, one column per period, cell = return.
pub fn svg_heatmap(title: &str, rows: &[String], cols: &[String], cell: &[Vec<Option<f64>>]) -> String {
    let (lw, cw, ch, top) = (230.0, 44.0, 24.0, 52.0);
    let w = lw + cw * cols.len() as f64 + 10.0;
    let h = top + ch * rows.len() as f64 + 30.0;
    let mut s = format!(r#"<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 {w} {h}" role="img" aria-label="{}" font-family="system-ui,sans-serif" font-size="11">"#, esc(title)) + SVG_STYLE;
    s += &format!(r#"<text x="4" y="20" font-size="15" font-weight="600" fill="currentColor">{}</text>"#, esc(title));
    for (j, c) in cols.iter().enumerate() {
        s += &format!(r#"<text x="{:.1}" y="{}" text-anchor="middle" fill="currentColor" fill-opacity="0.75">{}</text>"#, lw + cw * (j as f64 + 0.5), top - 8.0, esc(c));
    }
    for (i, r) in rows.iter().enumerate() {
        let yy = top + ch * i as f64;
        s += &format!(r#"<text x="{}" y="{:.1}" text-anchor="end" fill="currentColor">{}</text>"#, lw - 8.0, yy + ch * 0.65, esc(r));
        for (j, v) in cell[i].iter().enumerate() {
            let xx = lw + cw * j as f64;
            let Some(v) = v else { continue };
            let a = (v.abs() / 0.30).min(1.0) * 0.85 + 0.08;
            let col = if *v >= 0.0 { "22,163,74" } else { "220,38,38" };
            s += &format!(r#"<rect x="{xx:.1}" y="{yy:.1}" width="{}" height="{}" fill="rgba({col},{a:.2})"/><text x="{:.1}" y="{:.1}" text-anchor="middle" fill="currentColor">{:+.0}</text>"#, cw - 2.0, ch - 2.0, xx + cw / 2.0 - 1.0, yy + ch * 0.65, 100.0 * v);
        }
    }
    s += &format!(r#"<text x="4" y="{}" fill="currentColor" fill-opacity="0.7">Cells: total return of that period, %.  Green up, red down.</text>"#, h - 8.0);
    s + "</svg>\n"
}