//@version=6
// =============================================================================
//  TMU TIME CYCLE LEVELS
//  Liquidity H/L (sessions + prev day/week/month) + Opening Lines + Opening Gaps
//  Everything on NY time via "America/New_York" -> summer/winter time (DST) auto.
// -----------------------------------------------------------------------------
//  A) LIQUIDITY H/L
//     · Sessions (current trading day, reset 18:00) + Prev Week/Month (mitigation).
//     · Prev. Day: adjustable number of MOST RECENT highs/lows back in time.
//       By default only unmitigated; toggle to keep mitigated ones.
//     · Mitigation: line stops at the mitigation point; label is placed at that
//       END (high above, low below) so you can see it on long lines.
//     · Styling: unmitigated = 1 colour + solid, mitigated = 1 colour + dotted.
//  MERGE + TF-PRIORITY: all levels in 1 pool, grouped by price.
//     · Same price -> 1 line + merged label; other price -> separate lines.
//     · Within day/week/month family the HIGHEST TF wins (lower ones dropped).
//       Sessions + opens always merge in. A group with an opening line keeps
//       running and takes its style (an open does not mitigate).
//  B) OPENING LINES  — 09:30 . W.O. (Sunday 18:00) . M.O. . C.O. (current 90M).
//  C) OPENING GAPS   — NWOG (Fri-close -> Sun-open, whole week) + NDOG (18:00->18:00).
//  D) CYCLES — red (manipulation) cycles always keep the red colour; the other
//       90M windows are hidden, greyed out (own colour) or drawn in the original
//       AMD rotation, selectable via "Non-red 90M windows".
// -----------------------------------------------------------------------------
//  FIXES 2026-08-14 — levels/inputs unchanged, only wrong values corrected
//   1 Prev. Day is now a CALENDAR day. The old `dow != sunday` guard blocked the
//     seal on the Sunday 18:00 bar, so Friday + Sunday evening became one level.
//   2 C.O. ran on a SECOND 90M grid anchored at 01:00 that kept ticking overnight
//     (17:30 / 19:00 / 20:30 / 22:00 / 23:30 / 01:00). Now one raster, cyc90k,
//     shared with the boxes: 02:30-15:59, empty outside it.
//   3 09:30 was captured on window OVERLAP, so on a 1H chart it drew the 09:00
//     open. Now the bar-open itself is tested.
//   4 WITHDRAWN. I claimed the box trim was a bug ("the last candle hangs
//     outside its own box"). It is not: with xloc.bar_time a timestamp sits on
//     the CENTRE of its candle, so the original edges were already centred on
//     the first and last candle of the cycle, with one candle of air before the
//     next box. Two attempted fixes made it worse and were both reverted. The
//     box code is back to its original form - see the note in f_cycleBox.
//   5 "ALL red 3.33M" claimed to work on 1-min; 200 s boundaries cannot land on
//     60 s bars. Every cycle level is now gated on the grid it actually needs.
//   6 EQ lines were never deleted and ate the shared 500-line budget. Capped.
//  Timings are unchanged and were already right: 90M 02:30-15:59 in 9 cycles
//  closing on xx:29/xx:59, sessions 18:00-02:29 / 02:30-06:59 / 07:00-11:29 /
//  11:30-15:59, LON02 04:00-05:29 . AM02 08:30-09:59 . PM02 13:00-14:29.
// -----------------------------------------------------------------------------
//  REVISION 2026-08-18 — one real bug (7), the rest is structure. No level
//  moves, no input is removed, one input is added (12, default = old behaviour).
//   7 BUG. The C2 windows (LON02/AM02/PM02) were a SECOND hard-coded 90M raster
//     (240-329 / 510-599 / 780-869 min) sitting next to cyc90k -- exactly the
//     duplication fix 2 had just removed for C.O. -- AND they had no alignment
//     gate. On a 1H chart the 05:00 bar satisfies `mnts <= 329` but runs to
//     05:59, so half an hour of London-3 data was folded into the LON02 high/
//     low. Same at 09:00 for AM02 and 14:00 for PM02. The windows are now
//     derived from cyc90k (the red keys 3/6/9) and gated on ali30, like every
//     other cycle-based level. Consequence, deliberate and silent as elsewhere:
//     on a TF that is not a divisor of 30 min there are no C2 levels at all.
//   8 STRUCTURE. The parallel-array pattern is gone. Eight arrays held together
//     by comma-chained pushes (the render pool), six for the prev-day history,
//     five for C2, four for the C2 accumulator and seven for the session state
//     were one forgotten push away from a silent index shift -- a class of bug
//     that never shows up in the compiler, only on the chart, and only if you
//     happen to look. All of it is now four user-defined types: Sess, Lvl, Acc
//     and PLvl. Same data, same order, same output; one object per level.
//   9 The session-state arrays had a dead slot 4 (a leftover from when prev-day
//     lived in the same array). Week/month are now index 4/5 of a 6-slot array.
//  10 key32 and key3all were the same 200-second arithmetic twice with a
//     different filter. Folded into f_key200(gate, redOnly).
//  11 The "single source of truth" claim only held for the 90M raster; the
//     session/AM1/second-window boundaries were still magic numbers spread over
//     the file, with the header table as the only place they were written down.
//     Collected in one constants block, so the code IS the table.
//  12 A mitigated liquidity level that merges with an opening line loses every
//     visual trace of being mitigated: the group keeps running in the open's
//     style, so "Prev. Day H + 09:30" reads as a live level while the Prev. Day
//     side is already taken out. That is by design (an open does not mitigate),
//     but it is worth being able to see. New toggle marks such a member "(m)".
//     Default OFF = identical to the old label.
//  REVISION 2026-08-18b — prev day / prev week lows could sit on candles from
//  the CURRENT trading period (highs too, but overnight sessions set the low
//  far more often, so you see it on lows first):
//   13 The week sealed on weekofyear(). Whether that number flips on Sunday or
//     on Monday is a TradingView convention; with the Monday convention "prev
//     week" runs Mon 00:00 - Sun 23:59 NY and swallows the Sunday-evening
//     session of the NEW trading week -- the week-scale twin of fix 1. After a
//     Sunday gap-down the Prev. Week L then sat on a candle from THIS week.
//     wkid also misbehaved around New Year (week 1 vs 53 jump). The week now
//     seals on the trading-week event itself: the Sunday 18:00 open, the same
//     bar that captures W.O. Prev week = Sun 18:00 -> Fri 17:00 by
//     construction, no calendar convention involved. Edge case, accepted: if a
//     Sunday open is ever missing, that week seals on the next Sunday and
//     covers two weeks.
//   14 Prev. Day definition is now an input. "Calendar" (00:00-23:59, default,
//     the original spec, unchanged behaviour) includes 18:00-23:59 -- which is
//     the ASIA OPEN OF THE NEXT TRADING DAY. On Tuesday the "Prev. Day L" can
//     therefore be Monday-evening's Asia low, i.e. the low of the CURRENT
//     trading day, merged into one line with "Asia L". Not a code bug, but on
//     the chart it reads like one. New option "Trading day (18:00-17:00)"
//     seals on the 18:00 open instead; in that mode the 6-hour Sunday-evening
//     stub day does not exist (Sun 18:00 opens MONDAY's trading day), so the
//     "skip Sunday evening" toggle only applies to Calendar mode.
//   15 Not a bug, but it read like one: "Show prev. days = 3" means the 3 most
//     recent UNMITIGATED prev-days, so after a stretch where every recent low
//     got swept, the render walks back until it finds intact ones -- and a
//     "Prev. Day L" from 10 days ago shows up with a label that reads as
//     yesterday. Two additions: the prev-day label can carry the date of the
//     candle that made the level (default ON), and a max-age input caps how
//     far back the walk may go (0 = unlimited, the old behaviour). If you want
//     "always the last N days, swept ones included", that already exists: turn
//     on "also keep mitigated prev-days".
//  NOT CHANGED, on purpose -- both are known and now written down instead:
//   · Session H/L uses time()-windows on the BAR-OPEN, so on a TF that is not
//     30-min aligned the boundary candle smears into the neighbouring session
//     (1H: the 02:00 candle counts as Asia but contains 02:30-03:00). Gating it
//     on ali30 like the cycles would delete session levels entirely on 45m/1H
//     and up, which is a bigger loss than a one-candle smear. See f_updSession.
//   · f_render rebuilds the whole pool on every realtime tick and the merge is
//     O(n^2). At the input maxima n ~ 116, so ~13k comparisons per tick. Fine
//     today, but it is the most expensive path in the script -- see the note
//     above f_render before hanging another level family off the pool.
// =============================================================================

indicator("TMU Time Cycle Levels", "TMU Cycles", overlay = true, max_lines_count = 500, max_labels_count = 500, max_boxes_count = 800)

tz = "America/New_York"

f_style(s) => s == "Dashed" ? line.style_dashed : s == "Dotted" ? line.style_dotted : line.style_solid
f_size(s)  => s == "Tiny" ? size.tiny : s == "Small" ? size.small : s == "Large" ? size.large : size.normal

// ---------------------------------------------------------------------------
//  TIME CONSTANTS  (minutes / seconds since NY midnight)
//  This block replaces the timings table that used to live only in the header.
//  Header and code could drift apart; now there is one place.
//    Asia   18:00-02:29   (wraps midnight -> tested with OR, not AND)
//    London 02:30-06:59 . NY AM 07:00-11:29 . NY PM 11:30-15:59
//    90M raster + all lower cycles live inside 02:30-15:59.
//    AM1 = the 07:00-08:29 accumulation window before the NY AM manipulation.
// ---------------------------------------------------------------------------
M_ASIA_A = 1080     // 18:00
M_ASIA_B = 149      // 02:29
M_LON_A  = 150      // 02:30  — also the anchor of the 90M/30M/10M raster
M_LON_B  = 419      // 06:59
M_AM_A   = 420      // 07:00
M_AM_B   = 689      // 11:29
M_PM_A   = 690      // 11:30
M_PM_B   = 959      // 15:59  — also the last minute of the 90M raster
M_AM1_A  = 420      // 07:00
M_AM1_B  = 509      // 08:29
S_CYC_A  = 9000     // 02:30:00 in seconds
S_CYC_B  = 57599    // 15:59:59 in seconds
SEC_32   = 200      // one 3.33M cycle
TRIM_32  = 190      // last 10 s of a 3.33M cycle -> gap between boxes

// ---------------------------------------------------------------------------
//  TYPES  (see fix 8)
//  Sess = one liquidity source with its own reset rule (4 sessions + week + month)
//  Lvl  = one sealed high or low kept in history (prev-day, C2)
//  Acc  = the running high/low of a C2 window that has not sealed yet
//  PLvl = one entry in the render pool, before merging
// ---------------------------------------------------------------------------
type Sess
    float hp   = na
    int   ht   = na
    float lp   = na
    int   lt   = na
    int   mitH = na     // na = not yet mitigated
    int   mitL = na
    bool  has  = false

type Lvl
    float price = na
    int   t     = na    // time of the extreme itself
    int   mit   = na    // na = not yet mitigated
    int   ty    = 0     // 0 = high, 1 = low
    int   win   = 0     // C2 window: 0 LON02, 1 AM02, 2 PM02 (unused for prev-day)

type Acc
    float h  = na
    int   ht = na
    float l  = na
    int   lt = na

type PLvl
    float  price = na
    int    start = na
    int    mit   = na
    string name  = ""
    int    ty    = 0    // 0 = high, 1 = low
    int    rank  = 0    // 0 open . 1 session/C2 . 2 day . 3 week . 4 month
    int    style = -1   // index into the opening-line style arrays, -1 = none
    int    sort  = 0    // label order within a merged group

// ---------------------------------------------------------------------------
//  1  GENERAL
// ---------------------------------------------------------------------------
gGen       = "1  General"
extendBars = input.int(30, "Extend line (bars beyond live candle)", minval = 0, group = gGen)

// ---------------------------------------------------------------------------
//  2  LIQUIDITY H/L
// ---------------------------------------------------------------------------
gLiq = "2  Liquidity H/L"
liqAsia = input.bool(true, "Asia",       inline="lq1", group=gLiq)
liqLon  = input.bool(true, "London",     inline="lq1", group=gLiq)
liqNYAM = input.bool(true, "NY AM",      inline="lq2", group=gLiq)
liqNYPM = input.bool(true, "NY PM",      inline="lq2", group=gLiq)
liqPD   = input.bool(true, "Prev Day",   inline="lq3", group=gLiq)
liqPW   = input.bool(true, "Prev Week",  inline="lq3", group=gLiq)
liqPM   = input.bool(true, "Prev Month", inline="lq4", group=gLiq)
prevDayCount    = input.int(3, "Show prev. days", minval=1, maxval=20, group=gLiq, tooltip="How many of the most recent prev-day highs/lows you want to see back in time.")
pdDef           = input.string("Calendar (00:00-23:59)", "  └ prev. day definition", options=["Calendar (00:00-23:59)","Trading day (18:00-17:00)"], group=gLiq, tooltip="Calendar = the original definition; note that a calendar day INCLUDES its own 18:00-23:59 evening, which is the Asia open of the NEXT trading day -- so Prev. Day H/L can land on last night's Asia session. Trading day = 18:00 -> 17:00 NY; the day seals on the 18:00 open, Sunday evening simply belongs to Monday's trading day.")
showMitPrevDay  = input.bool(false, "  └ also keep mitigated prev-days", group=gLiq, tooltip="Off = only still-unmitigated. On = the N most recent prev-days regardless of mitigation (mitigated ones stop dotted at their mitigation point).")
pdDateOn        = input.bool(true, "  └ date in prev-day label", group=gLiq, tooltip="Adds dd/mm to the prev-day label, e.g. 'Prev. Day L · 08/08'. With unmitigated-only display a prev-day level can be many days old (every low in between got swept); without the date it reads as yesterday's. The date is that of the CANDLE that made the level -- in Trading-day mode a low made Sunday evening therefore shows Sunday's date even though it belongs to Monday's trading day.")
pdMaxAge        = input.int(0, "  └ max. prev-day age (days, 0 = off)", minval=0, maxval=90, group=gLiq, tooltip="Stops the backward walk after this many sealed prev-days, even if fewer than 'Show prev. days' unmitigated levels were found. 0 = walk the whole history (old behaviour). Counts sealed days, so with 'skip Sunday evening' on, skipped Sundays do not count.")
skipSunEve      = input.bool(false, "  └ skip Sunday evening (Calendar mode)", group=gLiq, tooltip="Only relevant when prev. day definition = Calendar: there Sunday 18:00-24:00 is a 6-hour day and gives a short level. On = leave that day out of the history. In Trading-day mode this stub day does not exist and the toggle does nothing. Friday is closed correctly on the Sunday 18:00 bar either way.")
pdCal           = pdDef == "Calendar (00:00-23:59)"
liqUnmitC = input.color(color.new(#B0BEC5, 0), "Unmitigated", inline="lqU", group=gLiq), liqUnmitW = input.int(1,"",minval=1,maxval=5,inline="lqU",group=gLiq), liqUnmitS = input.string("Solid","",options=["Solid","Dashed","Dotted"],inline="lqU",group=gLiq)
liqMitC   = input.color(color.new(#607D8B, 0), "Mitigated",   inline="lqM", group=gLiq), liqMitW   = input.int(1,"",minval=1,maxval=5,inline="lqM",group=gLiq), liqMitS   = input.string("Dotted","",options=["Solid","Dashed","Dotted"],inline="lqM",group=gLiq)
liqTsz    = input.string("Small", "Text size", options=["Tiny","Small","Normal","Large"], group=gLiq)
liqMerge  = input.int(0, "Merge tolerance (ticks)", minval=0, group=gLiq, tooltip="Levels within this distance are placed on 1 line. Also applies between liquidity and opening lines. 0 = exactly equal.")
liqPrice  = input.bool(false, "Price in label", group=gLiq)
// Fix 12. Only has an effect on a group that contains an opening line: that
// group keeps running (an open does not mitigate) and therefore shows no
// dotted style, so a mitigated liquidity member inside it is invisible.
liqMarkMit = input.bool(false, "Mark mitigated level merged with an open", group=gLiq, tooltip="A liquidity level that sits at the same price as an opening line keeps the open's style and keeps running, so you cannot see that the liquidity side is already taken. On = that member gets '(m)' in the label, e.g. 'Prev. Day H (m) + 09:30'. Off = the old label.")
c2On    = input.bool(true, "90M cycle levels (2nd/Manip.: LON02/AM02/PM02)", group=gLiq, tooltip="High/low of the 2nd 90M cycle of each session (London 04:00, NY AM 08:30, NY PM 13:00). Unmitigated extended; mitigated stops with label in the MIDDLE of the line. Needs a 30-min aligned TF (see fix 7).")
c2Count = input.int(2, "  └ count per window (H/L)", minval=1, maxval=10, group=gLiq)

// ---------------------------------------------------------------------------
//  3  OPENING LINES  (on . colour . width . style)
// ---------------------------------------------------------------------------
gOpen = "3  Opening lines"
o930On = input.bool(true, "09:30", inline="o1", group=gOpen), o930C = input.color(#EF5350, "", inline="o1", group=gOpen), o930W = input.int(1,"",minval=1,maxval=5,inline="o1",group=gOpen), o930S = input.string("Dotted","",options=["Solid","Dashed","Dotted"],inline="o1",group=gOpen)
woOn = input.bool(true, "W.O.", inline="o2", group=gOpen), woC = input.color(#FFA726, "", inline="o2", group=gOpen), woW = input.int(1,"",minval=1,maxval=5,inline="o2",group=gOpen), woS = input.string("Dotted","",options=["Solid","Dashed","Dotted"],inline="o2",group=gOpen)
moOn = input.bool(true, "M.O.", inline="o3", group=gOpen), moC = input.color(#AB47BC, "", inline="o3", group=gOpen), moW = input.int(1,"",minval=1,maxval=5,inline="o3",group=gOpen), moS = input.string("Dotted","",options=["Solid","Dashed","Dotted"],inline="o3",group=gOpen)
coOn = input.bool(true, "C.O. (90M)", inline="o4", group=gOpen), coC = input.color(#42A5F5, "", inline="o4", group=gOpen), coW = input.int(1,"",minval=1,maxval=5,inline="o4",group=gOpen), coS = input.string("Dotted","",options=["Solid","Dashed","Dotted"],inline="o4",group=gOpen)
openTsz = input.string("Small", "Text size", options=["Tiny","Small","Normal","Large"], group=gOpen)

// ---------------------------------------------------------------------------
//  4  OPENING GAPS  (box + CE line)
// ---------------------------------------------------------------------------
gGap = "4  Opening gaps"
nwogOn   = input.bool(true, "NWOG", inline="g1", group=gGap), nwogBoxC = input.color(color.new(#26A69A, 85), "Box", inline="g1", group=gGap), nwogCEC = input.color(#26A69A, "CE", inline="g1", group=gGap)
nwogHist = input.int(2, "NWOG history", minval=1, maxval=20, group=gGap)
ndogOn   = input.bool(true, "NDOG", inline="g2", group=gGap), ndogBoxC = input.color(color.new(#FFA726, 85), "Box", inline="g2", group=gGap), ndogCEC = input.color(#FFA726, "CE", inline="g2", group=gGap)
ndogHist = input.int(5, "NDOG history", minval=1, maxval=20, group=gGap)

// ---------------------------------------------------------------------------
//  5  CYCLES (AMD boxes)  — A/M/D rotation from 02:30 NY (blue/red/green)
//     London 02:30/04:00/05:30 · NY AM 07:00/08:30/10:00 · NY PM 11:30/13:00/14:30
// ---------------------------------------------------------------------------
gCyc = "5  Cycles (AMD boxes)"
cyc90 = input.bool(true,  "90M",           inline="cz", group=gCyc)
cyc30 = input.bool(true, "30M",           inline="cz", group=gCyc)
cyc10 = input.bool(true, "10M",           inline="cz", group=gCyc)
cyc32 = input.bool(true, "3.33M (10s TF)", inline="cz", group=gCyc, tooltip="200-second cycles (27 per 90M). Previously labelled 3.2M, which it never was. Only draws on a TF that divides 200 s: 10s / 20s / 40s / 50s.")
amdBlue  = input.color(#2962ff, "A", inline="amdc", group=gCyc)
amdRed   = input.color(#f23645, "M", inline="amdc", group=gCyc)
amdGreen = input.color(#089981, "D", inline="amdc", group=gCyc)
mode90      = input.string("Grey", "Non-red 90M windows", options=["Hide","Grey","AMD colours"], group=gCyc, tooltip="Hide = only the red (manipulation) 90M windows (LO2/AM2/PM2: 04:00, 08:30, 13:00 NY). Grey = all 90M windows, the non-red ones in the colour below. AMD colours = original blue/red/green rotation. The red windows always keep the M colour.")
c90OtherC   = input.color(color.new(#B0BEC5, 0), "  └ colour non-red 90M", group=gCyc)
lowInRed    = input.bool(true, "30/10/3.2M only inside RED 90M", group=gCyc, tooltip="Off = the lower cycles run across the whole day instead of only inside the red 90M windows.")
focusRedLo  = input.bool(true, "Focus: only RED 30/10/3.2M", group=gCyc, tooltip="Of the 30/10/3.2M only the red (2nd/Manipulation) boxes.")
focusPreRed = input.bool(false, "  └ (Hide mode) also 90M window before the red", group=gCyc, tooltip="Only relevant when 'Non-red 90M windows' = Hide. Then it also shows the Accumulation window (LO1/AM1/PM1) before each red window.")
am1On = input.bool(false, "  └ 90M 07:00-08:29 (AM1)", inline="am1", group=gCyc, tooltip="Draws the 07:00-08:29 accumulation window before the NY AM manipulation in its own colour, in every 90M mode.")
am1C  = input.color(#26A69A, "", inline="am1", group=gCyc)
allRed10 = input.bool(false, "Show ALL red 10M cycles", inline="allcyc", group=gCyc, tooltip="Every red (Manipulation) 10M cycle across the day (02:30-16:00 NY), independent of the 90M red windows. Standalone toggle.")
all3M    = input.bool(false, "Show ALL red 3.33M cycles",  inline="allcyc", group=gCyc, tooltip="Every RED (Manipulation) 3.33M cycle across the day, independent of the 90M red windows. Needs a TF that divides 200 s (10s / 20s / 40s / 50s) - NOT 1-min: there the boundaries fall mid-candle and the boxes came out 3 and 4 minutes wide alternating.")
cycTrans   = input.int(85, "Box transparency", minval=0, maxval=100, group=gCyc)
cycBordStr = input.string("Dotted", "Border", options=["Solid","Dashed","Dotted"], inline="cb", group=gCyc)
cycBordC   = input.color(color.gray, "", inline="cb", group=gCyc)
cycEQon    = input.bool(true, "EQ line (90M + sessions)", inline="ceq", group=gCyc)
cycEQred   = input.bool(false, "  └ only in RED 90M", group=gCyc, tooltip="Keeps the chart calm when all 90M windows are visible: the EQ line is then only drawn in the red windows (sessions keep theirs).")
cycEQstr   = input.string("Dashed", "", options=["Solid","Dashed","Dotted"], inline="ceq", group=gCyc)
cycEQC     = input.color(color.gray, "", inline="ceq", group=gCyc)

// ---------------------------------------------------------------------------
//  6  SESSION BOXES
// ---------------------------------------------------------------------------
gSbox = "6  Session boxes"
sbAsia = input.bool(true, "Asia",   inline="sb1", group=gSbox), sbAsiaC = input.color(color.gray, "", inline="sb1", group=gSbox)
sbLon  = input.bool(false, "London", inline="sb2", group=gSbox), sbLonC  = input.color(#2962ff, "", inline="sb2", group=gSbox)
sbNYAM = input.bool(false, "NY AM",  inline="sb3", group=gSbox), sbNYAMC = input.color(#f23645, "", inline="sb3", group=gSbox)
sbNYPM = input.bool(false, "NY PM",  inline="sb4", group=gSbox), sbNYPMC = input.color(#089981, "", inline="sb4", group=gSbox)
sbLblC  = input.color(color.black, "Label", inline="sbl", group=gSbox)
sbLblSz = input.string("Small", "", options=["Tiny","Small","Normal","Large"], inline="sbl", group=gSbox)

// ---------------------------------------------------------------------------
//  7  SESSION RANGE -> 15:59
//  Box from the session's highest to lowest candle, projected to 15:59 NY.
//  Finalised when the session ends (so it shows the COMPLETED range as a zone).
//  On a 1-min chart the high/low is exactly the highest/lowest 1-min candle;
//  on a higher TF it is the chart-TF extreme of that session.
// ---------------------------------------------------------------------------
gSR = "7  Session range -> 15:59"
srOn   = input.bool(false, "Show session range zones (-> 15:59)", group=gSR, tooltip="Off by default. Draws each session's high-to-low range as a box, projected to 15:59 NY of the trading day.")
srAsia = input.bool(true, "Asia",   inline="sr1", group=gSR), srAsiaC = input.color(color.gray, "", inline="sr1", group=gSR)
srLon  = input.bool(true, "London", inline="sr2", group=gSR), srLonC  = input.color(#2962ff, "", inline="sr2", group=gSR)
srAM   = input.bool(true, "NY AM",  inline="sr3", group=gSR), srAMC   = input.color(#f23645, "", inline="sr3", group=gSR)
srPM   = input.bool(false,"NY PM",  inline="sr4", group=gSR), srPMC   = input.color(#089981, "", inline="sr4", group=gSR)
srFrom = input.string("Session end (projection)", "Box starts at", options=["Session end (projection)","Session start (full)"], group=gSR, tooltip="Session end = clean forward zone from the session's close to 15:59 (your idea). Session start = the box also covers the session itself.")
srHist = input.int(1, "Days kept", minval=1, maxval=5, group=gSR, tooltip="How many trading days of session-range zones to keep on the chart.")
srTrans= input.int(88, "Fill transparency", minval=0, maxval=100, group=gSR)
srBord = input.bool(true, "Border", group=gSR)
srLbl  = input.bool(true, "Session label", group=gSR)
srFromEnd = srFrom == "Session end (projection)"

amd_col(int idx) =>
    int m = idx % 3
    m == 0 ? amdBlue : m == 1 ? amdRed : amdGreen

// ---------------------------------------------------------------------------
//  STATE
//  sessSt: 0 Asia . 1 London . 2 NY AM . 3 NY PM . 4 Prev Week . 5 Prev Month
//  (fix 9: the old 7-slot layout had a dead index 4 left over from when the
//   prev-day lived in the same array. Week/month moved down one slot.)
// ---------------------------------------------------------------------------
var array<Sess> sessSt = array.from(Sess.new(), Sess.new(), Sess.new(), Sess.new(), Sess.new(), Sess.new())

var float cdH=na, var int cdHt=na, var float cdL=na, var int cdLt=na
var float cwH=na, var int cwHt=na, var float cwL=na, var int cwLt=na
var float cmH=na, var int cmHt=na, var float cmL=na, var int cmLt=na

// Prev-day history. One Lvl per sealed high/low; .mit holds the mitigation time.
var array<Lvl> pdHi = array.new<Lvl>()
var array<Lvl> pdLo = array.new<Lvl>()

// 2nd-90M-cycle windows (0=LON02 04:00, 1=AM02 08:30, 2=PM02 13:00)
var array<Acc> c2acc = array.from(Acc.new(), Acc.new(), Acc.new())
var array<Lvl> c2Lv  = array.new<Lvl>()

// Opening lines state
var float o0930p=na, var int o0930t=na
var float woP=na,    var int woT=na
var float moP=na,    var int moT=na
var float coP=na,    var int coT=na

var array<line>  gLines  = array.new<line>()
var array<label> gLabels = array.new<label>()
// LINE BUDGET (max_lines_count = 500). Worst case with every input at its max:
//   render lines   <= pool size = 8 sessions + 40 prev-day (2 x 20)
//                     + 2 week + 2 month + 4 opens + 60 C2 (3 x 2 x 10) = 116
//   EQ lines        = 150 (capped just below)
//   NWOG/NDOG CEs  <= 20 + 20 = 40
//   total          <= 306 of 500
// Fix 6 created the EQ cap. If you raise it, or add a level family to the pool,
// redo this sum first -- when the budget runs out Pine silently drops the
// OLDEST lines, which are the EQ lines of the current session.
var array<line>  eqLines = array.new<line>()

var array<box>  nwogBoxes = array.new<box>()
var array<line> nwogCEs   = array.new<line>()
var array<box>  ndogBoxes = array.new<box>()
var array<line> ndogCEs   = array.new<line>()
var box  nwogCur   = na
var line nwogCurCE = na
var box  ndogCur   = na
var line ndogCurCE = na

// Session range zones (group 7). Independent of the render pool, like the gap
// boxes: persistent, capped, dropped oldest-first. srStart = session-open time.
var array<int>    srStart  = array.from(int(na), int(na), int(na), int(na))
var array<box>    srBoxes  = array.new<box>()
var array<label>  srLabels = array.new<label>()
srNames = array.from("Asia", "London", "NY AM", "NY PM")

// Cycle boxes are never deleted; they rely on Pine dropping the oldest at
// max_boxes_count = 800. That is intended -- it gives roughly a week of 10M
// history on a 1m chart and needs no bookkeeping.

// ---------------------------------------------------------------------------
//  TIME FLAGS
// ---------------------------------------------------------------------------
inAsia   = not na(time(timeframe.period, "1800-0230:1234567", tz))
inLondon = not na(time(timeframe.period, "0230-0700:1234567", tz))
inNYAM   = not na(time(timeframe.period, "0700-1130:1234567", tz))
inNYPM   = not na(time(timeframe.period, "1130-1600:1234567", tz))

did  = year(time, tz) * 10000 + month(time, tz) * 100 + dayofmonth(time, tz)
// wkid (weekofyear) is gone -- see fix 13: the week now seals on the Sunday
// 18:00 trading-week open, not on a calendar week number.
moid = year(time, tz) * 100   + month(time, tz)
dow  = dayofweek(time, tz)

isNewDay   = not barstate.isfirst and did  != did[1]
isNewMonth = not barstate.isfirst and moid != moid[1]

mnts = hour(time, tz) * 60 + minute(time, tz)
secs = hour(time, tz) * 3600 + minute(time, tz) * 60 + second(time, tz)

// ---------------------------------------------------------------------------
//  TF ALIGNMENT
//  Every cycle boundary is derived from the BAR-OPEN time. That is only exact
//  if the bar actually starts on the boundary. On a 45m/1H/4H chart 02:30 and
//  09:30 fall in the middle of a candle, so the "cycle" would silently start on
//  the wrong bar and the 09:30 line would show the 09:00 open.
//  Each level therefore states which grid it needs:
//    ali30  = boundaries on :00/:30      -> 90M, 30M, sessions boxes, 09:30,
//                                           C.O. and (since fix 7) the C2 windows
//    ali10  = boundaries every 10 min    -> 10M
//    ali200 = boundaries every 200 sec   -> 3.33M
//  Not aligned -> that level is simply not drawn. Silently, on purpose: no
//  warning label on the chart. Practical consequence to keep in mind:
//    1m  -> no 3.33M (200 s cannot land on 60 s bars)
//    15m -> no 10M
//    45m/1H and up -> nothing cycle-based at all, including C2 levels
// ---------------------------------------------------------------------------
tfSec  = timeframe.in_seconds()
ali30  = timeframe.isintraday and 1800 % tfSec == 0
ali10  = timeframe.isintraday and 600  % tfSec == 0
ali200 = timeframe.isintraday and 200  % tfSec == 0

// ---------------------------------------------------------------------------
//  90M RASTER — one single source of truth for boxes, C.O., the red windows
//  and (since fix 7) the C2 windows.
//  9 cycles, 02:30 (150 min) up to and including 15:59 (959 min), keys 2..10:
//    LO1 02:30-03:59 . LO2 04:00-05:29 . LO3 05:30-06:59
//    AM1 07:00-08:29 . AM2 08:30-09:59 . AM3 10:00-11:29
//    PM1 11:30-12:59 . PM2 13:00-14:29 . PM3 14:30-15:59
//  The window is half-open: the xx:00 / xx:30 candle belongs to the NEXT cycle,
//  the xx:29 / xx:59 candle is the last one of this cycle.
//  Outside 02:30-16:00 there is NO 90M cycle -> key 0.
//  isRed90 = the 2nd cycle of each session (keys 3, 6, 9) = LO2 / AM2 / PM2.
// ---------------------------------------------------------------------------
in90win  = mnts >= M_LON_A and mnts <= M_PM_B
cyc90k   = in90win ? math.floor((mnts - M_LON_A) / 90) + 2 : 0
newCycle = not barstate.isfirst and ali30 and cyc90k != 0 and cyc90k != cyc90k[1]
isRed90  = cyc90k != 0 and (cyc90k - 2) % 3 == 1

// 09:30 on the exact bar-open, not on window overlap.
at0930 = ali30 and hour(time, tz) == 9 and minute(time, tz) == 30
is0930 = at0930 and not at0930[1]

// ---------------------------------------------------------------------------
//  FUNCTIONS (updates)
// ---------------------------------------------------------------------------
// NOTE on TF alignment for sessions (see the header). inAsia/inLondon/... come
// from time()-windows evaluated on the bar-open, so on a TF that is not 30-min
// aligned the boundary candle is counted whole into the session it opens in.
// 1H example: the 02:00 candle is still "Asia" but contains 02:30-03:00, so
// London's first half hour can raise the Asia high. Deliberately NOT gated on
// ali30: that would remove session levels from 45m/1H+ entirely, which is worse
// than a one-candle smear. If you ever want it exact on high TFs, request the
// extremes from a 1-min security instead of widening the gate here.
f_updSession(int idx, bool inS, bool inSprev) =>
    Sess s = array.get(sessSt, idx)
    if inS and not inSprev
        s.hp := high, s.ht := time
        s.lp := low,  s.lt := time
        s.mitH := na, s.mitL := na
        s.has := true
    else if inS
        if high > s.hp
            s.hp := high, s.ht := time
        if low < s.lp
            s.lp := low,  s.lt := time
    int(na)     // CE10235 guard, see note below

// NOTE on the `int(na)` at the end of f_updSession / f_checkMit / f_c2.
// These are void functions, but Pine has no void: the last statement IS the
// return value, and an if/else chain must therefore have the same type in every
// branch. In the old array version every branch happened to end on array.set()
// (no value), so it never came up. With object fields the branches end on
// whatever field was assigned last -- `s.has := true` is bool, `s.lt := time` is
// int -> "Return type of one of the if blocks is not compatible" (CE10235).
// The trailing int(na) makes the whole function return one type. Do not delete
// it, and do not "clean up" a branch so it ends on a different field type.

f_checkMit(int idx, bool checkable) =>
    Sess s = array.get(sessSt, idx)
    if checkable and s.has
        if na(s.mitH) and high >= s.hp
            s.mitH := time
        if na(s.mitL) and low <= s.lp
            s.mitL := time
    int(na)     // CE10235 guard

// ---------------------------------------------------------------------------
//  SESSION RANGE ZONE (group 7)
//  Rising edge  -> remember the session-open time.
//  Falling edge -> the session is complete; draw a box from its high to its low,
//                  projected to 15:59 NY of the (calendar) day the session ends
//                  on. All of Asia/London/NY AM end before 15:59 on the same
//                  date, so no midnight wrap. NY PM ends AT 15:59, so in
//                  projection mode it has nothing to project and is skipped.
//  Reads sessSt[idx].hp/lp which still hold the just-completed session extremes
//  (they only reset on that session's next open). Call AFTER f_updSession.
// ---------------------------------------------------------------------------
f_sessRange(int idx, bool inS, bool inSprev, bool en, color col) =>
    if srOn and en
        if inS and not inSprev
            array.set(srStart, idx, time)
        if inSprev and not inS
            Sess s = array.get(sessSt, idx)
            if s.has and not na(s.hp) and not na(s.lp)
                int lft = srFromEnd ? time : nz(array.get(srStart, idx), time)
                int tgt = timestamp(tz, year(time, tz), month(time, tz), dayofmonth(time, tz), 15, 59, 0)
                if tgt > lft
                    box b = box.new(lft, s.hp, tgt, s.lp, xloc = xloc.bar_time, bgcolor = color.new(col, srTrans), border_color = srBord ? color.new(col, 10) : color(na), border_width = 1)
                    array.push(srBoxes, b)
                    if srLbl
                        label lb = label.new(lft, s.hp, array.get(srNames, idx), xloc = xloc.bar_time, style = label.style_label_down, color = color.new(col, 100), textcolor = color.new(col, 0), size = size.tiny)
                        array.push(srLabels, lb)
                    while array.size(srBoxes) > srHist * 4
                        box.delete(array.shift(srBoxes))
                    while array.size(srLabels) > srHist * 4
                        label.delete(array.shift(srLabels))
    int(na)

// ---------------------------------------------------------------------------
//  SESSION UPDATE
// ---------------------------------------------------------------------------
f_updSession(0, inAsia,   inAsia[1])
f_updSession(1, inLondon, inLondon[1])
f_updSession(2, inNYAM,   inNYAM[1])
f_updSession(3, inNYPM,   inNYPM[1])

// Session range zones (group 7) — after f_updSession so hp/lp are current.
f_sessRange(0, inAsia,   inAsia[1],   srAsia, srAsiaC)
f_sessRange(1, inLondon, inLondon[1], srLon,  srLonC)
f_sessRange(2, inNYAM,   inNYAM[1],   srAM,   srAMC)
f_sessRange(3, inNYPM,   inNYPM[1],   srPM,   srPMC)

// ---------------------------------------------------------------------------
//  TRADING DAY START (18:00) -> clear sessions + gap forming + week open
// ---------------------------------------------------------------------------
tradingDayStart = inAsia and not inAsia[1]
// Fix 13. The trading week starts here too: the Sunday 18:00 open. Sealing the
// week on this event instead of on weekofyear() makes prev week = Sun 18:00 ->
// Fri 17:00 regardless of which weekday TradingView starts its calendar week
// on, and sidesteps the week-1/week-53 jump around New Year.
weekSeal = tradingDayStart and dow == dayofweek.sunday
if tradingDayStart
    for i = 1 to 3
        Sess s = array.get(sessSt, i)
        s.has := false, s.mitH := na, s.mitL := na
    pc   = close[1]
    op   = open
    gTop = math.max(pc, op)
    gBot = math.min(pc, op)
    gCE  = (pc + op) / 2
    if dow == dayofweek.sunday
        woP := op, woT := time
        ndogCur := na
        if nwogOn
            b = box.new(time, gTop, time, gBot, xloc=xloc.bar_time, border_color=nwogBoxC, bgcolor=nwogBoxC, border_width=1)
            l = line.new(time, gCE, time, gCE, xloc=xloc.bar_time, color=nwogCEC, width=1, style=line.style_dashed)
            array.push(nwogBoxes, b), array.push(nwogCEs, l)
            nwogCur := b, nwogCurCE := l
            while array.size(nwogBoxes) > nwogHist
                box.delete(array.shift(nwogBoxes))
                line.delete(array.shift(nwogCEs))
    else
        if ndogOn
            b = box.new(time, gTop, time, gBot, xloc=xloc.bar_time, border_color=ndogBoxC, bgcolor=ndogBoxC, border_width=1)
            l = line.new(time, gCE, time, gCE, xloc=xloc.bar_time, color=ndogCEC, width=1, style=line.style_dashed)
            array.push(ndogBoxes, b), array.push(ndogCEs, l)
            ndogCur := b, ndogCurCE := l
            while array.size(ndogBoxes) > ndogHist
                box.delete(array.shift(ndogBoxes))
                line.delete(array.shift(ndogCEs))

// ---------------------------------------------------------------------------
//  DAY (history push) / WEEK / MONTH UPDATE (+ M.O.)
// ---------------------------------------------------------------------------
// PREV. DAY = CALENDAR DAY (00:00-23:59 NY).
// Was: `isNewDay and dow != dayofweek.sunday`. On the Sunday 18:00 bar `did`
// jumps from Friday to Sunday, so isNewDay is true - but the guard blocked the
// seal. cdH/cdL then kept running through the Sunday evening bars and only
// sealed on Monday 00:00, so FRIDAY AND SUNDAY EVENING ended up as one single
// "Prev. Day". A higher high on Sunday evening was shown as a Friday level that
// Friday never traded.
// Now every calendar day change seals: Friday closes on the Sunday 18:00 bar,
// Sunday evening becomes its own day (hide it with "skip Sunday evening").
// NOTE the deliberate mix: session levels still reset at 18:00 (trading day),
// prev-days follow the calendar.
// Fix 14: the above describes CALENDAR mode (the default). In Trading-day mode
// the seal moves to the 18:00 open and the whole Sunday discussion disappears:
// Sun 18:00 -> Mon 17:00 simply IS Monday's trading day.
sealDay = pdCal ? isNewDay : tradingDayStart
// dow[1] = the day we are closing now (the previous bar), not the new day.
// The Sunday-evening skip only exists in Calendar mode; in Trading mode there
// is no 6-hour stub day to skip.
pushDay = sealDay and (not pdCal or not skipSunEve or dow[1] != dayofweek.sunday)
if barstate.isfirst
    cdH := high, cdHt := time, cdL := low, cdLt := time
else if sealDay
    if pushDay
        array.push(pdHi, Lvl.new(cdH, cdHt, na, 0, 0))
        array.push(pdLo, Lvl.new(cdL, cdLt, na, 1, 0))
        if array.size(pdHi) > 90
            array.shift(pdHi)
        if array.size(pdLo) > 90
            array.shift(pdLo)
    cdH := high, cdHt := time, cdL := low, cdLt := time
else
    if high > cdH
        cdH := high, cdHt := time
    if low < cdL
        cdL := low, cdLt := time

if barstate.isfirst
    cwH := high, cwHt := time, cwL := low, cwLt := time
else if weekSeal
    Sess sw = array.get(sessSt, 4)
    sw.hp := cwH, sw.ht := cwHt, sw.lp := cwL, sw.lt := cwLt, sw.has := true
    sw.mitH := na, sw.mitL := na
    cwH := high, cwHt := time, cwL := low, cwLt := time
else
    if high > cwH
        cwH := high, cwHt := time
    if low < cwL
        cwL := low, cwLt := time

if barstate.isfirst
    cmH := high, cmHt := time, cmL := low, cmLt := time
else if isNewMonth
    Sess sm = array.get(sessSt, 5)
    sm.hp := cmH, sm.ht := cmHt, sm.lp := cmL, sm.lt := cmLt, sm.has := true
    sm.mitH := na, sm.mitL := na
    cmH := high, cmHt := time, cmL := low, cmLt := time
else
    if high > cmH
        cmH := high, cmHt := time
    if low < cmL
        cmL := low, cmLt := time

if isNewMonth
    moP := open, moT := time

// ---------------------------------------------------------------------------
//  OPENING LINES capture (09:30 + C.O.)
// ---------------------------------------------------------------------------
if is0930
    o0930p := open, o0930t := time
if newCycle
    coP := open, coT := time
// No 90M cycle outside 02:30-16:00 -> clear C.O. instead of keeping yesterday's
// open on screen as if it were the current cycle.
if not in90win
    coP := na, coT := na

// ---------------------------------------------------------------------------
//  MITIGATION CHECK
// ---------------------------------------------------------------------------
f_checkMit(0, not inAsia)
f_checkMit(1, not inLondon)
f_checkMit(2, not inNYAM)
f_checkMit(3, not inNYPM)
f_checkMit(4, true)
f_checkMit(5, true)

// prev-day mitigation: record mitigation time (na -> time)
if array.size(pdHi) > 0
    for i = 0 to array.size(pdHi) - 1
        Lvl l = array.get(pdHi, i)
        if na(l.mit) and high >= l.price
            l.mit := time
if array.size(pdLo) > 0
    for i = 0 to array.size(pdLo) - 1
        Lvl l = array.get(pdLo, i)
        if na(l.mit) and low <= l.price
            l.mit := time

// ---------------------------------------------------------------------------
//  2nd-90M-cycle windows: accumulate -> seal -> mitigation
//  FIX 7. The window flags are now derived from cyc90k instead of a second
//  hard-coded minute raster, and they carry the ali30 gate. c2win maps the red
//  90M keys onto the window index:  key 3 -> 0 (LON02)
//                                   key 6 -> 1 (AM02)
//                                   key 9 -> 2 (PM02)
//  Not 30-min aligned -> c2win is -1 on every bar -> nothing accumulates and
//  nothing seals, so no C2 levels appear. Same silent-absence rule as the boxes.
// ---------------------------------------------------------------------------
c2key = (ali30 and isRed90) ? cyc90k : 0
c2win = c2key == 0 ? -1 : int((c2key - 3) / 3)

f_c2(int w, bool inW, bool inWprev) =>
    Acc a = array.get(c2acc, w)
    if inW and not inWprev
        a.h := high, a.ht := time
        a.l := low,  a.lt := time
    if inW and inWprev
        if high > a.h
            a.h := high, a.ht := time
        if low < a.l
            a.l := low,  a.lt := time
    if not inW and inWprev and not na(a.h)
        array.push(c2Lv, Lvl.new(a.h, a.ht, na, 0, w))
        array.push(c2Lv, Lvl.new(a.l, a.lt, na, 1, w))
        while array.size(c2Lv) > 120
            array.shift(c2Lv)
        a.h := na, a.l := na
    int(na)     // CE10235 guard

inC2_0 = c2win == 0
inC2_1 = c2win == 1
inC2_2 = c2win == 2
f_c2(0, inC2_0, inC2_0[1])
f_c2(1, inC2_1, inC2_1[1])
f_c2(2, inC2_2, inC2_2[1])

if array.size(c2Lv) > 0
    for i = 0 to array.size(c2Lv) - 1
        Lvl l = array.get(c2Lv, i)
        if na(l.mit)
            if (l.ty == 0 and high >= l.price) or (l.ty == 1 and low <= l.price)
                l.mit := time

// ---------------------------------------------------------------------------
//  GAP BOXES follow live
// ---------------------------------------------------------------------------
if not na(nwogCur)
    box.set_right(nwogCur, time)
    line.set_x2(nwogCurCE, time)
if not na(ndogCur)
    box.set_right(ndogCur, time)
    line.set_x2(ndogCurCE, time)

// ---------------------------------------------------------------------------
//  CYCLES + SESSION BOXES  (gap-trim mechanism, optional EQ)
// ---------------------------------------------------------------------------
f_cycleBox(bool active, int key, color col, bool doLabel, string lblTxt, bool doEQ) =>
    var bool  inC   = false
    var int   prevK = 0
    var box   curB  = na
    var label curL  = na
    // DO NOT ADD AN OFFSET TO THESE TWO. Read this first.
    // With xloc.bar_time a timestamp lands on the CENTRE LINE of that candle,
    // not on its left edge. So `time` on the xx:00 candle already puts the left
    // edge in the middle of that candle, and `time[1]` on the close already puts
    // the right edge in the middle of the xx:29 candle. That is exactly the
    // wanted result: cycle xx:00-xx:29, box centred on the first and last candle
    // of it, one candle of air before the next box starts.
    // Two failed "fixes" on this exact line, both from misreading the above:
    //   + 1 bar   -> boxes touch, no gap at all.
    //   + 1/2 bar -> everything shifts right, box reads as xx:01 to xx:30.
    liveR = time + timeframe.in_seconds() * 1000
    gapR  = nz(time[1], time)
    if inC and active and key == prevK
        box.set_top(curB, math.max(box.get_top(curB), high))
        box.set_bottom(curB, math.min(box.get_bottom(curB), low))
        box.set_right(curB, liveR)
        if doLabel and not na(curL)
            int ctr = int(math.round((box.get_left(curB) + box.get_right(curB)) / 2))
            label.set_xy(curL, ctr, box.get_top(curB))
    else if inC
        box.set_right(curB, gapR)                       // trim last candle -> gap
        if doEQ
            float eqMid = (box.get_top(curB) + box.get_bottom(curB)) / 2
            eqL = line.new(box.get_left(curB), eqMid, box.get_right(curB), eqMid, xloc = xloc.bar_time, color = cycEQC, style = f_style(cycEQstr))
            array.push(eqLines, eqL)
            while array.size(eqLines) > 150
                line.delete(array.shift(eqLines))
        curB := na
        curL := na
        inC  := false
    if active and not inC
        // Plain `time`: already the centre of this cycle's first candle. See the
        // note at the top of this function before touching it.
        curB := box.new(time, high, liveR, low, xloc = xloc.bar_time, bgcolor = color.new(col, cycTrans), border_color = cycBordC, border_width = 1, border_style = f_style(cycBordStr))
        if doLabel
            curL := label.new(time, high, lblTxt, xloc.bar_time, yloc.price, color.new(color.white, 100), label.style_label_down, sbLblC, size = f_size(sbLblSz))
        prevK := key
        inC   := true

// 200-second (3.33M) key. FIX 10: key32 and key3all were the same arithmetic
// twice. gate = the caller's own on/off + window conditions, redOnly = keep
// only the Manipulation cycle of each A/M/D triplet.
// The `% SEC_32 < TRIM_32` test drops the last 10 s of every cycle so the box
// closes one bar early -- that is the gap between the boxes, same idea as the
// gapR trim in f_cycleBox.
f_key200(bool gate, bool redOnly) =>
    int k = 0
    if gate and ali200 and secs >= S_CYC_A and secs <= S_CYC_B
        off = secs - S_CYC_A
        if off % SEC_32 < TRIM_32
            idx = math.floor(off / SEC_32)
            if not redOnly or idx % 3 == 1
                k := idx + 1
    k

// AM1 = the 07:00-08:29 NY 90M window. When the toggle is on it always gets its
// own colour, in every 90M mode; the main 90M series is suppressed there.
am1Active = am1On and cyc90 and ali30 and mnts >= M_AM1_A and mnts <= M_AM1_B

// 90M (keys 2-10). Red windows always keep the M colour; the rest is hidden,
// drawn in c90OtherC, or drawn in the original AMD rotation.
key90    = (cyc90 and ali30) ? cyc90k : 0
isRedKey = key90 >= 2 and (key90 - 2) % 3 == 1
keep90   = isRedKey or (focusPreRed and key90 >= 2 and (key90 - 2) % 3 == 0)
if mode90 == "Hide" and not keep90
    key90 := 0
if am1Active and key90 == 5
    key90 := 0
col90 = key90 == 0 ? color.gray : isRedKey ? amdRed : mode90 == "AMD colours" ? amd_col(key90 - 2) : c90OtherC
f_cycleBox(key90 != 0, key90, col90, false, "", cycEQon and (isRedKey or not cycEQred))

// AM1 90M standalone (07:00-08:29 NY, own colour)
keyAM1 = am1Active ? 1 : 0
f_cycleBox(keyAM1 != 0, keyAM1, am1C, false, "", cycEQon and not cycEQred)

// 30M  (boundaries on :00/:30 -> ali30)
key30 = 0
if cyc30 and ali30 and in90win and (not lowInRed or isRed90)
    key30 := math.floor((mnts - M_LON_A) / 30) + 1
if focusRedLo and key30 != 0 and (key30 - 1) % 3 != 1
    key30 := 0
f_cycleBox(key30 != 0, key30, key30 != 0 ? amd_col(key30 - 1) : color.gray, false, "", false)

// 10M  (boundaries every 10 min -> ali10; on a 15m chart they cannot align)
key10 = 0
if cyc10 and ali10 and in90win and (not lowInRed or isRed90)
    key10 := math.floor((mnts - M_LON_A) / 10) + 1
if focusRedLo and key10 != 0 and (key10 - 1) % 3 != 1
    key10 := 0
f_cycleBox(key10 != 0, key10, key10 != 0 ? amd_col(key10 - 1) : color.gray, false, "", false)

// 3.33M (200 s) -- needs a TF that divides 200 s: 10s / 20s / 40s / 50s / 100s.
key32 = f_key200(cyc32 and (not lowInRed or isRed90), focusRedLo)
f_cycleBox(key32 != 0, key32, key32 != 0 ? amd_col(key32 - 1) : color.gray, false, "", false)

// ALL red 10M cycles (standalone, whole day, independent of 90M focus)
key10all = (allRed10 and ali10 and in90win and (math.floor((mnts - M_LON_A) / 10)) % 3 == 1) ? math.floor((mnts - M_LON_A) / 10) + 1 : 0
f_cycleBox(key10all != 0, key10all, amdRed, false, "", false)

// ALL red 3.33M cycles (standalone, whole day).
// Was gated on nothing, with a tooltip claiming it worked on 1-min. It does not:
// the boundaries sit every 200 s while 1m bar-opens are multiples of 60 s, so
// only every third boundary lands on a candle and the boxes came out 3 and 4
// minutes wide alternating, starting on whichever bar happened to cross. Now it
// only draws on a TF that divides 200 s (the ali200 gate lives in f_key200).
key3all = f_key200(all3M, true)
f_cycleBox(key3all != 0, key3all, amdRed, false, "", false)

// Session boxes (Asia without EQ, like the reference).
// 02:30 and 11:30 are half-hour boundaries -> ali30, otherwise the box would
// start on the wrong candle.
f_cycleBox(sbAsia and ali30 and (mnts >= M_ASIA_A or mnts <= M_ASIA_B), 1, sbAsiaC, true, "Asia",   false)
f_cycleBox(sbLon  and ali30 and mnts >= M_LON_A and mnts <= M_LON_B,    1, sbLonC,  true, "London", cycEQon)
f_cycleBox(sbNYAM and ali30 and mnts >= M_AM_A  and mnts <= M_AM_B,     1, sbNYAMC, true, "NY AM",  cycEQon)
f_cycleBox(sbNYPM and ali30 and mnts >= M_PM_A  and mnts <= M_PM_B,     1, sbNYPMC, true, "NY PM",  cycEQon)

// ---------------------------------------------------------------------------
//  UNIFIED RENDER (on last bar)
//  rank: 0 open . 1 session/C2 . 2 day . 3 week . 4 month  (within 2-4 highest wins)
//
//  COST. This runs on every realtime tick: the pool is rebuilt from scratch and
//  the merge is O(n^2) with a second O(n^2) insertion sort per group. At the
//  input maxima n ~ 116 -> ~13k comparisons per tick. That is fine, but it is
//  the heaviest thing in the script and it grows quadratically. If another level
//  family gets added, sort the pool by price ONCE and merge in a single linear
//  pass over neighbours instead of widening this.
// ---------------------------------------------------------------------------
// dd/mm of the candle that made a level (fix 15). "00" pads to two digits.
f_ddmm(int t) => str.tostring(dayofmonth(t, tz), "00") + "/" + str.tostring(month(t, tz), "00")

f_render(int x2) =>
    sessNames = array.from("Asia","London","NY AM","NY PM")
    sessShow  = array.from(liqAsia, liqLon, liqNYAM, liqNYPM)
    openOn    = array.from(o930On, woOn, moOn, coOn)
    openPx    = array.from(o0930p, woP, moP, coP)
    openTx    = array.from(o0930t, woT, moT, coT)
    openCols  = array.from(o930C, woC, moC, coC)
    openWids  = array.from(o930W, woW, moW, coW)
    openStys  = array.from(f_style(o930S), f_style(woS), f_style(moS), f_style(coS))
    openNames = array.from("09:30","W.O.","M.O.","C.O.")
    tol = liqMerge * syminfo.mintick

    array<PLvl> pool = array.new<PLvl>()

    // sessions (rank 1, sort 0-3)
    for i = 0 to 3
        Sess s = array.get(sessSt, i)
        if array.get(sessShow, i) and s.has
            if not na(s.hp)
                array.push(pool, PLvl.new(s.hp, s.ht, s.mitH, array.get(sessNames, i) + " H", 0, 1, -1, i))
            if not na(s.lp)
                array.push(pool, PLvl.new(s.lp, s.lt, s.mitL, array.get(sessNames, i) + " L", 1, 1, -1, i))

    // prev-day: N most recent (unmitigated; or also mitigated if toggle on).
    // Fix 15: the walk stops after pdMaxAge sealed days (0 = unlimited), and
    // the label can carry the date so an old survivor is recognisable as one.
    if liqPD
        lastIdx = array.size(pdHi) - 1
        cntH = 0
        ih = lastIdx
        while ih >= 0 and cntH < prevDayCount and (pdMaxAge == 0 or lastIdx - ih < pdMaxAge)
            Lvl l = array.get(pdHi, ih)
            if showMitPrevDay or na(l.mit)
                nmH = "Prev. Day H" + (pdDateOn ? " · " + f_ddmm(l.t) : "")
                array.push(pool, PLvl.new(l.price, l.t, l.mit, nmH, 0, 2, -1, 10))
                cntH := cntH + 1
            ih := ih - 1
        lastIdxL = array.size(pdLo) - 1
        cntL = 0
        il = lastIdxL
        while il >= 0 and cntL < prevDayCount and (pdMaxAge == 0 or lastIdxL - il < pdMaxAge)
            Lvl l = array.get(pdLo, il)
            if showMitPrevDay or na(l.mit)
                nmL = "Prev. Day L" + (pdDateOn ? " · " + f_ddmm(l.t) : "")
                array.push(pool, PLvl.new(l.price, l.t, l.mit, nmL, 1, 2, -1, 10))
                cntL := cntL + 1
            il := il - 1

    // week (slot 4)
    if liqPW
        Sess sw = array.get(sessSt, 4)
        if sw.has
            if not na(sw.hp)
                array.push(pool, PLvl.new(sw.hp, sw.ht, sw.mitH, "Prev. Week H", 0, 3, -1, 11))
            if not na(sw.lp)
                array.push(pool, PLvl.new(sw.lp, sw.lt, sw.mitL, "Prev. Week L", 1, 3, -1, 11))

    // month (slot 5)
    if liqPM
        Sess sm = array.get(sessSt, 5)
        if sm.has
            if not na(sm.hp)
                array.push(pool, PLvl.new(sm.hp, sm.ht, sm.mitH, "Prev. Month H", 0, 4, -1, 12))
            if not na(sm.lp)
                array.push(pool, PLvl.new(sm.lp, sm.lt, sm.mitL, "Prev. Month L", 1, 4, -1, 12))

    // opens (rank 0, sort 50+)
    for k = 0 to 3
        if array.get(openOn, k) and not na(array.get(openPx, k))
            array.push(pool, PLvl.new(array.get(openPx, k), array.get(openTx, k), na, array.get(openNames, k), 0, 0, k, 50 + k))

    // 2nd-90M-cycle levels (LON02/AM02/PM02): N most recent per window+type.
    // sort 5 -> flagged as "middle label on mitigation" further down.
    if c2On
        c2names = array.from("LON02","AM02","PM02")
        c2cnt = array.new_int(6, 0)
        ci = array.size(c2Lv) - 1
        while ci >= 0
            Lvl l = array.get(c2Lv, ci)
            slot = l.win * 2 + l.ty
            if array.get(c2cnt, slot) < c2Count and not na(l.price)
                array.push(pool, PLvl.new(l.price, l.t, l.mit, array.get(c2names, l.win) + (l.ty == 0 ? " H" : " L"), l.ty, 1, -1, 5))
                array.set(c2cnt, slot, array.get(c2cnt, slot) + 1)
            ci := ci - 1

    n = array.size(pool)
    if n > 0
        used = array.new_bool(n, false)
        for a = 0 to n - 1
            if not array.get(used, a)
                array.set(used, a, true)
                PLvl la = array.get(pool, a)
                pa = la.price
                memb = array.new_int()
                array.push(memb, a)
                for b = 0 to n - 1
                    if b > a and not array.get(used, b)
                        PLvl lb = array.get(pool, b)
                        if math.abs(lb.price - pa) <= tol
                            array.set(used, b, true)
                            array.push(memb, b)
                sz = array.size(memb)

                // pre-pass: highest day/week/month rank in the group (lower ones
                // are dropped) + does the group contain an opening line.
                maxDWM  = 0
                hasOpen = false
                for mi = 0 to sz - 1
                    PLvl p = array.get(pool, array.get(memb, mi))
                    if p.rank >= 2 and p.rank > maxDWM
                        maxDWM := p.rank
                    if p.rank == 0
                        hasOpen := true

                // order members by their sort key, so the merged label always
                // reads in the same order regardless of push order.
                for xi = 0 to sz - 1
                    minPos = xi
                    for yi = 0 to sz - 1
                        if yi > xi
                            PLvl py = array.get(pool, array.get(memb, yi))
                            PLvl pm = array.get(pool, array.get(memb, minPos))
                            if py.sort < pm.sort
                                minPos := yi
                    if minPos != xi
                        tmp = array.get(memb, xi)
                        array.set(memb, xi, array.get(memb, minPos))
                        array.set(memb, minPos, tmp)

                int minStart = na
                hasLiq  = false
                allLiqMit = true
                int grpMit = na
                anyHigh = false
                anyMid  = false
                openStyleIdx = -1
                txt = ""
                seen = array.new_string()
                for mi = 0 to sz - 1
                    PLvl p = array.get(pool, array.get(memb, mi))
                    keep = p.rank < 2 or p.rank == maxDWM
                    if keep
                        minStart := na(minStart) ? p.start : (p.start < minStart ? p.start : minStart)
                        anyMid := anyMid or p.sort == 5
                        if p.rank == 0
                            // First open in sort order wins the styling. Sort keys
                            // are 50+k, so the priority is fixed: 09:30 > W.O. >
                            // M.O. > C.O. Arbitrary but deterministic; change the
                            // sort keys if you want a different winner.
                            openStyleIdx := openStyleIdx == -1 ? p.style : openStyleIdx
                        else
                            hasLiq := true
                            anyHigh := anyHigh or p.ty == 0
                            if na(p.mit)
                                allLiqMit := false
                            else
                                // LAST mitigation of the group, not the first: the
                                // line represents every member at this price, so it
                                // stays alive until all of them are taken. Only
                                // differs from the first when merge tolerance > 0.
                                grpMit := na(grpMit) ? p.mit : (p.mit > grpMit ? p.mit : grpMit)
                        nm = p.name
                        // Fix 12: inside a group with an opening line the dotted
                        // "mitigated" style never appears, so flag the member.
                        if liqMarkMit and hasOpen and p.rank > 0 and not na(p.mit)
                            nm := nm + " (m)"
                        if not array.includes(seen, nm)
                            array.push(seen, nm)
                            txt := array.size(seen) == 1 ? nm : txt + " + " + nm
                if liqPrice
                    txt := txt + "  " + str.tostring(pa, format.mintick)
                isMitStop = hasLiq and allLiqMit and not hasOpen
                col = liqUnmitC
                lw  = liqUnmitW
                lst = f_style(liqUnmitS)
                tsz = f_size(liqTsz)
                if hasOpen
                    col := array.get(openCols, openStyleIdx)
                    lw  := array.get(openWids, openStyleIdx)
                    lst := array.get(openStys, openStyleIdx)
                    tsz := f_size(openTsz)
                else if isMitStop
                    col := liqMitC
                    lw  := liqMitW
                    lst := f_style(liqMitS)
                endT = isMitStop ? grpMit : x2
                array.push(gLines, line.new(minStart, pa, endT, pa, xloc=xloc.bar_time, color=col, width=lw, style=lst))
                if isMitStop
                    // 90M-cycle levels -> label in the MIDDLE; others at the mitigation point (end)
                    lblX   = anyMid ? int((minStart + endT) / 2) : endT
                    lstyle = anyHigh ? label.style_label_down : label.style_label_up
                    array.push(gLabels, label.new(lblX, pa, txt, xloc=xloc.bar_time, style=lstyle, color=color.new(col,100), textcolor=col, size=tsz, textalign=text.align_center))
                else
                    array.push(gLabels, label.new(x2, pa, txt, xloc=xloc.bar_time, style=label.style_label_left, color=color.new(col,100), textcolor=col, size=tsz, textalign=text.align_left))

if barstate.islast
    if array.size(gLines) > 0
        for i = 0 to array.size(gLines) - 1
            line.delete(array.get(gLines, i))
    if array.size(gLabels) > 0
        for i = 0 to array.size(gLabels) - 1
            label.delete(array.get(gLabels, i))
    array.clear(gLines)
    array.clear(gLabels)
    x2 = time + extendBars * timeframe.in_seconds() * 1000
    f_render(x2)