Vesper

//@version=6
// Vesper — Liquidity-Time Session Indicator
// Marks the day's session structure (Asia / London / NY), overlap zones,
// and session boundaries. Descriptive only: no predictions, no repainting.
// A single file, no imports, no external dependencies.
indicator("Vesper", "Vesper", overlay=true, precision=5)

// ─── Session Inputs ───
// Format: "HHMM-HHMM[:TZ]" (e.g. "0000-0700" or "0700-1600:GMT+1").
// Defaults are FX-first, expressed in the chart's exchange timezone.
asiaSession   = input.session("0000-0700", "Asia Session", group="Session Windows",
     tooltip="Asia session window. Format HHMM-HHMM[:TZ]. Default: 00:00-07:00 UTC.")
londonSession = input.session("0700-1300", "London Session", group="Session Windows",
     tooltip="London session window. Format HHMM-HHMM[:TZ]. Default: 07:00-13:00 UTC.")
nySession     = input.session("1300-2200", "NY Session", group="Session Windows",
     tooltip="New York session window. Format HHMM-HHMM[:TZ]. Default: 13:00-22:00 UTC.")

// ─── Session Colors (Kanagawa palette) ───
colorAsiaInput    = input.color(#6A9589, "Asia Color",    group="Session Colors",
     tooltip="WaveAqua — Kanagawa. Base color for the Asia session.")
colorLondonInput  = input.color(#E6C384, "London Color",  group="Session Colors",
     tooltip="CarpYellow — Kanagawa. Base color for the London session.")
colorNYInput      = input.color(#D27E99, "NY Color",      group="Session Colors",
     tooltip="SakuraPink — Kanagawa. Base color for the NY session.")
fillTranspAsia    = input.int(92, "Asia Fill Transparency", minval=0, maxval=100, group="Session Colors",
     tooltip="Fill opacity, 0 = opaque, 100 = invisible. Default ≈8% alpha.")
fillTranspLondon  = input.int(92, "London Fill Transparency", minval=0, maxval=100, group="Session Colors",
     tooltip="Fill opacity, 0 = opaque, 100 = invisible. Default ≈8% alpha.")
fillTranspNY      = input.int(92, "NY Fill Transparency", minval=0, maxval=100, group="Session Colors",
     tooltip="Fill opacity, 0 = opaque, 100 = invisible. Default ≈8% alpha.")
colorOverlapInput = input.color(#FFA066, "Overlap Color", group="Session Colors",
     tooltip="SurimiOrange — Kanagawa. Accent color for the overlap zones between sessions.")
fillTranspOverlap = input.int(78, "Overlap Fill Transparency", minval=0, maxval=100, group="Session Colors",
     tooltip="Fill opacity, 0 = opaque, 100 = invisible. Default ≈22% alpha so liquidity windows pop.")

asiaFill    = color.new(colorAsiaInput, fillTranspAsia)
londonFill  = color.new(colorLondonInput, fillTranspLondon)
nyFill      = color.new(colorNYInput, fillTranspNY)
overlapFill = color.new(colorOverlapInput, fillTranspOverlap)

// Kanagawa palette constants, shared by labels, table and box borders.
sumiInk   = #16161D
fujiWhite = #DCD7BA

// ─── Session Detection ───
// A bar belongs to a session when time(timeframe.period, session) is not na.
// Multiple sessions can be true on the same bar (overlap periods).
inAsia   = not na(time(timeframe.period, asiaSession))
inLondon = not na(time(timeframe.period, londonSession))
inNY     = not na(time(timeframe.period, nySession))

// ─── Timeframe Guard ───
// time(timeframe.period, session) returns na on daily and higher timeframes,
// so no session windows resolve there. The script degrades gracefully: no
// shading, no boxes, no H/L lines, no alerts — and the info table says so.
isDailyOrHigher = timeframe.in_seconds() >= 86400

// ─── Overlap Detection ───
// Pairwise session intersections — the high-liquidity windows where two
// major markets trade simultaneously. These render first, with the overlap
// accent, so they dominate the plain single-session fills.
inOverlapAsiaLondon = inAsia and inLondon
inOverlapLondonNY   = inLondon and inNY

// ─── Background Shading ───
// Single-session fill via bgcolor. Precedence: overlap → Asia → London → NY.
showShading  = input.bool(true, "Show Session Shading", group="Shading",
     tooltip="Master toggle for all session background fills.")
showOverlapFill = input.bool(true, "Show Overlap", group="Shading",
     tooltip="Highlight the overlap zones with the overlap accent color.")
showAsiaFill = input.bool(true, "Show Asia",   group="Shading",
     tooltip="Fill the Asia session window.")
showLondonFill = input.bool(true, "Show London", group="Shading",
     tooltip="Fill the London session window.")
showNYFill   = input.bool(true, "Show NY",     group="Shading",
     tooltip="Fill the NY session window.")

// ─── Render Mode Inputs ───
renderMode       = input.string("bgcolor", "Render Mode", options=["bgcolor", "boxes"], group="Rendering",
     tooltip="bgcolor shades bars in place; boxes draw full-height session rectangles.")
showSessionBoxes = input.bool(false, "Show Session Boxes", group="Rendering",
     tooltip="Draw one translucent box per session spanning its full window.")
boxTransp        = input.int(90, "Box Transparency", minval=0, maxval=100, group="Rendering",
     tooltip="Box fill opacity, 0 = opaque, 100 = invisible. Default ≈10% alpha.")

color barFillColor = na
if showShading and renderMode == "bgcolor"
    if showOverlapFill and (inOverlapAsiaLondon or inOverlapLondonNY)
        barFillColor := overlapFill
    else if inAsia and showAsiaFill
        barFillColor := asiaFill
    else if inLondon and showLondonFill
        barFillColor := londonFill
    else if inNY and showNYFill
        barFillColor := nyFill
bgcolor(barFillColor, title="Session Background")

// ─── Session High/Low Inputs ───
showSessionHL = input.bool(true, "Show Session High/Low", group="Session H/L",
     tooltip="Master toggle for the per-session high/low lines.")
showAsiaHL    = input.bool(true, "Show Asia H/L",   group="Session H/L",
     tooltip="Draw the Asia session high/low.")
showLondonHL  = input.bool(true, "Show London H/L", group="Session H/L",
     tooltip="Draw the London session high/low.")
showNYHL      = input.bool(true, "Show NY H/L",     group="Session H/L",
     tooltip="Draw the NY session high/low.")
hlWidth       = input.int(1, "H/L Line Width", minval=1, maxval=2, group="Session H/L",
     tooltip="Dashed line width for the session high/low levels.")

// ─── Alert Inputs ───
alertOpen  = input.bool(false, "Alert on Session Open", group="Alerts",
     tooltip="Fire an alert when a session opens. Create a TradingView alert with condition 'Any alert() function call'.")
alertClose = input.bool(false, "Alert on Session Close", group="Alerts",
     tooltip="Fire an alert when a session closes. Create a TradingView alert with condition 'Any alert() function call'.")

// ─── Session High/Low ───
// Open edges: the first bar of each session window. Na-protected so a chart
// starting mid-session still initializes its levels on the first bar.
asiaOpen   = na(time[1]) ? inAsia : (inAsia and not inAsia[1])
londonOpen = na(time[1]) ? inLondon : (inLondon and not inLondon[1])
nyOpen     = na(time[1]) ? inNY : (inNY and not inNY[1])

// ─── Session Boundaries (Alerts) ───
// Dedicated transition edges for alerting. Unlike the lifecycle edges above,
// they require a real previous bar (not na) so a chart that starts mid-session
// never fires a false "open"; "close" fires on the first bar outside the
// window and reports the previous (last session) bar.
asiaOpenEdge   = not na(time[1]) and inAsia and not inAsia[1]
londonOpenEdge = not na(time[1]) and inLondon and not inLondon[1]
nyOpenEdge     = not na(time[1]) and inNY and not inNY[1]
asiaCloseEdge   = not na(time[1]) and inAsia[1] and not inAsia
londonCloseEdge = not na(time[1]) and inLondon[1] and not inLondon
nyCloseEdge     = not na(time[1]) and inNY[1] and not inNY

// ─── Alerts ───
// Payload format: Vesper|<SESSION>|<EVENT>|price=<price>|ts=<ISO-UTC>.
// The timestamp is always UTC so webhook receivers are unambiguous.
// Single-fire guards: each event fires on the bar of its edge, at most once.
// Distinct events on the same bar (e.g. Asia close + London open at 07:00)
// still each fire their own alert.
payload(sessionName, event, price, ts) =>
    "Vesper|" + sessionName + "|" + event + "|price=" + str.tostring(price, format.mintick) + "|ts=" + str.format_time(ts, "yyyy-MM-dd'T'HH:mm:ss'Z'", "UTC")

var int asiaOpenFiredBar    = -1
var int londonOpenFiredBar  = -1
var int nyOpenFiredBar      = -1
var int asiaCloseFiredBar   = -1
var int londonCloseFiredBar = -1
var int nyCloseFiredBar     = -1

if alertOpen
    if asiaOpenEdge and bar_index != asiaOpenFiredBar
        asiaOpenFiredBar := bar_index
        alert(payload("ASIA", "OPEN", close, time), alert.freq_once_per_bar_close)
    if londonOpenEdge and bar_index != londonOpenFiredBar
        londonOpenFiredBar := bar_index
        alert(payload("LONDON", "OPEN", close, time), alert.freq_once_per_bar_close)
    if nyOpenEdge and bar_index != nyOpenFiredBar
        nyOpenFiredBar := bar_index
        alert(payload("NY", "OPEN", close, time), alert.freq_once_per_bar_close)
if alertClose
    if asiaCloseEdge and bar_index != asiaCloseFiredBar
        asiaCloseFiredBar := bar_index
        alert(payload("ASIA", "CLOSE", close[1], time[1]), alert.freq_once_per_bar_close)
    if londonCloseEdge and bar_index != londonCloseFiredBar
        londonCloseFiredBar := bar_index
        alert(payload("LONDON", "CLOSE", close[1], time[1]), alert.freq_once_per_bar_close)
    if nyCloseEdge and bar_index != nyCloseFiredBar
        nyCloseFiredBar := bar_index
        alert(payload("NY", "CLOSE", close[1], time[1]), alert.freq_once_per_bar_close)

// ─── Box Mode ───
// Full-height translucent rectangles, one per session per day. A box is
// created on its session's open bar, its right edge tracks the active bar,
// and it is deleted when the next session opens (see the lifecycle section).
var box asiaBox   = na
var box londonBox = na
var box nyBox     = na

// Per-session box fills at the box transparency, shared by border and fill.
asiaBoxColor   = color.new(colorAsiaInput, boxTransp)
londonBoxColor = color.new(colorLondonInput, boxTransp)
nyBoxColor     = color.new(colorNYInput, boxTransp)

// Session name labels, anchored to the box's opening bar.
var label asiaBoxLabel   = na
var label londonBoxLabel = na
var label nyBoxLabel     = na

if renderMode == "boxes" and showSessionBoxes
    if asiaOpen
        asiaBox := box.new(bar_index, 1e9, bar_index, -1e9, border_color=asiaBoxColor, bgcolor=asiaBoxColor)
        asiaBoxLabel := label.new(bar_index, high, "Asia", style=label.style_label_down, color=color.new(sumiInk, 40), textcolor=colorAsiaInput, size=size.small)
    if londonOpen
        londonBox := box.new(bar_index, 1e9, bar_index, -1e9, border_color=londonBoxColor, bgcolor=londonBoxColor)
        londonBoxLabel := label.new(bar_index, high, "London", style=label.style_label_down, color=color.new(sumiInk, 40), textcolor=colorLondonInput, size=size.small)
    if nyOpen
        nyBox := box.new(bar_index, 1e9, bar_index, -1e9, border_color=nyBoxColor, bgcolor=nyBoxColor)
        nyBoxLabel := label.new(bar_index, high, "NY", style=label.style_label_down, color=color.new(sumiInk, 40), textcolor=colorNYInput, size=size.small)
    if inAsia and not na(asiaBox)
        box.set_right(asiaBox, bar_index)
    if inLondon and not na(londonBox)
        box.set_right(londonBox, bar_index)
    if inNY and not na(nyBox)
        box.set_right(nyBox, bar_index)
else
    if not na(asiaBox)
        box.delete(asiaBox)
        asiaBox := na
    if not na(londonBox)
        box.delete(londonBox)
        londonBox := na
    if not na(nyBox)
        box.delete(nyBox)
        nyBox := na
    if not na(asiaBoxLabel)
        label.delete(asiaBoxLabel)
        asiaBoxLabel := na
    if not na(londonBoxLabel)
        label.delete(londonBoxLabel)
        londonBoxLabel := na
    if not na(nyBoxLabel)
        label.delete(nyBoxLabel)
        nyBoxLabel := na

// Running session highs, tracked from each session's first bar.
var float asiaHigh = na
var float londonHigh = na
var float nyHigh = na

// Running session lows, tracked from each session's first bar.
var float asiaLow = na
var float londonLow = na
var float nyLow = na

// All state mutations confined to active-session bars.
if inAsia
    if asiaOpen
        asiaHigh := na
        asiaLow := na
    asiaHigh := na(asiaHigh) ? high : math.max(asiaHigh, high)
    asiaLow := na(asiaLow) ? low : math.min(asiaLow, low)
if inLondon
    if londonOpen
        londonHigh := na
        londonLow := na
    londonHigh := na(londonHigh) ? high : math.max(londonHigh, high)
    londonLow := na(londonLow) ? low : math.min(londonLow, low)
if inNY
    if nyOpen
        nyHigh := na
        nyLow := na
    nyHigh := na(nyHigh) ? high : math.max(nyHigh, high)
    nyLow := na(nyLow) ? low : math.min(nyLow, low)

// Dashed H/L line references, one per session.
var line asiaHighLine = na
var line asiaLowLine = na
var line londonHighLine = na
var line londonLowLine = na
var line nyHighLine = na
var line nyLowLine = na

// H/L price labels, small and unobtrusive.
var label asiaHighLabel = na
var label asiaLowLabel = na
var label londonHighLabel = na
var label londonLowLabel = na
var label nyHighLabel = na
var label nyLowLabel = na

if showSessionHL and showAsiaHL and asiaOpen
    asiaHighLine := line.new(x1=bar_index, y1=asiaHigh, x2=bar_index, y2=asiaHigh, color=colorAsiaInput, style=line.style_dashed, width=hlWidth)
    asiaLowLine := line.new(x1=bar_index, y1=asiaLow, x2=bar_index, y2=asiaLow, color=colorAsiaInput, style=line.style_dashed, width=hlWidth)
    asiaHighLabel := label.new(bar_index, asiaHigh, "Asia H " + str.tostring(asiaHigh, format.mintick), style=label.style_label_left, color=color.new(sumiInk, 40), textcolor=colorAsiaInput, size=size.small)
    asiaLowLabel := label.new(bar_index, asiaLow, "Asia L " + str.tostring(asiaLow, format.mintick), style=label.style_label_left, color=color.new(sumiInk, 40), textcolor=colorAsiaInput, size=size.small)
if showSessionHL and showAsiaHL and inAsia
    if not na(asiaHighLine)
        line.set_y1(asiaHighLine, asiaHigh)
        line.set_xy2(asiaHighLine, bar_index, asiaHigh)
    if not na(asiaLowLine)
        line.set_y1(asiaLowLine, asiaLow)
        line.set_xy2(asiaLowLine, bar_index, asiaLow)
    if not na(asiaHighLabel)
        label.set_xy(asiaHighLabel, bar_index, asiaHigh)
        label.set_text(asiaHighLabel, "Asia H " + str.tostring(asiaHigh, format.mintick))
    if not na(asiaLowLabel)
        label.set_xy(asiaLowLabel, bar_index, asiaLow)
        label.set_text(asiaLowLabel, "Asia L " + str.tostring(asiaLow, format.mintick))
if showSessionHL and showLondonHL and londonOpen
    londonHighLine := line.new(x1=bar_index, y1=londonHigh, x2=bar_index, y2=londonHigh, color=colorLondonInput, style=line.style_dashed, width=hlWidth)
    londonLowLine := line.new(x1=bar_index, y1=londonLow, x2=bar_index, y2=londonLow, color=colorLondonInput, style=line.style_dashed, width=hlWidth)
    londonHighLabel := label.new(bar_index, londonHigh, "London H " + str.tostring(londonHigh, format.mintick), style=label.style_label_left, color=color.new(sumiInk, 40), textcolor=colorLondonInput, size=size.small)
    londonLowLabel := label.new(bar_index, londonLow, "London L " + str.tostring(londonLow, format.mintick), style=label.style_label_left, color=color.new(sumiInk, 40), textcolor=colorLondonInput, size=size.small)
if showSessionHL and showLondonHL and inLondon
    if not na(londonHighLine)
        line.set_y1(londonHighLine, londonHigh)
        line.set_xy2(londonHighLine, bar_index, londonHigh)
    if not na(londonLowLine)
        line.set_y1(londonLowLine, londonLow)
        line.set_xy2(londonLowLine, bar_index, londonLow)
    if not na(londonHighLabel)
        label.set_xy(londonHighLabel, bar_index, londonHigh)
        label.set_text(londonHighLabel, "London H " + str.tostring(londonHigh, format.mintick))
    if not na(londonLowLabel)
        label.set_xy(londonLowLabel, bar_index, londonLow)
        label.set_text(londonLowLabel, "London L " + str.tostring(londonLow, format.mintick))
if showSessionHL and showNYHL and nyOpen
    nyHighLine := line.new(x1=bar_index, y1=nyHigh, x2=bar_index, y2=nyHigh, color=colorNYInput, style=line.style_dashed, width=hlWidth)
    nyLowLine := line.new(x1=bar_index, y1=nyLow, x2=bar_index, y2=nyLow, color=colorNYInput, style=line.style_dashed, width=hlWidth)
    nyHighLabel := label.new(bar_index, nyHigh, "NY H " + str.tostring(nyHigh, format.mintick), style=label.style_label_left, color=color.new(sumiInk, 40), textcolor=colorNYInput, size=size.small)
    nyLowLabel := label.new(bar_index, nyLow, "NY L " + str.tostring(nyLow, format.mintick), style=label.style_label_left, color=color.new(sumiInk, 40), textcolor=colorNYInput, size=size.small)
if showSessionHL and showNYHL and inNY
    if not na(nyHighLine)
        line.set_y1(nyHighLine, nyHigh)
        line.set_xy2(nyHighLine, bar_index, nyHigh)
    if not na(nyLowLine)
        line.set_y1(nyLowLine, nyLow)
        line.set_xy2(nyLowLine, bar_index, nyLow)
    if not na(nyHighLabel)
        label.set_xy(nyHighLabel, bar_index, nyHigh)
        label.set_text(nyHighLabel, "NY H " + str.tostring(nyHigh, format.mintick))
    if not na(nyLowLabel)
        label.set_xy(nyLowLabel, bar_index, nyLow)
        label.set_text(nyLowLabel, "NY L " + str.tostring(nyLow, format.mintick))

// ─── Info Table Inputs ───
showTable = input.bool(true, "Show Info Table", group="Info Table",
     tooltip="Toggle the dark info panel (active session + session H/L).")

// ─── Info Table ───
// Dark Kanagawa panel in the top-right corner. Shows the active session(s) —
// joined when two trade simultaneously — and each session's current H/L.
string activeLabel = na
if isDailyOrHigher
    activeLabel := "Daily+ — no sessions"
else if inAsia and inLondon and inNY
    activeLabel := "Asia · London · NY"
else if inAsia and inLondon
    activeLabel := "Asia · London"
else if inAsia and inNY
    activeLabel := "Asia · NY"
else if inLondon and inNY
    activeLabel := "London · NY"
else if inAsia
    activeLabel := "Asia"
else if inLondon
    activeLabel := "London"
else if inNY
    activeLabel := "NY"
else
    activeLabel := "No session"

asiaHLCell   = na(asiaHigh) ? "—" : str.tostring(asiaHigh, format.mintick) + " / " + str.tostring(asiaLow, format.mintick)
londonHLCell = na(londonHigh) ? "—" : str.tostring(londonHigh, format.mintick) + " / " + str.tostring(londonLow, format.mintick)
nyHLCell     = na(nyHigh) ? "—" : str.tostring(nyHigh, format.mintick) + " / " + str.tostring(nyLow, format.mintick)

var table infoTable = table.new(position.top_right, 2, 4, bgcolor=color.new(sumiInk, 30), border_width=1, border_color=color.new(sumiInk, 100))

if showTable
    table.cell(infoTable, 0, 0, "Vesper", text_color=fujiWhite, text_size=size.small)
    table.cell(infoTable, 1, 0, activeLabel, text_color=fujiWhite, text_size=size.small)
    table.cell(infoTable, 0, 1, "Asia", text_color=colorAsiaInput, text_size=size.small)
    table.cell(infoTable, 1, 1, asiaHLCell, text_color=fujiWhite, text_size=size.small)
    table.cell(infoTable, 0, 2, "London", text_color=colorLondonInput, text_size=size.small)
    table.cell(infoTable, 1, 2, londonHLCell, text_color=fujiWhite, text_size=size.small)
    table.cell(infoTable, 0, 3, "NY", text_color=colorNYInput, text_size=size.small)
    table.cell(infoTable, 1, 3, nyHLCell, text_color=fujiWhite, text_size=size.small)

// Auto-clear: when a session opens, the previous session's lines are deleted
// so stale levels never accumulate. Order: Asia → London → NY → Asia.
if londonOpen
    if not na(asiaHighLine)
        line.delete(asiaHighLine)
        asiaHighLine := na
    if not na(asiaLowLine)
        line.delete(asiaLowLine)
        asiaLowLine := na
    if not na(asiaHighLabel)
        label.delete(asiaHighLabel)
        asiaHighLabel := na
    if not na(asiaLowLabel)
        label.delete(asiaLowLabel)
        asiaLowLabel := na
    if not na(asiaBox)
        box.delete(asiaBox)
        asiaBox := na
    if not na(asiaBoxLabel)
        label.delete(asiaBoxLabel)
        asiaBoxLabel := na
if nyOpen
    if not na(londonHighLine)
        line.delete(londonHighLine)
        londonHighLine := na
    if not na(londonLowLine)
        line.delete(londonLowLine)
        londonLowLine := na
    if not na(londonHighLabel)
        label.delete(londonHighLabel)
        londonHighLabel := na
    if not na(londonLowLabel)
        label.delete(londonLowLabel)
        londonLowLabel := na
    if not na(londonBox)
        box.delete(londonBox)
        londonBox := na
    if not na(londonBoxLabel)
        label.delete(londonBoxLabel)
        londonBoxLabel := na
if asiaOpen
    if not na(nyHighLine)
        line.delete(nyHighLine)
        nyHighLine := na
    if not na(nyLowLine)
        line.delete(nyLowLine)
        nyLowLine := na
    if not na(nyHighLabel)
        label.delete(nyHighLabel)
        nyHighLabel := na
    if not na(nyLowLabel)
        label.delete(nyLowLabel)
        nyLowLabel := na
    if not na(nyBox)
        box.delete(nyBox)
        nyBox := na
    if not na(nyBoxLabel)
        label.delete(nyBoxLabel)
        nyBoxLabel := na