Foreign-Domain Panes

//@version=3
// plotMatrix happy path, smallest viable call: data + rowLabels + colLabels
// only. format defaults to "number"; summary/highlight/gridHeight omitted.
// One cell reads the live close so the source stays wired.
define("PM Happy Minimal", "offchart", true)

timeseries d = source("ohlcv", currentSymbol, currentExchange)

if (isLastBar) {
  plotMatrix(
    data = [[0, 0, 0.5], [0, 1, -0.25], [1, 2, d.close]],
    rowLabels = ["A", "B"],
    colLabels = ["X", "Y", "Z"]
  )
}

//@version=3
// plotMatrix with every kwarg: percent format, one summary row whose values
// include na (renders blank / null on the wire), highlight row+col,
// gridHeight, hideLegendValues=false.
define("PM Full Kwargs", "offchart", true)

timeseries d = source("ohlcv", currentSymbol, currentExchange)

if (isLastBar) {
  plotMatrix(
    data = [[0, 0, 0.047], [0, 1, -0.012], [1, 0, 0.003], [1, 2, 0.101]],
    rowLabels = ["2023", "2024"],
    colLabels = ["Jan", "Feb", "Mar"],
    format = "percent",
    summary = [
      { label: "AVG", values: [0.025, -0.012, na] }
    ],
    highlight = { row: 1, col: 2 },
    gridHeight = 0.3,
    hideLegendValues = false
  )
}

//@version=3
// A data row whose value is na is DROPPED before any index validation:
// [1, 1, na] emits no cell, and even the wildly out-of-range [9, 9, na]
// does not error (the value short-circuit runs before the rowIdx/colIdx
// range checks). Only the two real cells reach the wire. gridHeight at the
// 0.05 minimum.
define("PM NA Drops Cell", "offchart", true)

timeseries d = source("ohlcv", currentSymbol, currentExchange)

if (isLastBar) {
  plotMatrix(
    data = [[0, 0, 1.5], [1, 1, na], [9, 9, na], [1, 0, 2.5]],
    rowLabels = ["A", "B"],
    colLabels = ["X", "Y"],
    gridHeight = 0.05
  )
}

//@version=3
// Weekday x calendar-month seasonality: each cell is the average single-bar
// close-over-close return for that (weekday, month) bucket across the loaded
// history. Buckets with no observations stay blank; the summary row is the
// per-month average across all weekdays. Highlight tracks the latest bar.
define("Seasonality Grid", "offchart", true)

timeseries d = source("ohlcv", currentSymbol, currentExchange)

static sums = []
static counts = []
static prevBox = []
static lastCell = []

if (sums.length == 0) {
  for (var i = 0; i < 84; i = i + 1) {
    sums.push(0)
    counts.push(0)
  }
  lastCell.push(0)
  lastCell.push(0)
}

var dayNames = ["monday", "tuesday", "wednesday", "thursday", "friday", "saturday", "sunday"]
var row = dayNames.indexOf(dayOfWeek())
var col = month() - 1
if (isnum(d.close) && row >= 0) {
  // The highlight tracks the latest NUMERIC bar even when its return is
  // skipped (first bar after a gap has no valid baseline).
  lastCell[0] = row
  lastCell[1] = col
  if (d.close > 0 && prevBox.length > 0 && isnum(prevBox[0]) && prevBox[0] > 0) {
    var idx = row * 12 + col
    sums[idx] = sums[idx] + (d.close / prevBox[0] - 1)
    counts[idx] = counts[idx] + 1
  }
}
if (prevBox.length == 0) {
  prevBox.push(d.close)
} else {
  prevBox[0] = d.close
}

if (isLastBar) {
  var cells = []
  for (var r = 0; r < 7; r = r + 1) {
    for (var c = 0; c < 12; c = c + 1) {
      var k = r * 12 + c
      if (counts[k] > 0) {
        cells.push([r, c, sums[k] / counts[k]])
      }
    }
  }
  var avgRow = []
  for (var c = 0; c < 12; c = c + 1) {
    var s = 0
    var n = 0
    for (var r = 0; r < 7; r = r + 1) {
      var k = r * 12 + c
      s = s + sums[k]
      n = n + counts[k]
    }
    if (n > 0) {
      avgRow.push(s / n)
    } else {
      avgRow.push(na)
    }
  }
  if (cells.length > 0) {
    plotMatrix(
      data = cells,
      rowLabels = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"],
      colLabels = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"],
      format = "percent",
      summary = [
        { label: "AVG", values: avgRow }
      ],
      highlight = { row: lastCell[0], col: lastCell[1] },
      gridHeight = 0.3
    )
  }
}

//@version=3
// ============================================================================
//  MONTHLY RETURNS
//  Month × year percentage returns rendered as a foreign-domain MATRIX pane
//  (rows = years, columns = months) with AVG / MED / WIN% summary rows per
//  month and the latest data month highlighted.
//
//  Computed from ONE source of truth: native daily history pinned to the
//  newest rows (requestBars + anchor "latest"), which the host keeps live
//  with a dedicated tail refresh. The grid is therefore identical on every
//  chart interval, stable across historical pans, and free of chart-window
//  freshness races; the live month's cell updates at the tail-refresh
//  cadence. Return for month M = close(M) / close(M-1) - 1, where close(M)
//  is the month's last daily close.
// ============================================================================
define("Monthly Returns", "offchart", true)

// The chart source only drives the bar timeline (isLastBar + re-runs); all
// returns math reads the anchored daily history below.
timeseries d = source("ohlcv", currentSymbol, currentExchange)

if (isLastBar) {
  // Three years of native daily bars, independent of the chart interval,
  // loaded depth, and historical pans.
  var rows = requestBars(currentSymbol, "1d", { bars: 1095, anchor: "latest" })

  // A venue with no native daily data makes requestBars fall back to
  // chart-interval rows. Detect that by the SMALLEST consecutive spacing
  // (real dailies have ~1-day minimum steps even when weekends or halts
  // leave larger gaps): multi-day fallback rows would mislabel months (a
  // bar's close can land in the month after its open), so treat them as
  // unusable rather than silently wrong. Intraday fallback rows bucket
  // correctly by timestamp, just over shallower history.
  if (rows.length > 1) {
    var minStep = na
    for (var i = 1; i < rows.length; i = i + 1) {
      var step = rows[i][0] - rows[i - 1][0]
      if (isnum(minStep) == false || step < minStep) {
        minStep = step
      }
    }
    if (isnum(minStep) && minStep > 129600000) {
      rows = []
    }
  }

  // Last daily close per calendar month, chronological: key = year*100+month.
  var monthKeys = []
  var monthCloses = []
  for (var i = 0; i < rows.length; i = i + 1) {
    var c = rows[i][4]
    if (isnum(c) && c > 0) {
      var key = year(rows[i][0]) * 100 + month(rows[i][0])
      if (monthKeys.length == 0 || monthKeys[monthKeys.length - 1] != key) {
        monthKeys.push(key)
        monthCloses.push(c)
      } else {
        monthCloses[monthCloses.length - 1] = c
      }
    }
  }

  if (monthKeys.length > 0) {
    // Distinct years, chronological (months arrive in order).
    var years = []
    for (var i = 0; i < monthKeys.length; i = i + 1) {
      var y = math.floor(monthKeys[i] / 100)
      if (years.length == 0 || years[years.length - 1] != y) {
        years.push(y)
      }
    }

    // Month-over-month % returns placed at [yearRow, monthCol]. Flat parallel
    // arrays (value + calendar month) so the summary pass below can re-bucket.
    // Ratio rows require strictly POSITIVE endpoints (the valid-only close
    // scan above guarantees that).
    var cells = []
    var retVals = []
    var retCols = []
    for (var i = 1; i < monthKeys.length; i = i + 1) {
      var key = monthKeys[i]
      var prevKey = monthKeys[i - 1]
      // Calendar adjacency: a month with no valid close must not turn the
      // next month's cell into a mislabeled multi-month move.
      var expected = prevKey % 100 == 12 ? (math.floor(prevKey / 100) + 1) * 100 + 1 : prevKey + 1
      if (key == expected) {
        var ret = monthCloses[i] / monthCloses[i - 1] - 1
        var row = years.indexOf(math.floor(key / 100))
        var col = key % 100 - 1
        cells.push([row, col, ret])
        retVals.push(ret)
        retCols.push(col)
      }
    }

    // Summary rows: AVG / MED / WIN% of each calendar month's returns across
    // years; months with no observations stay blank (na).
    var avgRow = []
    var medRow = []
    var winRow = []
    for (var m = 0; m < 12; m = m + 1) {
      var monthRets = []
      for (var i = 0; i < retVals.length; i = i + 1) {
        if (retCols[i] == m) {
          monthRets.push(retVals[i])
        }
      }
      if (monthRets.length == 0) {
        avgRow.push(na)
        medRow.push(na)
        winRow.push(na)
      } else {
        var sum = monthRets.reduce((acc, r) => acc + r, 0)
        var wins = monthRets.filter((r) => r > 0)
        var sorted = monthRets.slice(0, monthRets.length).sort()
        var mid = math.floor(sorted.length / 2)
        var med = sorted.length % 2 == 1 ? sorted[mid] : (sorted[mid - 1] + sorted[mid]) / 2
        avgRow.push(sum / monthRets.length)
        medRow.push(med)
        winRow.push(wins.length / monthRets.length)
      }
    }

    // Highlight the latest DATA month: the last daily bar's month is the one
    // still forming.
    var lastKey = monthKeys[monthKeys.length - 1]
    plotMatrix(
      data = cells,
      rowLabels = years.map((y) => "".concat(y)),
      colLabels = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"],
      format = "percent",
      summary = [
        { label: "AVG", values: avgRow },
        { label: "MED", values: medRow },
        { label: "WIN%", values: winRow }
      ],
      highlight = { row: years.indexOf(math.floor(lastKey / 100)), col: lastKey % 100 - 1 },
      gridHeight = 0.3
    )
  }
}

//@version=3
// Cross-symbol correlation matrix: pairwise Pearson correlation of single-bar
// returns for five majors on the chart's exchange, over the loaded shared
// history (capped at the most recent 365 aligned bars). Equal-interval
// sources align per bar, so the accumulation is a plain parallel pass: a bar
// contributes only when every symbol has a numeric close. Returns are stored
// in ONE flat array with stride 5 (kScript arrays are homogeneous and nested
// element methods are not analyzable, so flat + index math is the idiom).
// The pane ignores the time axis; each extra symbol consumes a source slot.
define("Correlation Grid", "offchart", true)

timeseries sBTC = source("ohlcv", "BTCUSDT", currentExchange)
timeseries sETH = source("ohlcv", "ETHUSDT", currentExchange)
timeseries sSOL = source("ohlcv", "SOLUSDT", currentExchange)
timeseries sXRP = source("ohlcv", "XRPUSDT", currentExchange)
timeseries sBNB = source("ohlcv", "BNBUSDT", currentExchange)

static prevRow = []
static rets = []

var closesNow = [sBTC.close, sETH.close, sSOL.close, sXRP.close, sBNB.close]
var allNum = true
for (var i = 0; i < 5; i = i + 1) {
  if (isnum(closesNow[i]) == false || closesNow[i] <= 0) {
    allNum = false
  }
}
if (allNum) {
  if (prevRow.length == 5) {
    // Rolling window: only the newest 366 strides are ever kept, so the
    // buffer stays far under the runtime's collection ceiling on long
    // intraday histories (the analysis window is 365 anyway).
    if (rets.length >= 5 * 366) {
      for (var i = 0; i < 5; i = i + 1) {
        rets.removeAt(0)
      }
    }
    for (var i = 0; i < 5; i = i + 1) {
      rets.push(closesNow[i] / prevRow[i] - 1)
    }
  }
  if (prevRow.length == 0) {
    for (var i = 0; i < 5; i = i + 1) {
      prevRow.push(closesNow[i])
    }
  } else {
    for (var i = 0; i < 5; i = i + 1) {
      prevRow[i] = closesNow[i]
    }
  }
} else {
  // A gap bar invalidates the baseline: without this, the next complete bar
  // would compute a multi-bar "return" against the pre-gap close.
  prevRow.clear()
}

if (isLastBar && rets.length >= 55) {
  var m = math.floor(rets.length / 5)
  var startBar = m > 365 ? m - 365 : 0
  var count = m - startBar

  // Per-symbol means over the window.
  var means = []
  for (var s = 0; s < 5; s = s + 1) {
    var sum = 0
    for (var k = startBar; k < m; k = k + 1) {
      sum = sum + rets[k * 5 + s]
    }
    means.push(sum / count)
  }

  var cells = []
  var colSums = []
  var colCounts = []
  for (var c = 0; c < 5; c = c + 1) {
    colSums.push(0)
    colCounts.push(0)
  }
  for (var a = 0; a < 5; a = a + 1) {
    for (var b = 0; b < 5; b = b + 1) {
      if (a == b) {
        cells.push([a, b, 1])
      } else {
        var cov = 0
        var varA = 0
        var varB = 0
        for (var k = startBar; k < m; k = k + 1) {
          var dx = rets[k * 5 + a] - means[a]
          var dy = rets[k * 5 + b] - means[b]
          cov = cov + dx * dy
          varA = varA + dx * dx
          varB = varB + dy * dy
        }
        if (varA > 0 && varB > 0) {
          var corr = cov / math.sqrt(varA * varB)
          cells.push([a, b, corr])
          colSums[b] = colSums[b] + corr
          colCounts[b] = colCounts[b] + 1
        }
      }
    }
  }

  var avgRow = []
  for (var c = 0; c < 5; c = c + 1) {
    if (colCounts[c] > 0) {
      avgRow.push(colSums[c] / colCounts[c])
    } else {
      avgRow.push(na)
    }
  }

  plotMatrix(
    data = cells,
    rowLabels = ["BTC", "ETH", "SOL", "XRP", "BNB"],
    colLabels = ["BTC", "ETH", "SOL", "XRP", "BNB"],
    format = "number",
    summary = [
      { label: "AVG", values: avgRow }
    ],
    gridHeight = 0.3
  )
}

//@version=3
// MINIMAL CALL: data only, every other kwarg omitted (no series, no style,
// no gridHeight). Proves which kwargs are truly optional.
define("Curve Minimal Data Only", "offchart", true)

timeseries d = source("ohlcv", currentSymbol, currentExchange)

if (isLastBar) {
  plotCurve(
    data = [
      [1, 10],
      [2, 12],
      [3, 11]
    ]
  )
}

//@version=3
// na series values are GAPS, not zeros: the line breaks at x=2 (series 1) and
// x=3 (series 2). Verifies na is accepted in value columns (only x must be a
// real ascending number) and lands as null on the wire.
define("Curve NA Gap", "offchart", true)

timeseries d = source("ohlcv", currentSymbol, currentExchange)

if (isLastBar) {
  plotCurve(
    data = [
      [1, 10, 20],
      [2, na, 21],
      [3, 12, na],
      [4, 13, 23],
      [5, 11, 22]
    ],
    series = [
      { label: "A", color: "#43d3c3" },
      { label: "B", color: "#7a8cff" }
    ],
    gridHeight = 0.2
  )
}

//@version=3
// Per-series style overrides the whole-pane default: pane style "line", but
// series 2 renders as bars. Also exercises hideLegendValues = true and the
// series-0 shorthands (color + fill at call level).
define("Curve Mixed Styles", "offchart", true)

timeseries d = source("ohlcv", currentSymbol, currentExchange)

if (isLastBar) {
  plotCurve(
    data = [
      [0, 5, 2],
      [1, 7, 4],
      [2, 6, 3],
      [3, 9, 5],
      [4, 8, 1]
    ],
    style = "line",
    color = "#5b8def",
    fill = true,
    series = [
      { label: "Curve" },
      { label: "Histogram", color: "#f5c518", style: "bars" }
    ],
    hideLegendValues = true,
    gridHeight = 0.25
  )
}

//@version=3
// CAP BOUNDARY (pass side): exactly 8 markers, first one with a label of
// exactly 16 chars ("ABCDEFGHIJKLMNOP"), plus the 'spot' literal tracker.
define("Curve Markers Max", "offchart", true)

timeseries d = source("ohlcv", currentSymbol, currentExchange)

if (isLastBar) {
  plotCurve(
    data = [
      [0, 10],
      [10, 12],
      [20, 11],
      [30, 14]
    ],
    series = [
      { label: "S0" }
    ],
    markers = [
      { x: 1, label: "ABCDEFGHIJKLMNOP", color: "#f5c518" },
      { x: "spot", label: "Spot" },
      { x: 3, label: "M3" },
      { x: 4, label: "M4" },
      { x: 5, label: "M5" },
      { x: 6, label: "M6" },
      { x: 7, label: "M7" },
      { x: 8, label: "M8" }
    ],
    gridHeight = 0.2
  )
}

//@version=3
// valueFormat "percent": values render AS-IS with a % suffix (no x100), so the
// script emits percent-unit values like 32.5 (not 0.325).
define("Curve ValueFormat Percent", "offchart", true)

timeseries d = source("ohlcv", currentSymbol, currentExchange)

if (isLastBar) {
  plotCurve(
    data = [
      [5, 62.4],
      [10, 55.1],
      [20, 48.9],
      [30, 44.2],
      [60, 39.7]
    ],
    series = [
      { label: "Ann. Vol" }
    ],
    valueFormat = "percent",
    gridHeight = 0.2
  )
}

//@version=3
// ============================================================================
//  GAMMA PROFILE (STATIC)
//  Dealer gamma exposure over hypothetical spot as a foreign-domain CURVE
//  pane: net GEX (filled, crossing zero at the gamma flip) plus absolute
//  GEX, a live 'spot' tracker marker, and the flip level marked. X is
//  hypothetical spot, so the pane ignores the chart's time axis entirely.
//
//  The rows below are an illustrative options-desk snapshot; the script
//  exists to prove the surface until a real options-chain source lands.
//  Swap `data` for computed [spot, netGex, absGex] rows when it does.
// ============================================================================
define("Gamma Profile", "offchart", true)

timeseries d = source("ohlcv", currentSymbol, currentExchange)

plotCurve(
  data = [
    [52000, -3.1, 3.4],
    [56000, -2.4, 2.9],
    [60000, -1.2, 2.1],
    [64000, -0.2, 1.8],
    [65500, 0.4, 1.9],
    [68000, 1.3, 2.4],
    [72000, 2.6, 3.1],
    [76000, 3.8, 4.0]
  ],
  markers = [
    { x: "spot", label: "Spot" },
    { x: 64800, label: "Gamma flip", color: "#f7525f" }
  ],
  series = [
    { label: "Net GEX ($B/1%)", color: "#43d3c3", fill: true },
    { label: "Abs GEX ($B/1%)", color: "#7a8cff", fill: false }
  ],
  style = "line",
  gridHeight = 0.22
)

//@version=3
// Histogram of single-bar percentage returns in 1% buckets clamped to +/-10%,
// rendered as a bars-style curve over the RETURN axis (not time). Reference
// markers pin the mean and +/-1 standard deviation of the distribution.
define("Return Distribution", "offchart", true)

timeseries d = source("ohlcv", currentSymbol, currentExchange)

static rets = []
static prevBox = []

if (isnum(d.close) && d.close > 0 && prevBox.length > 0 && isnum(prevBox[0]) && prevBox[0] > 0) {
  rets.push(d.close / prevBox[0] - 1)
}
if (prevBox.length == 0) {
  prevBox.push(d.close)
} else {
  prevBox[0] = d.close
}

if (isLastBar && rets.length > 1) {
  var counts = []
  for (var i = 0; i < 21; i = i + 1) {
    counts.push(0)
  }
  for (var i = 0; i < rets.length; i = i + 1) {
    var b = math.floor(rets[i] * 100 + 0.5) + 10
    if (b < 0) {
      b = 0
    }
    if (b > 20) {
      b = 20
    }
    counts[b] = counts[b] + 1
  }
  var rows = []
  for (var i = 0; i < 21; i = i + 1) {
    rows.push([i - 10, counts[i]])
  }
  var mean = rets.avg()
  var sd = rets.stdev()
  plotCurve(
    data = rows,
    style = "bars",
    color = "#5b8def",
    series = [
      { label: "Bars" }
    ],
    markers = [
      { x: mean * 100, label: "Mean", color: "#f5c518" },
      { x: (mean - sd) * 100, label: "-1 SD", color: "#8a8f98" },
      { x: (mean + sd) * 100, label: "+1 SD", color: "#8a8f98" }
    ],
    gridHeight = 0.28
  )
}

//@version=3
// Realized-volatility cone: for each horizon (in bars), the max / median / min
// annualized volatility across every rolling window of that length in the
// loaded history, plus the CURRENT (most recent) window. X is the horizon
// length, so the pane ignores the time axis entirely. Annualization assumes
// daily bars (sqrt(365)); on intraday charts read the values as relative.
define("Volatility Cone", "offchart", true)

timeseries d = source("ohlcv", currentSymbol, currentExchange)

static logRets = []
static prevBox = []

if (prevBox.length > 0 && isnum(prevBox[0]) && prevBox[0] > 0 && d.close > 0) {
  logRets.push(math.log(d.close / prevBox[0]))
}
if (prevBox.length == 0) {
  prevBox.push(d.close)
} else {
  prevBox[0] = d.close
}

if (isLastBar && logRets.length >= 10) {
  var horizons = [5, 10, 20, 30, 60, 90, 120]
  var ps = [0]
  var ps2 = [0]
  for (var i = 0; i < logRets.length; i = i + 1) {
    ps.push(ps[i] + logRets[i])
    ps2.push(ps2[i] + logRets[i] * logRets[i])
  }
  // Percent units (x100): valueFormat 'percent' renders values as-is with a
  // % suffix on both the Y axis and the hover card.
  var annFactor = math.sqrt(365) * 100
  var rows = []
  for (var hIdx = 0; hIdx < horizons.length; hIdx = hIdx + 1) {
    var h = horizons[hIdx]
    if (h <= logRets.length) {
      var vols = []
      for (var s = 0; s + h <= logRets.length; s = s + 1) {
        var mean = (ps[s + h] - ps[s]) / h
        var v = (ps2[s + h] - ps2[s]) / h - mean * mean
        if (v < 0) {
          v = 0
        }
        vols.push(math.sqrt(v) * annFactor)
      }
      rows.push([h, vols.max(), vols.median(), vols.min(), vols[vols.length - 1]])
    }
  }
  if (rows.length > 1) {
    plotCurve(
      data = rows,
      series = [
        { label: "Max", color: "#e5534b" },
        { label: "Median", color: "#8a8f98" },
        { label: "Min", color: "#3fb27f" },
        { label: "Current", color: "#f5c518" }
      ],
      valueFormat = "percent",
      gridHeight = 0.3
    )
  }
}

//@version=3
// Minimal plotTiles happy path: all four formats, accents, computed text via
// the texts kwarg overriding the static fallback, columns + gridHeight +
// hideLegendValues.
define("Tiles Minimal Probe", "offchart", true)

timeseries d = source("ohlcv", currentSymbol, currentExchange)

if (isLastBar) {
  plotTiles(
    tiles = [
      { label: "Last", format: "currency" },
      { label: "Change", caption: "one bar", format: "percent", accent: "auto" },
      { label: "Count", format: "number", accent: "pos" },
      { label: "Regime", format: "text", text: "AWAITING", accent: "neutral" }
    ],
    data = [
      [0, d.close],
      [1, d.close / d.open - 1],
      [2, barIndex]
    ],
    texts = [
      { tile: 3, text: d.close >= d.open ? "UP BAR" : "DOWN BAR" }
    ],
    columns = 2,
    gridHeight = 0.2,
    hideLegendValues = true
  )
}

//@version=3
// na drops a row BEFORE any validation, for both data rows and texts
// entries: tile index 99 is far out of range for a 2-tile dashboard, and
// [0, na] duplicates the finite [0, ...] row, yet the script runs clean
// because the na value/text removes the row first (no index error, no
// duplicate error).
define("Tiles NA Drop Probe", "offchart", true)

timeseries d = source("ohlcv", currentSymbol, currentExchange)

if (isLastBar) {
  plotTiles(
    tiles = [
      { label: "Last", format: "currency" },
      { label: "Regime", format: "text", text: "AWAITING" }
    ],
    data = [
      [0, d.close],
      [0, na],
      [99, na]
    ],
    texts = [
      { tile: 99, text: na }
    ],
    gridHeight = 0.15
  )
}

//@version=3
// A format:'text' tile with a static text and NO texts emission: the tile
// keeps its static fallback ("AWAITING"). The texts kwarg is present but its
// only entry carries na text, which drops the entry (before index validation),
// so no [tileIndex, string] wire row is emitted for tile 1.
define("Tiles Static Fallback Probe", "offchart", true)

timeseries d = source("ohlcv", currentSymbol, currentExchange)

if (isLastBar) {
  plotTiles(
    tiles = [
      { label: "Last", format: "currency" },
      { label: "Regime", format: "text", text: "AWAITING", accent: "neutral" }
    ],
    data = [
      [0, d.close]
    ],
    texts = [
      { tile: 1, text: barIndex < 0 ? "NEVER" : na }
    ],
    columns = 2,
    gridHeight = 0.15
  )
}

//@version=3
// Live KPI tiles computed from the loaded history: last close, one-bar change,
// 30-bar annualized volatility, drawdown from the loaded-range high, position
// inside the loaded range, the current run of consecutive up/down closes, and
// a COMPUTED text regime tile (texts kwarg, wire v1.2). All values arrive as
// data rows, so they refresh with the chart; tile structure is static
// settings. Annualization assumes daily bars.
define("Market Snapshot", "offchart", true)

timeseries d = source("ohlcv", currentSymbol, currentExchange)

static closes = []
static gapBox = []
static logRets = []
static prevBox = []

// Gap-filled bars can carry na closes: keep the series valid-only and record
// the boundary so streaks and the one-bar change never bridge a gap.
if (isnum(d.close)) {
  closes.push(d.close)
  // Single-bar log returns accumulate at SOURCE time, so a return can never
  // span a gap (the compacted closes array cannot guarantee adjacency).
  // Rolling 30-entry buffer: exactly the vol window, bounded forever.
  if (prevBox.length > 0 && isnum(prevBox[0]) && prevBox[0] > 0 && d.close > 0) {
    if (logRets.length >= 30) {
      logRets.removeAt(0)
    }
    logRets.push(math.log(d.close / prevBox[0]))
  }
  if (prevBox.length == 0) {
    prevBox.push(d.close)
  } else {
    prevBox[0] = d.close
  }
} else {
  if (prevBox.length > 0) {
    prevBox[0] = na
  }
  if (gapBox.length == 0) {
    gapBox.push(closes.length)
  } else {
    gapBox[0] = closes.length
  }
}

if (isLastBar && closes.length > 1) {
  var n = closes.length
  var last = closes[n - 1]
  var gapAt = gapBox.length > 0 ? gapBox[0] : -1
  // gapAt == n means the newest bar(s) carry na closes: the live edge has no
  // close yet, so there is no current one-bar change and no active streak.
  // Ratio rows also require strictly POSITIVE endpoints (shared corpus rule).
  var trailingGap = gapAt == n
  var change = trailingGap == false && gapAt != n - 1 && closes[n - 2] > 0 && last > 0 ? last / closes[n - 2] - 1 : na
  var hi = closes.max()
  var lo = closes.min()
  var annVol = logRets.length > 1 ? logRets.stdev() * math.sqrt(365) : na
  var trendWindow = n > 50 ? 50 : n
  var meanWindow = closes.slice(n - trendWindow, n).avg()
  var streak = 0
  var broken = trailingGap
  for (var i = n - 1; i > 0; i = i - 1) {
    if (broken == false) {
      if (i == gapAt) {
        // The pair (i, i-1) spans a data gap: the run ends here.
        broken = true
      } else {
      var delta = closes[i] - closes[i - 1]
      if (delta == 0) {
        // A flat close ends the run: it is neither an up nor a down bar.
        broken = true
      } else {
        var up = delta > 0
        if (streak == 0) {
          streak = up ? 1 : -1
        } else if ((streak > 0 && up) || (streak < 0 && up == false)) {
          streak = streak > 0 ? streak + 1 : streak - 1
        } else {
          broken = true
        }
      }
      }
    }
  }
  plotTiles(
    tiles = [
      { label: "Last", format: "currency" },
      { label: "1-Bar Change", format: "percent", accent: "auto" },
      { label: "Ann. Vol (30b)", caption: "log-return stdev, annualized", format: "percent" },
      { label: "Off High", caption: "from loaded-range high", format: "percent", accent: "auto" },
      { label: "Range Position", caption: "inside loaded range", format: "percent" },
      { label: "Bar Streak", caption: "consecutive up/down closes", format: "number", accent: "auto" },
      { label: "Regime", caption: "close vs 50-bar mean", format: "text", text: "AWAITING", accent: "neutral" }
    ],
    data = [
      [0, last],
      [1, change],
      [2, annVol],
      [3, hi > 0 && last > 0 ? last / hi - 1 : na],
      [4, hi != lo ? (last - lo) / (hi - lo) : na],
      [5, streak]
    ],
    texts = [
      { tile: 6, text: last >= meanWindow ? "UP TREND" : "DOWN TREND" }
    ],
    columns = 4,
    gridHeight = 0.2
  )
}