//@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) 90M BOXES — box only (their C2 levels are gone, see 2026-08-22). Red
//       (manipulation) windows always keep the red colour; the rest is hidden,
//       greyed out or drawn in the AMD rotation via "Non-red 90M windows".
//  E) ANCHOR CLUSTERS — soft red boxes around the star anchors 04:00 / 10:00 /
//       12:00 NY (-40m .. +40m), with the two anchor-adjacent 13.3m cycles
//       (C1/C2) as sub-boxes; their H/L feed the normal level pool and get the
//       unmitigated/mitigated styling of group 2 automatically.
// -----------------------------------------------------------------------------
//  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".
//  REVISION 2026-08-22 — v3, SLIM + ANCHOR CLUSTERS. Decided in consultation:
//  the chart was too busy and half the inputs served modules the other
//  indicators now cover.
//  REMOVED: 30M / 10M / 3.33M cycle boxes (incl. f_key200 and the ALL-red
//  toggles), AM1, red-focus toggles, and the C2 LEVELS (LON02/AM02/PM02).
//  Deliberate consequence of dropping C2: no more 08:30 / 13:00 levels -- the
//  anchor clusters below are the timing tool now. The 90M BOXES stay (box
//  only, original times), as do liquidity, opens, gaps and session boxes.
//  NEW: E) ANCHOR CLUSTERS -- per Leon's ladder screenshots, deliberately ONLY
//  the three anchors 04:00 / 10:00 / 12:00 NY (not 18:00, not the other star
//  anchors): three windows a day, calm chart, no overtrading.
//    · cluster box = anchor -40m .. +40m, i.e. 03:20-04:40, 09:20-10:40,
//      11:20-12:40, soft red fill + dotted border, star label (12:00 = 4-star,
//      the others 3-star).
//    · inside it the two ANCHOR-ADJACENT 13.3m cycles: C1 = the last 13.3
//      before the anchor, C2 = the first after it -- the CRT pair of the
//      anchor transition. CHOSEN RULE under Leon's standing mandate ("bij
//      twijfel mag Claude kiezen"): if his ladder file marks different 13.3s
//      as stars, edit the ancA/ancB window table -- one line, everything else
//      follows it.
//    · H/L of C1/C2 go into the normal level pool: merge, mitigation and the
//      unmitigated/mitigated styling of group 2 apply with zero extra inputs.
//    · TF: cluster boxes need a TF that divides 40m (1m..40m). The 13.3m grid
//      is 800 s; exact on 10s/20s/40s bars, on 1m the window edges quantise to
//      whole bars (up to ~1 bar smear -- same class as sessions on 1H).
//      Sub-boxes and levels are gated to <= 1m charts, silently, as always.
//  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 v3", "TMU Cycles v3", 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
// Anchor clusters (rev 2026-08-22), in SECONDS since NY midnight:
ANC1   = 14400      // 04:00
ANC2   = 36000      // 10:00
ANC3   = 43200      // 12:00
HALF40 = 2400       // half cluster width = one 40m cycle on each side
C13    = 800        // one 13.3m cycle (13m20s)

// ---------------------------------------------------------------------------
//  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     // anchor window 0-5 (see table above f_ancWin; 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.")

// ---------------------------------------------------------------------------
//  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  90M CYCLE BOXES  — box only (their C2 levels are gone, see 2026-08-22)
//     Red (manipulation) windows always keep the M colour.
// ---------------------------------------------------------------------------
gCyc = "5  90M cycle boxes"
cyc90 = input.bool(true, "90M boxes", group=gCyc)
cyc30 = input.bool(true,  "30M boxes", inline="lo", group=gCyc)
cyc10 = input.bool(true,  "10M boxes", inline="lo", group=gCyc)
loInRed = input.bool(false, "  └ 30/10 only inside RED 90M", group=gCyc, tooltip="Off = normal full AMD 30M/10M across 02:30-15:59 (the whole raster). On = only inside the red (manipulation) 90M windows, for a calmer chart.")
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)
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  ANCHOR CLUSTERS  (04:00 / 10:00 / 12:00 NY — see rev 2026-08-22)
//     Level styling reuses the unmitigated/mitigated rows of group 2.
// ---------------------------------------------------------------------------
gAnc = "6  Anchor clusters (04:00 / 10:00 / 12:00)"
ancOn      = input.bool(true, "Anchor clusters (module)", group=gAnc, tooltip="Master switch for the whole module: boxes AND levels. The three parts below can be toggled separately. Deliberately only the anchors 04:00 / 10:00 / 12:00 NY: three windows a day, no overtrading. Star label: 12:00 = 4-star, the others 3-star.")
anc40On    = input.bool(true, "40m cluster box (anchor -40m .. +40m)", group=gAnc, tooltip="The soft red box: 03:20-04:40, 09:20-10:40, 11:20-12:40 NY. Off = only the 13.3 sub-boxes and/or levels remain. Needs a TF that divides 40m (1m..40m).")
ancBoxC    = input.color(color.new(#f23645, 88), "Fill", inline="an1", group=gAnc)
ancBordC   = input.color(color.new(#f23645, 40), "Border", inline="an1", group=gAnc)
ancBordS   = input.string("Dotted", "", options=["Solid","Dashed","Dotted"], inline="an1", group=gAnc)
anc13On    = input.bool(true, "13.3 sub-boxes (C1/C2)", inline="an13", group=gAnc, tooltip="The two anchor-adjacent 13.3m cycles: C1 = the last 13.3 before the anchor, C2 = the first after it. They have their OWN fill (next to this toggle) so they stay visible as boxes when the 40m cluster box is off -- with the cluster on, the two fills stack and the 13.3s read slightly more saturated, like the star blocks in the ladder. Only on <= 1m charts; the 800 s grid is exact on 10s/20s/40s bars, on 1m the edges quantise to whole bars.")
anc13FillC = input.color(color.new(#f23645, 82), "fill", inline="an13", group=gAnc)
ancLvlOn   = input.bool(true, "13.3 H/L levels", inline="an2", group=gAnc)
ancLineC = input.color(color.new(#f23645, 0), "13.3 line style", inline="anL", group=gAnc)
ancLineW = input.int(1, "", minval=1, maxval=5, inline="anL", group=gAnc)
ancLineS = input.string("Solid", "", options=["Solid","Dashed","Dotted"], inline="anL", group=gAnc)
ancCount   = input.int(1, " history per level", minval=1, maxval=5, inline="an2", group=gAnc, tooltip="How many of the most recent C1/C2 highs/lows to keep per window. They join the normal level pool: merge, mitigation and the unmitigated/mitigated colours/widths of group 2 apply automatically. Only accumulated on <= 1m charts.")

// ---------------------------------------------------------------------------
//  7  SESSION BOXES
// ---------------------------------------------------------------------------
gSbox = "7  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)

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>()

// Anchor-cluster 13.3m windows, w = cluster*2 + [C1=0 | C2=1] (see the
// window table above f_ancWin). Six separate Acc objects on purpose --
// array.new<Acc>(6, Acc.new()) would be six references to ONE object.
var array<Acc> ancAcc = array.from(Acc.new(), Acc.new(), Acc.new(), Acc.new(), Acc.new(), Acc.new())
var array<Lvl> ancLv  = 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 anchor (12 slots x max 5) = 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

// 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 boxes, sessions boxes,
//                                           09:30 and C.O.
//    ali40  = boundaries on the 40m grid -> anchor cluster boxes
//    ancSubOK = TF <= 1 min              -> 13.3m sub-boxes + their levels
//               (the 800 s grid is exact on 10s/20s/40s; on 1m the window
//                edges quantise to whole bars, up to ~1 bar smear)
//  Not aligned -> that element is simply not drawn. Silently, on purpose.
//  Practical: 45m/1H and up -> no boxes at all, levels/opens/gaps only.
// ---------------------------------------------------------------------------
tfSec  = timeframe.in_seconds()
ali30  = timeframe.isintraday and 1800 % tfSec == 0
ali40    = timeframe.isintraday and 2400 % tfSec == 0
ali10    = timeframe.isintraday and 600  % tfSec == 0
ancSubOK = timeframe.isintraday and tfSec <= 60

// ---------------------------------------------------------------------------
//  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.
// ---------------------------------------------------------------------------
in90win  = mnts >= M_LON_A and mnts <= M_PM_B
cyc90k   = in90win ? math.floor((mnts - M_LON_A) / 90) + 2 : 0
isRed90  = cyc90k != 0 and (cyc90k - 2) % 3 == 1
newCycle = not barstate.isfirst and ali30 and cyc90k != 0 and cyc90k != cyc90k[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 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])

// ---------------------------------------------------------------------------
//  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

// ---------------------------------------------------------------------------
//  ANCHOR 13.3m WINDOWS: accumulate -> seal -> mitigation  (rev 2026-08-22)
//  Six windows, w = cluster*2 + [C1=0 | C2=1]:
//    w0 04:00 C1  03:46:40-04:00      w1 04:00 C2  04:00-04:13:20
//    w2 10:00 C1  09:46:40-10:00      w3 10:00 C2  10:00-10:13:20
//    w4 12:00 C1  11:46:40-12:00      w5 12:00 C2  12:00-12:13:20
//  C1 = the last 13.3m cycle before the anchor, C2 = the first after it:
//  the CRT pair of the anchor transition. Chosen rule under the standing
//  mandate; if the ladder file marks other 13.3s, edit ancA/ancB below --
//  one table, everything else follows it.
// ---------------------------------------------------------------------------
var array<int> ancA = array.from(ANC1 - C13, ANC1, ANC2 - C13, ANC2, ANC3 - C13, ANC3)
var array<int> ancB = array.from(ANC1, ANC1 + C13, ANC2, ANC2 + C13, ANC3, ANC3 + C13)

f_ancIdx(int sNow) =>
    int r = -1
    for w = 0 to 5
        if sNow >= array.get(ancA, w) and sNow < array.get(ancB, w)
            r := w
    r

f_clusterIdx(int sNow) =>
    sNow >= ANC1 - HALF40 and sNow < ANC1 + HALF40 ? 1 : sNow >= ANC2 - HALF40 and sNow < ANC2 + HALF40 ? 2 : sNow >= ANC3 - HALF40 and sNow < ANC3 + HALF40 ? 3 : 0

// No var/varip and no [] history inside, so the call from a for-loop is safe.
f_ancWin(int w, bool inW, bool inWprev) =>
    Acc a = array.get(ancAcc, 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(ancLv, Lvl.new(a.h, a.ht, na, 0, w))
        array.push(ancLv, Lvl.new(a.l, a.lt, na, 1, w))
        while array.size(ancLv) > 120
            array.shift(ancLv)
        a.h := na, a.l := na
    int(na)     // CE10235 guard

// Accumulation runs whenever the TF allows it (ancSubOK), independent of the
// display toggles, so switching a toggle later does not lose history.
ancIdx     = ancSubOK ? f_ancIdx(secs) : -1
prevAncIdx = nz(ancIdx[1], -1)
for w = 0 to 5
    f_ancWin(w, ancIdx == w, prevAncIdx == w)

if array.size(ancLv) > 0
    for i = 0 to array.size(ancLv) - 1
        Lvl l = array.get(ancLv, 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 bg, color bcol, string bsty, bool doLabel, string lblTxt, bool doEQ, bool centerLbl) =>
    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, centerLbl ? (box.get_top(curB) + box.get_bottom(curB)) / 2 : 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 = bg, border_color = bcol, border_width = 1, border_style = bsty)
        if doLabel
            curL := label.new(time, centerLbl ? (high + low) / 2 : high, lblTxt, xloc.bar_time, yloc.price, color.new(color.white, 100), centerLbl ? label.style_none : label.style_label_down, sbLblC, size = f_size(sbLblSz))
        prevK := key
        inC   := true

// 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
if mode90 == "Hide" and not isRedKey
    key90 := 0
col90 = key90 == 0 ? color.gray : isRedKey ? amdRed : mode90 == "AMD colours" ? amd_col(key90 - 2) : c90OtherC
f_cycleBox(key90 != 0, key90, color.new(col90, cycTrans), cycBordC, f_style(cycBordStr), false, "", cycEQon and (isRedKey or not cycEQred), false)

// 30M / 10M cycle boxes (normal AMD rotation) -- re-added on request; the 90M
// boxes and anchor clusters stay exactly as they were. loInRed limits them to
// the red 90M windows for a calmer chart (default off = full raster).
key30 = 0
if cyc30 and ali30 and in90win and (not loInRed or isRed90)
    key30 := int(math.floor((mnts - M_LON_A) / 30)) + 1
f_cycleBox(key30 != 0, key30, color.new(key30 != 0 ? amd_col(key30 - 1) : color.gray, cycTrans), cycBordC, f_style(cycBordStr), false, "", false, false)

key10 = 0
if cyc10 and ali10 and in90win and (not loInRed or isRed90)
    key10 := int(math.floor((mnts - M_LON_A) / 10)) + 1
f_cycleBox(key10 != 0, key10, color.new(key10 != 0 ? amd_col(key10 - 1) : color.gray, cycTrans), cycBordC, f_style(cycBordStr), false, "", false, false)

// ANCHOR CLUSTERS (rev 2026-08-22). Cluster box: anchor -40m .. +40m, soft
// red, star label. Sub-boxes: the C1/C2 13.3m windows, border only. The
// sub-box key is ancIdx+1 so the C1->C2 transition closes C1 with the normal
// one-candle gap, exactly like every other cycle box.
cIdx = (ancOn and anc40On and ali40) ? f_clusterIdx(secs) : 0
cLbl = cIdx == 1 ? "04:00 ★3" : cIdx == 2 ? "10:00 ★3" : "12:00 ★4"
f_cycleBox(cIdx != 0, cIdx, ancBoxC, ancBordC, f_style(ancBordS), true, cLbl, false, false)
f_cycleBox(ancOn and anc13On and ancIdx >= 0, ancIdx + 1, anc13FillC, ancBordC, f_style(ancBordS), true, "⭐", false, true)

// 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, color.new(sbAsiaC, cycTrans), cycBordC, f_style(cycBordStr), true, "Asia",   false, false)
f_cycleBox(sbLon  and ali30 and mnts >= M_LON_A and mnts <= M_LON_B,    1, color.new(sbLonC, cycTrans),  cycBordC, f_style(cycBordStr), true, "London", cycEQon, false)
f_cycleBox(sbNYAM and ali30 and mnts >= M_AM_A  and mnts <= M_AM_B,     1, color.new(sbNYAMC, cycTrans), cycBordC, f_style(cycBordStr), true, "NY AM",  cycEQon, false)
f_cycleBox(sbNYPM and ali30 and mnts >= M_PM_A  and mnts <= M_PM_B,     1, color.new(sbNYPMC, cycTrans), cycBordC, f_style(cycBordStr), true, "NY PM",  cycEQon, false)

// ---------------------------------------------------------------------------
//  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))

    // Anchor 13.3m levels (C1/C2 per anchor): N most recent per window+type.
    // sort 5 -> flagged as "middle label on mitigation" further down.
    if ancOn and ancLvlOn
        ancCnt = array.new_int(12, 0)
        ci = array.size(ancLv) - 1
        while ci >= 0
            Lvl l = array.get(ancLv, ci)
            slot = l.win * 2 + l.ty
            if array.get(ancCnt, slot) < ancCount and not na(l.price)
                array.push(pool, PLvl.new(l.price, l.t, l.mit, "", l.ty, 1, -1, 5))
                array.set(ancCnt, slot, array.get(ancCnt, 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 nm != "" and 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 anyMid
                    col := ancLineC
                    lw  := ancLineW
                    lst := f_style(ancLineS)
                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
                    // anchor levels (sort 5) -> 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
                    if txt != ""
                        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
                    if txt != ""
                        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)