//@version=6
// ╔═══════════════════════════════════════════════════════════════════════════╗
// ║  Liq Heat Map and Vol Prof  +  HTF Reversal Divergences  |  Pine v6     ║
// ║  + Kalman D7  |  Version 22  (v20 + level-1 fixes, 17 Sep 2026)          ║
// ║  v22: ⑮ iceberg counted per side (VAL→buy, VAH→sell) · ⑮ RQ level uses   ║
// ║       slow kernel only · ⑮ MC band must be within its projection window ║
// ║       · ⑳ Donchian BO fires once per direction (was every new high)     ║
// ║       · ⑳ zone/table say 'rally-sell' in downtrends · ATR moved global   ║
// ║       · LBMA windows in Europe/London, CME window in America/New_York    ║
// ║       · defaults = user's live H1 settings (TFH1 build) · v21 (session AVWAP) skipped ║
// ║  AMT Rejection  → QC_SovereignMatrix v2.1  §5 global + §14 (verbatim)  ║
// ║  Volume Profile → QC_SovereignMatrix v2.1  §25 (verbatim)              ║
// ║  Liq Heatmap    → EA Quantum FundOS v2.1   §7 + §9 (verbatim)          ║
// ║  HTF Reversal   → LuxAlgo  (CC BY-NC-SA 4.0)                           ║
// ║  Kalman D7      → et20tradeview  (MPL 2.0)                              ║
// ║  Monte Carlo    → LuxAlgo Predictive Monte Carlo Engine (CC BY-NC-SA)  ║
// ╠═══════════════════════════════════════════════════════════════════════════╣
// ║  v3 → v4 Changelog:                                                      ║
// ║   ⑩ Hilbert Transform Dominant Cycle (Adaptive HM/VP Lookback)          ║
// ║   ⑪ RQ-Kernel Rational Quadratic Regression Lines + Uncertainty Band    ║
// ║   ⑫ Shannon Entropy Market Quality Filter                                ║
// ║   ⑬ VPIN Proxy Informed Flow Detector                                   ║
// ╠═══════════════════════════════════════════════════════════════════════════╣
// ║  v4 → v5 Changelog (nothing from v4 removed — pure addition):            ║
// ║   ⑭ Predictive Monte Carlo Engine (GBM / SRW / Historical Shuffle)      ║
// ║      • Regime filter (Trend SMA / Momentum RSI), anchor mode            ║
// ║      • Percentile path coloring, envelope, average path                 ║
// ║      • S/R projection zones + Monte Carlo dashboard + forecast candle   ║
// ║      All MC identifiers namespaced (mc_/MC_) to avoid any collision.     ║
// ╠═══════════════════════════════════════════════════════════════════════════╣
// ║  v5 → v8 Changelog (pure addition, nothing removed):                     ║
// ║   ⑮ Confluence BUY/SELL Signal — fires when ALL align:                   ║
// ║      • Price INSIDE Monte Carlo band (between S1 and R1)                 ║
// ║      • Near a significant level (AMT VWMA value band / RQ-Kernel)        ║
// ║      • Multi-TF OB/OS : current(M5) + (H1 or H4) agree                   ║
// ║      • Order-flow confirm: rejection / iceberg / delta (≥ N of 3)        ║
// ║      • Kalman turn + Shannon-Entropy quality (optional confluence)       ║
// ║      Independent toggles: Labels on/off · Arrows(plotshape) on/off       ║
// ║      + 2 alerts (Confluence BUY / SELL)                                  ║
// ╠═══════════════════════════════════════════════════════════════════════════╣
// ║  v8 → v9 Changelog (pure default tuning, nothing removed or added):      ║
// ║   INPUT DEFAULT CHANGES:                                                  ║
// ║   ⑭ MC Regime Filter: None → Trend (SMA)                                ║
// ║   ⑭ MC Historical Lookback: 100 → 200                                   ║
// ║   ⑭ MC Volatility Multiplier: 1.0 → 1.2                                 ║
// ║   ⑮ Confluence MC band zone: Inside (S1-R1) → Lower/Upper half          ║
// ╠═══════════════════════════════════════════════════════════════════════════╣
// ║  v9 → v10 Changelog (pure addition, nothing from v9 removed):            ║
// ║   ⑯ Triple MTF Conf Signal — overlay ★ CONF BUY / ★ CONF SELL labels   ║
// ║      Condition: M5 + H1 + H4 ALL show WMA-RSI OS (BUY) / OB (SELL)      ║
// ║               + AMT Rejection on the same bar (_rej_bot / _rej_top)      ║
// ║      OS = WMA(RSI(5),mw) < WMA(RSI(20),mw) AND slow < 50  at ALL 3 TFs  ║
// ║      OB = WMA(RSI(5),mw) > WMA(RSI(20),mw) AND slow > 50  at ALL 3 TFs  ║
// ║      mw=20 matches MoConf v11 momentumWindow (same fast/slow RSI WMAs    ║
// ║      as the MLMI kNN features — no state divergence, no init artefacts)  ║
// ║      Independent toggles: Labels on/off · Arrows(plotshape) on/off       ║
// ║      + 2 alertconditions                                                  ║
// ╠═══════════════════════════════════════════════════════════════════════════╣
// ║  v10 → v11 Changelog (targeted fix, nothing from v10 removed):           ║
// ║   ⑯ Fixed false positives — added absolute fast WMA RSI threshold        ║
// ║      Root cause: "fast<slow AND slow<50" fires when fast=41–49 (mildly   ║
// ║      bearish) but MLMI kNN OS zone requires fast < 40 (genuine OS).      ║
// ║      v11 OS = fast<slow AND fast<i_tri_os(40) AND slow<50  — ALL 3 TFs  ║
// ║      v11 OB = fast>slow AND fast>i_tri_ob(60) AND slow>50  — ALL 3 TFs  ║
// ║      2 new inputs: i_tri_os (default 40) · i_tri_ob (default 60)        ║
// ╠═══════════════════════════════════════════════════════════════════════════╣
// ║  v11 → v12 Changelog (pure addition, nothing from v11 removed):          ║
// ║   ⑰ ML YZ — Adaptive Yang-Zhang Volatility Bands (ML YZ v1)             ║
// ║      • Pure Yang-Zhang 3-component estimator (OC + RS + CO)             ║
// ║      • kNN regime classifier: 3 features (BW-ROC / RelVol / PriceDist)  ║
// ║        → Balance(1) / Neutral(0) / Imbalance(-1)  via YZ vol rank label ║
// ║      • Adaptive band width: tighter on Balance, wider on Imbalance       ║
// ║      • KAMA middle band (or EMA/SMA/WMA/HMA — selectable)               ║
// ║      • AMT signals: Initiative BUY/SELL + Responsive BUY/SELL            ║
// ║      • Value Area inner bands + VWAP-proxy POC line                      ║
// ║      • Regime label on last bar + 4 alertconditions                      ║
// ╠═══════════════════════════════════════════════════════════════════════════╣
// ║  v12 → v16 Changelog (bug fix only — no logic/inputs/signals changed):    ║
// ║   ⑰ FIX: ML YZ Regime label stacked up on every bar close (see report).  ║
// ║      Cause: the last-bar label used a bare label.new() with no var/delete ║
// ║      → each closed bar committed its label permanently while the next     ║
// ║      bar drew another, piling up IMBALANCE/BALANCE/NEUTRAL · YZ=x.xx.     ║
// ║      Fix: var label _yz_lbl + label.delete() before redraw (same idiom    ║
// ║      as the §14b market-quality label) → exactly ONE YZ label persists.   ║
// ╠═══════════════════════════════════════════════════════════════════════════╣
// ║  v16 → v17 Changelog (pure addition, nothing removed — display-only):      ║
// ║   ⑱ HV-Pivot Levels + CLV-Delta   (default OFF — levels-eyes, no gate)    ║
// ║      • Volume-gated pivots (BigBeluga concept, ported as a FILTER not the  ║
// ║        full zone system): ta.pivothigh/low kept only if the pivot bar's    ║
// ║        volume[len] > SMA(volume, maLen) × mult.                            ║
// ║      • CVD via CLV×vol :  ((C−L)−(H−C))/(H−L) × volume  — replaces the     ║
// ║        weak candle-direction proxy (close≥open?+v:−v). Same principle as   ║
// ║        KV-MACD v8 ㉓ leg-delta → one delta definition across the suite.    ║
// ║      • Draws ONE horizontal ray per level (extend right) + a CVD label.    ║
// ║        NO boxes · NO polylines · capped last N per side (default 3) →      ║
// ║        ≤ 6 lines + ≤ 6 labels total. Anti-bloat by construction.           ║
// ║      • Does NOT touch ⑮/⑯/⑰ signals. Additive; delete §22 to revert.      ║
// ╠═══════════════════════════════════════════════════════════════════════════╣
// ║  v17 → v18 Changelog (OPT-IN entry-logic — ALL gates default OFF):         ║
// ║   ⑱ CVD-Confluence GATE — wire the HV-Pivot levels into ⑮/⑯ as an extra   ║
// ║      directional confluence (KV-MACD i_ladGate discipline: OFF by default).║
// ║      • BUY passes only if price is within Xatr of an HV-SUPPORT whose      ║
// ║        CLV-CVD ≥ min (accumulation-confirmed floor).                       ║
// ║      • SELL passes only if price is within Xatr of an HV-RESISTANCE whose  ║
// ║        CLV-CVD ≤ −min (distribution-confirmed ceiling).                    ║
// ║      • Independent toggles i_hv_gate_sig (⑮) / i_hv_gate_tri (⑯); both     ║
// ║        auto-relax to no-op unless ⑱ levels are enabled. When OFF the ⑮/⑯   ║
// ║        signals are byte-for-byte the validated v11 behaviour.              ║
// ║      • §18b computes the gate booleans BEFORE §19 (reads prior-bar levels, ║
// ║        no lookahead). §22 detection/labels unchanged.                      ║
// ║   ⚠ CHANGES ENTRY LOGIC when enabled → must pass walk-forward OOS before   ║
// ║     any live use (gospel: no un-OOS'd entry change reaches capital).        ║
// ╚═══════════════════════════════════════════════════════════════════════════╝
// ╠═══════════════════════════════════════════════════════════════════════════╣
// ║  v19 → v20 Changelog (pure addition, nothing removed):                    ║
// ║   ⑳ Trend Breakout + Correction Meter (M5) — DISPLAY-ONLY.               ║
// ║      (A) Donchian N-bar high/low breakout lines (100 + 200) = trend-      ║
// ║          follow trigger, with BO up/down markers. (B) Correction Meter    ║
// ║          table = MR-into-trend read: after a breakout, measures pullback  ║
// ║          depth as a Fib retrace of the impulse (deeper = higher-prob      ║
// ║          continuation), plus a dip-buy zone box (Fib .5–.618). Uses only  ║
// ║          line/label/box/table → 0 plot-budget (no RE10140 risk). Nothing  ║
// ║          feeds any signal / gate / score — pure visual reference.         ║
// ╠═══════════════════════════════════════════════════════════════════════════╣
// ║  v18 → v19 Changelog (pure addition, nothing removed):                    ║
// ║   ⑲ VWAP Stdev Bands (session-anchored, tuned for M5) — DISPLAY-ONLY.     ║
// ║      Ported from "VWAP Stdev Bands v2 Mod" (Pine v2 → v6). Session VWAP    ║
// ║      + up to 5 stdev band groups + over/under fills + optional VWAP-zone  ║
// ║      bar color (default OFF so it never fights existing bar coloring).    ║
// ║      Daily anchor = correct intraday VWAP on M5. Nothing fed to any       ║
// ║      signal / gate / score — pure visual reference.                       ║
// ╚═══════════════════════════════════════════════════════════════════════════╝
indicator(
     title              = "Liq Heat Map and Vol Prof v22 TFH1",
     shorttitle         = "LiqHM+VP+Kalman+MC v22 TFH1",
     overlay            = true,
     max_lines_count    = 500,
     max_labels_count   = 500,
     max_boxes_count    = 500,
     max_polylines_count= 100,
     max_bars_back      = 500)

// ═══════════════════════════════════════════════════════════════════════════
// §1  UDT
// ═══════════════════════════════════════════════════════════════════════════
type pivot
    float value
    int   index
    float volume_
    float vol
    bool  isLower

// ── ⑱ HV-Pivot level (one persistent ray + its snapshot CLV-CVD) ───────────
type hvLevel
    line  ln
    float price
    float cvd

type HTFData
    float o
    float h
    float l
    float c
    int   oIdx
    int   hIdx
    int   lIdx
    float delta
    int   startTime

type HTFCandleUI
    box   body
    line  wick
    line  oM
    line  hM
    line  lM
    line  cM
    label oL
    label hL
    label lL
    label cL
    label dL
    label tL

// ── ⑭ Monte Carlo UDT (LuxAlgo) ───────────────────────────────────────────
type LCG
    int seed

method next(LCG this) =>
    this.seed := (1103515245 * this.seed + 12345) % 2147483647
    if this.seed < 0
        this.seed += 2147483647
    float(this.seed) / 2147483647.0

method nextInt(LCG this, int min, int max) =>
    this.seed := (1103515245 * this.seed + 12345) % 2147483647
    if this.seed < 0
        this.seed += 2147483647
    min + (this.seed % (max - min + 1))

method nextGaussian(LCG this) =>
    float u1 = this.next()
    if u1 <= 0.00001
        u1 := 0.00001
    float u2 = this.next()
    math.sqrt(-2.0 * math.log(u1)) * math.cos(2.0 * math.pi * u2)

type Path
    array<chart.point> pts
    float endPrice

// ═══════════════════════════════════════════════════════════════════════════
// §2  INPUTS
// ═══════════════════════════════════════════════════════════════════════════

// ── ① AMT Rejection ────────────────────────────────────────────────────────
const string G_AMT = "① AMT Rejection  (VWMA50 ± StdDev50 × 1.5  — Fixed)"
bool   i_show_amt = input.bool(true, "Show Iceberg / Rejection Signals", group=G_AMT)

// ── ② Volume Profile ───────────────────────────────────────────────────────
const string G_VP = "② Volume Profile  (QC_SovereignMatrix v2.1)"
bool   i_show_vp         = input.bool(false, "Show Volume Profile", group=G_VP)
int    i_vp_bars         = input.int(500,    "VP Lookback Bars",                 group=G_VP, minval=20, maxval=500)
int    i_vp_rows         = input.int(100,    "VP Row Count",                     group=G_VP, minval=5,  maxval=100)
float  i_vp_pct          = input.float(90.0, "Value Area %",                     group=G_VP, minval=0,  maxval=100)
bool   i_vp_show_boxes   = input.bool(false, "Show VP Boxes (Volume Histogram)", group=G_VP)
bool   i_vp_show_poc     = input.bool(false, "Show POC Line",                    group=G_VP)
color  i_c_poc_line      = input.color(color.new(#FF1744, 0), "POC Color",       group=G_VP)
string i_poc_style       = input.string("Dotted", "POC Style",                   group=G_VP, options=["Solid","Dashed","Dotted"])
int    i_poc_width       = input.int(2, "POC Width",                             group=G_VP, minval=1, maxval=5)
bool   i_vp_show_poc_lbl = input.bool(true, "Show POC Label",                    group=G_VP)
bool   i_vp_show_vah     = input.bool(true,  "Show VAH Line",                    group=G_VP)
color  i_c_vah_line      = input.color(color.new(#00BCD4, 0), "VAH Color",       group=G_VP)
string i_vah_style       = input.string("Dotted", "VAH Style",                   group=G_VP, options=["Solid","Dashed","Dotted"])
int    i_vah_width       = input.int(2, "VAH Width",                             group=G_VP, minval=1, maxval=5)
bool   i_vp_show_vah_lbl = input.bool(true, "Show VAH Label",                    group=G_VP)
bool   i_vp_show_val     = input.bool(true,  "Show VAL Line",                    group=G_VP)
color  i_c_val_line      = input.color(color.new(#00BCD4, 0), "VAL Color",       group=G_VP)
string i_val_style       = input.string("Dotted", "VAL Style",                   group=G_VP, options=["Solid","Dashed","Dotted"])
int    i_val_width       = input.int(2, "VAL Width",                             group=G_VP, minval=1, maxval=5)
bool   i_vp_show_val_lbl = input.bool(true, "Show VAL Label",                    group=G_VP)

// ── ③ Liquidity Heatmap ────────────────────────────────────────────────────
const string grp_hm    = "③ Liquidity Heatmap  (EA Quantum FundOS v2.1)"
int    lookBack_hm     = input.int(377,  "Calculated Bars",                      group=grp_hm, minval=10, maxval=500)
int    hm_offset       = input.int(30,   "➡️ Profile X-Axis Offset",              group=grp_hm, minval=0,  maxval=150)
bool   displPf         = input.bool(true, "Show Profile",                        group=grp_hm)
bool   i_hm_show_boxes = input.bool(true, "Show Heatmap Boxes",                  group=grp_hm)
bool   i_hm_show_lines = input.bool(true, "Show Heatmap Lines",                  group=grp_hm)
int    bins            = input.int(85,   "Resolution (Bins)",                     group=grp_hm, minval=5, maxval=200)
color  sellColor       = input.color(color.new(#FF6D00, 0), "Sell Liquidity Color", group=grp_hm)
color  buyColor        = input.color(color.new(#00E676, 0), "Buy Liquidity Color",  group=grp_hm)
int    i_sell_tr       = input.int(19, "Sell Line Transparency (0=opaque)",      group=grp_hm, minval=0, maxval=100)
int    i_buy_tr        = input.int(19, "Buy Line Transparency (0=opaque)",       group=grp_hm, minval=0, maxval=100)
bool   poc_show        = input.bool(true, "Show POC",                            group=grp_hm)
color  maxColor        = input.color(color.new(#6A1E9A, 0), "Max Point (POC) Color", group=grp_hm)

// ── ④ LBMA / CME Fix Windows ───────────────────────────────────────────────
const string G_FIX = "④ LBMA / CME Fix Windows"
bool  i_show_fix    = input.bool(true,  "Show Fix Window Backgrounds",           group=G_FIX,
     tooltip="Highlights LBMA AM, LBMA PM, and CME NY fix windows on the price chart.\nTimes are based on UTC+0.")
bool  i_fix_am_en   = input.bool(true,  "LBMA AM Fix  (10:00 – 10:30 London)",      group=G_FIX)
bool  i_fix_pm_en   = input.bool(true,  "LBMA PM Fix  (15:00 – 15:15 London)",      group=G_FIX)
bool  i_fix_cme_en  = input.bool(true,  "CME NY Close (13:20 – 13:30 New York)",      group=G_FIX)
int   i_fix_utc     = input.int(0,      "Extra hour offset (normally 0)",                    group=G_FIX, minval=-12, maxval=14)
color i_col_fix_am  = input.color(color.new(#4CAF50, 88), "LBMA AM Color",      group=G_FIX)
color i_col_fix_pm  = input.color(color.new(#4CAF50, 88), "LBMA PM Color",      group=G_FIX)
color i_col_fix_cme = input.color(color.new(#4CAF50, 88), "CME NY Color",       group=G_FIX)

// ── ⑤ HTF Reversal Patterns ────────────────────────────────────────────────
const string G_HTF = "⑤ HTF Reversal Patterns  (LuxAlgo)"
string htfInput           = input.timeframe("60", "High Timeframe",             group=G_HTF, tooltip="Timeframe to check for reversal patterns.")
bool   showEngulfingInput = input.bool(true,      "Show Engulfing Patterns",    group=G_HTF)
bool   showPinBarsInput   = input.bool(true,      "Show Pin Bars",              group=G_HTF, tooltip="Includes Hammer and Shooting Star patterns.")
color  bullPatternColInput = input.color(#00E676, "Bullish Pattern Color",      group=G_HTF, inline="HTFcol")
color  bearPatternColInput = input.color(#FF6D00, "Bearish Pattern Color",      group=G_HTF, inline="HTFcol")

// ── ⑥ RSI Divergence ───────────────────────────────────────────────────────
const string G_RSI = "⑥ RSI Divergence  (LuxAlgo)"
bool   showDivInput    = input.bool(false, "Show RSI Divergences", group=G_RSI)
int    rsiLenInput     = input.int(14,    "RSI Length",                         group=G_RSI, minval=1)
int    lbRInput        = input.int(5,     "Pivot Right Lookback",               group=G_RSI)
int    lbLInput        = input.int(5,     "Pivot Left Lookback",                group=G_RSI)
color  bullDivColInput = input.color(#089981, "Bullish Div Color",              group=G_RSI, inline="DIVcol")
color  bearDivColInput = input.color(#f23645, "Bearish Div Color",              group=G_RSI, inline="DIVcol")

// ── ⑦ HTF PO3 ──────────────────────────────────────────────────────────────
const string G_PO3 = "⑦ HTF PO3  (LuxAlgo)"
bool   showPo3Input       = input.bool(false, "Show HTF PO3", group=G_PO3, tooltip="Projects HTF candles to the right of price.")
int    candleCountInput   = input.int(3,      "Candles to Show",                group=G_PO3, minval=1, maxval=10)
int    po3OffsetInput     = input.int(50, "Right Offset (Bars)", group=G_PO3, minval=5, tooltip="If Heatmap Profile is also enabled, increase this to avoid overlap.")
bool   showPo3LabelsInput = input.bool(true,  "Show PO3 Price Labels",          group=G_PO3)
bool   showPo3DeltaInput  = input.bool(true,  "Show PO3 Running Delta",         group=G_PO3)

// ── ⑧ Alerts ───────────────────────────────────────────────────────────────
const string G_ALERT = "⑧ Alerts"
bool   alertBullDivInput = input.bool(true, "Bullish Divergence",               group=G_ALERT)
bool   alertBearDivInput = input.bool(true, "Bearish Divergence",               group=G_ALERT)
bool   alertBullEngInput = input.bool(true, "Bullish Engulfing",                group=G_ALERT)
bool   alertBearEngInput = input.bool(true, "Bearish Engulfing",                group=G_ALERT)
bool   alertHammerInput  = input.bool(true, "Hammer",                           group=G_ALERT)
bool   alertStarInput    = input.bool(true, "Shooting Star",                    group=G_ALERT)

// ── ⑨ Kalman D7  (et20tradeview — MPL 2.0) ────────────────────────────────
const string G_KLM = "⑨ Kalman D7  (et20tradeview)"
bool   show_pul    = input.bool(false,  "Show EMA",                             group=G_KLM)
source             = input(close,       "Source",                                group=G_KLM)
float  factor      = input.float(0.5,   "EMA Length 1",   minval=0.1, step=0.1, group=G_KLM)
float  factor2     = input.float(0.5,   "EMA Length 2",   minval=0.1, step=0.1, group=G_KLM)
int    r_ratiob    = input.int(200,     "R base",         step=5,               group=G_KLM, tooltip="Uncertainty measurement lookback")
float  q_ratiob    = input.float(0.002, "q multiplier base", step=0.001,        group=G_KLM, tooltip="Process noise variance, higher = more responsive")
float  r_gate_multb = input.float(1.5, "R Gate Multiplier base", step=0.1,     group=G_KLM, tooltip="R sensitivity baseline")
int    r_ratios    = input.int(20,      "R fast",         step=5,               group=G_KLM, tooltip="Uncertainty measurement lookback (fast)")
float  q_ratios    = input.float(0.005, "q multiplier fast", step=0.001,        group=G_KLM, tooltip="Process noise variance (fast), higher = more responsive")
float  r_gate_mults = input.float(1.2, "R Gate Multiplier fast", step=0.1,     group=G_KLM, tooltip="R sensitivity baseline (fast)")

// ── ⑩ Hilbert DC — Adaptive Line Reach ────────────────────────────────────
// DC adaptive controls HM LINE REACH (how far back lines extend on chart).
// Pivot stats (h_l array, vb_max, step_bin) always use full lookBack_hm input
// to keep box text identical to v3. VP always uses full i_vp_bars input.
const string G_DC = "⑩ Hilbert DC — Adaptive HM Line Reach"
bool  i_dc_en        = input.bool(true,  "Enable Adaptive DC Line Reach (HM)", group=G_DC, tooltip="Adjusts how far Heatmap lines extend back based on dominant cycle.\nPivot stats and box text are unchanged (identical to v3).\nVP lookback is also unaffected.")
bool  i_dc_show_lbl  = input.bool(true,  "Show DC Info Label",                  group=G_DC)
int   i_dc_hm_mult   = input.int(13,     "HM Line Reach Multiplier (×DC)",      group=G_DC, minval=4, maxval=30, tooltip="Heatmap line reach = DC × this bars. Default 13 (Fibonacci). Fast market → shorter reach. Slow market → longer reach.")

// ── ⑪ RQ-Kernel (Rational Quadratic Regression) ───────────────────────────
const string G_RQ = "⑪ RQ-Kernel (Rational Quadratic Regression)"
bool  i_rq_en        = input.bool(true,  "Enable RQ-Kernel Lines",              group=G_RQ)
int   i_rq_h_fast    = input.int(8,      "Fast Bandwidth (h)",                  group=G_RQ, minval=2, maxval=50)
int   i_rq_h_slow    = input.int(25,     "Slow Bandwidth (h)",                  group=G_RQ, minval=5, maxval=100)
float i_rq_alpha     = input.float(1.0,  "Alpha (Multi-Scale)",                 group=G_RQ, step=0.25, minval=0.25, maxval=10.0)
int   i_rq_len       = input.int(50,     "Max Lookback (bars)",                 group=G_RQ, minval=10, maxval=200)
bool  i_rq_show_ub   = input.bool(true,  "Show Uncertainty Band",               group=G_RQ)
color i_rq_fast_col  = input.color(color.new(#00E5FF, 10), "RQ Fast Color",     group=G_RQ)
color i_rq_slow_col  = input.color(color.new(#FF6F00, 10), "RQ Slow Color",     group=G_RQ)
color i_rq_ub_col    = input.color(color.new(#607D8B, 88), "Uncertainty Band Color", group=G_RQ)

// ── ⑫ Shannon Entropy (Market Quality Filter) ─────────────────────────────
const string G_ENT = "⑫ Shannon Entropy (Market Quality Filter)"
bool  i_ent_en       = input.bool(true,  "Enable Entropy Filter",               group=G_ENT)
int   i_ent_len      = input.int(50,     "Lookback (bars)",                     group=G_ENT, minval=20, maxval=200)
int   i_ent_bins     = input.int(8,      "Discretization Bins",                 group=G_ENT, minval=4, maxval=16)
bool  i_ent_show_lbl = input.bool(true,  "Show Entropy Label",                  group=G_ENT)
float i_ent_str_thr  = input.float(0.35, "Structured Threshold (<)",            group=G_ENT, step=0.05, minval=0.10, maxval=0.60)
float i_ent_ran_thr  = input.float(0.65, "Random Threshold (>)",                group=G_ENT, step=0.05, minval=0.40, maxval=0.90)

// ── ⑬ VPIN — Informed Flow Detector ───────────────────────────────────────
const string G_VPIN = "⑬ VPIN — Informed Flow Detector"
bool  i_vpin_en       = input.bool(true,  "Enable VPIN Detection",              group=G_VPIN)
int   i_vpin_len      = input.int(20,     "Smoothing Length (bars)",            group=G_VPIN, minval=5, maxval=100)
float i_vpin_tox      = input.float(0.35, "Toxic Flow Threshold",               group=G_VPIN, step=0.05, minval=0.15, maxval=0.70)
float i_vpin_bal      = input.float(0.15, "Balanced Flow Threshold",            group=G_VPIN, step=0.05, minval=0.05, maxval=0.40)
bool  i_vpin_show_lbl = input.bool(true,  "Show VPIN Label",                    group=G_VPIN)
color i_vpin_tox_col  = input.color(color.new(#FF1744, 0), "Toxic Color",       group=G_VPIN)
color i_vpin_bal_col  = input.color(color.new(#00E676, 0), "Balanced Color",    group=G_VPIN)

// ── ⑭ Predictive Monte Carlo Engine (LuxAlgo) ─────────────────────────────
// Verbatim LuxAlgo logic; identifiers namespaced mc_/MC_ to coexist with v4.
const string MC_METHOD_GBM = "Geometric Brownian Motion"
const string MC_METHOD_SRW = "Simple Random Walk"
const string MC_METHOD_HS  = "Historical Shuffle"

const string MC_REGIME_NONE     = "None"
const string MC_REGIME_TREND    = "Trend (SMA)"
const string MC_REGIME_MOMENTUM = "Momentum (RSI)"

const color MC_DATA       = #DBDBDB
const color MC_HEADERS    = #808080
const color MC_BACKGROUND = #161616
const color MC_BORDERS    = #2E2E2E

const string MC_TOP_RIGHT    = 'Top Right'
const string MC_BOTTOM_RIGHT = 'Bottom Right'
const string MC_BOTTOM_LEFT  = 'Bottom Left'

const string MC_TINY   = 'Tiny'
const string MC_SMALL  = 'Small'
const string MC_NORMAL = 'Normal'
const string MC_LARGE  = 'Large'
const string MC_HUGE   = 'Huge'

const string G_MC      = "⑭ Monte Carlo — Settings  (LuxAlgo)"
const string G_MC_STY  = "⑭ Monte Carlo — Style"
const string G_MC_DASH = "⑭ Monte Carlo — Dashboard"

bool   mc_enableInput = input.bool(true, "Enable Monte Carlo Engine", group=G_MC, tooltip="Master switch for the Predictive Monte Carlo module. When off, no MC drawings or dashboard are rendered.")
string mc_methodInput = input.string(MC_METHOD_GBM, "Simulation Method", options = [MC_METHOD_GBM, MC_METHOD_SRW, MC_METHOD_HS], group = G_MC, tooltip = "Select the mathematical method used to project the future price paths.")
string mc_regimeInput = input.string(MC_REGIME_TREND, "Regime Filter", options = [MC_REGIME_NONE, MC_REGIME_TREND, MC_REGIME_MOMENTUM], group = G_MC, tooltip = "Only sample past returns and volatilities that match the current market regime. Works for all methods.")
int    mc_lookbackInput = input.int(200, "Historical Lookback", minval = 10, maxval = 1000, group = G_MC, tooltip = "Number of historical bars used to calculate drift and volatility.")
int    mc_projInput     = input.int(50, "Projection Length", minval = 5, maxval = 200, group = G_MC, tooltip = "Number of bars to project into the future.")
int    mc_simInput      = input.int(200, "Simulation Count", minval = 2, maxval = 200, group = G_MC, tooltip = "Number of paths to simulate. Max 200.")
float  mc_volMulti      = input.float(1.2, "Volatility Multiplier", minval = 0.1, maxval = 5.0, step = 0.1, group = G_MC, tooltip = "Multiply the historical volatility to stress-test projections. Higher values make GBM and SRW deviate more.")
int    mc_seedInput     = input.int(12345, "Random Seed", group = G_MC, tooltip = "Change this value to generate an entirely new set of random paths.")
bool   mc_anchorInput   = input.bool(true, "Enable Anchor Mode", group = G_MC, tooltip = "Locks the projection and only updates every X bars, leaving historical S/R zones on the chart to see how price reacted.")
int    mc_anchorStep    = input.int(100, "Anchor Update Step (Bars)", minval = 10, group = G_MC, tooltip = "How often to cast a new historical projection when Anchor Mode is enabled.")
bool   mc_anchorPaths   = input.bool(false, "Draw Paths in Anchor Mode", group = G_MC, tooltip = "TradingView only allows 100 polylines per chart. Enabling this in Anchor Mode will cause older envelopes to disappear.")

float  mc_topPercentile = input.float(90.0, "Top Path Percentile", minval = 50.0, maxval = 100.0, group = G_MC_STY, tooltip = "Paths ending above this percentile are colored with the Top Color.")
float  mc_botPercentile = input.float(10.0, "Bottom Path Percentile", minval = 0.0, maxval = 50.0, group = G_MC_STY, tooltip = "Paths ending below this percentile are colored with the Bottom Color.")
color  mc_topColor      = input.color(color.rgb(255, 77, 0, 0), "Top Color", group = G_MC_STY, inline = "mccolors")
color  mc_midColor      = input.color(color.gray, "Middle Color", group = G_MC_STY, inline = "mccolors")
color  mc_bottomColor   = input.color(color.rgb(89, 255, 0, 0), "Bottom Color", group = G_MC_STY, inline = "mccolors")
int    mc_transpInput   = input.int(60, "Path Transparency", minval = 0, maxval = 100, group = G_MC_STY)
color  mc_avgColor      = input.color(color.new(color.white, 0), "Average Line Color", group = G_MC_STY)
color  mc_envColor      = input.color(color.new(color.gray, 90), "Envelope Fill Color", group = G_MC_STY)
bool   mc_srInput       = input.bool(true, "Show S/R Levels", group = G_MC_STY, tooltip = "Display horizontal support and resistance lines based on the projection limits.")

bool   mc_dashboardInput         = input.bool(true, 'Show Dashboard', group = G_MC_DASH, tooltip = "Enable or disable the Monte Carlo dashboard.")
string mc_dashboardPositionInput = input.string(MC_TOP_RIGHT, 'Position', group = G_MC_DASH, tooltip = "Select the dashboard location.", options = [MC_TOP_RIGHT, MC_BOTTOM_RIGHT, MC_BOTTOM_LEFT])
string mc_dashboardSizeInput     = input.string("Small", 'Size', group = G_MC_DASH, tooltip = "Select the dashboard size.", options = [MC_TINY, MC_SMALL, MC_NORMAL, MC_LARGE, MC_HUGE])
bool   mc_dash2Input             = input.bool(false, 'Show Next Candle Prediction', group = G_MC_DASH)
color  mc_bullColor              = input.color(#089981, "Bullish Color", group = G_MC_DASH, inline = "mcc1")
color  mc_bearColor              = input.color(#f23645, "Bearish Color", group = G_MC_DASH, inline = "mcc1")

// ── ⑮ Confluence Buy/Sell Signal ───────────────────────────────────────────
const string G_SIG = "⑮ Confluence Buy/Sell Signal"
bool   i_sig_en      = input.bool(true,  "Enable Confluence Signal (master)", group=G_SIG, tooltip="Master switch. Fires only when ALL conditions align:\n• Price INSIDE Monte Carlo band (between S1 and R1)\n• Near a significant level (AMT value band / RQ-Kernel)\n• Multi-TF OB/OS : current(M5) + (H1 or H4)\n• Order-flow confirm: rejection / iceberg / delta\n• (optional) Kalman turn + Entropy quality")
bool   i_sig_show_lbl= input.bool(true,  "  Show LABELS (▲BUY / ▼SELL)",  group=G_SIG)
bool   i_sig_show_shp= input.bool(true,  "  Show ARROWS (plotshape)",      group=G_SIG)
bool   i_sig_confirm = input.bool(true,  "Signal on bar close only (less repaint)", group=G_SIG)
string i_sig_band    = input.string("Lower/Upper half", "MC band zone", group=G_SIG, options=["Inside (S1-R1)","Lower/Upper half"], tooltip="Inside = price anywhere between S1 and R1.\nLower/Upper half = BUY only below mean, SELL only above mean.")
bool   i_sig_use_kal = input.bool(true,  "Require Kalman turn confirm",   group=G_SIG, tooltip="BUY: Kalman fast ticking up. SELL: ticking down.")
bool   i_sig_use_ent = input.bool(true,  "Require Entropy quality",       group=G_SIG, tooltip="Skip signals when market is RANDOM (low quality).")
bool   i_sig_ent_str = input.bool(false, "  Entropy must be STRUCTURED",  group=G_SIG, tooltip="Stricter: require STRUCTURED (not just not-random).")
int    i_sig_rsi_len = input.int(14,     "RSI Length (OB/OS)",            group=G_SIG, minval=2)
float  i_sig_ob      = input.float(70.0, "Overbought level (≥)",          group=G_SIG, step=1.0)
float  i_sig_os      = input.float(30.0, "Oversold level (≤)",            group=G_SIG, step=1.0)
string i_sig_htf1    = input.timeframe("60",  "HTF 1 (H1)",               group=G_SIG)
string i_sig_htf2    = input.timeframe("240", "HTF 2 (H4)",               group=G_SIG)
float  i_sig_mc_tol  = input.float(0.0,  "MC band edge tolerance ($)",    group=G_SIG, step=0.1, minval=0.0, tooltip="How far inside/outside the MC R1/S1 band still counts as 'at edge'. 0 = exact edge.")
float  i_sig_lvl_atr = input.float(0.5,  "Significant-level proximity (xATR14)", group=G_SIG, step=0.05, tooltip="Price must be within this × ATR of a significant level (AMT VWMA value band / RQ-Kernel).")
int    i_sig_need_of = input.int(1,      "Min order-flow confirms (1-3)", group=G_SIG, minval=1, maxval=3, tooltip="Need at least this many of: rejection · iceberg · delta direction.")
int    i_sig_gap     = input.int(5,      "Min bars between signals",      group=G_SIG, minval=1, maxval=50)
bool   i_sig_use_rq  = input.bool(true,  "Include RQ-Kernel as a level",  group=G_SIG)
color  i_sig_buy_col = input.color(#00E676, "BUY Label Color",            group=G_SIG)
color  i_sig_sell_col= input.color(#FF1744, "SELL Label Color",           group=G_SIG)
string i_sig_size    = input.string("Normal", "Label Size",               group=G_SIG, options=["Tiny","Small","Normal","Large"])

// ── ⑯ Triple MTF Conf Signal ──────────────────────────────────────────────
const string G_TRI = "⑯ Triple MTF Conf Signal  (M5+H1+H4 WMA-RSI + AMT Rejection)"
bool   i_tri_en       = input.bool(true,  "Enable Triple MTF Conf Signal",         group=G_TRI,
     tooltip="★ CONF BUY : WMA(RSI) bearish on ALL 3 TFs + AMT rejection ↑ (wick below VAL, close above).\n★ CONF SELL: WMA(RSI) bullish on ALL 3 TFs + AMT rejection ↓ (wick above VAH, close below).\nOS : fast WMA(RSI(5),mw) < slow WMA(RSI(20),mw)  AND  slow < 50  at all 3 TFs.\nOB : fast > slow  AND  slow > 50.\nMatches MoConf v11 MLMI momentum direction (same RSI features, no state divergence).")
bool   i_tri_show_lbl = input.bool(true,  "  Show Labels (★ CONF BUY / SELL)",    group=G_TRI)
bool   i_tri_show_shp = input.bool(true,  "  Show Arrows (plotshape)",             group=G_TRI)
string i_tri_m5_tf    = input.timeframe("5",   "Base TF (M5)",                     group=G_TRI,
     tooltip="Timeframe for the shortest momentum check. Default M5 — explicit, not chart-TF dependent.")
string i_tri_htf1     = input.timeframe("60",  "HTF 1 (H1)",                       group=G_TRI)
string i_tri_htf2     = input.timeframe("240", "HTF 2 (H4)",                       group=G_TRI)
int    i_tri_mw       = input.int(20,  "Momentum Window (WMA length of RSI)",      group=G_TRI, minval=5, maxval=100,
     tooltip="WMA length applied to both RSI(5) and RSI(20).\nDefault 20 = MoConf v11 momentumWindow.\nLarger → smoother, fewer signals. Smaller → faster, more noise.")
float  i_tri_os       = input.float(40.0, "OS threshold (fast WMA RSI ≤)",         group=G_TRI, step=1.0, minval=20.0, maxval=49.0,
     tooltip="Fast WMA(RSI(5),mw) must be below this at ALL 3 TFs for OS (BUY setup).\nDefault 40 — matches genuine MLMI kNN OS zone.\nRejects mildly bearish fast=41–49 that MLMI does NOT classify as OS.\nExample: fast=18 passes, fast=41 is rejected.")
float  i_tri_ob       = input.float(60.0, "OB threshold (fast WMA RSI ≥)",         group=G_TRI, step=1.0, minval=51.0, maxval=80.0,
     tooltip="Fast WMA(RSI(5),mw) must be above this at ALL 3 TFs for OB (SELL setup).\nDefault 60 — matches genuine MLMI kNN OB zone.\nRejects mildly bullish fast=51–59 that MLMI does NOT classify as OB.")
int    i_tri_gap      = input.int(3,   "Min bars between signals",                 group=G_TRI, minval=1, maxval=50)
color  i_tri_buy_col  = input.color(color.new(#00E676, 0), "BUY Label Color",      group=G_TRI)
color  i_tri_sell_col = input.color(color.new(#FF1744, 0), "SELL Label Color",     group=G_TRI)

// ── ⑰ ML YZ — Adaptive Volatility Bands ──────────────────────────────────
const string G_YZ1 = "⑰ ML YZ — Yang-Zhang"
const string G_YZ2 = "⑰ ML YZ — ML / kNN"
const string G_YZ3 = "⑰ ML YZ — AMT Zones"
const string G_YZ4 = "⑰ ML YZ — Display"
bool   i_yz_en        = input.bool  (false, "Enable ML YZ Bands", group=G_YZ1)
int    i_yz_len       = input.int   (20,     "YZ Period",      minval=5, maxval=300, group=G_YZ1)
float  i_yz_mult      = input.float (1.5,    "Band Multiplier",minval=0.1, step=0.1, group=G_YZ1)
string i_yz_ma_type   = input.string("KAMA", "Middle Band MA",
     options=["EMA","HMA","SMA","WMA","KAMA"],                                    group=G_YZ1)
int    i_yz_ma_len    = input.int   (20,     "MA Period",      minval=5, maxval=200, group=G_YZ1)
int    i_yz_knn_k     = input.int   (5,      "kNN — K Neighbors", minval=3, maxval=20, group=G_YZ2)
int    i_yz_knn_lb    = input.int   (100,    "kNN — Lookback",    minval=50,maxval=300,group=G_YZ2)
bool   i_yz_adapt     = input.bool  (true,   "Adaptive Band Width",              group=G_YZ2)
float  i_yz_mul_low   = input.float (0.8,    "Low-Vol Multiplier", minval=0.5,maxval=1.0,step=0.1,group=G_YZ2)
float  i_yz_mul_high  = input.float (1.4,    "High-Vol Multiplier",minval=1.0,maxval=2.0,step=0.1,group=G_YZ2)
int    i_yz_poc_len   = input.int   (50,     "VA / POC Lookback", minval=10,maxval=200, group=G_YZ3)
float  i_yz_va_pct    = input.float (70.0,   "Value Area %",   minval=50.0,maxval=95.0, group=G_YZ3)
bool   i_yz_show_va   = input.bool  (true,   "Show Value Area",                  group=G_YZ3)
bool   i_yz_show_poc  = input.bool  (true,   "Show POC (VWAP proxy)",            group=G_YZ3)
bool   i_yz_col_bars  = input.bool  (false,  "Color Bars by YZ State",           group=G_YZ4,
     tooltip="Bar color override: Bull=green / Bear=red / Neutral=grey.\nDefault OFF — LiqHM already colours bars via Kalman direction.")
bool   i_yz_show_sig  = input.bool  (true,   "Show YZ AMT Signals",             group=G_YZ4)
bool   i_yz_show_lbl  = input.bool  (true,   "Show YZ Regime Label",            group=G_YZ4)

// ── ⑱ HV-Pivot Levels + CLV-Delta  (BigBeluga concept, display-only) ───────
const string G_HV = "⑱ HV-Pivot Levels  (volume-gated S/R + CLV-CVD)"
bool  i_hv_en       = input.bool (false, "Enable HV-Pivot Levels",              group=G_HV,
     tooltip="Ports ONLY the volume-gated-pivot concept from BigBeluga's High-Volume Pivot S/R (not the box/CVD-polyline system).\nA pivot high/low is kept as an S/R level ONLY if the pivot bar traded on high volume.\nDisplay-only: draws one ray + a CVD label per level. Does not feed the ⑮/⑯/⑰ signals.\nDefault OFF.")
int   i_hv_res_len  = input.int  (144,  "Resistance Pivot Length",  minval=2, maxval=240, group=G_HV,
     tooltip="Bars required before AND after a swing high to confirm a resistance pivot (BigBeluga default 144). Larger = fewer, more structural levels. Confirms len bars late (non-repainting once confirmed).\nCapped at 240: the pivot needs 2×len bars of history and the indicator declares max_bars_back=500.")
int   i_hv_sup_len  = input.int  (144,  "Support Pivot Length",     minval=2, maxval=240, group=G_HV,
     tooltip="Bars required before AND after a swing low to confirm a support pivot.\nCapped at 240 (2×len must fit max_bars_back=500).")
int   i_hv_vol_ma   = input.int  (89,   "Volume MA Length",         minval=1,   group=G_HV,
     tooltip="SMA length of volume used as the baseline for the high-volume test (BigBeluga default 89 in your setup).")
float i_hv_vol_mult = input.float(1.5,  "Volume Threshold Multiplier", minval=0.1, step=0.1, group=G_HV,
     tooltip="Pivot bar's volume must exceed SMA(volume, maLen) × this to qualify (your setup = 1.5). Higher = stricter = fewer levels.")
int   i_hv_keep     = input.int  (3,    "Levels Kept Per Side",     minval=1, maxval=15, group=G_HV,
     tooltip="Only the most-recent N resistance and N support levels are drawn; older ones are deleted. Caps object count (≤ 2×N lines + 2×N labels). Anti-bloat control.")
bool  i_hv_show_cvd = input.bool (true, "Show CVD Label (CLV×vol)",             group=G_HV,
     tooltip="Label each level with its formation-window CVD, computed as CLV×volume ( ((C−L)−(H−C))/(H−L) × vol ) summed over the pivot window.\nPositive = accumulation into the level, negative = distribution. This is the CLV×vol fix vs the raw candle-direction proxy.")
color i_hv_res_col  = input.color(color.new(#2196F3, 0), "Resistance Color",    group=G_HV)
color i_hv_sup_col  = input.color(color.new(#FFC13B, 0), "Support Color",       group=G_HV)

// ── ⑱ CVD-Confluence GATE  (v18 — OPT-IN, changes entry logic, default OFF) ─
const string G_HVG = "⑱ HV-Pivot — CVD Confluence Gate  (v18, default OFF)"
bool  i_hv_gate_sig = input.bool (true, "Gate ⑮ Confluence by CVD-level", group=G_HVG, 
     tooltip="When ON, the ⑮ Confluence BUY/SELL fires ONLY if price is also at a CVD-confirmed HV-Pivot level (BUY→accumulation support, SELL→distribution resistance).\nWhen OFF (default) ⑮ is byte-for-byte the validated behaviour.\nAuto-relaxes to no-op unless ⑱ Enable HV-Pivot Levels is also ON.\n⚠ Changes entry logic — walk-forward OOS before any live use.")
bool  i_hv_gate_tri = input.bool (true, "Gate ⑯ Triple MTF by CVD-level", group=G_HVG, 
     tooltip="Same CVD-level requirement applied to the ⑯ Triple MTF Conf signal. Default OFF.\n⚠ Changes entry logic — OOS before live.")
float i_hv_gate_atr = input.float(0.5,   "Level proximity (×ATR14)",  minval=0.05, step=0.05, group=G_HVG,
     tooltip="Price must be within this × ATR(14) of the HV-level for the gate to allow the signal. Same units as the ⑮ significant-level proximity.")
float i_hv_gate_cvd = input.float(0.0,   "Min |CVD| to confirm level",  minval=0.0, step=100.0, group=G_HVG,
     tooltip="Minimum formation CVD magnitude for a level to count: a support needs CVD ≥ +this, a resistance needs CVD ≤ −this.\n0 = sign only (any accumulation counts for support, any distribution for resistance). Raise to demand stronger accumulation/distribution.")

// ═══════════════════════════════════════════════════════════════════════════
// §3  COLORS
// ═══════════════════════════════════════════════════════════════════════════
color C_CYAN          = color.new(#00BCD4, 0)
color C_GOLD          = color.new(#FFD700, 0)
const color NEUTRAL_COLOR = #787b86
// ── ⑰ ML YZ colors ────────────────────────────────────────────────────────
const color YZ_BULL   = #2DD204
const color YZ_BEAR   = #D2042D
const color YZ_NEUT   = #B0B0B0
const color YZ_BLUE   = #00BFFF

// ═══════════════════════════════════════════════════════════════════════════
// §4  FUNCTIONS (HTF + Kalman + RQ-Kernel + Shannon Entropy + Monte Carlo)
// ═══════════════════════════════════════════════════════════════════════════
formatDelta(float val) =>
    string sign  = val > 0 ? "+" : ""
    float absVal = math.abs(val)
    absVal >= 1000000 ? sign + str.format("{0,number,#.#}M", val / 1000000) :
     absVal >= 1000   ? sign + str.format("{0,number,#.#}K", val / 1000)    :
     sign + str.tostring(val)

drawHtfPattern(string name, float h, float l, float o, float c, int tStart, int tEnd, color col, bool isBullish) =>
    string timeStr  = str.format_time(tStart, "HH:mm", syminfo.timezone)
    string labelTxt = name + "\n" + timeStr
    int    midTime  = math.round((tStart + tEnd) / 2)
    int    timeInset = math.round((tEnd - tStart) * 0.1)
    box.new(tStart, h, tEnd, l,
         xloc=xloc.bar_time, bgcolor=color.new(col, 90), border_color=color.new(col, 50), border_width=1)
    box.new(tStart + timeInset, math.max(o, c), tEnd - timeInset, math.min(o, c),
         xloc=xloc.bar_time, bgcolor=color.new(col, 60), border_color=color.new(col, 20), border_width=1)
    line.new(midTime, h, midTime, l,
         xloc=xloc.bar_time, color=color.new(col, 20), width=1)
    label.new(midTime, isBullish ? l : h, labelTxt,
         xloc=xloc.bar_time, yloc=yloc.price, color=#00000000, textcolor=col,
         style=isBullish ? label.style_label_up : label.style_label_down, size=size.small)

// Kalman helper: custom EMA
pine_ema(float src, float length) =>
    float alpha = 2 / (length + 1)
    float sum   = src
    sum := alpha * src + (1 - alpha) * nz(sum[1])

// Kalman helper: clamp
klm_clamp(float x, float a, float b) =>
    math.min(math.max(x, a), b)

// Kalman core filter function
calc_kalman(float src, float p_state, float p_cv, float R_raw, float Q_raw, float res_var, float q_ratio, float gate_mult) =>
    float q_process       = klm_clamp(nz(Q_raw, 0.1), 0.001, 10.0) * q_ratio
    float r_dynamic_floor = res_var * gate_mult
    float r_adaptive      = math.max(nz(R_raw, 1.0), r_dynamic_floor)
    float current_p_cov   = p_cv + q_process
    float k_gain          = current_p_cov / (current_p_cov + r_adaptive + 1e-10)
    float next_state      = nz(p_state, src)
    float next_cov        = current_p_cov
    if not na(k_gain)
        next_state := next_state + k_gain * (src - next_state)
        next_cov   := (1 - k_gain) * current_p_cov
    [next_state, next_cov]

// RQ-Kernel function
f_rq_kernel(float src, int h, float alpha, int len) =>
    float _ws = 0.0
    float _wv = 0.0
    float _2ah2 = 2.0 * alpha * float(h) * float(h)
    for _i = 0 to len - 1
        float _w = math.pow(1.0 + float(_i * _i) / _2ah2, -alpha)
        _wv += nz(src[_i]) * _w
        _ws += _w
    _ws > 0.0 ? _wv / _ws : src

// Shannon Entropy function
f_shannon_entropy(float src, int len, int n_bins) =>
    float _hi = src
    float _lo = src
    for _k = 1 to len - 1
        _hi := math.max(_hi, nz(src[_k], src))
        _lo := math.min(_lo, nz(src[_k], src))
    float _rng  = math.max(_hi - _lo, syminfo.mintick * 10.0)
    float _step = _rng / float(n_bins)
    float _ent  = 0.0
    for _b = 0 to n_bins - 1
        float _blo = _lo + _step * float(_b)
        float _bhi = _blo + _step
        int   _cnt = 0
        for _i = 0 to len - 1
            float _v = nz(src[_i], src)
            if _v >= _blo and _v < _bhi
                _cnt += 1
        float _p = float(_cnt) / float(len)
        if _p > 0.0
            _ent -= _p * math.log(_p) / math.log(2.0)
    float _max = math.log(float(n_bins)) / math.log(2.0)
    _max > 0.0 ? _ent / _max : 0.5

// ── ⑭ Monte Carlo dashboard helpers (LuxAlgo) ─────────────────────────────
var string mc_parsedDashboardPosition = switch mc_dashboardPositionInput
    MC_TOP_RIGHT    => position.top_right
    MC_BOTTOM_RIGHT => position.bottom_right
    MC_BOTTOM_LEFT  => position.bottom_left
    =>                 position.top_right

var string mc_parsedDashboardSize = switch mc_dashboardSizeInput
    MC_TINY   => size.tiny
    MC_SMALL  => size.small
    MC_NORMAL => size.normal
    MC_LARGE  => size.large
    MC_HUGE   => size.huge
    =>           size.normal

mc_cell(table t_able, int column, int row, string data, color text_col = #FFFFFF, string align = text.align_right, color background = na, float height = 0) =>
    t_able.cell(column, row, data, text_color = text_col, text_size = mc_parsedDashboardSize, text_halign = align, bgcolor = background, height = height)

mc_divider(table t_able, int row, int lastColumn) =>
    string rowDivider = '━━━━━━━━━━━━━━'
    t_able.merge_cells(0, row, lastColumn, row)
    mc_cell(t_able, 0, row, rowDivider, text_col = MC_BORDERS, align = text.align_center, height = 0.5)

// ── ⑯ TF name helper ──────────────────────────────────────────────────────
f_tri_tf_name(string tf) =>
    switch tf
        "1"   => "M1"
        "5"   => "M5"
        "15"  => "M15"
        "30"  => "M30"
        "60"  => "H1"
        "120" => "H2"
        "240" => "H4"
        "D"   => "D1"
        "W"   => "W1"
        =>        tf

// ── ⑰ Yang-Zhang pure volatility estimator ────────────────────────────────
// σ²_YZ = σ²_OC + k·σ²_CO + (1-k)·σ²_RS
// OC = overnight, CO = open-to-close, RS = Rogers-Satchell
yzVol(int per) =>
    float k    = 0.34 / (1.34 + (per + 1.0) / math.max(per - 1.0, 1.0))
    float lnOC = math.log(open  / nz(close[1], close))
    float lnCO = math.log(close / open)
    float lnHO = math.log(high  / open)
    float lnLO = math.log(low   / open)
    float rs   = lnHO * (lnHO - lnCO) + lnLO * (lnLO - lnCO)
    float vOC  = ta.variance(lnOC, per)
    float vCO  = ta.variance(lnCO, per)
    float vRS  = ta.sma(rs, per)
    math.sqrt(math.max(vOC + k * vCO + (1.0 - k) * vRS, 0.0))

// ── ⑰ Kaufman Adaptive MA ─────────────────────────────────────────────────
// ER = net direction / path noise; SC = (ER*(fast-slow)+slow)²
kamaCalc(float src, int len) =>
    float fast  = 2.0 / 3.0
    float slow  = 2.0 / 31.0
    float dir   = math.abs(src - nz(src[len], src))
    float noise = math.sum(math.abs(src - nz(src[1], src)), len)
    float er    = noise > 0.0 ? dir / noise : 0.0
    float sc    = math.pow(er * (fast - slow) + slow, 2.0)
    var float _kv = na
    _kv          := na(_kv) ? src : _kv + sc * (src - _kv)
    _kv

// ── ⑰ kNN regime classifier ───────────────────────────────────────────────
// 3-feature Euclidean kNN → Balance(1) / Neutral(0) / Imbalance(-1)
knnRegime(float f1, float f2, float f3, float lbl_s, int k_n, int lb) =>
    float[] dists = array.new_float(lb, 0.0)
    for i = 1 to lb
        float d = math.sqrt(
             math.pow(f1 - f1[i], 2.0) +
             math.pow(f2 - f2[i], 2.0) +
             math.pow(f3 - f3[i], 2.0))
        array.set(dists, i - 1, d)
    float[] srt = array.copy(dists)
    array.sort(srt, order.ascending)
    float thr = array.get(srt, math.min(k_n - 1, array.size(srt) - 1))
    float vote = 0.0
    int   cnt  = 0
    for i = 0 to lb - 1
        if array.get(dists, i) <= thr and cnt < k_n
            float lbl = 0.0
            if lbl_s[i + 1] > 0.65
                lbl := -1.0
            else if lbl_s[i + 1] < 0.35
                lbl := 1.0
            vote += lbl
            cnt  += 1
    vote > 0.0 ? 1 : vote < 0.0 ? -1 : 0

// ═══════════════════════════════════════════════════════════════════════════
// §5  GLOBAL TA PRECOMPUTE
// ═══════════════════════════════════════════════════════════════════════════

// ── AMT ───────────────────────────────────────────────────────────────────
float _vol_ma50 = ta.sma(volume, 50)
float _mass     = _vol_ma50 > 0.0 ? volume / _vol_ma50 : 1.0
float _m_mean   = ta.vwma(close, 50)
float _m_dev    = ta.stdev(close, 50) * 1.5
float _m_vah    = _m_mean + _m_dev
float _m_val    = _m_mean - _m_dev
float _tol_z    = _m_dev * 0.1

// ── VP range ──────────────────────────────────────────────────────────────
float _vp_top = ta.highest(i_vp_bars)
float _vp_bot = ta.lowest(i_vp_bars)

// ── Heatmap ───────────────────────────────────────────────────────────────
float _hm_vol     = math.sum(volume, 10)
float _hm_vol_max = ta.highest(_hm_vol, lookBack_hm)
float _nVol       = _hm_vol_max > 0 ? (_hm_vol / _hm_vol_max * 100) : 0.0
float _atr_hm     = ta.atr(5) / 50
float _hm_atr_off = ta.highest(_atr_hm * _nVol, lookBack_hm)

// ── 2-bar pivot detection ─────────────────────────────────────────────────
float _h2 = ta.highest(2)
float _l2  = ta.lowest(2)

// ── Fix Window Detection ──────────────────────────────────────────────────
// v22: LBMA auctions are 10:30 / 15:00 LONDON time and COMEX settles 13:30 NEW YORK — evaluate each in its own zone (DST-safe)
int  _fx_hm  = (hour(time, "Europe/London") + i_fix_utc) * 100 + minute(time, "Europe/London")
int  _fx_ny  = (hour(time, "America/New_York") + i_fix_utc) * 100 + minute(time, "America/New_York")
bool _fx_am  = _fx_hm >= 1000 and _fx_hm < 1030
bool _fx_pm  = _fx_hm >= 1500 and _fx_hm < 1515
bool _fx_cme = _fx_ny >= 1320 and _fx_ny < 1330

// ── RSI + divergence pivots ───────────────────────────────────────────────
float rsiValue = ta.rsi(close, rsiLenInput)
float phRsi    = ta.pivothigh(rsiValue, lbLInput, lbRInput)
float plRsi    = ta.pivotlow(rsiValue,  lbLInput, lbRInput)

// ── ⑮ Multi-TF RSI for confluence signal (current TF + H1 + H4) ───────────
float sig_rsi_cur = ta.rsi(close, i_sig_rsi_len)
float sig_rsi_h1  = request.security(syminfo.tickerid, i_sig_htf1, ta.rsi(close, i_sig_rsi_len), barmerge.gaps_off, barmerge.lookahead_off)
float sig_rsi_h4  = request.security(syminfo.tickerid, i_sig_htf2, ta.rsi(close, i_sig_rsi_len), barmerge.gaps_off, barmerge.lookahead_off)

// ── ⑯ Triple MTF WMA-RSI momentum ─────────────────────────────────────────
// rq = fast = WMA(RSI(5), mw)   rs = slow = WMA(RSI(20), mw)
// OS: fast < slow AND slow < 50  (bearish momentum in bearish regime)
// OB: fast > slow AND slow > 50  (bullish momentum in bullish regime)
// Using same RSI features as MoConf v11 MLMI kNN (rsi_quick / rsi_slow),
// computed directly — no kNN state divergence, no initialisation artefacts.
[_tri_rq_m5, _tri_rs_m5] = request.security(syminfo.tickerid, i_tri_m5_tf,
     [ta.wma(ta.rsi(close, 5), i_tri_mw), ta.wma(ta.rsi(close, 20), i_tri_mw)],
     barmerge.gaps_off, barmerge.lookahead_off)
[_tri_rq_h1, _tri_rs_h1] = request.security(syminfo.tickerid, i_tri_htf1,
     [ta.wma(ta.rsi(close, 5), i_tri_mw), ta.wma(ta.rsi(close, 20), i_tri_mw)],
     barmerge.gaps_off, barmerge.lookahead_off)
[_tri_rq_h4, _tri_rs_h4] = request.security(syminfo.tickerid, i_tri_htf2,
     [ta.wma(ta.rsi(close, 5), i_tri_mw), ta.wma(ta.rsi(close, 20), i_tri_mw)],
     barmerge.gaps_off, barmerge.lookahead_off)
string _tri_tf0n = f_tri_tf_name(i_tri_m5_tf)
string _tri_tf1n = f_tri_tf_name(i_tri_htf1)
string _tri_tf2n = f_tri_tf_name(i_tri_htf2)

// ── HTF bar detection + data fetch ───────────────────────────────────────
bool htfNewBar = nz(ta.change(time(htfInput))) != 0

[hOpen, hHigh, hLow, hClose, hPrevOpen, hPrevClose, hTimeStart, hTimeEnd] =
     request.security(syminfo.tickerid, htfInput,
     [open[1], high[1], low[1], close[1], open[2], close[2], time[1], time_close[1]])

// ── Kalman EMA state measurement ──────────────────────────────────────────
int   qlen   = 5
float ema1   = pine_ema(source, factor)
float ema2   = pine_ema(ema1, factor2)

// ── Kalman base filter state ──────────────────────────────────────────────
var float kf_stateb = na
var float p_covb    = 1.0

float residualb          = ema2 - nz(kf_stateb[1], ema2)
float _atr14_g           = ta.atr(14)   // v22: single global ATR14 (was also called inside barstate.islast → na label)
float vol_baseb          = math.max(_atr14_g, 1e-6)
float residual_varianceb = math.pow(residualb, 2) / math.pow(vol_baseb, 2)
float R_rawb             = nz(ta.rma(residual_varianceb, r_ratiob), 1.0)
float Q_rawb             = nz(ta.rma(residual_varianceb, qlen),     0.1)

[new_valb, new_covb] = calc_kalman(ema2, kf_stateb, p_covb, R_rawb, Q_rawb, residual_varianceb, q_ratiob, r_gate_multb)
kf_stateb := new_valb
p_covb    := new_covb
float smoothb = pine_ema(kf_stateb, 3)

// ── Kalman fast filter state ──────────────────────────────────────────────
var float kf_states = na
var float p_covs    = 1.0

float residuals          = ema2 - nz(kf_states[1], ema2)
float vol_bases          = math.max(ta.atr(14), 1e-6)
float residual_variances = math.pow(residuals, 2) / math.pow(vol_bases, 2)
float R_raws             = nz(ta.rma(residual_variances, r_ratios), 1.0)
float Q_raws             = nz(ta.rma(residual_variances, qlen),     0.1)

[new_vals, new_covs] = calc_kalman(ema2, kf_states, p_covs, R_raws, Q_raws, residual_variances, q_ratios, r_gate_mults)
kf_states := new_vals
p_covs    := new_covs
float smooths = pine_ema(kf_states, 5)

// ═══════════════════════════════════════════════════════════════════════════
// §5b  NEW v4 COMPUTATIONS
// ═══════════════════════════════════════════════════════════════════════════

// ── Hilbert Transform Dominant Cycle (Ehlers Homodyne Discriminator) ──────
var float _ht_smooth = 0.0
var float _ht_dtr    = 0.0
var float _ht_I1     = 0.0
var float _ht_Q1     = 0.0
var float _ht_jI     = 0.0
var float _ht_jQ     = 0.0
var float _ht_I2     = 0.0
var float _ht_Q2     = 0.0
var float _ht_Re     = 0.0
var float _ht_Im     = 0.0
var float _ht_per    = 20.0
var float _ht_dc     = 20.0

float _ht_coef = 0.075 * nz(_ht_dc, 20.0) + 0.54
_ht_smooth := (4.0*close + 3.0*nz(close[1]) + 2.0*nz(close[2]) + nz(close[3])) / 10.0
_ht_dtr    := (0.0962*_ht_smooth + 0.5769*nz(_ht_smooth[2]) - 0.5769*nz(_ht_smooth[4]) - 0.0962*nz(_ht_smooth[6])) * _ht_coef
_ht_I1     := nz(_ht_dtr[3])
_ht_Q1     := (0.0962*_ht_dtr + 0.5769*nz(_ht_dtr[2]) - 0.5769*nz(_ht_dtr[4]) - 0.0962*nz(_ht_dtr[6])) * _ht_coef
_ht_jI     := (0.0962*_ht_I1 + 0.5769*nz(_ht_I1[2]) - 0.5769*nz(_ht_I1[4]) - 0.0962*nz(_ht_I1[6])) * _ht_coef
_ht_jQ     := (0.0962*_ht_Q1 + 0.5769*nz(_ht_Q1[2]) - 0.5769*nz(_ht_Q1[4]) - 0.0962*nz(_ht_Q1[6])) * _ht_coef
_ht_I2     := 0.2*(_ht_I1 - _ht_jQ) + 0.8*nz(_ht_I2[1])
_ht_Q2     := 0.2*(_ht_Q1 + _ht_jI) + 0.8*nz(_ht_Q2[1])
_ht_Re     := 0.2*(_ht_I2*nz(_ht_I2[1]) + _ht_Q2*nz(_ht_Q2[1])) + 0.8*nz(_ht_Re[1])
_ht_Im     := 0.2*(_ht_I2*nz(_ht_Q2[1]) - _ht_Q2*nz(_ht_I2[1])) + 0.8*nz(_ht_Im[1])
if _ht_Im != 0.0 and _ht_Re != 0.0
    _ht_per := 2.0 * math.acos(-1.0) / math.atan(_ht_Im / _ht_Re)
if _ht_per > 1.5 * nz(_ht_per[1], 20.0)
    _ht_per := 1.5 * nz(_ht_per[1], 20.0)
if _ht_per < 0.67 * nz(_ht_per[1], 20.0)
    _ht_per := 0.67 * nz(_ht_per[1], 20.0)
_ht_per := math.max(6.0, math.min(50.0, _ht_per))
_ht_dc  := 0.2*_ht_per + 0.8*nz(_ht_dc[1])

int dc_int      = math.max(6, math.min(50, math.round(_ht_dc)))
// DC adaptive: HM lookback only — VP always uses user's full i_vp_bars setting
// VP needs maximum history for accurate POC/VAH/VAL; shrinking it via DC would
// cause the exact v3→v4 regression visible in the before/after screenshots.
int hm_lb_adapt = math.max(30, math.min(lookBack_hm, dc_int * i_dc_hm_mult))
int hm_lb_eff   = i_dc_en ? hm_lb_adapt : lookBack_hm
int vp_lb_eff   = i_vp_bars  // always full user input — never DC-reduced

// ── RQ-Kernel ─────────────────────────────────────────────────────────────
float rq_fast = i_rq_en ? f_rq_kernel(close, i_rq_h_fast, i_rq_alpha, i_rq_len) : na
float rq_slow = i_rq_en ? f_rq_kernel(close, i_rq_h_slow, i_rq_alpha, i_rq_len) : na

// ── Shannon Entropy ───────────────────────────────────────────────────────
float _ent_norm   = i_ent_en ? f_shannon_entropy(close, i_ent_len, i_ent_bins) : 0.5
bool  _ent_struct = _ent_norm < i_ent_str_thr
bool  _ent_random = _ent_norm > i_ent_ran_thr
string _ent_str   = _ent_struct ? "STRUCTURED" : _ent_random ? "RANDOM" : "TRANSITIONAL"
color  _ent_col   = _ent_struct ? color.new(#00E676,0) : _ent_random ? color.new(#FF1744,0) : color.new(#FFD700,0)
int _ent_tr_add   = i_ent_en ? int(_ent_norm * 60.0) : 0

// ── VPIN Proxy ────────────────────────────────────────────────────────────
float _vp_rng_b  = math.max(high - low, syminfo.mintick)
float _vpin_bvol = volume * ((close - low)  / _vp_rng_b)
float _vpin_svol = volume * ((high - close) / _vp_rng_b)
float _vpin_imb  = math.abs(_vpin_bvol - _vpin_svol)
float _vpin_smi  = ta.sma(_vpin_imb, i_vpin_len)
float _vpin_smt  = math.max(ta.sma(volume, i_vpin_len), 1.0)
float _vpin_val  = math.min(_vpin_smi / _vpin_smt, 1.0)
bool  _vpin_toxic = i_vpin_en and _vpin_val >= i_vpin_tox
bool  _vpin_blncd = i_vpin_en and _vpin_val <= i_vpin_bal
float _vpin_net   = ta.sma(_vpin_bvol - _vpin_svol, i_vpin_len)
bool  _vpin_tox_bull = _vpin_toxic and _vpin_net > 0.0
bool  _vpin_tox_bear = _vpin_toxic and _vpin_net < 0.0
string _vpin_str  = _vpin_toxic ? (_vpin_tox_bull ? "TOXIC-BUY" : "TOXIC-SELL") : _vpin_blncd ? "BALANCED" : "NEUTRAL"
color  _vpin_col  = _vpin_tox_bull ? i_vpin_tox_col : _vpin_tox_bear ? i_vpin_tox_col : _vpin_blncd ? i_vpin_bal_col : color.new(#607D8B,0)

// ═══════════════════════════════════════════════════════════════════════════
// §5c  ⑭ MONTE CARLO — CORE LOGIC (LuxAlgo, namespaced)
// ═══════════════════════════════════════════════════════════════════════════
var array<float>    mc_logReturns = array.new<float>()
var array<float>    mc_simReturns = array.new<float>()
var array<int>      mc_regimes    = array.new<int>()
var array<polyline> mc_polylines  = array.new<polyline>()
var array<line>     mc_srLines    = array.new<line>()
var array<label>    mc_srLabels   = array.new<label>()
var array<box>      mc_srBoxes    = array.new<box>()

// ⑮ Persistent MC band bounds (updated whenever MC recomputes; used by signal §19)
var float mc_bandR1  = na
var float mc_bandS1  = na
var float mc_bandMax = na
var float mc_bandMin = na
var float mc_bandMean= na

float mc_lr = math.log(close / nz(close[1], close))
float mc_sr = close - nz(close[1], close)

float mc_sma50 = ta.sma(close, 50)
float mc_rsi14 = ta.rsi(close, 14)

int mc_currentRegime = 0
if mc_regimeInput == MC_REGIME_TREND
    mc_currentRegime := close > nz(mc_sma50, close) ? 1 : -1
else if mc_regimeInput == MC_REGIME_MOMENTUM
    mc_currentRegime := nz(mc_rsi14, 50) > 50 ? 1 : -1

if mc_enableInput
    if barstate.isnew
        mc_logReturns.push(mc_lr)
        mc_simReturns.push(mc_sr)
        mc_regimes.push(mc_currentRegime)
        if mc_logReturns.size() > mc_lookbackInput
            mc_logReturns.shift()
            mc_simReturns.shift()
            mc_regimes.shift()
    else if mc_logReturns.size() > 0
        mc_logReturns.set(mc_logReturns.size() - 1, mc_lr)
        mc_simReturns.set(mc_simReturns.size() - 1, mc_sr)
        mc_regimes.set(mc_regimes.size() - 1, mc_currentRegime)

// ═══════════════════════════════════════════════════════════════════════════
// §5d  ⑰ ML YZ — GLOBAL PRECOMPUTES  (must run every bar)
// ═══════════════════════════════════════════════════════════════════════════

// ── All MA variants computed unconditionally (CW10003 guard) ──────────────
float _yz_ma_ema = ta.ema(close, i_yz_ma_len)
float _yz_ma_sma = ta.sma(close, i_yz_ma_len)
float _yz_ma_wma = ta.wma(close, i_yz_ma_len)
int   _yz_hma_s  = math.max(math.round(math.sqrt(float(i_yz_ma_len))), 1)
float _yz_hma_w1 = ta.wma(close, math.max(i_yz_ma_len / 2, 1))
float _yz_hma_w2 = ta.wma(close, i_yz_ma_len)
float _yz_ma_hma = ta.wma(2.0 * _yz_hma_w1 - _yz_hma_w2, _yz_hma_s)
float _yz_ma_kama= kamaCalc(close, i_yz_ma_len)

// ── Core YZ computation ────────────────────────────────────────────────────
float yz_vol  = i_yz_en ? yzVol(i_yz_len) : na
float yz_mid  = switch i_yz_ma_type
    "EMA" => _yz_ma_ema
    "SMA" => _yz_ma_sma
    "WMA" => _yz_ma_wma
    "HMA" => _yz_ma_hma
    =>       _yz_ma_kama

// Band width in price units
float yz_bw_px  = nz(yz_vol) * close
float yz_bw_sma = ta.sma(yz_bw_px, i_yz_len)
float yz_bw_roc = yz_bw_sma > 0.0 ? (yz_bw_px - nz(yz_bw_px[i_yz_len], yz_bw_px)) / yz_bw_sma : 0.0

// Volume activity (relative to historical average)
float yz_vol_sma = ta.sma(volume, i_yz_knn_lb)
float yz_rel_vol = yz_vol_sma > 0.0 ? float(volume) / yz_vol_sma : 1.0

// Price distance from midline (normalised by band width)
float yz_pd_raw  = yz_bw_px > 0.0 ? math.abs(close - yz_mid) / yz_bw_px : 0.5

// ── Normalised features (percentile rank 0–1) ─────────────────────────────
float yz_feat1  = ta.percentrank(yz_bw_roc,  i_yz_knn_lb) / 100.0
float yz_feat2  = ta.percentrank(yz_rel_vol, i_yz_knn_lb) / 100.0
float yz_feat3  = ta.percentrank(yz_pd_raw,  i_yz_knn_lb) / 100.0
float yz_vrank  = ta.percentrank(nz(yz_vol), i_yz_knn_lb) / 100.0

// ── ML kNN regime classification ──────────────────────────────────────────
int yz_regime = i_yz_en ? knnRegime(yz_feat1, yz_feat2, yz_feat3, yz_vrank, i_yz_knn_k, i_yz_knn_lb) : 0

// ── Adaptive multiplier ────────────────────────────────────────────────────
float yz_eff_mult = i_yz_adapt
     ? (yz_regime ==  1 ? i_yz_mult * i_yz_mul_low
     :  yz_regime == -1 ? i_yz_mult * i_yz_mul_high
     :  i_yz_mult)
     : i_yz_mult

// ── Outer bands ────────────────────────────────────────────────────────────
float yz_upper = yz_mid + yz_bw_px * yz_eff_mult
float yz_lower = yz_mid - yz_bw_px * yz_eff_mult

// ── Band direction ─────────────────────────────────────────────────────────
bool  yz_expanding   = yz_bw_px > nz(yz_bw_px[1], yz_bw_px) and yz_bw_px > yz_bw_sma
bool  yz_contracting = yz_bw_px < nz(yz_bw_px[1], yz_bw_px) and yz_bw_px < yz_bw_sma

// ── AMT Value Area + POC ──────────────────────────────────────────────────
float yz_va_half  = yz_bw_px * yz_eff_mult * (i_yz_va_pct / 100.0)
float yz_va_upper = yz_mid + yz_va_half
float yz_va_lower = yz_mid - yz_va_half

float _yz_poc_num = math.sum(close * float(volume), i_yz_poc_len)
float _yz_poc_den = math.sum(float(volume), i_yz_poc_len)
float yz_poc      = _yz_poc_den > 0.0 ? _yz_poc_num / _yz_poc_den : close

// ── AMT Signals ───────────────────────────────────────────────────────────
bool yz_init_buy  = i_yz_en and ta.crossover (close, yz_upper)    and (yz_expanding  or yz_regime == -1)
bool yz_init_sell = i_yz_en and ta.crossunder(close, yz_lower)    and (yz_expanding  or yz_regime == -1)
bool yz_resp_buy  = i_yz_en and ta.crossover (close, yz_va_lower) and yz_contracting
bool yz_resp_sell = i_yz_en and ta.crossunder(close, yz_va_upper) and yz_contracting

// Directional state memory
var int yz_state = 0
yz_state := yz_init_buy ? 1 : yz_init_sell ? -1 : nz(yz_state[1])

// ── Regime / state colors ─────────────────────────────────────────────────
color yz_c_st  = yz_state ==  1 ? YZ_BULL : yz_state == -1 ? YZ_BEAR : YZ_NEUT
color yz_c_reg = yz_regime ==  1 ? C_GOLD : yz_regime == -1 ? YZ_BEAR : YZ_NEUT

// ═══════════════════════════════════════════════════════════════════════════
// §6  AMT REJECTION SIGNALS
// ═══════════════════════════════════════════════════════════════════════════
bool _ice_vah = math.abs(close - _m_vah) <= _tol_z and _mass > 1.8 and close <= _m_vah
bool _ice_val = math.abs(close - _m_val) <= _tol_z and _mass > 1.8 and close >= _m_val
bool _rej_top = high > _m_vah and close < _m_vah and not _ice_vah
bool _rej_bot = low  < _m_val and close > _m_val and not _ice_val
bool _is_ice  = _ice_vah or _ice_val

// ═══════════════════════════════════════════════════════════════════════════
// §7  HEATMAP PIVOT ENGINE
// ═══════════════════════════════════════════════════════════════════════════
int resolution = 100

var array<box>   hm_boxes    = array.new<box>()
var array<label> hm_labels   = array.new<label>()
var array<line>  hm_lines    = array.new<line>()
var array<float> volume_bins = array.new<float>(bins, 0.)
var array<pivot> pivots      = array.new<pivot>()

// §7: ALWAYS use full lookBack_hm for h_l + pivot stats (preserves v3 display)
// DC adaptive (hm_lb_eff) applies ONLY to the line-reach in §14 hm_start loop.
// Changing this to hm_lb_eff shifts vb_max/step_bin → breaks box text format.
array<float> h_l = array.new<float>()
for i = 0 to lookBack_hm - 1
    h_l.push(high[i] + _hm_atr_off[i])
    h_l.push(low[i]  - _hm_atr_off[i])

if last_bar_index - bar_index < lookBack_hm
    float top  = h_l.max()
    float bot  = h_l.min()
    float step = (top - bot) / resolution
    float level1 = high + _atr_hm * _nVol
    float level2 = low  - _atr_hm * _nVol
    if _h2 == high
        for i = 0 to resolution - 1
            float lower = bot + step * i
            float mid   = lower + step / 2
            if math.abs(level1 - mid) <= step
                pivots.push(pivot.new(mid, bar_index, _nVol, _hm_vol, false))
    if _l2 == low
        for i = 0 to resolution - 1
            float lower = bot + step * i
            float mid   = lower + step / 2
            if math.abs(level2 - mid) <= step
                pivots.push(pivot.new(mid - _atr_hm * _nVol, bar_index, _nVol, _hm_vol, true))
    if pivots.size() > 0
        for i = pivots.size() - 1 to 0
            pivot p    = pivots.get(i)
            float y    = p.value
            bool  isLw = p.isLower
            if isLw and low < y
                pivots.remove(i)
            else if not isLw and high > y
                pivots.remove(i)

// ═══════════════════════════════════════════════════════════════════════════
// §8  PO3 TRACKING
// ═══════════════════════════════════════════════════════════════════════════
var htfHistory = array.new<HTFData>()
var float curO = na, var float curH = na, var float curL = na
var int   curOIdx = na, var int curHIdx = na, var int curLIdx = na
var float curDelta = 0.0
var int   curStartTime = na

if showPo3Input
    if htfNewBar
        if not na(curO)
            htfHistory.unshift(HTFData.new(curO, curH, curL, close[1], curOIdx, curHIdx, curLIdx, curDelta, curStartTime))
            if htfHistory.size() > 10
                htfHistory.pop()
        curO := open, curH := high, curL := low
        curOIdx := bar_index, curHIdx := bar_index, curLIdx := bar_index
        curDelta := (close > open ? volume : close < open ? -volume : 0)
        curStartTime := time
    else
        if high > curH or na(curH)
            curH := high, curHIdx := bar_index
        if low < curL or na(curL)
            curL := low, curLIdx := bar_index
        curDelta += (close > open ? volume : close < open ? -volume : 0)

// ═══════════════════════════════════════════════════════════════════════════
// §9  HTF PATTERN LOGIC
// ═══════════════════════════════════════════════════════════════════════════
bool isBullEngulfing = showEngulfingInput and hClose > hOpen and hPrevClose < hPrevOpen and hClose >= hPrevOpen and hOpen <= hPrevClose
bool isBearEngulfing = showEngulfingInput and hClose < hOpen and hPrevClose > hPrevOpen and hClose <= hPrevOpen and hOpen >= hPrevClose
bool isHammer        = showPinBarsInput   and (math.min(hOpen, hClose) - hLow) > (hHigh - hLow) * 0.6 and math.abs(hClose - hOpen) < (hHigh - hLow) * 0.3
bool isShootingStar  = showPinBarsInput   and (hHigh - math.max(hOpen, hClose)) > (hHigh - hLow) * 0.6 and math.abs(hClose - hOpen) < (hHigh - hLow) * 0.3
bool isBullPattern   = isBullEngulfing or isHammer
bool isBearPattern   = isBearEngulfing or isShootingStar

// ═══════════════════════════════════════════════════════════════════════════
// §10  RSI DIVERGENCE LOGIC  (price-scale lines only — oscillator removed)
// ═══════════════════════════════════════════════════════════════════════════
bool bullDivConfirmed = false
bool bearDivConfirmed = false

var float plPriceMem = na, var float plRsiMem = na, var int plIndexMem = na
if not na(plRsi)
    if not na(plPriceMem) and rsiValue[lbRInput] > plRsiMem and low[lbRInput] < plPriceMem
        bullDivConfirmed := true
        if showDivInput
            line.new(plIndexMem, plPriceMem, bar_index - lbRInput, low[lbRInput],
                 color=bullDivColInput, width=2)
            label.new(bar_index - lbRInput, low[lbRInput], "Bull Div",
                 yloc=yloc.belowbar, textcolor=bullDivColInput, color=#00000000,
                 size=size.small, style=label.style_label_up)
    plPriceMem := low[lbRInput], plRsiMem := rsiValue[lbRInput], plIndexMem := bar_index - lbRInput

var float phPriceMem = na, var float phRsiMem = na, var int phIndexMem = na
if not na(phRsi)
    if not na(phPriceMem) and rsiValue[lbRInput] < phRsiMem and high[lbRInput] > phPriceMem
        bearDivConfirmed := true
        if showDivInput
            line.new(phIndexMem, phPriceMem, bar_index - lbRInput, high[lbRInput],
                 color=bearDivColInput, width=2)
            label.new(bar_index - lbRInput, high[lbRInput], "Bear Div",
                 yloc=yloc.abovebar, textcolor=bearDivColInput, color=#00000000,
                 size=size.small, style=label.style_label_down)
    phPriceMem := high[lbRInput], phRsiMem := rsiValue[lbRInput], phIndexMem := bar_index - lbRInput

// ═══════════════════════════════════════════════════════════════════════════
// §11  FIX WINDOW BGCOLOR
// ═══════════════════════════════════════════════════════════════════════════
bgcolor(i_show_fix and i_fix_am_en  and _fx_am  ? i_col_fix_am  : na, title="LBMA AM Fix BG", display=display.none)
bgcolor(i_show_fix and i_fix_pm_en  and _fx_pm  ? i_col_fix_pm  : na, title="LBMA PM Fix BG", display=display.none)
bgcolor(i_show_fix and i_fix_cme_en and _fx_cme ? i_col_fix_cme : na, title="CME NY Fix BG", display=display.none)

// ═══════════════════════════════════════════════════════════════════════════
// §12  PLOTSHAPES — AMT Rejection
// ═══════════════════════════════════════════════════════════════════════════
plotshape(i_show_amt and _is_ice,  "Iceberg", shape.labelup,   location.belowbar, color.new(color.white, 100), size=size.small, text="🧊", textcolor=C_CYAN)
plotshape(i_show_amt and _rej_top, "Rej Top", shape.labeldown, location.abovebar, color.new(color.white, 100), size=size.small, text="⏹",  textcolor=C_GOLD)
plotshape(i_show_amt and _rej_bot, "Rej Bot", shape.labelup,   location.belowbar, color.new(color.white, 100), size=size.small, text="⏹",  textcolor=C_GOLD)

// ═══════════════════════════════════════════════════════════════════════════
// §13  HTF PATTERN DRAWINGS (fires on each new HTF bar)
// ═══════════════════════════════════════════════════════════════════════════
if htfNewBar and not na(hTimeStart)
    if isBullPattern
        drawHtfPattern(
             isBullEngulfing ? "Bull Engulfing" : "Hammer",
             hHigh, hLow, hOpen, hClose, hTimeStart, hTimeEnd, bullPatternColInput, true)
    if isBearPattern
        drawHtfPattern(
             isBearEngulfing ? "Bear Engulfing" : "Shooting Star",
             hHigh, hLow, hOpen, hClose, hTimeStart, hTimeEnd, bearPatternColInput, false)

// ═══════════════════════════════════════════════════════════════════════════
// §14  BARSTATE.ISLAST — Volume Profile + Heatmap + Info Label
// ═══════════════════════════════════════════════════════════════════════════
var array<box>   _vp_boxes = array.new<box>()
var array<line>  _vp_lines = array.new<line>()
var array<label> _vp_lbls  = array.new<label>()
var int hm_start = 0
var label _mq_lbl = na

if barstate.islast

    // ── Line style helpers ────────────────────────────────────────────────
    string _poc_ls = switch i_poc_style
        "Dashed" => line.style_dashed
        "Dotted" => line.style_dotted
        =>          line.style_solid
    string _vah_ls = switch i_vah_style
        "Dashed" => line.style_dashed
        "Dotted" => line.style_dotted
        =>          line.style_solid
    string _val_ls = switch i_val_style
        "Dashed" => line.style_dashed
        "Dotted" => line.style_dotted
        =>          line.style_solid

    // ── Clear VP objects ──────────────────────────────────────────────────
    if array.size(_vp_boxes) > 0
        for _vpb in _vp_boxes
            box.delete(_vpb)
        array.clear(_vp_boxes)
    if array.size(_vp_lines) > 0
        for _vpln in _vp_lines
            line.delete(_vpln)
        array.clear(_vp_lines)
    if array.size(_vp_lbls) > 0
        for _vplb in _vp_lbls
            label.delete(_vplb)
        array.clear(_vp_lbls)

    // ══════════════════════════════════════════════════════════════════════
    // VOLUME PROFILE  (QC_SovereignMatrix v2.1 §25 — verbatim, adaptive range)
    // ══════════════════════════════════════════════════════════════════════
    if i_show_vp
        // Adaptive VP range using vp_lb_eff
        int   _vp_bars_act = vp_lb_eff
        float _vp_hi_act   = close
        float _vp_lo_act   = close
        for _ri = 1 to _vp_bars_act - 1
            _vp_hi_act := math.max(_vp_hi_act, nz(high[_ri],  high))
            _vp_lo_act := math.min(_vp_lo_act, nz(low[_ri],   low))

        float _vp_step = math.max((_vp_hi_act - _vp_lo_act) / i_vp_rows, syminfo.mintick)
        float[] _vp_lv = array.new_float(i_vp_rows + 1)
        for _i = 0 to i_vp_rows
            array.set(_vp_lv, _i, _vp_lo_act + float(_i) * _vp_step)
        float[] _vp_bu = array.new_float(i_vp_rows, 0.0)
        float[] _vp_be = array.new_float(i_vp_rows, 0.0)
        for _b = 0 to _vp_bars_act - 1
            int _ix = math.max(0, math.min(i_vp_rows - 1, int((close[_b] - _vp_lo_act) / _vp_step)))
            if close[_b] >= open[_b]
                array.set(_vp_bu, _ix, array.get(_vp_bu, _ix) + volume[_b])
            else
                array.set(_vp_be, _ix, array.get(_vp_be, _ix) + volume[_b])
        float[] _tv      = array.new_float(i_vp_rows)
        float   _mx_v    = 0.0
        int     _poc_idx = 0
        for _i = 0 to i_vp_rows - 1
            float _vp_t = array.get(_vp_bu, _i) + array.get(_vp_be, _i)
            array.set(_tv, _i, _vp_t)
            if _vp_t > _mx_v
                _mx_v    := _vp_t
                _poc_idx := _i
        float _va_total  = array.get(_tv, _poc_idx)
        float _va_target = array.sum(_tv) * i_vp_pct / 100.0
        int   _va_up     = _poc_idx
        int   _va_dn     = _poc_idx
        for _x = 0 to i_vp_rows - 1
            if _va_total >= _va_target
                break
            float _uv = _va_up < i_vp_rows - 1 ? array.get(_tv, _va_up + 1) : 0.0
            float _dv = _va_dn > 0             ? array.get(_tv, _va_dn - 1) : 0.0
            if _uv >= _dv
                _va_total += _uv
                _va_up    += 1
            else
                _va_total += _dv
                _va_dn    -= 1
        float _poc_lvl = (array.get(_vp_lv, _poc_idx) + array.get(_vp_lv, _poc_idx + 1)) / 2.0
        float _vah_lvl = array.get(_vp_lv, math.min(_va_up + 1, i_vp_rows))
        float _val_lvl = array.get(_vp_lv, _va_dn)
        float _dist_vp = (_vp_hi_act - _vp_lo_act) / 500.0
        int   _vp_left = bar_index - _vp_bars_act + 1
        int   _vp_rght = bar_index + 10
        if i_vp_show_boxes and _mx_v > 0
            for _i = 0 to i_vp_rows - 1
                float _bu2 = array.get(_vp_bu, _i)
                float _be2 = array.get(_vp_be, _i)
                float _tot = _bu2 + _be2
                if _tot > 0
                    int   _nv  = int(math.round((_tot / _mx_v) * _vp_bars_act))
                    int   _nb  = int(math.round((_bu2 / _tot) * _nv))
                    int   _xl  = bar_index + _vp_bars_act - _nv
                    float _lo  = array.get(_vp_lv, _i)
                    float _hi  = array.get(_vp_lv, _i + 1)
                    bool  _inva = _i >= _va_dn and _i <= _va_up
                    if _nb > 0
                        array.push(_vp_boxes, box.new(_xl, _hi - _dist_vp, _xl + _nb, _lo + _dist_vp,
                             border_color=na, bgcolor=_inva ? color.new(#2962FF, 30) : color.new(#2962FF, 75)))
                    int _nbe = _nv - _nb
                    if _nbe > 0
                        array.push(_vp_boxes, box.new(_xl + _nb, _hi - _dist_vp, _xl + _nv, _lo + _dist_vp,
                             border_color=na, bgcolor=_inva ? color.new(#FF6F00, 30) : color.new(#FF6F00, 75)))
        if i_vp_show_poc
            array.push(_vp_lines, line.new(_vp_left, _poc_lvl, _vp_rght, _poc_lvl,
                 color=i_c_poc_line, width=i_poc_width, style=_poc_ls))
            if i_vp_show_poc_lbl
                array.push(_vp_lbls, label.new(_vp_rght, _poc_lvl,
                     "POC $" + str.tostring(math.round_to_mintick(_poc_lvl)),
                     style=label.style_label_left,
                     color=color.new(i_c_poc_line, 80), textcolor=i_c_poc_line, size=size.tiny))
        if i_vp_show_vah
            array.push(_vp_lines, line.new(_vp_left, _vah_lvl, _vp_rght, _vah_lvl,
                 color=i_c_vah_line, width=i_vah_width, style=_vah_ls))
            if i_vp_show_vah_lbl
                array.push(_vp_lbls, label.new(_vp_rght, _vah_lvl, "VAH",
                     style=label.style_none, textcolor=i_c_vah_line, size=size.tiny))
        if i_vp_show_val
            array.push(_vp_lines, line.new(_vp_left, _val_lvl, _vp_rght, _val_lvl,
                 color=i_c_val_line, width=i_val_width, style=_val_ls))
            if i_vp_show_val_lbl
                array.push(_vp_lbls, label.new(_vp_rght, _val_lvl, "VAL",
                     style=label.style_none, textcolor=i_c_val_line, size=size.tiny))

    // ══════════════════════════════════════════════════════════════════════
    // HEATMAP VISUALIZATION  (EA FundOS v2.1 §9 — verbatim, entropy-adjusted)
    // ══════════════════════════════════════════════════════════════════════
    if hm_lines.size() > 0
        for _hln in hm_lines
            _hln.delete()
        hm_lines.clear()
    for b in hm_boxes
        b.delete()
    hm_boxes.clear()
    for lbl in hm_labels
        lbl.delete()
    hm_labels.clear()

    // Entropy-adjusted transparency
    int _adj_tr_buy  = math.min(95, i_buy_tr  + _ent_tr_add)
    int _adj_tr_sell = math.min(95, i_sell_tr + _ent_tr_add)

    if h_l.size() >= 2
        float _hl_max = h_l.max()
        float _hl_min = h_l.min()
        if not na(_hl_max) and not na(_hl_min) and _hl_max > _hl_min
            float step_bin = (_hl_max - _hl_min) / bins
            for j = 0 to bins - 1
                volume_bins.set(j, 0)
            if pivots.size() > 0
                for i = 0 to pivots.size() - 1
                    pivot lvl    = pivots.get(i)
                    float vol_   = lvl.vol
                    float line_y = lvl.value
                    for j = 0 to bins - 1
                        float lower_b = _hl_min + step_bin * j
                        float mid_b   = lower_b + step_bin / 2
                        if math.abs(line_y - mid_b) < step_bin
                            volume_bins.set(j, volume_bins.get(j) + vol_)
            float vb_max = volume_bins.max()
            float vb_min = volume_bins.min()
            float vb_avg = volume_bins.avg()
            if vb_max > 0
                for j = 0 to bins - 1
                    float lower_b  = _hl_min + step_bin * j
                    float upper_b  = lower_b + step_bin
                    float mid_b    = lower_b + step_bin / 2
                    float voll     = volume_bins.get(j)
                    float valueVol = voll / vb_max * 50
                    color col_bin  = close > mid_b ? buyColor : sellColor
                    color m_col    = color.from_gradient(voll, vb_min, vb_max,
                                         color.new(col_bin, 80), color.new(col_bin, 0))
                    color m_col1   = color.from_gradient(voll, vb_min, vb_max,
                                         color.new(col_bin, 50), color.new(col_bin, 0))
                    if not (close < upper_b and close > lower_b)
                        if displPf and valueVol != 0 and i_hm_show_boxes
                            hm_boxes.push(box.new(
                                 bar_index + hm_offset,
                                 upper_b,
                                 bar_index + hm_offset + int(valueVol),
                                 lower_b,
                                 bgcolor      = voll == vb_max and poc_show ? maxColor : m_col,
                                 border_color = chart.bg_color,
                                 text         = voll > vb_avg ? str.tostring(voll, format.volume) : "",
                                 text_halign  = text.align_left))
                            hm_boxes.push(box.new(
                                 bar_index + hm_offset,
                                 upper_b,
                                 bar_index + hm_offset + 5,
                                 lower_b,
                                 text         = str.tostring(valueVol * 2, format.percent),
                                 bgcolor      = color(na),
                                 border_color = color(na),
                                 text_color   = voll == vb_max ? maxColor : m_col1))
                        if i_hm_show_lines
                            bool isLower_cond = close > mid_b
                            for i = 0 to hm_lb_eff - 1
                                if isLower_cond
                                    if low[i] < mid_b
                                        hm_start := bar_index - i
                                        break
                                    if i == hm_lb_eff - 1
                                        hm_start := bar_index - i
                                        break
                                else
                                    if high[i] > mid_b
                                        hm_start := bar_index - i
                                        break
                                    if i == hm_lb_eff - 1
                                        hm_start := bar_index - i
                                        break
                            color color_ln = voll == vb_max and poc_show
                                 ? maxColor
                                 : color.from_gradient(valueVol, 0, 50, color(na),
                                       isLower_cond
                                       ? color.new(buyColor,  _adj_tr_buy)
                                       : color.new(sellColor, _adj_tr_sell))
                            hm_lines.push(line.new(
                                 hm_start + 3, mid_b,
                                 bar_index + hm_offset, mid_b,
                                 width = math.max(1, int(valueVol / 5)),
                                 color = color_ln))

    // ══════════════════════════════════════════════════════════════════════
    // §14b  MARKET QUALITY INFO LABEL (DC + Entropy + VPIN)
    // ══════════════════════════════════════════════════════════════════════
    if i_dc_show_lbl or i_ent_show_lbl or i_vpin_show_lbl
        label.delete(_mq_lbl)
        string _s1 = i_dc_en   ? "DC:" + str.tostring(dc_int) + "b  HM:" + str.tostring(hm_lb_eff) + "  VP:" + str.tostring(i_vp_bars) + "(fixed)" : ""
        string _s2 = i_ent_en  ? "H:" + str.tostring(math.round(_ent_norm*100.0)) + "%  " + _ent_str : ""
        string _s3 = i_vpin_en ? "VPIN:" + str.tostring(math.round(_vpin_val*100.0)) + "%  " + _vpin_str : ""
        string _sep1 = _s1 != "" and _s2 != "" ? "\n" : ""
        string _sep2 = (_s1 != "" or _s2 != "") and _s3 != "" ? "\n" : ""
        string _full = _s1 + _sep1 + _s2 + _sep2 + _s3
        if _full != ""
            _mq_lbl := label.new(bar_index + 4, high + _atr14_g*0.8, _full,
                 style=label.style_label_left, color=color.new(#0D1117,75),
                 textcolor=_ent_col, size=size.small)

// ═══════════════════════════════════════════════════════════════════════════
// §15  BARSTATE.ISLAST — PO3 UI
// ═══════════════════════════════════════════════════════════════════════════
var uiElements = array.new<HTFCandleUI>()

if barstate.islast and showPo3Input
    if uiElements.size() > 0
        for i = 0 to uiElements.size() - 1
            HTFCandleUI ui = uiElements.get(i)
            ui.body.delete()
            ui.wick.delete()
            if not na(ui.oM)
                ui.oM.delete()
            if not na(ui.hM)
                ui.hM.delete()
            if not na(ui.lM)
                ui.lM.delete()
            if not na(ui.cM)
                ui.cM.delete()
            if not na(ui.oL)
                ui.oL.delete()
            if not na(ui.hL)
                ui.hL.delete()
            if not na(ui.lL)
                ui.lL.delete()
            if not na(ui.cL)
                ui.cL.delete()
            if not na(ui.dL)
                ui.dL.delete()
            if not na(ui.tL)
                ui.tL.delete()
    uiElements.clear()

    int candleWidth = 6
    int candleGap   = 10
    for p = 0 to candleCountInput - 1
        bool isLive   = (p == candleCountInput - 1)
        HTFData data  = isLive
             ? HTFData.new(curO, curH, curL, close, curOIdx, curHIdx, curLIdx, curDelta, curStartTime)
             : (htfHistory.size() > (candleCountInput - 2) - p ? htfHistory.get((candleCountInput - 2) - p) : na)
        if not na(data)
            int   startIdx  = last_bar_index + po3OffsetInput + (p * (candleWidth + candleGap))
            int   endIdx    = startIdx + candleWidth
            int   midIdx    = (startIdx + endIdx) / 2
            color baseColor = data.c >= data.o ? bullPatternColInput : bearPatternColInput
            color wickColor = isLive ? baseColor : color.new(baseColor, 70)
            line  wLine     = line.new(midIdx, data.h, midIdx, data.l, color=wickColor, width=2)
            box   bBox      = box.new(startIdx, math.max(data.o, data.c), endIdx, math.min(data.o, data.c),
                 border_color=wickColor, bgcolor=color.new(baseColor, isLive ? 20 : 85))
            line oM = na, line hM = na, line lM = na, line cM = na
            label oL = na, label hL = na, label lL = na, label cL = na, label dL = na
            if isLive
                oM := line.new(data.oIdx, data.o, startIdx, data.o, color=NEUTRAL_COLOR,       style=line.style_dashed)
                hM := line.new(data.hIdx, data.h, midIdx,   data.h, color=bullPatternColInput, style=line.style_dashed)
                lM := line.new(data.lIdx, data.l, midIdx,   data.l, color=bearPatternColInput, style=line.style_dashed)
                cM := line.new(bar_index, data.c, endIdx,   data.c, color=baseColor,           style=line.style_dashed)
                if showPo3LabelsInput
                    oL := label.new(endIdx + 1, data.o, "Open: "  + str.tostring(data.o, format.mintick), color=#00000000, textcolor=NEUTRAL_COLOR,       style=label.style_label_left, size=size.small)
                    hL := label.new(endIdx + 1, data.h, "High: "  + str.tostring(data.h, format.mintick), color=#00000000, textcolor=bullPatternColInput, style=label.style_label_left, size=size.small)
                    lL := label.new(endIdx + 1, data.l, "Low: "   + str.tostring(data.l, format.mintick), color=#00000000, textcolor=bearPatternColInput, style=label.style_label_left, size=size.small)
                    cL := label.new(endIdx + 1, data.c, "Close: " + str.tostring(data.c, format.mintick), color=#00000000, textcolor=baseColor,            style=label.style_label_left, size=size.small)
            int    totalMins = timeframe.in_seconds(htfInput) / 60
            string tfStr     = totalMins >= 1440 ? str.tostring(totalMins / 1440) + "D" :
                               totalMins >= 60   ? str.tostring(totalMins / 60)   + "H" :
                               str.tostring(totalMins) + "m"
            label tL = label.new(midIdx, data.h,
                 tfStr + (not isLive ? "\n" + str.format_time(data.startTime, "HH:mm", syminfo.timezone) : ""),
                 color=#00000000,
                 textcolor=isLive ? NEUTRAL_COLOR : color.new(NEUTRAL_COLOR, 60),
                 style=label.style_label_down, size=size.normal)
            if showPo3DeltaInput
                dL := label.new(midIdx, data.l, "Delta: " + formatDelta(data.delta),
                     color=#00000000,
                     textcolor=isLive ? (data.delta >= 0 ? bullPatternColInput : bearPatternColInput) : color.new(NEUTRAL_COLOR, 60),
                     style=label.style_label_up, size=size.normal)
            uiElements.push(HTFCandleUI.new(bBox, wLine, oM, hM, lM, cM, oL, hL, lL, cL, dL, tL))

// ═══════════════════════════════════════════════════════════════════════════
// §16  ALERTS
// ═══════════════════════════════════════════════════════════════════════════
if alertBullDivInput and bullDivConfirmed
    alert("Bullish RSI Divergence on " + syminfo.ticker, alert.freq_once_per_bar_close)
if alertBearDivInput and bearDivConfirmed
    alert("Bearish RSI Divergence on " + syminfo.ticker, alert.freq_once_per_bar_close)
if alertBullEngInput and htfNewBar and isBullEngulfing
    alert("HTF Bullish Engulfing on " + syminfo.ticker, alert.freq_once_per_bar_close)
if alertBearEngInput and htfNewBar and isBearEngulfing
    alert("HTF Bearish Engulfing on " + syminfo.ticker, alert.freq_once_per_bar_close)
if alertHammerInput and htfNewBar and isHammer
    alert("HTF Hammer on " + syminfo.ticker, alert.freq_once_per_bar_close)
if alertStarInput and htfNewBar and isShootingStar
    alert("HTF Shooting Star on " + syminfo.ticker, alert.freq_once_per_bar_close)
// ── v4 Alerts ─────────────────────────────────────────────────────────────
if _vpin_tox_bull and not _vpin_tox_bull[1]
    alert("VPIN Toxic Bull Flow on " + syminfo.ticker, alert.freq_once_per_bar_close)
if _vpin_tox_bear and not _vpin_tox_bear[1]
    alert("VPIN Toxic Bear Flow on " + syminfo.ticker, alert.freq_once_per_bar_close)
if _ent_struct and not _ent_struct[1]
    alert("Entropy: Market turned STRUCTURED on " + syminfo.ticker, alert.freq_once_per_bar_close)
if _ent_random and not _ent_random[1]
    alert("Entropy: Market turned RANDOM on " + syminfo.ticker, alert.freq_once_per_bar_close)

// ═══════════════════════════════════════════════════════════════════════════
// §17  KALMAN D7 PLOTS  (et20tradeview — MPL 2.0)
// ═══════════════════════════════════════════════════════════════════════════
p2 = plot(show_pul ? ema2 : na, "Pumori",        color=color.new(color.purple, 70), force_overlay=true)
p3 = plot(show_pul ? ema2 : na, offset=-1,        color=color.new(color.purple, 70), force_overlay=true)
fill(p2, p3, color=color.new(#69359C, 70), title="Lag Shading")

p4 = plot(smoothb, "Kalman Base", color=color.rgb(230, 65, 195), linewidth=2, display=display.none)
p5 = plot(smooths, "Kalman Fast", color=color.rgb(80, 100, 240), linewidth=2, display=display.none)

fill(p4, p5, color=smooths > smoothb ? color.new(color.aqua, 80) : color.new(color.red, 80), title="Kalman Fill")

// ── RQ-Kernel Plots ───────────────────────────────────────────────────────
p_rq_fast = plot(i_rq_en ? rq_fast : na, "RQ-Kernel Fast", color=i_rq_fast_col, linewidth=2, display=display.none)
p_rq_slow = plot(i_rq_en ? rq_slow : na, "RQ-Kernel Slow", color=i_rq_slow_col, linewidth=2, display=display.none)
fill(p_rq_fast, p5, i_rq_en and i_rq_show_ub ? i_rq_ub_col : na, title="RQ-Kalman Uncertainty Band")

// ── VPIN Plotshapes ───────────────────────────────────────────────────────
plotshape(i_vpin_en and _vpin_tox_bull and not _vpin_tox_bull[1], "VPIN Toxic Bull", shape.labeldown, location.abovebar, color.new(i_vpin_tox_col,20), size=size.tiny, text="⚡", textcolor=color.white, display=display.none)
plotshape(i_vpin_en and _vpin_tox_bear and not _vpin_tox_bear[1], "VPIN Toxic Bear", shape.labelup, location.belowbar, color.new(i_vpin_tox_col,20), size=size.tiny, text="⚡", textcolor=color.white, display=display.none)

// ═══════════════════════════════════════════════════════════════════════════
// §18  ⑭ PREDICTIVE MONTE CARLO ENGINE — VISUALIZATION (LuxAlgo, namespaced)
// ═══════════════════════════════════════════════════════════════════════════
bool mc_isTrigger = barstate.islast
if mc_anchorInput
    mc_isTrigger := (bar_index % mc_anchorStep == 0)

if mc_enableInput and mc_isTrigger
    if not mc_anchorInput
        for pl in mc_polylines
            pl.delete()
        mc_polylines.clear()
        for l in mc_srLines
            l.delete()
        mc_srLines.clear()
        for lbl in mc_srLabels
            lbl.delete()
        mc_srLabels.clear()
        for b in mc_srBoxes
            b.delete()
        mc_srBoxes.clear()

    if mc_logReturns.size() >= 2
        // Filter valid indices for Regime
        array<int>   mc_validIndices    = array.new<int>()
        array<float> mc_validLogReturns = array.new<float>()
        array<float> mc_validSimReturns = array.new<float>()

        for k = 0 to mc_simReturns.size() - 1
            if mc_regimeInput == MC_REGIME_NONE or mc_regimes.get(k) == mc_currentRegime
                mc_validIndices.push(k)
                mc_validLogReturns.push(mc_logReturns.get(k))
                mc_validSimReturns.push(mc_simReturns.get(k))

        if mc_validIndices.size() == 0 // Fallback if no matching regime found
            for k = 0 to mc_simReturns.size() - 1
                mc_validIndices.push(k)
                mc_validLogReturns.push(mc_logReturns.get(k))
                mc_validSimReturns.push(mc_simReturns.get(k))

        float mc_muLog = mc_validLogReturns.avg()
        float mc_sigmaLog = nz(mc_validLogReturns.stdev() * mc_volMulti)

        float mc_muSimp = mc_validSimReturns.avg()
        float mc_sigmaSimp = nz(mc_validSimReturns.stdev() * mc_volMulti)

        int mc_seedSalt = 0
        if mc_methodInput == MC_METHOD_GBM
            mc_seedSalt := 1000
        else if mc_methodInput == MC_METHOD_SRW
            mc_seedSalt := 2000

        LCG mc_rng = LCG.new(int(time) + mc_seedInput + mc_seedSalt)
        array<Path> mc_paths = array.new<Path>()

        array<float> mc_avgPathPoints = array.new<float>(mc_projInput + 1, 0.0)

        for i = 0 to mc_simInput - 1
            array<chart.point> pts = array.new<chart.point>()
            pts.push(chart.point.now(close))
            mc_avgPathPoints.set(0, mc_avgPathPoints.get(0) + close)

            float currentPrice = close

            for j = 1 to mc_projInput
                float stepReturn = 0.0

                if mc_methodInput == MC_METHOD_HS
                    int idx = mc_rng.nextInt(0, mc_validIndices.size() - 1)
                    stepReturn := mc_simReturns.get(mc_validIndices.get(idx))
                    currentPrice += stepReturn

                else if mc_methodInput == MC_METHOD_SRW
                    float z = mc_rng.nextGaussian()
                    stepReturn := mc_muSimp + mc_sigmaSimp * z
                    currentPrice += stepReturn

                else if mc_methodInput == MC_METHOD_GBM
                    float z = mc_rng.nextGaussian()
                    stepReturn := math.exp((mc_muLog - math.pow(mc_sigmaLog, 2) / 2.0) + mc_sigmaLog * z)
                    currentPrice *= stepReturn

                pts.push(chart.point.from_index(bar_index + j, currentPrice))
                mc_avgPathPoints.set(j, mc_avgPathPoints.get(j) + currentPrice)

            mc_paths.push(Path.new(pts, currentPrice))

        // Get Percentiles for Path Coloring
        array<float> mc_endPrices = array.new<float>()
        for p in mc_paths
            mc_endPrices.push(p.endPrice)

        mc_endPrices.sort()
        float mc_pTopRaw = mc_endPrices.percentile_nearest_rank(mc_topPercentile)
        float mc_pBotRaw = mc_endPrices.percentile_nearest_rank(mc_botPercentile)

        float mc_pMean = mc_endPrices.avg()
        float mc_pMedian = mc_endPrices.percentile_nearest_rank(50.0)
        float mc_pMaxRaw = mc_endPrices.max()
        float mc_pMinRaw = mc_endPrices.min()

        float mc_pTop = math.max(mc_pTopRaw, close)
        float mc_pBot = math.min(mc_pBotRaw, close)
        float mc_pMax = math.max(mc_pMaxRaw, mc_pTop + syminfo.mintick)
        float mc_pMin = math.min(mc_pMinRaw, mc_pBot - syminfo.mintick)

        // ⑮ persist band bounds for the confluence signal
        mc_bandR1   := mc_pTop
        mc_bandS1   := mc_pBot
        mc_bandMax  := mc_pMax
        mc_bandMin  := mc_pMin
        mc_bandMean := mc_pMean

        if mc_srInput
            int endIdx = bar_index + mc_projInput

            float zHeight = (mc_pMax - mc_pMin) * 0.015
            int hSteps = math.min(50, mc_projInput)
            float stepSize = float(mc_projInput) / hSteps

            for i = 0 to hSteps - 1
                int leftBar = bar_index + math.round(i * stepSize)
                int rightBar = bar_index + math.round((i + 1) * stepSize)
                int transp = 30 + int(70 * (float(i) / (hSteps - 1)))

                mc_srBoxes.push(box.new(leftBar, mc_pMax + zHeight, rightBar, mc_pMax - zHeight, border_color = na, bgcolor = color.new(mc_topColor, transp)))
                mc_srBoxes.push(box.new(leftBar, mc_pTop + zHeight, rightBar, mc_pTop - zHeight, border_color = na, bgcolor = color.new(mc_topColor, transp)))
                mc_srBoxes.push(box.new(leftBar, mc_pBot + zHeight, rightBar, mc_pBot - zHeight, border_color = na, bgcolor = color.new(mc_bottomColor, transp)))
                mc_srBoxes.push(box.new(leftBar, mc_pMin + zHeight, rightBar, mc_pMin - zHeight, border_color = na, bgcolor = color.new(mc_bottomColor, transp)))

            mc_srLabels.push(label.new(endIdx, mc_pMax, "Max", color = #00000000, textcolor = mc_topColor, style = label.style_label_left, size = size.small))
            mc_srLabels.push(label.new(endIdx, mc_pTop, "R1", color = #00000000, textcolor = mc_topColor, style = label.style_label_left, size = size.small))
            mc_srLabels.push(label.new(endIdx, mc_pBot, "S1", color = #00000000, textcolor = mc_bottomColor, style = label.style_label_left, size = size.small))
            mc_srLabels.push(label.new(endIdx, mc_pMin, "Min", color = #00000000, textcolor = mc_bottomColor, style = label.style_label_left, size = size.small))

        // Draw the simulation polylines
        if not mc_anchorInput or mc_anchorPaths
            for p in mc_paths
                color pathColor = mc_midColor
                if p.endPrice >= mc_pTop
                    pathColor := mc_topColor
                else if p.endPrice <= mc_pBot
                    pathColor := mc_bottomColor

                mc_polylines.push(polyline.new(p.pts, line_color = color.new(pathColor, mc_transpInput), line_width = 1))

        // Calculate Envelope Coordinates
        array<chart.point> mc_maxPts = array.new<chart.point>()
        array<chart.point> mc_minPts = array.new<chart.point>()

        for j = 0 to mc_projInput
            float maxAtJ = na
            float minAtJ = na
            for i = 0 to mc_simInput - 1
                float val = mc_paths.get(i).pts.get(j).price
                if na(maxAtJ) or val > maxAtJ
                    maxAtJ := val
                if na(minAtJ) or val < minAtJ
                    minAtJ := val

            mc_maxPts.push(chart.point.from_index(bar_index + j, maxAtJ))
            mc_minPts.unshift(chart.point.from_index(bar_index + j, minAtJ))

        array<chart.point> mc_envPts = array.copy(mc_maxPts)
        for pt in mc_minPts
            mc_envPts.push(pt)
        mc_envPts.push(mc_maxPts.get(0))

        // Draw the envelope and average
        mc_polylines.push(polyline.new(mc_envPts, line_color = na, fill_color = mc_envColor))

        array<chart.point> mc_avgPts = array.new<chart.point>()
        for j = 0 to mc_projInput
            mc_avgPts.push(chart.point.from_index(bar_index + j, mc_avgPathPoints.get(j) / mc_simInput))

        mc_polylines.push(polyline.new(mc_avgPts, line_color = mc_avgColor, line_width = 2))

        // Combine Dashboard
        if mc_dashboardInput
            var table t_able = table.new(mc_parsedDashboardPosition, mc_dash2Input ? 5 : 2, 9, bgcolor = MC_BACKGROUND, border_width = 0, frame_color = MC_BORDERS, frame_width = 1, force_overlay = false)

            t_able.merge_cells(0, 0, 1, 0)
            mc_cell(t_able, 0, 0, 'Monte Carlo Metrics', text_col = MC_DATA, align = text.align_center)

            mc_divider(t_able, 1, mc_dash2Input ? 4 : 1)

            mc_cell(t_able, 0, 2, 'Mean Expected', text_col = MC_HEADERS, align = text.align_left)
            mc_cell(t_able, 1, 2, str.tostring(mc_pMean, format.mintick), text_col = MC_DATA)

            mc_divider(t_able, 3, mc_dash2Input ? 4 : 1)

            mc_cell(t_able, 0, 4, 'Median Expected', text_col = MC_HEADERS, align = text.align_left)
            mc_cell(t_able, 1, 4, str.tostring(mc_pMedian, format.mintick), text_col = MC_DATA)

            mc_divider(t_able, 5, mc_dash2Input ? 4 : 1)

            mc_cell(t_able, 0, 6, 'Max Projection', text_col = MC_HEADERS, align = text.align_left)
            mc_cell(t_able, 1, 6, str.tostring(mc_pMax, format.mintick), text_col = MC_DATA)

            mc_divider(t_able, 7, mc_dash2Input ? 4 : 1)

            mc_cell(t_able, 0, 8, 'Min Projection', text_col = MC_HEADERS, align = text.align_left)
            mc_cell(t_able, 1, 8, str.tostring(mc_pMin, format.mintick), text_col = MC_DATA)

            // Render the candle next to the metrics if dashed input is on
            if mc_dash2Input
                if mc_endPrices.size() > 0
                    float pred_open = close
                    float pred_close = mc_pMean
                    float p90 = mc_endPrices.percentile_nearest_rank(90.0)
                    float p10 = mc_endPrices.percentile_nearest_rank(10.0)

                    float pred_high = math.max(p90, math.max(pred_open, pred_close))
                    float pred_low = math.min(p10, math.min(pred_open, pred_close))

                    color pred_color = pred_close >= pred_open ? mc_bullColor : mc_bearColor

                    t_able.merge_cells(2, 0, 4, 0)
                    mc_cell(t_able, 2, 0, 'Forecasted Candle', text_col = MC_DATA, align = text.align_center)

                    mc_cell(t_able, 2, 2, 'Direction', text_col = MC_HEADERS, align = text.align_left)
                    mc_cell(t_able, 3, 2, pred_close >= pred_open ? "Bullish" : "Bearish", text_col = pred_color)

                    mc_cell(t_able, 2, 4, 'Expected High', text_col = MC_HEADERS, align = text.align_left)
                    mc_cell(t_able, 3, 4, str.tostring(pred_high, format.mintick), text_col = MC_DATA)

                    mc_cell(t_able, 2, 6, 'Expected Close', text_col = MC_HEADERS, align = text.align_left)
                    mc_cell(t_able, 3, 6, str.tostring(pred_close, format.mintick), text_col = MC_DATA)

                    mc_cell(t_able, 2, 8, 'Expected Low', text_col = MC_HEADERS, align = text.align_left)
                    mc_cell(t_able, 3, 8, str.tostring(pred_low, format.mintick), text_col = MC_DATA)

                    t_able.merge_cells(4, 2, 4, 8)

                    float pRange = math.max(pred_high - pred_low, syminfo.mintick)
                    float bodyTop = math.max(pred_open, pred_close)
                    float bodyBot = math.min(pred_open, pred_close)

                    int totalLevels = 9
                    int topWickLevels = math.max(0, math.round((pred_high - bodyTop) / pRange * totalLevels))
                    int botWickLevels = math.max(0, math.round((bodyBot - pred_low) / pRange * totalLevels))
                    int bodyLevels = math.max(1, math.round((bodyTop - bodyBot) / pRange * totalLevels))

                    int currentTotal = topWickLevels + botWickLevels + bodyLevels
                    if currentTotal > totalLevels
                        int diff = currentTotal - totalLevels
                        while diff > 0
                            if topWickLevels >= botWickLevels and topWickLevels > 0
                                topWickLevels -= 1
                            else if botWickLevels > 0
                                botWickLevels -= 1
                            else
                                bodyLevels -= 1
                            diff -= 1
                    else if currentTotal < totalLevels
                        int diff = totalLevels - currentTotal
                        bodyLevels += diff

                    string visualCandle = ""
                    if topWickLevels > 0
                        for i = 1 to topWickLevels
                            visualCandle += "│\n"
                    if bodyLevels > 0
                        for i = 1 to bodyLevels
                            visualCandle += "██\n"
                    if botWickLevels > 0
                        for i = 1 to botWickLevels
                            visualCandle += "│\n"

                    visualCandle := str.substring(visualCandle, 0, math.max(0, str.length(visualCandle) - 1))

                    mc_cell(t_able, 4, 2, visualCandle, text_col = pred_color, align = text.align_center)

// ═══════════════════════════════════════════════════════════════════════════
// §18b  ⑱ CVD-CONFLUENCE GATE — booleans consumed by ⑮/⑯  (v18, default OFF)
//   Declared here (before §19) so the signals can read the HV-Pivot level
//   arrays. Arrays are var + maintained in §22, which runs LATER in the bar, so
//   here we see levels confirmed up to the PREVIOUS bar → no lookahead. A gate
//   only bites when its toggle AND ⑱ levels are both ON; otherwise it is a
//   transparent no-op and ⑮/⑯ keep their exact validated behaviour.
// ═══════════════════════════════════════════════════════════════════════════
var array<hvLevel> _hv_res = array.new<hvLevel>()   // maintained in §22
var array<hvLevel> _hv_sup = array.new<hvLevel>()   // maintained in §22

bool  _hv_gate_sig_on = i_hv_gate_sig and i_hv_en
bool  _hv_gate_tri_on = i_hv_gate_tri and i_hv_en

float _hv_g_atr = ta.atr(14)
float _hv_g_tol = nz(_hv_g_atr, syminfo.mintick * 50.0) * i_hv_gate_atr

// BUY needs an accumulation-confirmed support at price; SELL a distribution-
// confirmed resistance. Proximity already implies price is AT the level, so no
// separate above/below check is needed — the CVD sign does the quality filter.
bool _hv_buy_ok = false
if i_hv_en
    for _lv in _hv_sup
        if math.abs(close - _lv.price) <= _hv_g_tol and _lv.cvd >= i_hv_gate_cvd
            _hv_buy_ok := true
bool _hv_sell_ok = false
if i_hv_en
    for _lv in _hv_res
        if math.abs(close - _lv.price) <= _hv_g_tol and _lv.cvd <= -i_hv_gate_cvd
            _hv_sell_ok := true

// ═══════════════════════════════════════════════════════════════════════════
// §19  ⑮ CONFLUENCE BUY / SELL SIGNAL  (v8)
//      ALL must align:
//        1) Price INSIDE Monte Carlo band (between S1 and R1)
//        2) Near a significant level (AMT VWMA value band / RQ-Kernel)
//        3) Multi-TF OB/OS : current(M5) + (H1 or H4) agree
//        4) Order-flow confirm : rejection / iceberg / delta  (>= i_sig_need_of)
//        5) (optional) Kalman turn  +  (optional) Entropy quality
//      Labels and Arrows(plotshape) toggle independently.
// ═══════════════════════════════════════════════════════════════════════════
// 1) Price INSIDE the Monte Carlo band (between S1 and R1)
bool  _sig_ready = i_sig_en and not na(mc_bandS1) and not na(mc_bandR1) and (not mc_anchorInput or (bar_index % mc_anchorStep) <= mc_projInput)   // v22: band expires with its projection
float _mc_mid    = nz(mc_bandMean, (nz(mc_bandS1) + nz(mc_bandR1)) / 2.0)
bool  _in_band   = _sig_ready and close >= mc_bandS1 - i_sig_mc_tol and close <= mc_bandR1 + i_sig_mc_tol
bool  _buy_band  = _in_band and (i_sig_band == "Lower/Upper half" ? close <= _mc_mid : true)
bool  _sell_band = _in_band and (i_sig_band == "Lower/Upper half" ? close >= _mc_mid : true)

// 2) Significant-level proximity (AMT VWMA value band + RQ-Kernel)
float _sig_atr  = ta.atr(14)
float _sig_ltol = nz(_sig_atr, syminfo.mintick * 50.0) * i_sig_lvl_atr
bool _near_rq      = i_sig_use_rq and i_rq_en and math.abs(close - nz(rq_slow, close)) <= _sig_ltol   // v22: fast kernel (bw 8) hugs price → was always true
bool _near_lvl_buy  = math.abs(close - _m_val) <= _sig_ltol or math.abs(close - _m_mean) <= _sig_ltol or _near_rq
bool _near_lvl_sell = math.abs(close - _m_vah) <= _sig_ltol or math.abs(close - _m_mean) <= _sig_ltol or _near_rq

// 3) Multi-TF OB/OS — current(M5) AND (H1 or H4)
bool _os_2tf = (sig_rsi_cur <= i_sig_os) and ((sig_rsi_h1 <= i_sig_os) or (sig_rsi_h4 <= i_sig_os))
bool _ob_2tf = (sig_rsi_cur >= i_sig_ob) and ((sig_rsi_h1 >= i_sig_ob) or (sig_rsi_h4 >= i_sig_ob))

// 4) Order-flow confirm (rejection / iceberg / delta direction)
float _sig_dlt = _vpin_bvol - _vpin_svol
int _of_buy  = (_rej_bot ? 1 : 0) + (_ice_val ? 1 : 0) + (_sig_dlt > 0.0 ? 1 : 0)   // v22: iceberg at VAL only (was VAH or VAL)
int _of_sell = (_rej_top ? 1 : 0) + (_ice_vah ? 1 : 0) + (_sig_dlt < 0.0 ? 1 : 0)   // v22: iceberg at VAH only

// 5) Kalman turn + Entropy quality (optional)
bool _kal_bull = (not i_sig_use_kal) or (smooths > smooths[1])
bool _kal_bear = (not i_sig_use_kal) or (smooths < smooths[1])
bool _ent_ok   = (not i_sig_use_ent) or (i_sig_ent_str ? _ent_struct : (not _ent_random))

bool _sig_ok_bar = (not i_sig_confirm) or barstate.isconfirmed
bool _raw_buy  = i_sig_en and _sig_ok_bar and _buy_band  and _near_lvl_buy  and _os_2tf and _of_buy  >= i_sig_need_of and _kal_bull and _ent_ok and (not _hv_gate_sig_on or _hv_buy_ok)
bool _raw_sell = i_sig_en and _sig_ok_bar and _sell_band and _near_lvl_sell and _ob_2tf and _of_sell >= i_sig_need_of and _kal_bear and _ent_ok and (not _hv_gate_sig_on or _hv_sell_ok)

// dedup spacing
var int _sig_last_bar = -100000
bool sigBuy  = _raw_buy  and (bar_index - _sig_last_bar) >= i_sig_gap
bool sigSell = _raw_sell and (bar_index - _sig_last_bar) >= i_sig_gap
if sigBuy or sigSell
    _sig_last_bar := bar_index

string _sig_sz = switch i_sig_size
    "Tiny"   => size.tiny
    "Small"  => size.small
    "Large"  => size.large
    =>          size.normal

// ── LABELS (toggle: i_sig_show_lbl) ──
if i_sig_en and i_sig_show_lbl and sigBuy
    string _tipB = "CONFLUENCE BUY ▲\n──────────────\nInside MC band  S1 " + str.tostring(mc_bandS1, format.mintick) + " — R1 " + str.tostring(mc_bandR1, format.mintick) + "\nLevel: near AMT/RQ value\nMTF OS: M5 " + str.tostring(sig_rsi_cur,"#.0") + " · H1 " + str.tostring(sig_rsi_h1,"#.0") + " · H4 " + str.tostring(sig_rsi_h4,"#.0") + "\nOrder-flow: " + (_rej_bot?"Rej ":"") + (_is_ice?"Ice ":"") + (_sig_dlt>0?"Δ+ ":"") + "(" + str.tostring(_of_buy) + "/3)\nKalman " + (smooths>smooths[1]?"↑":"↓") + "  Entropy " + _ent_str
    label.new(bar_index, low, "▲ BUY", yloc=yloc.belowbar, style=label.style_label_up, color=color.new(i_sig_buy_col, 0), textcolor=color.white, size=_sig_sz, tooltip=_tipB)
if i_sig_en and i_sig_show_lbl and sigSell
    string _tipS = "CONFLUENCE SELL ▼\n──────────────\nInside MC band  S1 " + str.tostring(mc_bandS1, format.mintick) + " — R1 " + str.tostring(mc_bandR1, format.mintick) + "\nLevel: near AMT/RQ value\nMTF OB: M5 " + str.tostring(sig_rsi_cur,"#.0") + " · H1 " + str.tostring(sig_rsi_h1,"#.0") + " · H4 " + str.tostring(sig_rsi_h4,"#.0") + "\nOrder-flow: " + (_rej_top?"Rej ":"") + (_is_ice?"Ice ":"") + (_sig_dlt<0?"Δ- ":"") + "(" + str.tostring(_of_sell) + "/3)\nKalman " + (smooths<smooths[1]?"↓":"↑") + "  Entropy " + _ent_str
    label.new(bar_index, high, "▼ SELL", yloc=yloc.abovebar, style=label.style_label_down, color=color.new(i_sig_sell_col, 0), textcolor=color.white, size=_sig_sz, tooltip=_tipS)

// ── ARROWS / plotshape (toggle: i_sig_show_shp) ──
plotshape(i_sig_en and i_sig_show_shp and sigBuy, title="Confluence BUY ▲", style=shape.triangleup, location=location.belowbar, color=i_sig_buy_col, size=size.small, text="BUY", textcolor=color.new(i_sig_buy_col,0), display=display.none)
plotshape(i_sig_en and i_sig_show_shp and sigSell, title="Confluence SELL ▼", style=shape.triangledown, location=location.abovebar, color=i_sig_sell_col, size=size.small, text="SELL", textcolor=color.new(i_sig_sell_col,0), display=display.none)

alertcondition(sigBuy,  title="[LiqHM v22] CONFLUENCE BUY",  message="LiqHM v22 — Confluence BUY: price inside MC band + value level + MTF OS (M5+H1/H4) + order-flow + Kalman/Entropy.")
alertcondition(sigSell, title="[LiqHM v22] CONFLUENCE SELL", message="LiqHM v22 — Confluence SELL: price inside MC band + value level + MTF OB (M5+H1/H4) + order-flow + Kalman/Entropy.")

// ═══════════════════════════════════════════════════════════════════════════
// §20  ⑯ TRIPLE MTF CONF SIGNAL  (v11)
//      Condition: ALL 3 TFs show WMA-RSI OS (BUY) or OB (SELL)
//                + AMT Rejection on the same bar
//      OS: fast < slow  AND  fast < i_tri_os(40)  AND  slow < 50   ← v11 fix
//      OB: fast > slow  AND  fast > i_tri_ob(60)  AND  slow > 50   ← v11 fix
//      v10 bug: "fast<slow AND slow<50" fired with fast=41–49 (mildly bearish)
//      which MLMI kNN does NOT classify as OS (requires genuine lower range).
//      v11 adds i_tri_os/i_tri_ob absolute gate so fast must be genuinely
//      oversold/overbought at ALL 3 TFs — matches MLMI OS/OB zone threshold.
//      Labels and Arrows toggle independently. Dedup gap = i_tri_gap bars.
// ═══════════════════════════════════════════════════════════════════════════

// OS: fast < slow  AND  fast < i_tri_os  AND  slow < 50
// Requires fast WMA RSI to be genuinely in OS territory (< 40 default),
// not just "barely below slow" (gap=3, fast=41). Filters false positives.
bool _tri_os_m5 = i_tri_en and not na(_tri_rq_m5) and _tri_rq_m5 < _tri_rs_m5 and _tri_rq_m5 < i_tri_os and _tri_rs_m5 < 50.0
bool _tri_os_h1 = i_tri_en and not na(_tri_rq_h1) and _tri_rq_h1 < _tri_rs_h1 and _tri_rq_h1 < i_tri_os and _tri_rs_h1 < 50.0
bool _tri_os_h4 = i_tri_en and not na(_tri_rq_h4) and _tri_rq_h4 < _tri_rs_h4 and _tri_rq_h4 < i_tri_os and _tri_rs_h4 < 50.0

// OB: fast > slow  AND  fast > i_tri_ob  AND  slow > 50
bool _tri_ob_m5 = i_tri_en and not na(_tri_rq_m5) and _tri_rq_m5 > _tri_rs_m5 and _tri_rq_m5 > i_tri_ob and _tri_rs_m5 > 50.0
bool _tri_ob_h1 = i_tri_en and not na(_tri_rq_h1) and _tri_rq_h1 > _tri_rs_h1 and _tri_rq_h1 > i_tri_ob and _tri_rs_h1 > 50.0
bool _tri_ob_h4 = i_tri_en and not na(_tri_rq_h4) and _tri_rq_h4 > _tri_rs_h4 and _tri_rq_h4 > i_tri_ob and _tri_rs_h4 > 50.0

bool _tri_os_triple = _tri_os_m5 and _tri_os_h1 and _tri_os_h4
bool _tri_ob_triple = _tri_ob_m5 and _tri_ob_h1 and _tri_ob_h4

bool _tri_raw_buy  = _tri_os_triple and _rej_bot and (not _hv_gate_tri_on or _hv_buy_ok)
bool _tri_raw_sell = _tri_ob_triple and _rej_top and (not _hv_gate_tri_on or _hv_sell_ok)

var int _tri_last_bar = -100000
bool _tri_buy  = _tri_raw_buy  and (bar_index - _tri_last_bar) >= i_tri_gap
bool _tri_sell = _tri_raw_sell and (bar_index - _tri_last_bar) >= i_tri_gap
if _tri_buy or _tri_sell
    _tri_last_bar := bar_index

// ── LABELS (toggle: i_tri_show_lbl) ──
if i_tri_en and i_tri_show_lbl and _tri_buy
    string _tip_buy = "★ TRIPLE CONF BUY\n─────────────────────\n" +
         "Triple WMA-RSI OS (fast<slow AND fast<" + str.tostring(i_tri_os, "#") + " AND slow<50):\n" +
         "  " + _tri_tf0n + ": fast=" + str.tostring(_tri_rq_m5, "#.1") + "  slow=" + str.tostring(_tri_rs_m5, "#.1") + "\n" +
         "  " + _tri_tf1n + ": fast=" + str.tostring(_tri_rq_h1, "#.1") + "  slow=" + str.tostring(_tri_rs_h1, "#.1") + "\n" +
         "  " + _tri_tf2n + ": fast=" + str.tostring(_tri_rq_h4, "#.1") + "  slow=" + str.tostring(_tri_rs_h4, "#.1") + "\n" +
         "Rejection ↑: wick below VAL (" + str.tostring(_m_val, format.mintick) + "), close above"
    label.new(bar_index, low, "★ CONF BUY",
         yloc=yloc.belowbar, style=label.style_label_up,
         color=color.new(i_tri_buy_col, 0), textcolor=color.white,
         size=size.small, tooltip=_tip_buy)

if i_tri_en and i_tri_show_lbl and _tri_sell
    string _tip_sell = "★ TRIPLE CONF SELL\n─────────────────────\n" +
         "Triple WMA-RSI OB (fast>slow AND fast>" + str.tostring(i_tri_ob, "#") + " AND slow>50):\n" +
         "  " + _tri_tf0n + ": fast=" + str.tostring(_tri_rq_m5, "#.1") + "  slow=" + str.tostring(_tri_rs_m5, "#.1") + "\n" +
         "  " + _tri_tf1n + ": fast=" + str.tostring(_tri_rq_h1, "#.1") + "  slow=" + str.tostring(_tri_rs_h1, "#.1") + "\n" +
         "  " + _tri_tf2n + ": fast=" + str.tostring(_tri_rq_h4, "#.1") + "  slow=" + str.tostring(_tri_rs_h4, "#.1") + "\n" +
         "Rejection ↓: wick above VAH (" + str.tostring(_m_vah, format.mintick) + "), close below"
    label.new(bar_index, high, "★ CONF SELL",
         yloc=yloc.abovebar, style=label.style_label_down,
         color=color.new(i_tri_sell_col, 0), textcolor=color.white,
         size=size.small, tooltip=_tip_sell)

// ── ARROWS / plotshape (toggle: i_tri_show_shp) ──
plotshape(i_tri_en and i_tri_show_shp and _tri_buy,  title="★ Triple CONF BUY",
     style=shape.triangleup,   location=location.belowbar,
     color=i_tri_buy_col,  size=size.tiny)
plotshape(i_tri_en and i_tri_show_shp and _tri_sell, title="★ Triple CONF SELL",
     style=shape.triangledown, location=location.abovebar,
     color=i_tri_sell_col, size=size.tiny)

// ── ALERTS ──
alertcondition(_tri_buy,  title="[LiqHM v22] ★ TRIPLE CONF BUY",
     message="LiqHM v22 ★ Triple CONF BUY: WMA-RSI OS on all 3 TFs (fast<slow AND fast<40 AND slow<50) + AMT rejection ↑ at value band.")
alertcondition(_tri_sell, title="[LiqHM v22] ★ TRIPLE CONF SELL",
     message="LiqHM v22 ★ Triple CONF SELL: WMA-RSI OB on all 3 TFs (fast>slow AND fast>60 AND slow>50) + AMT rejection ↓ at value band.")

// ═══════════════════════════════════════════════════════════════════════════
// §21  ⑰ ML YZ — PLOTS + SIGNALS + ALERTS
// ═══════════════════════════════════════════════════════════════════════════

// ── Outer bands ────────────────────────────────────────────────────────────
p_yz_up = plot(i_yz_en ? yz_upper : na, "YZ Outer Upper", color=color.new(yz_c_st, 20), linewidth=1, force_overlay=true, display=display.none)
p_yz_dn = plot(i_yz_en ? yz_lower : na, "YZ Outer Lower", color=color.new(yz_c_st, 20), linewidth=1, force_overlay=true, display=display.none)
plot(i_yz_en ? yz_mid : na, "YZ Middle", color=yz_c_st, linewidth=2, force_overlay=true, display=display.none)
fill(p_yz_up, p_yz_dn, color=color.new(yz_c_reg, 90))

// ── Value Area bands ───────────────────────────────────────────────────────
p_yz_va_u = plot(i_yz_en and i_yz_show_va ? yz_va_upper : na, "YZ VA Upper", color=color.new(C_GOLD, 40), linewidth=1, style=plot.style_stepline, force_overlay=true, display=display.none)
p_yz_va_d = plot(i_yz_en and i_yz_show_va ? yz_va_lower : na, "YZ VA Lower", color=color.new(C_GOLD, 40), linewidth=1, style=plot.style_stepline, force_overlay=true, display=display.none)
fill(p_yz_va_u, p_yz_va_d, color=color.new(C_GOLD, 93))

// ── POC (VWAP proxy) ───────────────────────────────────────────────────────
plot(i_yz_en and i_yz_show_poc ? yz_poc : na, "YZ POC", color=YZ_BLUE, linewidth=1, style=plot.style_circles, force_overlay=true, display=display.none)

// ── AMT Initiative signals (outer-band break, Imbalance regime) ────────────
plotshape(i_yz_en and i_yz_show_sig and yz_init_buy, "YZ Initiative BUY", shape.triangleup, location.belowbar, YZ_BULL, text="IB", textcolor=YZ_BULL, size=size.small, display=display.none)
plotshape(i_yz_en and i_yz_show_sig and yz_init_sell, "YZ Initiative SELL", shape.triangledown, location.abovebar, YZ_BEAR, text="IS", textcolor=YZ_BEAR, size=size.small, display=display.none)

// ── AMT Responsive signals (VA re-entry, Balance regime) ──────────────────
plotshape(i_yz_en and i_yz_show_sig and yz_resp_buy, "YZ Responsive BUY", shape.circle, location.belowbar, color.new(YZ_BULL, 40), text="RB", textcolor=YZ_BULL, size=size.tiny, display=display.none)
plotshape(i_yz_en and i_yz_show_sig and yz_resp_sell, "YZ Responsive SELL", shape.circle, location.abovebar, color.new(YZ_BEAR, 40), text="RS", textcolor=YZ_BEAR, size=size.tiny, display=display.none)

// ── Optional bar color override ────────────────────────────────────────────
barcolor(i_yz_en and i_yz_col_bars ? yz_c_st : na, title="Bar Color", display=display.none)

// ── Regime label (last bar only) ──────────────────────────────────────────
// v16 FIX (object lifecycle): keep ONE persistent label handle and delete it
// before each redraw. The v12 code called a bare label.new() under
// barstate.islast, so every bar that closed committed its own regime label
// permanently while the new last bar drew another → the labels stacked up
// ("IMBALANCE/BALANCE/NEUTRAL · YZ=x.xx" piling on top of each other).
// var label + label.delete() mirrors the §14b market-quality label lifecycle,
// so exactly one ML YZ regime label ever exists on the chart.
var label _yz_lbl = na
if i_yz_en and i_yz_show_lbl and barstate.islast
    label.delete(_yz_lbl)
    string _yr = yz_regime ==  1 ? "⚖ BALANCE"
               : yz_regime == -1 ? "⚡ IMBALANCE"
               : "◈ NEUTRAL"
    string _ys = yz_state ==  1 ? " · BULL" : yz_state == -1 ? " · BEAR" : ""
    string _yv = " · YZ=" + str.tostring(math.round(nz(yz_vol) * close * 100.0) / 100.0, "#.##")
    _yz_lbl := label.new(bar_index, yz_upper,
         _yr + _ys + _yv,
         color     = color.new(yz_c_reg, 20),
         textcolor = color.white,
         style     = label.style_label_lower_left,
         size      = size.small)

// ── ML YZ Alerts ──────────────────────────────────────────────────────────
alertcondition(yz_init_buy,  title="[LiqHM v22] ML YZ Initiative BUY",
     message="LiqHM v22 ML YZ Initiative BUY  | {{ticker}} | {{close}}")
alertcondition(yz_init_sell, title="[LiqHM v22] ML YZ Initiative SELL",
     message="LiqHM v22 ML YZ Initiative SELL | {{ticker}} | {{close}}")
alertcondition(yz_resp_buy,  title="[LiqHM v22] ML YZ Responsive BUY",
     message="LiqHM v22 ML YZ Responsive BUY  | {{ticker}} | {{close}}")
alertcondition(yz_resp_sell, title="[LiqHM v22] ML YZ Responsive SELL",
     message="LiqHM v22 ML YZ Responsive SELL | {{ticker}} | {{close}}")

// ═══════════════════════════════════════════════════════════════════════════
// §22  ⑱ HV-PIVOT LEVELS + CLV-DELTA  (display-only, additive — v17)
//   Volume-gated pivot S/R (BigBeluga concept ported as a FILTER, not the box
//   system). CVD = CLV×vol, NOT the candle-direction proxy. One ray + one CVD
//   label per level; capped last N per side. NO boxes, NO polylines. Purely a
//   pair of eyes for LOCATION — does not gate ⑮/⑯/⑰.
// ═══════════════════════════════════════════════════════════════════════════
// ── Precompute (must run every bar: ta.* keep state) ──────────────────────
float _hv_vsma  = ta.sma(volume, i_hv_vol_ma)
bool  _hv_hivol = _hv_vsma > 0.0 and volume > _hv_vsma * i_hv_vol_mult
float _hv_ph    = ta.pivothigh(high, i_hv_res_len, i_hv_res_len)
float _hv_pl    = ta.pivotlow (low,  i_hv_sup_len, i_hv_sup_len)

// CLV×vol delta (the fix): ((C−L)−(H−C))/(H−L) × volume. Guard H==L bars.
float _hv_rng   = high - low
float _hv_clv   = _hv_rng > 0.0 ? ((close - low) - (high - close)) / _hv_rng : 0.0
float _hv_delta = _hv_clv * volume

// Formation-window CVD — hoisted to global scope so math.sum runs EVERY bar
// (stateful rolling sum; calling it only inside an if-branch = consistency error).
float _hv_cvd_res = math.sum(_hv_delta, i_hv_res_len + 1)
float _hv_cvd_sup = math.sum(_hv_delta, i_hv_sup_len + 1)

// Valid pivot = pivot confirmed AND the pivot bar (len bars back) was high-vol
bool  _hv_valid_res = i_hv_en and not na(_hv_ph) and _hv_hivol[i_hv_res_len]
bool  _hv_valid_sup = i_hv_en and not na(_hv_pl) and _hv_hivol[i_hv_sup_len]

// ── Persistent level stores (capped per side) ──────────────────────────────
// _hv_res / _hv_sup are declared in §18b (so ⑮/⑯ can read them); maintained here.
var array<label>   _hv_labels = array.new<label>()

// ── Create ray + snapshot CVD on confirmation; evict oldest beyond N ────────
if _hv_valid_res
    float _p   = high[i_hv_res_len]
    line  _ln  = line.new(bar_index - i_hv_res_len, _p, bar_index, _p,
         color=color.new(i_hv_res_col, 0), width=1, extend=extend.right)
    _hv_res.push(hvLevel.new(_ln, _p, _hv_cvd_res))
    if _hv_res.size() > i_hv_keep
        hvLevel _old = _hv_res.shift()
        line.delete(_old.ln)

if _hv_valid_sup
    float _p   = low[i_hv_sup_len]
    line  _ln  = line.new(bar_index - i_hv_sup_len, _p, bar_index, _p,
         color=color.new(i_hv_sup_col, 0), width=1, extend=extend.right)
    _hv_sup.push(hvLevel.new(_ln, _p, _hv_cvd_sup))
    if _hv_sup.size() > i_hv_keep
        hvLevel _old = _hv_sup.shift()
        line.delete(_old.ln)

// ── Refresh CVD labels at the right edge (last bar only — cheap, house style) ─
if i_hv_en and barstate.islast
    for _lb in _hv_labels
        label.delete(_lb)
    _hv_labels.clear()
    if i_hv_show_cvd
        // Anchor a few bars into the empty right void; R box sits ABOVE the line
        // (style_label_down = box above anchor), S box BELOW (style_label_up) so
        // the ray never runs through the text.
        int _hv_lx = bar_index + 3
        for _lv in _hv_res
            _hv_labels.push(label.new(_hv_lx, _lv.price,
                 "R " + str.tostring(_lv.price, format.mintick) + "  CVD " + formatDelta(_lv.cvd),
                 style=label.style_label_down, color=color.new(i_hv_res_col, 80),
                 textcolor=i_hv_res_col, size=size.tiny))
        for _lv in _hv_sup
            _hv_labels.push(label.new(_hv_lx, _lv.price,
                 "S " + str.tostring(_lv.price, format.mintick) + "  CVD " + formatDelta(_lv.cvd),
                 style=label.style_label_up, color=color.new(i_hv_sup_col, 80),
                 textcolor=i_hv_sup_col, size=size.tiny))

// ============================================================================
//  ⑲ VWAP STDEV BANDS  (session-anchored · tuned for M5)  ──  DISPLAY-ONLY
//  Ported from "VWAP Stdev Bands v2 Mod" (Pine v2 → v6). Session VWAP + 3 stdev
//  band groups + inner over/under fills. (Outer band groups 4-5 and the VWAP-zone
//  bar-color feature were dropped to stay under Pine's shared 64-plot-per-script
//  cap — RE10140.) Anchor resets each new period (default Daily → true intraday
//  VWAP on M5). NOTHING here feeds any signal / gate / score — pure reference.
// ============================================================================
g_vwb = "⑲ VWAP Stdev Bands (M5)"
i_vwb_on   = input.bool(false, "Enable VWAP Stdev Bands", group=g_vwb)
i_vwb_anch = input.timeframe("D", "Anchor / reset period", group=g_vwb, tooltip="Session anchor. 'D' = daily reset = standard intraday VWAP (correct for M5). 'W' weekly, 'M' monthly.")
i_vwb_src  = input.source(hl2,  "VWAP price source", group=g_vwb)

i_vwb_u1 = input.float(2.1278, "Stdev above (1)", group=g_vwb, inline="v1")
i_vwb_d1 = input.float(2.1278, "below (1)", group=g_vwb, inline="v1")
i_vwb_u2 = input.float(2.887, "Stdev above (2)", group=g_vwb, inline="v2")
i_vwb_d2 = input.float(2.887, "below (2)", group=g_vwb, inline="v2")
i_vwb_u3 = input.float(3.414, "Stdev above (3)", group=g_vwb, inline="v3")
i_vwb_d3 = input.float(3.414, "below (3)", group=g_vwb, inline="v3")

i_vwb_g2 = input.bool(true, "Show band group 2", group=g_vwb)
i_vwb_g3 = input.bool(true, "Show band group 3", group=g_vwb)

// ── session reset + cumulative sums (var + nz self-reference = v6 idiom) ──────
int   vwb_anchT = request.security(syminfo.tickerid, i_vwb_anch, time, lookahead=barmerge.lookahead_off)
int   vwb_anchC = ta.change(vwb_anchT)   // computed unconditionally (avoids ta.* inside conditional warning)
bool  vwb_new   = i_vwb_on and vwb_anchC != 0
float vwb_sr    = i_vwb_src
var float vwb_pv  = na
var float vwb_vv  = na
var float vwb_pv2 = na
vwb_pv  := vwb_new ? vwb_sr * volume          : nz(vwb_pv[1])  + vwb_sr * volume
vwb_vv  := vwb_new ? volume                   : nz(vwb_vv[1])  + volume
vwb_pv2 := vwb_new ? vwb_sr * vwb_sr * volume : nz(vwb_pv2[1]) + vwb_sr * vwb_sr * volume
float vwb_vwap = vwb_vv != 0 ? vwb_pv / vwb_vv : na
float vwb_dev  = vwb_vv != 0 ? math.sqrt(math.max(vwb_pv2 / vwb_vv - vwb_vwap * vwb_vwap, 0)) : na

// ── band levels (3 groups) ───────────────────────────────────────────────────
float vwb_U1 = vwb_vwap + i_vwb_u1 * vwb_dev
float vwb_D1 = vwb_vwap - i_vwb_d1 * vwb_dev
float vwb_U2 = vwb_vwap + i_vwb_u2 * vwb_dev
float vwb_D2 = vwb_vwap - i_vwb_d2 * vwb_dev
float vwb_U3 = vwb_vwap + i_vwb_u3 * vwb_dev
float vwb_D3 = vwb_vwap - i_vwb_d3 * vwb_dev

// ── plots — VWAP + 3 band groups (7 plots; groups 2-3 by their toggles) ──────
vwb_pA  = plot(i_vwb_on              ? vwb_vwap : na, "VWAP", color=color.black, style=plot.style_circles, display=display.none)
vwb_pU1 = plot(i_vwb_on              ? vwb_U1   : na, "VWAP Upper (1)", color=color.gray, style=plot.style_line, display=display.none)
vwb_pD1 = plot(i_vwb_on              ? vwb_D1   : na, "VWAP Lower (1)", color=color.gray, style=plot.style_line, display=display.none)
vwb_pU2 = plot(i_vwb_on and i_vwb_g2 ? vwb_U2   : na, "VWAP Upper (2)", color=color.red, display=display.none)
vwb_pD2 = plot(i_vwb_on and i_vwb_g2 ? vwb_D2   : na, "VWAP Lower (2)", color=color.green, display=display.none)
vwb_pU3 = plot(i_vwb_on and i_vwb_g3 ? vwb_U3   : na, "VWAP Upper (3)", color=color.red, display=display.none)
vwb_pD3 = plot(i_vwb_on and i_vwb_g3 ? vwb_D3   : na, "VWAP Lower (3)", color=color.green, display=display.none)

// ── inner over/under fills (4; each also counts toward the 64-plot cap) ───────
fill(vwb_pU1, vwb_pU2, color=color.new(color.red,   90), title="OB Fill 1")
fill(vwb_pD1, vwb_pD2, color=color.new(color.green, 90), title="OS Fill 1")
fill(vwb_pU2, vwb_pU3, color=color.new(color.red,   90), title="OB Fill 2")
fill(vwb_pD2, vwb_pD3, color=color.new(color.green, 90), title="OS Fill 2")

// ============================================================================
//  ⑳ TREND BREAKOUT + CORRECTION METER  (M5)  ──  DISPLAY-ONLY   [v20]
//  Two complementary tools from the "3 primitives" framework:
//   (A) Donchian N-bar high/low = the TREND-FOLLOW trigger (break of the
//       highest-high / lowest-low over N bars; longer N = stronger edge).
//   (B) Correction Meter = the MR-INTO-TREND read: after a breakout it
//       measures how deep the pullback into the trend is (Fib retrace of the
//       impulse). Deeper pullback = higher-probability continuation entry.
//  Uses ONLY line / label / box / table  → 0 plot-budget (safe vs the shared
//  64-plot cap / RE10140). NOTHING feeds any signal / gate / score.
// ============================================================================
g_tbk = "⑳ Trend Breakout + Correction Meter (M5)"
i_tbk_on    = input.bool(true,  "Enable Trend Breakout module", group=g_tbk)
i_tbk_lines = input.bool(true,  "  Show Donchian breakout lines", group=g_tbk)
i_tbk_len1  = input.int(144, "  Primary length (bars)", group=g_tbk, minval=10, tooltip="M5 default 100 ≈ 1 session of structure. Longer = stronger trend edge (transcript: 100/200/ATH).")
i_tbk_l2on  = input.bool(true,  "  Show secondary length", group=g_tbk, inline="tbk2")
i_tbk_len2  = input.int(233, "", group=g_tbk, inline="tbk2", minval=10)
i_tbk_mark  = input.bool(false, "  Show BO up/down breakout markers", group=g_tbk)
i_tbk_upc   = input.color(color.new(#D85A30,0), "  DCH (resistance) color", group=g_tbk)
i_tbk_dnc   = input.color(color.new(#1D9E75,0), "  DCL (support) color", group=g_tbk)
i_tbk_lsty  = input.string("Dashed", "  Line style", group=g_tbk, options=["Solid","Dashed","Dotted"])
i_tbk_ext   = input.int(6, "  Line extend (bars right)", group=g_tbk, minval=0, maxval=100)
i_tbk_lblsz = input.string("Tiny", "  Line label size", group=g_tbk, options=["Tiny","Small","Normal"])
i_tbk_meter = input.bool(true, "  Show Correction Meter", group=g_tbk)
i_tbk_mpos  = input.string("Bottom Left", "  Meter position", group=g_tbk, options=["Top Left", "Top Right", "Bottom Left", "Bottom Right"])
i_tbk_msz   = input.string("Small", "  Meter text size", group=g_tbk, options=["Tiny","Small","Normal"])
i_tbk_zone  = input.bool(true, "  Show dip-buy zone (Fib)", group=g_tbk)
i_tbk_znc   = input.color(color.new(#1D9E75,86), "  Dip-buy zone color", group=g_tbk)
i_tbk_flo   = input.float(0.5,   "  Zone Fib low",  group=g_tbk, inline="tbkfib", step=0.01, minval=0.1, maxval=0.9)
i_tbk_fhi   = input.float(0.618, "  Zone Fib high", group=g_tbk, inline="tbkfib", step=0.01, minval=0.2, maxval=1.0)

color TBK_BULL = #97C459
color TBK_BEAR = #EF5350

// ── Donchian levels + breakout events ────────────────────────────────────────
float tbk_dch1 = ta.highest(high, i_tbk_len1)
float tbk_dcl1 = ta.lowest(low,  i_tbk_len1)
float tbk_dch2 = ta.highest(high, i_tbk_len2)
float tbk_dcl2 = ta.lowest(low,  i_tbk_len2)
var int   tbk_dir = 0   // v22: declared here so the breakout test can read the PREVIOUS state
bool  tbk_boU  = i_tbk_on and close > tbk_dch1[1] and tbk_dir != 1    // v22: was close[1] <= dch1[1] (always true) → re-fired every new high and reset the impulse origin
bool  tbk_boD  = i_tbk_on and close < tbk_dcl1[1] and tbk_dir != -1

// ── trend + impulse/pullback state (for the Correction Meter) ────────────────
var float tbk_org = na
var float tbk_ext = na
var int   tbk_bar = na
if tbk_boU
    tbk_dir := 1
    tbk_org := tbk_dch1[1]
    tbk_ext := high
    tbk_bar := bar_index
else if tbk_boD
    tbk_dir := -1
    tbk_org := tbk_dcl1[1]
    tbk_ext := low
    tbk_bar := bar_index
else if tbk_dir == 1
    tbk_ext := math.max(nz(tbk_ext, high), high)
else if tbk_dir == -1
    tbk_ext := math.min(nz(tbk_ext, low), low)

float tbk_imp   = tbk_dir == 1 ? tbk_ext - tbk_org : tbk_dir == -1 ? tbk_org - tbk_ext : na
float tbk_pb    = tbk_dir == 1 ? tbk_ext - low     : tbk_dir == -1 ? high - tbk_ext    : na
float tbk_depth = not na(tbk_imp) and tbk_imp > 0 ? tbk_pb / tbk_imp : na
float tbk_zt    = tbk_dir == 1 ? tbk_ext - i_tbk_flo * tbk_imp : tbk_dir == -1 ? tbk_ext + i_tbk_fhi * tbk_imp : na
float tbk_zb    = tbk_dir == 1 ? tbk_ext - i_tbk_fhi * tbk_imp : tbk_dir == -1 ? tbk_ext + i_tbk_flo * tbk_imp : na

// ── breakout markers (label = 0 plot-budget) ─────────────────────────────────
var array<label> tbk_mk = array.new_label()
if i_tbk_on and i_tbk_mark and tbk_boU
    array.push(tbk_mk, label.new(bar_index, low, "BO▲" + str.tostring(i_tbk_len1), style=label.style_label_up, color=color.new(TBK_BULL, 15), textcolor=color.white, size=size.small, tooltip="Donchian " + str.tostring(i_tbk_len1) + "-bar HIGH broken → trend-long trigger"))
    if array.size(tbk_mk) > 120
        label.delete(array.shift(tbk_mk))
if i_tbk_on and i_tbk_mark and tbk_boD
    array.push(tbk_mk, label.new(bar_index, high, "BO▼" + str.tostring(i_tbk_len1), style=label.style_label_down, color=color.new(TBK_BEAR, 15), textcolor=color.white, size=size.small, tooltip="Donchian " + str.tostring(i_tbk_len1) + "-bar LOW broken → trend-short trigger"))
    if array.size(tbk_mk) > 120
        label.delete(array.shift(tbk_mk))

// ── persistent drawables (redrawn on last bar only = clean, cheap) ───────────
tbk_lsty_r  = switch i_tbk_lsty
    "Solid"  => line.style_solid
    "Dotted" => line.style_dotted
    =>          line.style_dashed
tbk_lblsz_r = switch i_tbk_lblsz
    "Small"  => size.small
    "Normal" => size.normal
    =>          size.tiny
tbk_msz_r   = switch i_tbk_msz
    "Tiny"   => size.tiny
    "Normal" => size.normal
    =>          size.small
tbk_mpos_r  = switch i_tbk_mpos
    "Top Right"    => position.top_right
    "Bottom Left"  => position.bottom_left
    "Bottom Right" => position.bottom_right
    =>                position.top_left

var line  tbk_l_dch1 = na
var line  tbk_l_dcl1 = na
var line  tbk_l_dch2 = na
var line  tbk_l_dcl2 = na
var label tbk_lb_dch = na
var label tbk_lb_dcl = na
var box   tbk_zbx    = na
var table tbk_tbl    = table.new(tbk_mpos_r, 2, 6, border_width=1, frame_color=color.new(#2c3440, 0), frame_width=1)

if barstate.islast
    line.delete(tbk_l_dch1)
    line.delete(tbk_l_dcl1)
    line.delete(tbk_l_dch2)
    line.delete(tbk_l_dcl2)
    label.delete(tbk_lb_dch)
    label.delete(tbk_lb_dcl)
    box.delete(tbk_zbx)
    table.clear(tbk_tbl, 0, 0, 1, 5)
    if i_tbk_on
        int _lx = bar_index - math.min(i_tbk_len1, 300)
        int _rx = bar_index + i_tbk_ext
        if i_tbk_lines
            tbk_l_dch1 := line.new(_lx, tbk_dch1, _rx, tbk_dch1, color=i_tbk_upc, style=tbk_lsty_r, width=1)
            tbk_l_dcl1 := line.new(_lx, tbk_dcl1, _rx, tbk_dcl1, color=i_tbk_dnc, style=tbk_lsty_r, width=1)
            tbk_lb_dch := label.new(_rx, tbk_dch1, "DCH " + str.tostring(i_tbk_len1) + "  " + str.tostring(tbk_dch1, format.mintick) + "  BO→long", style=label.style_label_left, color=color.new(i_tbk_upc, 82), textcolor=i_tbk_upc, size=tbk_lblsz_r)
            tbk_lb_dcl := label.new(_rx, tbk_dcl1, "DCL " + str.tostring(i_tbk_len1) + "  " + str.tostring(tbk_dcl1, format.mintick) + "  BO→short", style=label.style_label_left, color=color.new(i_tbk_dnc, 82), textcolor=i_tbk_dnc, size=tbk_lblsz_r)
            if i_tbk_l2on
                tbk_l_dch2 := line.new(_lx, tbk_dch2, _rx, tbk_dch2, color=color.new(i_tbk_upc, 55), style=tbk_lsty_r, width=1)
                tbk_l_dcl2 := line.new(_lx, tbk_dcl2, _rx, tbk_dcl2, color=color.new(i_tbk_dnc, 55), style=tbk_lsty_r, width=1)
        if i_tbk_zone and tbk_dir != 0 and not na(tbk_zt) and not na(tbk_zb) and nz(tbk_imp) > 0
            int _zl = math.max(nz(tbk_bar, bar_index - 30), bar_index - 100)
            color _zc = tbk_dir == 1 ? i_tbk_znc : color.new(i_tbk_upc, color.t(i_tbk_znc))   // v22: downtrend zone = rally-SELL, coloured as resistance
            tbk_zbx := box.new(_zl, tbk_zt, _rx, tbk_zb, border_color=color.new(_zc, 40), border_style=line.style_dotted, border_width=1, bgcolor=_zc, text=tbk_dir == 1 ? "dip-buy zone" : "rally-sell zone", text_color=color.new(tbk_dir == 1 ? i_tbk_dnc : i_tbk_upc, 0), text_size=size.tiny, text_halign=text.align_left, text_valign=text.align_bottom)
        if i_tbk_meter
            color _bg  = color.new(#161B22, 0)
            color _lbc = #6b7686
            table.cell(tbk_tbl, 0, 0, "correction meter", text_color=#8b98a8, text_size=tbk_msz_r, bgcolor=_bg, text_halign=text.align_left)
            table.cell(tbk_tbl, 1, 0, "", bgcolor=_bg)
            if tbk_dir == 0
                table.cell(tbk_tbl, 0, 1, "trend",  text_color=_lbc, text_size=tbk_msz_r, bgcolor=_bg, text_halign=text.align_left)
                table.cell(tbk_tbl, 1, 1, "waiting for breakout", text_color=#c9d1d9, text_size=tbk_msz_r, bgcolor=_bg, text_halign=text.align_left)
            else
                string _tdir = tbk_dir == 1 ? "UP" : "DN"
                color  _tcol = tbk_dir == 1 ? TBK_BULL : TBK_BEAR
                int    _age  = bar_index - nz(tbk_bar, bar_index)
                float  _d    = nz(tbk_depth, 0.0)
                int    _ns   = _d < 0.382 ? 1 : _d < 0.5 ? 2 : _d < 0.618 ? 3 : _d < 0.786 ? 4 : 5
                string _star = _d > 1.0 ? "⚠ broke origin" : _ns == 1 ? "★☆☆☆☆" : _ns == 2 ? "★★☆☆☆" : _ns == 3 ? "★★★☆☆" : _ns == 4 ? "★★★★☆" : "★★★★★"
                string _fib  = _d < 0.382 ? "shallow" : _d < 0.5 ? "Fib .382" : _d < 0.618 ? "Fib .5" : _d < 0.786 ? "Fib .618" : _d <= 1.0 ? "Fib .786" : "≥1.0"
                table.cell(tbk_tbl, 0, 1, "trend",    text_color=_lbc, text_size=tbk_msz_r, bgcolor=_bg, text_halign=text.align_left)
                table.cell(tbk_tbl, 1, 1, _tdir + " · DCH" + str.tostring(i_tbk_len1) + " broke " + str.tostring(_age) + " bars ago", text_color=_tcol, text_size=tbk_msz_r, bgcolor=_bg, text_halign=text.align_left)
                table.cell(tbk_tbl, 0, 2, "impulse",  text_color=_lbc, text_size=tbk_msz_r, bgcolor=_bg, text_halign=text.align_left)
                table.cell(tbk_tbl, 1, 2, str.tostring(tbk_org, format.mintick) + " → " + str.tostring(tbk_ext, format.mintick) + "  (" + (tbk_dir == 1 ? "+" : "−") + str.tostring(nz(tbk_imp), format.mintick) + ")", text_color=#c9d1d9, text_size=tbk_msz_r, bgcolor=_bg, text_halign=text.align_left)
                table.cell(tbk_tbl, 0, 3, "pullback", text_color=_lbc, text_size=tbk_msz_r, bgcolor=_bg, text_halign=text.align_left)
                table.cell(tbk_tbl, 1, 3, str.tostring(tbk_ext, format.mintick) + " → " + str.tostring(tbk_dir == 1 ? low : high, format.mintick) + "  (" + (tbk_dir == 1 ? "−" : "+") + str.tostring(nz(tbk_pb), format.mintick) + ")", text_color=#c9d1d9, text_size=tbk_msz_r, bgcolor=_bg, text_halign=text.align_left)
                table.cell(tbk_tbl, 0, 4, "depth",    text_color=_lbc, text_size=tbk_msz_r, bgcolor=_bg, text_halign=text.align_left)
                table.cell(tbk_tbl, 1, 4, str.tostring(_d * 100.0, "#") + "%   " + _fib, text_color=#EF9F27, text_size=tbk_msz_r, bgcolor=_bg, text_halign=text.align_left)
                table.cell(tbk_tbl, 0, 5, tbk_dir == 1 ? "dip-buy" : "rally-sell",  text_color=_lbc, text_size=tbk_msz_r, bgcolor=_bg, text_halign=text.align_left)
                table.cell(tbk_tbl, 1, 5, _star + "  (deeper = higher prob)", text_color=_d > 1.0 ? TBK_BEAR : (tbk_dir == 1 ? TBK_BULL : TBK_BEAR), text_size=tbk_msz_r, bgcolor=_bg, text_halign=text.align_left)

// == END  LiqHM+VP + HTF Reversal + Kalman D7 + Monte Carlo + Confluence Signal + Triple MTF Conf + ML YZ + HV-Pivot + CVD-Gate + VWAP-Bands + TrendBreakout+CorrMeter  |  Pine v6  |  v22  overlay=true ==