@forgecharts/sdk 1.1.32 → 1.1.36

package/dist/index.js

@@ -91,9 +91,73 @@ function computeTicks(min, max, targetCount) {
   return ticks;
 }
 
+// ../shared/src/time/timeframeRegistry.ts
+function isCalendarTimeframe(key) {
+  return key === "1w" || key === "1M" || key === "3M" || key === "6M" || key === "12M";
+}
+
+// ../shared/src/time/timeUtils.ts
+var MONDAY_EPOCH_OFFSET_MS = 3456e5;
+var WEEK_MS = 6048e5;
+function timeframeToMs(tf) {
+  if (isCalendarTimeframe(tf)) return null;
+  const secs = parseTfSeconds(tf);
+  return secs !== null ? secs * 1e3 : null;
+}
+function parseTfSeconds(tf) {
+  const m = /^(\d+)(s|m|h|d|w|M)$/.exec(tf);
+  if (!m) return null;
+  const n = parseInt(m[1], 10);
+  const unit = m[2];
+  const UNIT_SECONDS = {
+    s: 1,
+    m: 60,
+    h: 3600,
+    d: 86400,
+    w: 604800,
+    M: 2592e3
+  };
+  const unitSec = UNIT_SECONDS[unit];
+  return unitSec !== void 0 ? n * unitSec : null;
+}
+function getBucketStart(timeMs, timeframe) {
+  if (timeframe === "1w") return getWeekBucketStart(timeMs);
+  if (timeframe === "1M") return getMonthBucketStart(timeMs);
+  if (timeframe === "3M") return getQuarterBucketStart(timeMs);
+  if (timeframe === "6M") return getHalfYearBucketStart(timeMs);
+  if (timeframe === "12M") return getYearBucketStart(timeMs);
+  const secs = parseTfSeconds(timeframe);
+  if (secs && secs > 0) return Math.floor(timeMs / (secs * 1e3)) * (secs * 1e3);
+  return Math.floor(timeMs / 6e4) * 6e4;
+}
+function getWeekBucketStart(timeMs) {
+  return Math.floor((timeMs - MONDAY_EPOCH_OFFSET_MS) / WEEK_MS) * WEEK_MS + MONDAY_EPOCH_OFFSET_MS;
+}
+function getMonthBucketStart(timeMs) {
+  const d = new Date(timeMs);
+  return Date.UTC(d.getUTCFullYear(), d.getUTCMonth(), 1);
+}
+function getQuarterBucketStart(timeMs) {
+  const d = new Date(timeMs);
+  const quarterMonth = Math.floor(d.getUTCMonth() / 3) * 3;
+  return Date.UTC(d.getUTCFullYear(), quarterMonth, 1);
+}
+function getHalfYearBucketStart(timeMs) {
+  const d = new Date(timeMs);
+  const halfMonth = d.getUTCMonth() < 6 ? 0 : 6;
+  return Date.UTC(d.getUTCFullYear(), halfMonth, 1);
+}
+function getYearBucketStart(timeMs) {
+  return Date.UTC(new Date(timeMs).getUTCFullYear(), 0, 1);
+}
+
 // ../utils/src/time.ts
+function parseTimeframeSeconds(tf) {
+  return parseTfSeconds(tf);
+}
 function formatTimestampLabel(ts, stepSeconds, tz) {
-  const timeZone = !tz || tz === "exchange" ? "UTC" : tz;
+  const userTZ = !tz || tz === "exchange" ? "UTC" : tz;
+  const timeZone = stepSeconds >= 86400 ? "UTC" : userTZ;
   const d = new Date(ts * 1e3);
   if (stepSeconds < 3600) {
     return new Intl.DateTimeFormat("en-US", {
@@ -124,9 +188,19 @@ function formatTimestampLabel(ts, stepSeconds, tz) {
   );
   const yearStr = new Intl.DateTimeFormat("en-US", { year: "numeric", timeZone }).format(d);
   const monthStr = new Intl.DateTimeFormat("en-US", { month: "short", timeZone }).format(d);
-  if (stepSeconds >= 25 * 86400) {
+  if (stepSeconds >= 182 * 86400) {
     return month === 1 ? yearStr : monthStr;
   }
+  if (stepSeconds <= 3 * 86400) {
+    const dayNum2 = parseInt(
+      new Intl.DateTimeFormat("en-US", { day: "numeric", timeZone }).format(d),
+      10
+    );
+    if (dayNum2 === 1) {
+      return month === 1 ? yearStr : monthStr;
+    }
+    return String(dayNum2);
+  }
   const dayNum = parseInt(
     new Intl.DateTimeFormat("en-US", { day: "numeric", timeZone }).format(d),
     10
@@ -264,6 +338,8 @@ var TimeScale = class {
     return 70;
   }
   _niceTimeStep(rawSeconds) {
+    const minStep = parseTimeframeSeconds(this._activeTimeframe) ?? 1;
+    const effectiveRaw = Math.max(rawSeconds, minStep);
     const nice = [
       1,
       5,
@@ -281,6 +357,10 @@ var TimeScale = class {
       43200,
       86400,
       // 1 day
+      2 * 86400,
+      // 2 days
+      3 * 86400,
+      // 3 days
       7 * 86400,
       // 1 week
       14 * 86400,
@@ -295,9 +375,9 @@ var TimeScale = class {
       // ~1 year
     ];
     for (const s of nice) {
-      if (s >= rawSeconds) return s;
+      if (s >= effectiveRaw) return s;
     }
-    return 365 * 86400 * Math.ceil(rawSeconds / (365 * 86400));
+    return 365 * 86400 * Math.ceil(effectiveRaw / (365 * 86400));
   }
 };
 
@@ -732,17 +812,18 @@ var Crosshair = class {
   }
   /** Formats a Unix timestamp (seconds) as a human-readable date/time string. */
   _formatTime(time) {
-    const timeZone = !this.timezone || this.timezone === "exchange" ? "UTC" : this.timezone;
+    const userTZ = !this.timezone || this.timezone === "exchange" ? "UTC" : this.timezone;
     const d = new Date(time * 1e3);
-    const weekday = d.toLocaleDateString("en-US", { weekday: "short", timeZone });
-    const day = d.toLocaleDateString("en-US", { day: "2-digit", timeZone });
-    const month = d.toLocaleDateString("en-US", { month: "short", timeZone });
-    const year = d.toLocaleDateString("en-US", { year: "2-digit", timeZone });
-    const datePart = `${weekday} ${day} ${month} '${year}`;
     const dailyIntervals = /* @__PURE__ */ new Set(["1d", "2d", "3d", "1w", "2w", "1M", "3M", "6M", "12M"]);
+    const dateZone = dailyIntervals.has(this.interval) ? "UTC" : userTZ;
+    const weekday = d.toLocaleDateString("en-US", { weekday: "short", timeZone: dateZone });
+    const day = d.toLocaleDateString("en-US", { day: "2-digit", timeZone: dateZone });
+    const month = d.toLocaleDateString("en-US", { month: "short", timeZone: dateZone });
+    const year = d.toLocaleDateString("en-US", { year: "2-digit", timeZone: dateZone });
+    const datePart = `${weekday} ${day} ${month} '${year}`;
     if (dailyIntervals.has(this.interval)) return datePart;
-    const hh = d.toLocaleString("en-US", { hour: "2-digit", hour12: false, timeZone });
-    const mm = d.toLocaleString("en-US", { minute: "2-digit", timeZone }).padStart(2, "0");
+    const hh = d.toLocaleString("en-US", { hour: "2-digit", hour12: false, timeZone: userTZ });
+    const mm = d.toLocaleString("en-US", { minute: "2-digit", timeZone: userTZ }).padStart(2, "0");
     return `${datePart}  ${hh}:${mm}`;
   }
 };
@@ -781,12 +862,8 @@ var CandlestickRenderer = class {
     const pixelsPerSecond = visibleSpan > 0 ? plotW / visibleSpan : 1;
     const barPitch = candleInterval > 0 ? candleInterval * pixelsPerSecond : plotW / Math.max(1, plotData.length);
     const minBarWidth = 1;
-    const maxBarWidth = 20;
     const gap = Math.max(1, Math.round(barPitch * 0.15));
-    const barWidth = Math.min(
-      maxBarWidth,
-      Math.max(minBarWidth, Math.floor(barPitch) - gap)
-    );
+    const barWidth = Math.max(minBarWidth, Math.floor(barPitch) - gap);
     const halfBar = Math.max(0.5, barWidth / 2);
     for (const bar of plotData) {
       const x = mapRange(
@@ -1039,6 +1116,8 @@ var InteractionManager = class {
   // ── Hit-test data feeds ───────────────────────────────────────────────────
   _drawings = [];
   _bars = [];
+  /** Overlay indicator polylines for hit-testing. Each entry is an indicator id + its data points. */
+  _indicatorLines = [];
   // ── Mouse state ───────────────────────────────────────────────────────────
   _isDragging = false;
   _dragStartX = 0;
@@ -1055,9 +1134,11 @@ var InteractionManager = class {
   _drawingMode = false;
   /** True when the native cursor should be hidden (crosshair / dot / demonstration). */
   _hideCursor = false;
-  /** Sets cursor style, respecting _hideCursor — 'none' always wins when hiding. */
+  /** Sets cursor style, respecting _hideCursor — axis resize cursors always show
+   * even in crosshair/dot/demonstration mode so the user knows they can drag the axes. */
   _setCursor(style) {
-    this._el.style.cursor = this._hideCursor ? "none" : style;
+    const isAxisCursor = style === "ns-resize" || style === "ew-resize";
+    this._el.style.cursor = this._hideCursor && !isAxisCursor ? "none" : style;
   }
   /** Set when a drawing is committed mid-mousedown; prevents the paired mouseup from auto-selecting it. */
   _suppressNextClick = false;
@@ -1098,6 +1179,13 @@ var InteractionManager = class {
   setBars(bars) {
     this._bars = bars;
   }
+  /**
+   * Provide overlay indicator polylines for proximity hit-testing.
+   * Each line is an indicator id + array of { time, value } points.
+   */
+  setIndicatorLines(lines) {
+    this._indicatorLines = lines;
+  }
   // ─── Selection ────────────────────────────────────────────────────────────
   /** Id of the currently selected drawing, or `null`. */
   get selectedDrawingId() {
@@ -1254,10 +1342,16 @@ var InteractionManager = class {
     if (!this._isDragging) {
       if (x >= this._transform.plotWidth && y < this._transform.plotHeight) {
         this._setCursor("ns-resize");
+      } else if (y >= this._transform.plotHeight) {
+        this._setCursor("ew-resize");
       } else if (hit.kind === "drawingHandle") {
         this._setCursor("grab");
       } else if (hit.kind === "drawing") {
         this._setCursor("grab");
+      } else if (hit.kind === "indicator") {
+        this._setCursor("pointer");
+      } else if (hit.kind === "bar") {
+        this._setCursor("pointer");
       } else {
         this._setCursor("default");
       }
@@ -1395,6 +1489,9 @@ var InteractionManager = class {
     if (hit.kind === "drawing") {
       this._selectedDrawingId = hit.id;
       this._handlers.onSelect?.(x, y, hit);
+    } else if (hit.kind === "indicator") {
+      this._selectedDrawingId = null;
+      this._handlers.onSelect?.(x, y, hit);
     } else if (hit.kind === "bar") {
       this._selectedDrawingId = null;
       this._handlers.onSelect?.(x, y, hit);
@@ -1425,6 +1522,10 @@ var InteractionManager = class {
     if (drawingHit !== null) {
       return { kind: "drawing", id: drawingHit.id, type: drawingHit.type };
     }
+    const indicatorId = this._hitTestIndicators(x, y);
+    if (indicatorId !== null) {
+      return { kind: "indicator", indicatorId };
+    }
     const barHit = this._hitTestBar(x);
     if (barHit !== null) {
       return { kind: "bar", index: barHit.index, bar: barHit.bar };
@@ -1441,6 +1542,34 @@ var InteractionManager = class {
     }
     return -1;
   }
+  _hitTestIndicators(x, y) {
+    const t = this._transform;
+    const { from, to } = t.timeRange;
+    let bestId = null;
+    let bestDist = DRAWING_HIT_PX + 1;
+    for (const line of this._indicatorLines) {
+      const pts = line.points;
+      for (let i = 0; i < pts.length - 1; i++) {
+        const a = pts[i];
+        const b = pts[i + 1];
+        if (a.time < from && b.time < from) continue;
+        if (a.time > to && b.time > to) continue;
+        const dist = this._distPointToSegment(
+          x,
+          y,
+          t.timeToX(a.time),
+          t.priceToY(a.value),
+          t.timeToX(b.time),
+          t.priceToY(b.value)
+        );
+        if (dist < bestDist) {
+          bestDist = dist;
+          bestId = line.id;
+        }
+      }
+    }
+    return bestId;
+  }
   _hitTestDrawings(x, y) {
     let bestId = null;
     let bestType = null;
@@ -1677,26 +1806,14 @@ function rayExit(plotW, plotH, px, py, dx, dy) {
   else if (dy < 0) tMin = Math.min(tMin, -py / dy);
   return tMin === Infinity ? { x: px, y: py } : { x: px + dx * tMin, y: py + dy * tMin };
 }
-var TF_SECS = {
-  "1s": 1,
-  "5s": 5,
-  "10s": 10,
-  "30s": 30,
-  "1m": 60,
-  "3m": 180,
-  "5m": 300,
-  "15m": 900,
-  "30m": 1800,
-  "1h": 3600,
-  "2h": 7200,
-  "4h": 14400,
-  "6h": 21600,
-  "12h": 43200,
-  "1d": 86400,
-  "3d": 259200,
-  "1w": 604800,
-  "1M": 2592e3
-};
+var TF_SECS = new Proxy({}, {
+  get(_t, tf) {
+    return parseTfSeconds(tf) ?? 3600;
+  },
+  has(_t, _tf) {
+    return true;
+  }
+});
 function formatDuration(seconds) {
   if (seconds < 60) return `${seconds}s`;
   if (seconds < 3600) {
@@ -2534,29 +2651,68 @@ var LIGHT_COLORS = {
   crosshair: "#000000"
 };
 
+// src/services/serverClock.ts
+var PROBES = 3;
+var RESYNC_INTERVAL = 30 * 60 * 1e3;
+var _clientToServerOffset = 0;
+var _providerOffset = 0;
+var _endpoint = "/api/time";
+var _syncTimer = null;
+var _initialised = false;
+function exchangeNow() {
+  return Date.now() + _clientToServerOffset + _providerOffset;
+}
+function serverNow() {
+  return exchangeNow();
+}
+function serverClockOffset() {
+  return _clientToServerOffset + _providerOffset;
+}
+async function initServerClock(endpoint = "/api/time") {
+  _endpoint = endpoint;
+  if (!_initialised) {
+    _initialised = true;
+    if (_syncTimer) clearInterval(_syncTimer);
+    _syncTimer = setInterval(() => void _sync(), RESYNC_INTERVAL);
+  }
+  await _sync();
+}
+async function _probe() {
+  const t0 = Date.now();
+  try {
+    const resp = await fetch(_endpoint, { cache: "no-store" });
+    const t2 = Date.now();
+    if (!resp.ok) return null;
+    const body = await resp.json();
+    if (typeof body.serverTime !== "number") return null;
+    const rtt = t2 - t0;
+    const offset = body.serverTime - (t0 + rtt / 2);
+    const providerOffset = typeof body.providerOffset === "number" ? body.providerOffset : 0;
+    return { offset, rtt, providerOffset };
+  } catch {
+    return null;
+  }
+}
+async function _sync() {
+  const results = [];
+  for (let i = 0; i < PROBES; i++) {
+    const r = await _probe();
+    if (r) results.push(r);
+  }
+  if (results.length === 0) {
+    return;
+  }
+  results.sort((a, b) => a.rtt - b.rtt);
+  _clientToServerOffset = results[0].offset;
+  _providerOffset = results[0].providerOffset;
+  console.log(
+    `[serverClock] clientToServer=${_clientToServerOffset > 0 ? "+" : ""}${Math.round(_clientToServerOffset)}ms providerOffset=${_providerOffset > 0 ? "+" : ""}${Math.round(_providerOffset)}ms rtt=${results[0].rtt}ms (${results.length}/${PROBES} probes ok)`
+  );
+}
+
 // src/core/Chart.ts
-var _TF_SECONDS = {
-  "1s": 1,
-  "5s": 5,
-  "10s": 10,
-  "30s": 30,
-  "1m": 60,
-  "3m": 180,
-  "5m": 300,
-  "15m": 900,
-  "30m": 1800,
-  "1h": 3600,
-  "2h": 7200,
-  "4h": 14400,
-  "6h": 21600,
-  "12h": 43200,
-  "1d": 86400,
-  "3d": 259200,
-  "1w": 604800,
-  "1M": 2592e3
-};
 function _tfToSeconds(tf) {
-  return _TF_SECONDS[tf] ?? 3600;
+  return parseTfSeconds(tf) ?? 3600;
 }
 function _formatLastPrice(price) {
   const decimals = price < 1 ? 6 : price < 1e3 ? 4 : 2;
@@ -2569,6 +2725,20 @@ function _formatCountdown(secs) {
   if (h > 0) return `${h}:${String(m).padStart(2, "0")}:${String(s).padStart(2, "0")}`;
   return `${m}:${String(s).padStart(2, "0")}`;
 }
+function _orderRoleLabel(role) {
+  switch (role) {
+    case "stop_loss":
+      return "SL";
+    case "take_profit":
+      return "TP";
+    case "limit":
+      return "LMT";
+    case "stop":
+      return "STP";
+    default:
+      return "";
+  }
+}
 var Chart = class {
   _container;
   _options;
@@ -2577,6 +2747,9 @@ var Chart = class {
   _gridLayer;
   _seriesLayer;
   _overlayLayer;
+  /** Dedicated layer for the crosshair — rendered synchronously on every
+   * mousemove so there is zero rAF-frame lag between the pointer and the cross. */
+  _crosshairLayer;
   _timeScale;
   _priceScale;
   _transform;
@@ -2603,6 +2776,9 @@ var Chart = class {
   _drawingCursorPt = null;
   /** When false the crosshair is suppressed (e.g. Arrow/cursor mode). */
   _crosshairEnabled = true;
+  // ── Trading overlay ───────────────────────────────────────────────────────────
+  /** Current set of order lines supplied by TChart for canvas rendering. */
+  _tradingOrders = [];
   /** Called whenever a drawing is committed (created or updated). */
   onDrawingCommitted;
   /** Called whenever a drawing is deleted. */
@@ -2626,6 +2802,7 @@ var Chart = class {
     this._gridLayer = new CanvasLayer(container, { width, height, dpr, zIndex: 1 });
     this._seriesLayer = new CanvasLayer(container, { width, height, dpr, zIndex: 2 });
     this._overlayLayer = new CanvasLayer(container, { width, height, dpr, zIndex: 3 });
+    this._crosshairLayer = new CanvasLayer(container, { width, height, dpr, zIndex: 4 });
     this._timeScale = new TimeScale(this._gridLayer, this._colors, this._options.timeScale);
     this._priceScale = new PriceScale(this._gridLayer, this._colors, this._options.priceScale);
     this._transform = new CoordTransform(
@@ -2657,19 +2834,20 @@ var Chart = class {
         },
         onCrosshairMove: (x, y) => {
           if (!this._crosshairEnabled) return;
-          const { x: snappedX, time: snappedTime } = this._snapXToBar(x);
+          const { x: snappedX, time: snappedTime } = this.snapXToBar(x);
           this._crosshair.update(snappedX, y, snappedTime);
-          this._dirty = true;
+          this._renderCrosshairNow();
         },
         onCrosshairHide: () => {
           this._crosshair.hide();
-          this._dirty = true;
+          this._renderCrosshairNow();
         },
         onKeyAction: (action) => {
           this._handleKeyAction(action);
         },
         onFitContent: () => {
-          this.scrollToEnd();
+          this.fitDefaultView();
+          this._dirty = true;
         },
         onPriceScaleZoom: (factor, originY) => {
           this._priceScaleManual = true;
@@ -2808,9 +2986,11 @@ var Chart = class {
     this._gridLayer.resize(width, height, dpr);
     this._seriesLayer.resize(width, height, dpr);
     this._overlayLayer.resize(width, height, dpr);
+    this._crosshairLayer.resize(width, height, dpr);
     this._transform.update(width, height);
     this._dirty = true;
     this._render();
+    this._renderCrosshairNow();
   }
   destroy() {
     if (this._animationFrame !== null) cancelAnimationFrame(this._animationFrame);
@@ -2819,6 +2999,7 @@ var Chart = class {
     this._gridLayer.destroy();
     this._seriesLayer.destroy();
     this._overlayLayer.destroy();
+    this._crosshairLayer.destroy();
     this._crosshair.destroy();
     this._plugins.forEach((p) => p.onDetach());
     this._series = [];
@@ -2845,6 +3026,18 @@ var Chart = class {
     this._renderOverlay();
     this._plugins.forEach((p) => p.onRender());
   }
+  /**
+   * Clears and redraws only the crosshair canvas layer.
+   * Called synchronously inside the mousemove handler — bypassing the
+   * dirty-flag / rAF queue — so the crosshair has zero frame lag relative
+   * to the actual pointer position.
+   */
+  _renderCrosshairNow() {
+    const ctx = this._crosshairLayer.context;
+    const { width, height } = this._crosshairLayer;
+    ctx.clearRect(0, 0, width, height);
+    this._crosshair.render(ctx, width, height);
+  }
   _renderGrid() {
     const ctx = this._gridLayer.context;
     const { width, height } = this._gridLayer;
@@ -2878,16 +3071,17 @@ var Chart = class {
     const ctx = this._overlayLayer.context;
     const { width, height } = this._overlayLayer;
     ctx.clearRect(0, 0, width, height);
+    this._renderTradingOrders(ctx);
     const selectedId = this._interaction.selectedDrawingId;
     const candles = this._series[0]?.data() ?? [];
     this._drawingMgr.render(ctx, this._transform, selectedId, this._interval, candles);
     this._interaction.setDrawings(this._drawingMgr.all());
+    this._interaction.setBars(candles);
     if (this._drawingTool !== null && this._drawingCursorPt !== null) {
       const draft = this._buildDraftPreview();
       if (draft) this._drawingMgr.renderPreview(ctx, this._transform, draft, this._interval, candles);
     }
     this._renderLastPriceLine(ctx);
-    this._crosshair.render(ctx, width, height);
   }
   // ─── Private helpers ─────────────────────────────────────────────────────────
   /**
@@ -2895,7 +3089,8 @@ var Chart = class {
    * If no bars are loaded, or the nearest bar is more than SNAP_PX pixels away,
    * returns the original x so the crosshair always renders at the cursor position.
    */
-  _snapXToBar(x) {
+  /** Snap a pixel x-coordinate to the nearest bar center. Public so it can be used by PointerOverlay. */
+  snapXToBar(x) {
     const SNAP_PX = 20;
     let times = null;
     for (const s of this._series) {
@@ -2955,7 +3150,8 @@ var Chart = class {
         this._transform.zoomTime(zf, cx);
         break;
       case "scrollToEnd":
-        this._scrollToLatestBar();
+        this.fitDefaultView();
+        this._dirty = true;
         break;
       case "scrollToStart":
         break;
@@ -3018,12 +3214,11 @@ var Chart = class {
     ctx.stroke();
     ctx.setLineDash([]);
     const tfSecs = _tfToSeconds(this._interval);
-    const now = Math.floor(Date.now() / 1e3);
-    const remaining = lastBar.time + tfSecs - now;
-    const showCd = remaining > 0 && remaining <= tfSecs;
+    const now = Math.floor(exchangeNow() / 1e3);
+    const remaining = tfSecs - now % tfSecs;
     const priceLabel = _formatLastPrice(price);
     const lineH = 15;
-    const boxH = showCd ? lineH * 2 + 1 : lineH;
+    const boxH = lineH * 2 + 1 ;
     const boxY = y - lineH / 2;
     ctx.fillStyle = lineColor;
     ctx.fillRect(plotWidth, boxY, psWidth, boxH);
@@ -3032,13 +3227,57 @@ var Chart = class {
     ctx.textBaseline = "middle";
     ctx.font = "bold 11px system-ui, sans-serif";
     ctx.fillText(priceLabel, plotWidth + 5, boxY + lineH / 2);
-    if (showCd) {
+    {
       ctx.font = "10px system-ui, sans-serif";
       ctx.fillStyle = "rgba(255,255,255,0.85)";
       ctx.fillText(_formatCountdown(remaining), plotWidth + 5, boxY + lineH + 1 + lineH / 2);
     }
     ctx.restore();
   }
+  /** Provides the overlay renderer with the latest order list from TChart. */
+  setTradingOrders(orders) {
+    this._tradingOrders = orders;
+  }
+  /** Renders active order lines above the series but below chart drawings. */
+  _renderTradingOrders(ctx) {
+    if (this._tradingOrders.length === 0) return;
+    const plotWidth = this._transform.plotWidth;
+    const plotHeight = this._transform.plotHeight;
+    const psWidth = this._transform.priceScaleWidth;
+    ctx.save();
+    ctx.font = "bold 10px system-ui, sans-serif";
+    ctx.textBaseline = "middle";
+    ctx.textAlign = "left";
+    for (const order of this._tradingOrders) {
+      if (order.status === "cancelled" || order.status === "rejected" || order.status === "expired" || order.status === "filled") continue;
+      const y = this._transform.priceToY(order.price);
+      if (y < 0 || y > plotHeight) continue;
+      const isBuy = order.side === "buy";
+      const isPending = order.status === "pending";
+      const color = isBuy ? "#26a641" : "#f85149";
+      ctx.beginPath();
+      ctx.strokeStyle = color;
+      ctx.lineWidth = 1;
+      ctx.globalAlpha = isPending ? 0.6 : 1;
+      ctx.setLineDash(isPending ? [4, 4] : []);
+      ctx.moveTo(0, y);
+      ctx.lineTo(plotWidth, y);
+      ctx.stroke();
+      ctx.setLineDash([]);
+      ctx.globalAlpha = 1;
+      const roleLabel = _orderRoleLabel(order.role);
+      const label = roleLabel ? `${roleLabel} ${order.qty}` : `${order.side.toUpperCase()} ${order.qty}`;
+      const lineH = 15;
+      const boxY = y - lineH / 2;
+      ctx.globalAlpha = isPending ? 0.6 : 1;
+      ctx.fillStyle = color;
+      ctx.fillRect(plotWidth, boxY, psWidth, lineH);
+      ctx.globalAlpha = 1;
+      ctx.fillStyle = "#ffffff";
+      ctx.fillText(label, plotWidth + 4, y);
+    }
+    ctx.restore();
+  }
   /** Pans the viewport so the latest bar sits near the right edge. */
   _scrollToLatestBar() {
     let latestTime = -Infinity;
@@ -3069,6 +3308,7 @@ var Chart = class {
     this._priceScale.setVisibleRange(v.priceRange);
     this._priceScaleManual = true;
     this._dirty = true;
+    this.onViewportChanged?.();
   }
   /**
    * Clears the manual-price-scale flag so the price axis returns to auto-fit mode.
@@ -3100,6 +3340,7 @@ var Chart = class {
     });
     this._priceScaleManual = false;
     this._dirty = true;
+    this.onViewportChanged?.();
   }
   // ─── Drawing tool API ──────────────────────────────────────────────────────
   /** Returns the DrawingManager owned by this chart. */
@@ -3153,6 +3394,10 @@ var Chart = class {
   setNativeCursorHidden(hidden) {
     this._interaction.setHideCursor(hidden);
   }
+  /** Feed overlay indicator polylines for hit-testing. */
+  setIndicatorLines(lines) {
+    this._interaction.setIndicatorLines(lines);
+  }
   /** Deletes the currently selected drawing (if any). */
   deleteSelectedDrawing() {
     const id = this._interaction.selectedDrawingId;
@@ -3518,58 +3763,6 @@ var PaneManager = class {
   }
 };
 
-// ../shared/src/time/timeframeRegistry.ts
-var TIMEFRAMES = {
-  // ── Sub-hour ──────────────────────────────────────────────────────────────
-  "1m": { key: "1m", kind: "fixed", ms: 6e4 },
-  "2m": { key: "2m", kind: "fixed", ms: 12e4 },
-  "3m": { key: "3m", kind: "fixed", ms: 18e4 },
-  "4m": { key: "4m", kind: "fixed", ms: 24e4 },
-  "5m": { key: "5m", kind: "fixed", ms: 3e5 },
-  "10m": { key: "10m", kind: "fixed", ms: 6e5 },
-  "15m": { key: "15m", kind: "fixed", ms: 9e5 },
-  "20m": { key: "20m", kind: "fixed", ms: 12e5 },
-  "30m": { key: "30m", kind: "fixed", ms: 18e5 },
-  "45m": { key: "45m", kind: "fixed", ms: 27e5 },
-  // ── Hourly ────────────────────────────────────────────────────────────────
-  "1h": { key: "1h", kind: "fixed", ms: 36e5 },
-  "2h": { key: "2h", kind: "fixed", ms: 72e5 },
-  "4h": { key: "4h", kind: "fixed", ms: 144e5 },
-  "6h": { key: "6h", kind: "fixed", ms: 216e5 },
-  "12h": { key: "12h", kind: "fixed", ms: 432e5 },
-  // ── Daily ─────────────────────────────────────────────────────────────────
-  "1d": { key: "1d", kind: "fixed", ms: 864e5 },
-  "3d": { key: "3d", kind: "fixed", ms: 2592e5 },
-  // ── Calendar — MUST NOT have a fixed ms value ──────────────────────────
-  "1w": { key: "1w", kind: "calendar_week" },
-  "1M": { key: "1M", kind: "calendar_month" }
-};
-
-// ../shared/src/time/timeUtils.ts
-var MONDAY_EPOCH_OFFSET_MS = 3456e5;
-var WEEK_MS = 6048e5;
-function timeframeToMs(tf) {
-  const def = TIMEFRAMES[tf];
-  if (!def || def.kind !== "fixed") return null;
-  return def.ms;
-}
-function getBucketStart(timeMs, timeframe) {
-  const def = TIMEFRAMES[timeframe];
-  if (!def) {
-    return Math.floor(timeMs / 6e4) * 6e4;
-  }
-  if (def.kind === "calendar_week") return getWeekBucketStart(timeMs);
-  if (def.kind === "calendar_month") return getMonthBucketStart(timeMs);
-  return Math.floor(timeMs / def.ms) * def.ms;
-}
-function getWeekBucketStart(timeMs) {
-  return Math.floor((timeMs - MONDAY_EPOCH_OFFSET_MS) / WEEK_MS) * WEEK_MS + MONDAY_EPOCH_OFFSET_MS;
-}
-function getMonthBucketStart(timeMs) {
-  const d = new Date(timeMs);
-  return Date.UTC(d.getUTCFullYear(), d.getUTCMonth(), 1);
-}
-
 // src/engine/timeframeUtils.ts
 function timeframeToMs2(timeframe) {
   return timeframeToMs(timeframe) ?? 6e4;
@@ -3923,51 +4116,12 @@ var CandleEngine = class {
 function toOHLCV(bar) {
   return { time: bar.time, open: bar.open, high: bar.high, low: bar.low, close: bar.close, volume: bar.volume };
 }
-var HISTORY_WINDOWS = {
-  // Sub-hour: small display window; DB fills 12 months in background for scrollback.
-  "1m": 3 * 24 * 3600,
-  //   3 days  → ~4 320 bars
-  "3m": 7 * 24 * 3600,
-  //   7 days  → ~3 360 bars
-  "5m": 10 * 24 * 3600,
-  //  10 days  → ~2 880 bars
-  "15m": 30 * 24 * 3600,
-  //  30 days  → ~2 880 bars
-  "30m": 60 * 24 * 3600,
-  //  60 days  → ~2 880 bars
-  "1h": 90 * 24 * 3600,
-  //  90 days  → ~2 160 bars
-  // 4h and above: 12 months — bar counts are small enough to load in full.
-  "2h": 365 * 86400,
-  // 12 months → ~4 380 bars
-  "4h": 365 * 86400,
-  // 12 months → ~2 190 bars
-  "6h": 365 * 86400,
-  // 12 months → ~1 460 bars
-  "12h": 365 * 86400,
-  // 12 months →   ~730 bars
-  "1d": 365 * 86400,
-  // 12 months →   ~365 bars
-  "3d": 365 * 86400,
-  // 12 months →   ~122 bars
-  "1w": 365 * 86400,
-  // 12 months →    ~52 bars
-  "1M": 365 * 86400
-  // 12 months →    ~12 bars
-};
-var DEFAULT_HISTORY_WINDOW = 90 * 24 * 3600;
-var PAGE_SIZES = {
-  "1m": 500 * 60,
-  "5m": 500 * 300,
-  "15m": 500 * 900,
-  "30m": 500 * 1800,
-  "1h": 500 * 3600,
-  "4h": 500 * 4 * 3600,
-  "1d": 500 * 86400,
-  "1w": 500 * 7 * 86400,
-  "1M": 500 * 30 * 86400
-};
-var DEFAULT_PAGE_SIZE = 500 * 3600;
+function _historyWindow(tf) {
+  return 500 * (parseTfSeconds(tf) ?? 3600);
+}
+function _pageSize(tf) {
+  return 500 * (parseTfSeconds(tf) ?? 3600);
+}
 var _uidCounter = 0;
 var DatafeedConnector = class {
   _datafeed;
@@ -3997,12 +4151,13 @@ var DatafeedConnector = class {
    */
   connect(symbol, timeframe) {
     if (this._destroyed) return;
+    if (!symbol) return;
     this._cancelActive();
     const uid = `forgecharts-${symbol}-${timeframe}-${++_uidCounter}`;
     this._activeUID = uid;
     this._cb.onLoading(symbol, timeframe);
     const to = Math.floor(Date.now() / 1e3);
-    const from = to - (HISTORY_WINDOWS[timeframe] ?? DEFAULT_HISTORY_WINDOW);
+    const from = to - _historyWindow(timeframe);
     const engine = new CandleEngine({
       // Every live tick mutates the engine's bar array and the chart series.
       onBarUpdated: (bar) => {
@@ -4089,7 +4244,7 @@ var DatafeedConnector = class {
     if (!oldest) return;
     const uid = this._activeUID;
     const to = Math.floor(oldest.timeMs / 1e3);
-    const page = PAGE_SIZES[timeframe] ?? DEFAULT_PAGE_SIZE;
+    const page = _pageSize(timeframe);
     const from = to - page;
     this._isLoadingMore = true;
     this._datafeed.getHistoricalBars(symbol, timeframe, from, to - 1).then(({ bars }) => {
@@ -4334,6 +4489,9 @@ var LicenseManager = class _LicenseManager {
   }
 };
 
+// src/licensing/licenseTypes.ts
+var TRADING_TIERS = /* @__PURE__ */ new Set(["trading", "dom"]);
+
 // src/licensing/ChartRuntimeResolver.ts
 var ChartRuntimeResolver = class _ChartRuntimeResolver {
   static instance = null;
@@ -4385,33 +4543,45 @@ var ChartRuntimeResolver = class _ChartRuntimeResolver {
   /**
    * Built-in order entry UI hooks.
    * Requires managed mode AND the `orderEntry` feature flag (or no flag restriction).
+   * When a tier is present on the license, the tier must be 'trading' or 'dom'.
    */
   canUseOrderEntry() {
     if (this.isUnmanagedMode()) return false;
+    const tier = this.lm.getLicense()?.tier;
+    if (tier && !TRADING_TIERS.has(tier)) return false;
     return this.#featureOrDefault("orderEntry", true);
   }
   /**
    * Managed trading service hooks (broker execution, position management).
    * Requires managed mode AND the `managedTrading` feature flag (or no flag restriction).
+   * When a tier is present on the license, the tier must be 'trading' or 'dom'.
    */
   canUseManagedTrading() {
     if (this.isUnmanagedMode()) return false;
+    const tier = this.lm.getLicense()?.tier;
+    if (tier && !TRADING_TIERS.has(tier)) return false;
     return this.#featureOrDefault("managedTrading", true);
   }
   /**
    * Drag-to-price order placement.
    * Requires managed mode AND the `draggableOrders` feature flag (or no flag restriction).
+   * When a tier is present on the license, the tier must be 'trading' or 'dom'.
    */
   canUseDraggableOrders() {
     if (this.isUnmanagedMode()) return false;
+    const tier = this.lm.getLicense()?.tier;
+    if (tier && !TRADING_TIERS.has(tier)) return false;
     return this.#featureOrDefault("draggableOrders", true);
   }
   /**
    * Bracket / OCO order support.
    * Requires managed mode AND the `bracketOrders` feature flag (or no flag restriction).
+   * When a tier is present on the license, the tier must be 'trading' or 'dom'.
    */
   canUseBracketOrders() {
     if (this.isUnmanagedMode()) return false;
+    const tier = this.lm.getLicense()?.tier;
+    if (tier && !TRADING_TIERS.has(tier)) return false;
     return this.#featureOrDefault("bracketOrders", true);
   }
   // ── UI render capability checks ──────────────────────────────────────────────
@@ -4902,26 +5072,6 @@ var ManagedTradingController = class {
 };
 
 // src/api/TChart.ts
-var _TF_SECS = {
-  "1s": 1,
-  "5s": 5,
-  "10s": 10,
-  "30s": 30,
-  "1m": 60,
-  "3m": 180,
-  "5m": 300,
-  "15m": 900,
-  "30m": 1800,
-  "1h": 3600,
-  "2h": 7200,
-  "4h": 14400,
-  "6h": 21600,
-  "12h": 43200,
-  "1d": 86400,
-  "3d": 259200,
-  "1w": 604800,
-  "1M": 2592e3
-};
 var TChart = class {
   _core;
   _bus;
@@ -4999,9 +5149,14 @@ var TChart = class {
     };
     this._series = this._core.addSeries({ type: "candlestick" });
     this._core.setInterval(this._interval);
+    this._core.setTradingOrders(this._overlayStore.getOrders());
+    this._overlayStore.onChange(() => {
+      this._core.setTradingOrders(this._overlayStore.getOrders());
+      this._core.markDirty();
+    });
     if (config.datafeed !== void 0) {
       this._connector = this._buildConnector(config.datafeed);
-      this._connector.connect(this._symbol, this._interval);
+      if (this._symbol) this._connector.connect(this._symbol, this._interval);
     }
     this._core.onViewportChanged = () => {
       const connector = this._connector;
@@ -5009,9 +5164,9 @@ var TChart = class {
       const bars = this._series.data();
       if (bars.length === 0) return;
       const oldestBarTime = bars[0].time;
-      const { from } = this._core.getViewport().timeRange;
-      const tfSec = _TF_SECS[this._interval] ?? 3600;
-      if (from < oldestBarTime + tfSec * 30) {
+      const { from, to } = this._core.getViewport().timeRange;
+      const visibleSpan = to - from;
+      if (from <= oldestBarTime + visibleSpan * 0.75) {
         connector.loadMoreHistory(this._symbol, this._interval);
       }
     };
@@ -5093,7 +5248,7 @@ var TChart = class {
     if (symbol === this._symbol) return;
     this._symbol = symbol;
     this._bus.emit("symbolChanged", { symbol });
-    this._connector?.reconnect(symbol, this._interval);
+    if (symbol) this._connector?.reconnect(symbol, this._interval);
   }
   /**
    * Changes the active interval.
@@ -5268,6 +5423,16 @@ var TChart = class {
     this._assertAlive();
     this._core.setNativeCursorHidden(hidden);
   }
+  /** Feed overlay indicator polylines for hit-testing. */
+  setIndicatorLines(lines) {
+    this._assertAlive();
+    this._core.setIndicatorLines(lines);
+  }
+  /** Snap a pixel x-coordinate to the nearest bar center (for pointer overlay snapping). */
+  snapXToBar(x) {
+    this._assertAlive();
+    return this._core.snapXToBar(x);
+  }
   /** Deletes the currently selected drawing (if any). */
   deleteSelectedDrawing() {
     this._assertAlive();
@@ -5903,7 +6068,7 @@ function computeWMAFromSeries(input, period) {
   return result;
 }
 
-// src/tscript/series.ts
+// src/forgescript/series.ts
 var Series2 = class {
   _buf;
   _cap;
@@ -5969,6 +6134,51 @@ var Lexer = class {
     this._src = src;
   }
   tokenize() {
+    const raw = this._rawTokenize();
+    return this._injectIndents(raw);
+  }
+  // ─── INDENT/DEDENT injection ──────────────────────────────────────────────
+  /** After each NEWLINE, inject INDENT/DEDENT tokens based on the indentation
+   *  of the following non-blank line. Enables indented if/else blocks. */
+  _injectIndents(raw) {
+    const out = [];
+    const indentStack = [0];
+    let i = 0;
+    while (i < raw.length) {
+      const tok = raw[i];
+      if (tok.kind !== "NEWLINE") {
+        out.push(tok);
+        i++;
+        continue;
+      }
+      out.push(tok);
+      i++;
+      while (i < raw.length && raw[i].kind === "NEWLINE") {
+        out.push(raw[i]);
+        i++;
+      }
+      if (i >= raw.length || raw[i].kind === "EOF") break;
+      const nextTok = raw[i];
+      const spaces = nextTok.col - 1;
+      const currentIndent = indentStack[indentStack.length - 1];
+      if (spaces > currentIndent) {
+        indentStack.push(spaces);
+        out.push({ kind: "INDENT", value: "", line: nextTok.line, col: 1 });
+      } else {
+        while (spaces < indentStack[indentStack.length - 1]) {
+          indentStack.pop();
+          out.push({ kind: "DEDENT", value: "", line: nextTok.line, col: 1 });
+        }
+      }
+    }
+    while (indentStack.length > 1) {
+      indentStack.pop();
+      out.push({ kind: "DEDENT", value: "", line: 0, col: 0 });
+    }
+    out.push({ kind: "EOF", value: "", line: this._line, col: this._col });
+    return out;
+  }
+  _rawTokenize() {
     const tokens = [];
     while (this._pos < this._src.length) {
       this._skipWhitespaceAndComments();
@@ -5993,7 +6203,23 @@ var Lexer = class {
         tokens.push(this._readIdent());
         continue;
       }
+      if (ch === "#") {
+        tokens.push(this._readColor());
+        continue;
+      }
       const two = this._src.slice(this._pos, this._pos + 2);
+      if (two === ":=") {
+        tokens.push(this._make("COLONEQ", two));
+        this._pos += 2;
+        this._col += 2;
+        continue;
+      }
+      if (two === "=>") {
+        tokens.push(this._make("ARROW", two));
+        this._pos += 2;
+        this._col += 2;
+        continue;
+      }
       if (two === "<=") {
         tokens.push(this._make("LTE", two));
         this._pos += 2;
@@ -6028,6 +6254,7 @@ var Lexer = class {
         ">": "GT",
         "?": "QMARK",
         ":": "COLON",
+        ".": "DOT",
         "(": "LPAREN",
         ")": "RPAREN",
         "[": "LBRACKET",
@@ -6041,7 +6268,7 @@ var Lexer = class {
         this._col++;
         continue;
       }
-      throw new SyntaxError(`[TScript] Unexpected character '${ch}' at ${this._line}:${this._col}`);
+      throw new SyntaxError(`[ForgeScript] Unexpected character '${ch}' at ${this._line}:${this._col}`);
     }
     tokens.push(this._make("EOF", ""));
     return tokens;
@@ -6124,14 +6351,31 @@ var Lexer = class {
     }
     return { kind: "IDENT", value: name, line: this._line, col: startCol };
   }
+  _readColor() {
+    const startCol = this._col;
+    this._pos++;
+    this._col++;
+    let hex = "#";
+    while (this._pos < this._src.length && this._isHex(this._src[this._pos])) {
+      hex += this._src[this._pos];
+      this._pos++;
+      this._col++;
+    }
+    if (hex.length !== 4 && hex.length !== 7 && hex.length !== 9) {
+      throw new SyntaxError(`[ForgeScript] Invalid color literal '${hex}' at ${this._line}:${startCol}`);
+    }
+    return { kind: "COLOR", value: hex, line: this._line, col: startCol };
+  }
+  _isHex(ch) {
+    return ch >= "0" && ch <= "9" || ch >= "a" && ch <= "f" || ch >= "A" && ch <= "F";
+  }
 };
 
-// src/tscript/parser.ts
+// src/forgescript/parser.ts
 var Parser = class {
   _tokens;
   _pos = 0;
   constructor(src) {
-    this._tokens = new Lexer(src).tokenize().filter((t) => t.kind !== "NEWLINE" || this._isStatementBoundary(t));
     this._tokens = this._collapseNewlines(new Lexer(src).tokenize());
   }
   parse() {
@@ -6145,21 +6389,83 @@ var Parser = class {
   }
   // ─── Statements ─────────────────────────────────────────────────────────────
   _stmt() {
+    if (this._checkIdent("if")) {
+      return this._ifStmt();
+    }
+    if (this._checkIdent("while")) {
+      return this._whileStmt();
+    }
+    if (this._checkIdent("for")) {
+      return this._forStmt();
+    }
+    if (this._checkIdent("var") || this._checkIdent("varip")) {
+      return this._varDeclStmt();
+    }
     if (this._checkIdent("indicator")) {
       return this._indicatorDecl();
     }
+    if (this._check("IDENT") && this._peekKind(1) === "LPAREN" && this._isFnDecl()) {
+      return this._fnDeclStmt();
+    }
     if (this._check("IDENT") && this._peekKind(1) === "EQ") {
       return this._assign();
     }
+    if (this._check("IDENT") && this._peekKind(1) === "COLONEQ") {
+      return this._reassign();
+    }
     return this._exprStmt();
   }
   _indicatorDecl() {
     this._consumeIdent("indicator");
     this._consume("LPAREN", "Expected '(' after 'indicator'");
     const title = this._consume("STRING", "Expected string title in indicator()").value;
-    this._consume("RPAREN", "Expected ')' after indicator title");
+    const namedArgs = /* @__PURE__ */ new Map();
+    while (this._match("COMMA")) {
+      if (this._check("IDENT") && this._peekKind(1) === "EQ") {
+        const key = this._consume("IDENT", "Expected named arg").value;
+        this._consume("EQ", "Expected '='");
+        namedArgs.set(key, this._expr());
+      } else {
+        this._expr();
+      }
+    }
+    this._consume("RPAREN", "Expected ')' after indicator args");
+    this._consumeNewlineOrEOF();
+    return { kind: "IndicatorDecl", title, namedArgs };
+  }
+  _varDeclStmt() {
+    const modifier = this._consume("IDENT", "Expected 'var' or 'varip'").value;
+    if (this._check("IDENT") && this._peekKind(1) === "IDENT") {
+      this._advance();
+    }
+    const name = this._consume("IDENT", "Expected variable name after var/varip").value;
+    this._consume("EQ", "Expected '=' in var declaration");
+    const value = this._expr();
+    this._consumeNewlineOrEOF();
+    return { kind: "VarDeclStmt", modifier, name, value };
+  }
+  _reassign() {
+    const name = this._consume("IDENT", "Expected identifier").value;
+    this._consume("COLONEQ", "Expected ':='");
+    const value = this._expr();
+    this._consumeNewlineOrEOF();
+    return { kind: "ReassignStmt", name, value };
+  }
+  _forStmt() {
+    this._consumeIdent("for");
+    const name = this._consume("IDENT", "Expected loop variable after 'for'").value;
+    this._consume("EQ", "Expected '=' after loop variable");
+    const start = this._expr();
+    this._consumeIdent("to");
+    const end = this._expr();
+    let step = null;
+    if (this._checkIdent("by")) {
+      this._advance();
+      step = this._expr();
+    }
     this._consumeNewlineOrEOF();
-    return { kind: "IndicatorDecl", title };
+    const body = this._indentedBlock();
+    return { kind: "ForStmt", name, start, end, step, body };
   }
   _assign() {
     const name = this._consume("IDENT", "Expected identifier").value;
@@ -6173,6 +6479,75 @@ var Parser = class {
     this._consumeNewlineOrEOF();
     return { kind: "ExprStmt", expr };
   }
+  _ifStmt() {
+    this._consumeIdent("if");
+    const condition = this._expr();
+    this._consumeNewlineOrEOF();
+    const then = this._indentedBlock();
+    let else_ = [];
+    if (this._checkIdent("else")) {
+      this._advance();
+      this._consumeNewlineOrEOF();
+      else_ = this._indentedBlock();
+    }
+    return { kind: "IfStmt", condition, then, else_ };
+  }
+  _whileStmt() {
+    this._consumeIdent("while");
+    const condition = this._expr();
+    this._consumeNewlineOrEOF();
+    const body = this._indentedBlock();
+    return { kind: "WhileStmt", condition, body };
+  }
+  /** Lookahead: is this IDENT '(' ... ')' '=>'? Scans without consuming. */
+  _isFnDecl() {
+    let depth = 0;
+    let i = this._pos + 1;
+    while (i < this._tokens.length) {
+      const k = this._tokens[i].kind;
+      if (k === "LPAREN") depth++;
+      else if (k === "RPAREN") {
+        depth--;
+        if (depth === 0) break;
+      } else if (k === "EOF" || k === "NEWLINE") return false;
+      i++;
+    }
+    return i + 1 < this._tokens.length && this._tokens[i + 1].kind === "ARROW";
+  }
+  /** Parse: name(p1, p2, ...) => expr  OR  name(p1, p2, ...) =>\n  block */
+  _fnDeclStmt() {
+    const name = this._consume("IDENT", "Expected function name").value;
+    this._consume("LPAREN", "Expected '(' after function name");
+    const params = [];
+    if (!this._check("RPAREN")) {
+      params.push(this._consume("IDENT", "Expected parameter name").value);
+      while (this._match("COMMA")) {
+        params.push(this._consume("IDENT", "Expected parameter name").value);
+      }
+    }
+    this._consume("RPAREN", "Expected ')' after parameters");
+    this._consume("ARROW", "Expected '=>'");
+    if (this._check("NEWLINE") || this._check("EOF")) {
+      this._consumeNewlineOrEOF();
+      const body = this._indentedBlock();
+      return { kind: "FnDeclStmt", name, params, body };
+    }
+    const expr = this._expr();
+    this._consumeNewlineOrEOF();
+    return { kind: "FnDeclStmt", name, params, body: [{ kind: "ExprStmt", expr }] };
+  }
+  _indentedBlock() {
+    const stmts = [];
+    if (!this._check("INDENT")) return stmts;
+    this._advance();
+    this._skipNewlines();
+    while (!this._check("DEDENT") && !this._check("EOF")) {
+      stmts.push(this._stmt());
+      this._skipNewlines();
+    }
+    if (this._check("DEDENT")) this._advance();
+    return stmts;
+  }
   // ─── Expressions ────────────────────────────────────────────────────────────
   _expr() {
     return this._ternary();
@@ -6307,11 +6682,19 @@ var Parser = class {
       const node = { kind: "BoolLit", value: tok.value === "true" };
       return node;
     }
+    if (tok.kind === "COLOR") {
+      this._advance();
+      const node = { kind: "ColorLit", value: tok.value };
+      return node;
+    }
     if (tok.kind === "IDENT" && tok.value === "na") {
       this._advance();
       const node = { kind: "NumberLit", value: NaN };
       return node;
     }
+    if (tok.kind === "IDENT" && this._peekKind(1) === "DOT") {
+      return this._nsCallOrMember();
+    }
     if (tok.kind === "IDENT" && this._peekKind(1) === "LPAREN") {
       return this._callExpr();
     }
@@ -6334,21 +6717,57 @@ var Parser = class {
       return inner;
     }
     throw new SyntaxError(
-      `[TScript] Unexpected token '${tok.value}' (${tok.kind}) at ${tok.line}:${tok.col}`
+      `[ForgeScript] Unexpected token '${tok.value}' (${tok.kind}) at ${tok.line}:${tok.col}`
     );
   }
-  _callExpr() {
+  /** Parse IDENT.IDENT or IDENT.IDENT(args) */
+  _nsCallOrMember() {
+    const ns = this._consume("IDENT", "Expected namespace").value;
+    this._consume("DOT", "Expected '.'");
+    const member = this._consume("IDENT", "Expected member name").value;
+    if (this._check("LPAREN")) {
+      this._advance();
+      const { posArgs, namedArgs } = this._argList();
+      this._consume("RPAREN", "Expected ')'");
+      const node2 = { kind: "NsCallExpr", namespace: ns, fn: member, args: posArgs, namedArgs };
+      return node2;
+    }
+    let node = { kind: "MemberExpr", object: ns, prop: member };
+    while (this._check("LBRACKET")) {
+      this._advance();
+      const index = this._expr();
+      this._consume("RBRACKET", "Expected ']'");
+      const indexNode = { kind: "IndexExpr", series: node, index };
+      node = indexNode;
+    }
+    return node;
+  }
+  _callExpr() {
     const callee = this._consume("IDENT", "Expected function name").value;
     this._consume("LPAREN", "Expected '('");
-    const args = [];
-    if (!this._check("RPAREN")) {
-      args.push(this._expr());
-      while (this._match("COMMA")) {
-        args.push(this._expr());
+    const { posArgs, namedArgs } = this._argList();
+    this._consume("RPAREN", "Expected ')'");
+    return { kind: "CallExpr", callee, args: posArgs, namedArgs };
+  }
+  /** Parse a mixed positional + named argument list. */
+  _argList() {
+    const posArgs = [];
+    const namedArgs = /* @__PURE__ */ new Map();
+    if (this._check("RPAREN")) return { posArgs, namedArgs };
+    const parseArg = () => {
+      if (this._check("IDENT") && this._peekKind(1) === "EQ") {
+        const key = this._consume("IDENT", "Expected named arg").value;
+        this._consume("EQ", "Expected '='");
+        namedArgs.set(key, this._expr());
+      } else {
+        posArgs.push(this._expr());
       }
+    };
+    parseArg();
+    while (this._match("COMMA")) {
+      parseArg();
     }
-    this._consume("RPAREN", "Expected ')'");
-    return { kind: "CallExpr", callee, args };
+    return { posArgs, namedArgs };
   }
   // ─── Utility helpers ────────────────────────────────────────────────────────
   _binop(op, left, right) {
@@ -6380,12 +6799,12 @@ var Parser = class {
   _consume(kind, msg) {
     if (this._check(kind)) return this._advance();
     const t = this._current();
-    throw new SyntaxError(`[TScript] ${msg} \u2014 got '${t.value}' at ${t.line}:${t.col}`);
+    throw new SyntaxError(`[ForgeScript] ${msg} \u2014 got '${t.value}' at ${t.line}:${t.col}`);
   }
   _consumeIdent(name) {
     if (this._checkIdent(name)) return this._advance();
     const t = this._current();
-    throw new SyntaxError(`[TScript] Expected '${name}' \u2014 got '${t.value}' at ${t.line}:${t.col}`);
+    throw new SyntaxError(`[ForgeScript] Expected '${name}' \u2014 got '${t.value}' at ${t.line}:${t.col}`);
   }
   _consumeNewlineOrEOF() {
     if (this._check("NEWLINE") || this._check("EOF")) {
@@ -6415,12 +6834,52 @@ var Parser = class {
   }
 };
 
-// src/tscript/runtime.ts
+// src/forgescript/runtime.ts
+var TArray = class _TArray {
+  items;
+  constructor(items = []) {
+    this.items = items;
+  }
+  size() {
+    return this.items.length;
+  }
+  get(i) {
+    return i >= 0 && i < this.items.length ? this.items[i] : NaN;
+  }
+  set(i, v) {
+    if (i >= 0 && i < this.items.length) this.items[i] = v;
+  }
+  push(v) {
+    this.items.push(v);
+  }
+  pop() {
+    return this.items.length > 0 ? this.items.pop() : NaN;
+  }
+  remove(i) {
+    if (i < 0 || i >= this.items.length) return NaN;
+    return this.items.splice(i, 1)[0];
+  }
+  clear() {
+    this.items.length = 0;
+  }
+  includes(v) {
+    return this.items.includes(v);
+  }
+  indexOf(v) {
+    return this.items.indexOf(v);
+  }
+  slice(start, end) {
+    return new _TArray(this.items.slice(start, end));
+  }
+  join(sep) {
+    return this.items.map(String).join(sep);
+  }
+};
 function _num(v, ctx) {
   if (v instanceof Series2) return v.value;
   if (typeof v === "number") return v;
   if (typeof v === "boolean") return v ? 1 : 0;
-  throw new TypeError(`[TScript] ${ctx}: expected number, got ${typeof v}`);
+  throw new TypeError(`[ForgeScript] ${ctx}: expected number, got ${typeof v}`);
 }
 function _bool(v) {
   if (v instanceof Series2) return !isNaN(v.value) && v.value !== 0;
@@ -6428,11 +6887,31 @@ function _bool(v) {
   if (typeof v === "boolean") return v;
   return Boolean(v);
 }
-var TScriptRuntime = class {
+var ForgeScriptRuntime = class _ForgeScriptRuntime {
   _program;
   _scope = /* @__PURE__ */ new Map();
   _plotSeries = [];
   // one entry per plot() call order
+  _plotMetas = [];
+  _hlines = [];
+  _fills = [];
+  _bgcolors = [];
+  _barcolors = [];
+  _shapes = [];
+  _tables = [];
+  _functions = /* @__PURE__ */ new Map();
+  /** Tracks which vars have been initialized (for var/varip init-once semantics). */
+  _varInitialized = /* @__PURE__ */ new Set();
+  /** varip variables update intra-bar; we track their names to handle them differently. */
+  _varipNames = /* @__PURE__ */ new Set();
+  /** Current bar index for use in output functions. */
+  _barIndex = 0;
+  /** Total number of bars in the current run (for barstate). */
+  _totalBars = 0;
+  /** Current bar for output timestamp. */
+  _currentBar = null;
+  /** Whether this indicator is an overlay. */
+  _overlay = false;
   // Public metadata set by indicator() declaration
   title = "Script";
   constructor(src) {
@@ -6440,6 +6919,8 @@ var TScriptRuntime = class {
     for (const stmt of this._program.stmts) {
       if (stmt.kind === "IndicatorDecl") {
         this.title = stmt.title;
+        const ov = stmt.namedArgs.get("overlay");
+        if (ov && ov.kind === "BoolLit") this._overlay = ov.value;
         break;
       }
     }
@@ -6454,6 +6935,8 @@ var TScriptRuntime = class {
    * @returns the current values of all `plot()` series after this bar.
    */
   execBar(bar, barIndex) {
+    this._currentBar = bar;
+    this._barIndex = barIndex;
     this._pushBuiltin("open", bar.open);
     this._pushBuiltin("high", bar.high);
     this._pushBuiltin("low", bar.low);
@@ -6476,11 +6959,16 @@ var TScriptRuntime = class {
    */
   run(bars) {
     this.reset();
+    this._totalBars = bars.length;
     for (let i = 0; i < bars.length; i++) {
       this.execBar(bars[i], i);
     }
     return this.getPlots(bars);
   }
+  /** Set total bar count for barstate properties (call before execBar loop). */
+  setTotalBars(n) {
+    this._totalBars = n;
+  }
   /**
    * Snapshot the current plot series as IndicatorPoint arrays.
    * Must be called after `run()` or after the last `execBar()`.
@@ -6496,6 +6984,21 @@ var TScriptRuntime = class {
       })).filter((p) => !isNaN(p.value));
     });
   }
+  /** Return the full script result including all output types. */
+  getResult(bars) {
+    return {
+      title: this.title,
+      plots: this.getPlots(bars),
+      plotMetas: this._plotMetas,
+      hlines: this._hlines,
+      fills: this._fills,
+      bgcolors: this._bgcolors,
+      barcolors: this._barcolors,
+      shapes: this._shapes,
+      tables: this._tables,
+      overlay: this._overlay
+    };
+  }
   /** Reset all persistent series state (call on symbol/timeframe change). */
   reset() {
     for (const v of this._scope.values()) {
@@ -6503,6 +7006,17 @@ var TScriptRuntime = class {
     }
     for (const s of this._plotSeries) s.reset();
     this._plotIdx = 0;
+    this._varInitialized.clear();
+    this._internalState.clear();
+    this._hlines.length = 0;
+    this._fills.length = 0;
+    this._bgcolors.length = 0;
+    this._barcolors.length = 0;
+    this._shapes.length = 0;
+    this._tables.length = 0;
+    this._plotMetas.length = 0;
+    this._functions.clear();
+    this._tableCounter = 0;
   }
   // ─── Private: statement execution ───────────────────────────────────────────
   _execStmt(stmt) {
@@ -6510,17 +7024,102 @@ var TScriptRuntime = class {
       case "IndicatorDecl":
         break;
       // handled at construction
+      case "VarDeclStmt":
+        this._execVarDecl(stmt);
+        break;
       case "AssignStmt":
         this._execAssign(stmt);
         break;
+      case "ReassignStmt":
+        this._execReassign(stmt);
+        break;
       case "ExprStmt":
         this._evalExpr(stmt.expr);
         break;
+      case "IfStmt":
+        this._execIf(stmt);
+        break;
+      case "WhileStmt":
+        this._execWhile(stmt);
+        break;
+      case "ForStmt":
+        this._execFor(stmt);
+        break;
+      case "FnDeclStmt":
+        this._functions.set(stmt.name, stmt);
+        break;
+    }
+  }
+  _execIf(stmt) {
+    const branch = _bool(this._evalExpr(stmt.condition)) ? stmt.then : stmt.else_;
+    for (const s of branch) this._execStmt(s);
+  }
+  _execWhile(stmt) {
+    const MAX_ITER = 1e4;
+    let count = 0;
+    while (_bool(this._evalExpr(stmt.condition))) {
+      if (++count > MAX_ITER) {
+        throw new RangeError("[ForgeScript] while loop exceeded 10,000 iterations \u2014 possible infinite loop");
+      }
+      for (const s of stmt.body) this._execStmt(s);
+    }
+  }
+  _execFor(stmt) {
+    const startVal = _num(this._evalExpr(stmt.start), "for start");
+    const endVal = _num(this._evalExpr(stmt.end), "for end");
+    const stepVal = stmt.step ? _num(this._evalExpr(stmt.step), "for step") : 1;
+    if (stepVal === 0) throw new RangeError("[ForgeScript] for loop step cannot be 0");
+    const MAX_ITER = 1e5;
+    let count = 0;
+    for (let i = startVal; stepVal > 0 ? i <= endVal : i >= endVal; i += stepVal) {
+      if (++count > MAX_ITER) {
+        throw new RangeError("[ForgeScript] for loop exceeded 100,000 iterations");
+      }
+      this._scope.set(stmt.name, i);
+      for (const s of stmt.body) this._execStmt(s);
+    }
+  }
+  /** var / varip — only initialize on the first bar (bar_index 0). */
+  _execVarDecl(stmt) {
+    if (stmt.modifier === "varip") this._varipNames.add(stmt.name);
+    if (!this._varInitialized.has(stmt.name)) {
+      this._varInitialized.add(stmt.name);
+      const rhs = this._evalExpr(stmt.value);
+      if (typeof rhs === "number" || rhs instanceof Series2) {
+        const series = new Series2(1e3);
+        series.push(rhs instanceof Series2 ? rhs.value : rhs);
+        this._scope.set(stmt.name, series);
+      } else {
+        this._scope.set(stmt.name, rhs);
+      }
+    } else {
+      const existing = this._scope.get(stmt.name);
+      if (existing instanceof Series2) {
+        existing.push(existing.value);
+      }
+    }
+  }
+  /** := reassignment — variable must already exist. */
+  _execReassign(stmt) {
+    const rhs = this._evalExpr(stmt.value);
+    const existing = this._scope.get(stmt.name);
+    if (existing === void 0) {
+      throw new ReferenceError(`[ForgeScript] Cannot reassign undefined variable '${stmt.name}'`);
+    }
+    if (existing instanceof Series2) {
+      const numVal = _num(rhs, `reassignment to '${stmt.name}'`);
+      existing.push(numVal);
+    } else {
+      this._scope.set(stmt.name, rhs);
     }
   }
   _execAssign(stmt) {
     const rhs = this._evalExpr(stmt.value);
     const existing = this._scope.get(stmt.name);
+    if (rhs instanceof TArray || typeof rhs === "string" && rhs.startsWith("__table_")) {
+      this._scope.set(stmt.name, rhs);
+      return;
+    }
     if (existing instanceof Series2) {
       existing.push(_num(rhs, `assignment to '${stmt.name}'`));
     } else {
@@ -6543,12 +7142,18 @@ var TScriptRuntime = class {
         return expr.value;
       case "BoolLit":
         return expr.value;
+      case "ColorLit":
+        return expr.value;
       case "Identifier":
         return this._evalIdent(expr);
       case "IndexExpr":
         return this._evalIndex(expr);
       case "CallExpr":
         return this._evalCall(expr);
+      case "NsCallExpr":
+        return this._evalNsCall(expr);
+      case "MemberExpr":
+        return this._evalMember(expr);
       case "BinaryExpr":
         return this._evalBinary(expr);
       case "UnaryExpr":
@@ -6562,7 +7167,7 @@ var TScriptRuntime = class {
   _evalIdent(expr) {
     const v = this._scope.get(expr.name);
     if (v === void 0) {
-      throw new ReferenceError(`[TScript] Undefined variable '${expr.name}'`);
+      throw new ReferenceError(`[ForgeScript] Undefined variable '${expr.name}'`);
     }
     return v;
   }
@@ -6570,13 +7175,20 @@ var TScriptRuntime = class {
     const series = this._evalExpr(expr.series);
     const idx = _num(this._evalExpr(expr.index), "series index");
     if (!(series instanceof Series2)) {
-      throw new TypeError("[TScript] Index operator [] can only be applied to a series");
+      throw new TypeError("[ForgeScript] Index operator [] can only be applied to a series");
     }
     return series.get(Math.round(idx));
   }
   _evalBinary(expr) {
-    const l = _num(this._evalExpr(expr.left), `left of '${expr.op}'`);
-    const r = _num(this._evalExpr(expr.right), `right of '${expr.op}'`);
+    const rawL = this._evalExpr(expr.left);
+    const rawR = this._evalExpr(expr.right);
+    if (expr.op === "+" && (typeof rawL === "string" || typeof rawR === "string")) {
+      const ls = rawL instanceof Series2 ? String(rawL.value) : String(rawL);
+      const rs = rawR instanceof Series2 ? String(rawR.value) : String(rawR);
+      return ls + rs;
+    }
+    const l = _num(rawL, `left of '${expr.op}'`);
+    const r = _num(rawR, `right of '${expr.op}'`);
     switch (expr.op) {
       case "+":
         return l + r;
@@ -6614,6 +7226,349 @@ var TScriptRuntime = class {
     if (expr.op === "and") return l ? _bool(this._evalExpr(expr.right)) : false;
     return l ? true : _bool(this._evalExpr(expr.right));
   }
+  // ─── Namespace call dispatch ───────────────────────────────────────────────
+  _evalNsCall(expr) {
+    const { namespace, fn, args } = expr;
+    switch (namespace) {
+      case "ta":
+        return this._evalTaCall(fn, args);
+      case "math":
+        return this._evalMathCall(fn, args);
+      case "color":
+        return this._evalColorCall(fn, args);
+      case "str":
+        return this._evalStrCall(fn, args);
+      case "array":
+        return this._evalArrayCall(fn, args);
+      case "table":
+        return this._evalTableCall(fn, args, expr.namedArgs);
+      case "input":
+        return this._evalInputNsCall(fn, args);
+      default:
+        throw new ReferenceError(`[ForgeScript] Unknown namespace '${namespace}'`);
+    }
+  }
+  _evalTaCall(method, args) {
+    switch (method) {
+      case "sma":
+        return this._ta_sma(args);
+      case "ema":
+        return this._ta_ema(args);
+      case "wma":
+        return this._ta_wma(args);
+      case "rma":
+        return this._ta_rma(args);
+      case "stdev":
+        return this._ta_stdev(args);
+      case "highest":
+        return this._ta_rolling(args, Math.max);
+      case "lowest":
+        return this._ta_rolling(args, Math.min);
+      case "change":
+        return this._ta_change(args);
+      case "mom":
+        return this._ta_change(args);
+      case "atr":
+        return this._ta_atr(args);
+      case "rsi":
+        return this._ta_rsi(args);
+      case "crossover":
+        return this._ta_crossover(args);
+      case "crossunder":
+        return this._ta_crossunder(args);
+      case "cross":
+        return this._ta_cross(args);
+      case "barssince":
+        return this._ta_barssince(args);
+      case "macd":
+        return this._ta_macd(args);
+      case "bb":
+        return this._ta_bb(args);
+      case "stoch":
+        return this._ta_stoch(args);
+      case "obv":
+        return this._ta_obv(args);
+      case "correlation":
+        return this._ta_correlation(args);
+      case "dev":
+        return this._ta_dev(args);
+      case "variance":
+        return this._ta_variance(args);
+      case "cum":
+        return this._ta_cum(args);
+      case "sum":
+        return this._ta_sum(args);
+      case "valuewhen":
+        return this._ta_valuewhen(args);
+      case "pivothigh":
+        return this._ta_pivothigh(args);
+      case "pivotlow":
+        return this._ta_pivotlow(args);
+      case "tr":
+        return this._ta_tr(args);
+      case "swma":
+        return this._ta_swma(args);
+      case "vwma":
+        return this._ta_vwma(args);
+      case "rising":
+        return this._ta_rising(args);
+      case "falling":
+        return this._ta_falling(args);
+      default:
+        throw new ReferenceError(`[ForgeScript] Unknown ta function 'ta.${method}'`);
+    }
+  }
+  _evalMathCall(method, args) {
+    switch (method) {
+      case "abs":
+        return Math.abs(_num(this._evalExpr(args[0]), "math.abs()"));
+      case "round":
+        return Math.round(_num(this._evalExpr(args[0]), "math.round()"));
+      case "floor":
+        return Math.floor(_num(this._evalExpr(args[0]), "math.floor()"));
+      case "ceil":
+        return Math.ceil(_num(this._evalExpr(args[0]), "math.ceil()"));
+      case "sqrt":
+        return Math.sqrt(_num(this._evalExpr(args[0]), "math.sqrt()"));
+      case "log":
+        return Math.log(_num(this._evalExpr(args[0]), "math.log()"));
+      case "log10":
+        return Math.log10(_num(this._evalExpr(args[0]), "math.log10()"));
+      case "sign":
+        return Math.sign(_num(this._evalExpr(args[0]), "math.sign()"));
+      case "exp":
+        return Math.exp(_num(this._evalExpr(args[0]), "math.exp()"));
+      case "pow": {
+        const base = _num(this._evalExpr(args[0]), "math.pow() base");
+        const exp = _num(this._evalExpr(args[1]), "math.pow() exponent");
+        return Math.pow(base, exp);
+      }
+      case "max":
+        return Math.max(...args.map((a) => _num(this._evalExpr(a), "math.max()")));
+      case "min":
+        return Math.min(...args.map((a) => _num(this._evalExpr(a), "math.min()")));
+      case "avg": {
+        const vals = args.map((a) => _num(this._evalExpr(a), "math.avg()"));
+        return vals.reduce((s, v) => s + v, 0) / vals.length;
+      }
+      case "sum": {
+        return args.map((a) => _num(this._evalExpr(a), "math.sum()")).reduce((s, v) => s + v, 0);
+      }
+      case "todegrees":
+        return _num(this._evalExpr(args[0]), "math.todegrees()") * (180 / Math.PI);
+      case "toradians":
+        return _num(this._evalExpr(args[0]), "math.toradians()") * (Math.PI / 180);
+      case "sin":
+        return Math.sin(_num(this._evalExpr(args[0]), "math.sin()"));
+      case "cos":
+        return Math.cos(_num(this._evalExpr(args[0]), "math.cos()"));
+      case "tan":
+        return Math.tan(_num(this._evalExpr(args[0]), "math.tan()"));
+      case "asin":
+        return Math.asin(_num(this._evalExpr(args[0]), "math.asin()"));
+      case "acos":
+        return Math.acos(_num(this._evalExpr(args[0]), "math.acos()"));
+      case "atan":
+        return Math.atan(_num(this._evalExpr(args[0]), "math.atan()"));
+      case "random":
+        return Math.random();
+      default:
+        throw new ReferenceError(`[ForgeScript] Unknown math function 'math.${method}'`);
+    }
+  }
+  _evalColorCall(method, args) {
+    if (method === "new") {
+      const base = String(this._evalExpr(args[0]));
+      const transp = _num(this._evalExpr(args[1]), "color.new() transparency");
+      const alpha = Math.round(255 * (1 - transp / 100));
+      const hex = base.startsWith("#") ? base.slice(0, 7) : base;
+      return hex + alpha.toString(16).padStart(2, "0");
+    }
+    if (method === "rgb") {
+      const r = Math.round(_num(this._evalExpr(args[0]), "color.rgb() r"));
+      const g = Math.round(_num(this._evalExpr(args[1]), "color.rgb() g"));
+      const b = Math.round(_num(this._evalExpr(args[2]), "color.rgb() b"));
+      const t = args.length > 3 ? _num(this._evalExpr(args[3]), "color.rgb() transp") : 0;
+      const a = Math.round(255 * (1 - t / 100));
+      return `#${r.toString(16).padStart(2, "0")}${g.toString(16).padStart(2, "0")}${b.toString(16).padStart(2, "0")}${a.toString(16).padStart(2, "0")}`;
+    }
+    throw new ReferenceError(`[ForgeScript] Unknown color function 'color.${method}'`);
+  }
+  _evalStrCall(method, args) {
+    switch (method) {
+      case "tostring":
+        return String(this._evalExpr(args[0]));
+      case "tonumber": {
+        const v = Number(this._evalExpr(args[0]));
+        return isNaN(v) ? NaN : v;
+      }
+      case "format": {
+        let fmt = String(this._evalExpr(args[0]));
+        for (let i = 1; i < args.length; i++) {
+          fmt = fmt.replace(`{${i - 1}}`, String(this._evalExpr(args[i])));
+        }
+        return fmt;
+      }
+      case "length":
+        return String(this._evalExpr(args[0])).length;
+      case "trim":
+        return String(this._evalExpr(args[0])).trim();
+      case "contains": {
+        const s = String(this._evalExpr(args[0]));
+        const sub = String(this._evalExpr(args[1]));
+        return s.includes(sub);
+      }
+      case "substring": {
+        const s = String(this._evalExpr(args[0]));
+        const start = Math.trunc(Number(this._evalExpr(args[1])));
+        const end = args.length > 2 ? Math.trunc(Number(this._evalExpr(args[2]))) : void 0;
+        return s.substring(start, end);
+      }
+      case "replace_all": {
+        const s = String(this._evalExpr(args[0]));
+        const target = String(this._evalExpr(args[1]));
+        const replacement = String(this._evalExpr(args[2]));
+        return s.split(target).join(replacement);
+      }
+      case "upper":
+        return String(this._evalExpr(args[0])).toUpperCase();
+      case "lower":
+        return String(this._evalExpr(args[0])).toLowerCase();
+      case "split": {
+        const s = String(this._evalExpr(args[0]));
+        const sep = args.length > 1 ? String(this._evalExpr(args[1])) : ",";
+        return new TArray(s.split(sep));
+      }
+      default:
+        throw new ReferenceError(`[ForgeScript] Unknown str function 'str.${method}'`);
+    }
+  }
+  // ─── Member access dispatch ──────────────────────────────────────────────────
+  static _COLOR_MAP = {
+    red: "#FF0000",
+    green: "#00FF00",
+    blue: "#0000FF",
+    white: "#FFFFFF",
+    black: "#000000",
+    yellow: "#FFFF00",
+    orange: "#FF9800",
+    purple: "#9C27B0",
+    aqua: "#00BCD4",
+    lime: "#8BC34A",
+    teal: "#009688",
+    fuchsia: "#E040FB",
+    silver: "#9E9E9E",
+    gray: "#787B86",
+    olive: "#808000",
+    maroon: "#880E4F",
+    navy: "#311B92"
+  };
+  _evalMember(expr) {
+    const { object, prop } = expr;
+    switch (object) {
+      case "color":
+        return _ForgeScriptRuntime._COLOR_MAP[prop] ?? NaN;
+      case "syminfo": {
+        switch (prop) {
+          case "tickerid":
+            return this._scope.get("__syminfo_tickerid") ?? "";
+          case "ticker":
+            return this._scope.get("__syminfo_ticker") ?? "";
+          case "mintick":
+            return this._scope.get("__syminfo_mintick") ?? 0.01;
+          case "pointvalue":
+            return this._scope.get("__syminfo_pointvalue") ?? 1;
+          case "currency":
+            return "USD";
+          case "type":
+            return "stock";
+          default:
+            return NaN;
+        }
+      }
+      case "timeframe": {
+        switch (prop) {
+          case "period":
+            return this._scope.get("__timeframe_period") ?? "1";
+          case "multiplier":
+            return this._scope.get("__timeframe_multiplier") ?? 1;
+          case "isintraday":
+            return true;
+          case "isdaily":
+            return false;
+          case "isweekly":
+            return false;
+          case "ismonthly":
+            return false;
+          default:
+            return NaN;
+        }
+      }
+      // Pine v6 enum-like namespaces — return property name as string
+      case "shape":
+        return prop;
+      // shape.circle → "circle"
+      case "location":
+        return prop;
+      // location.abovebar → "abovebar"
+      case "plot":
+        return prop.replace(/^style_/, "");
+      // plot.style_line → "line"
+      case "math": {
+        switch (prop) {
+          case "pi":
+            return Math.PI;
+          case "e":
+            return Math.E;
+          default:
+            return NaN;
+        }
+      }
+      case "barstate": {
+        switch (prop) {
+          case "islast":
+            return this._totalBars > 0 && this._barIndex === this._totalBars - 1;
+          case "isfirst":
+            return this._barIndex === 0;
+          case "isconfirmed":
+            return true;
+          // historical bars are always confirmed
+          case "isnew":
+            return true;
+          // each bar is "new" in per-bar execution
+          case "isrealtime":
+            return false;
+          // ForgeScript runs on historical data
+          case "ishistory":
+            return true;
+          default:
+            return false;
+        }
+      }
+      case "position":
+        return prop;
+      // position.top_right → "top_right"
+      case "size":
+        return prop;
+      // size.large → "large"
+      case "text": {
+        return prop.replace(/^align_/, "");
+      }
+      case "bar_index":
+        return this._barIndex;
+      case "close":
+      case "open":
+      case "high":
+      case "low":
+      case "volume":
+      case "time": {
+        const v = this._scope.get(object);
+        return v === void 0 ? NaN : v;
+      }
+      default:
+        throw new ReferenceError(`[ForgeScript] Unknown member access '${object}.${prop}'`);
+    }
+  }
   // ─── Built-in function dispatch ──────────────────────────────────────────────
   _plotIdx = 0;
   _evalCall(expr) {
@@ -6621,16 +7576,32 @@ var TScriptRuntime = class {
     const args = expr.args;
     switch (fn) {
       // ── Utility ────────────────────────────────────────────────────────────
-      case "input": {
+      case "input":
+      case "input.text_area":
+      case "input.string": {
         if (args.length === 0) return 0;
         const def = this._evalExpr(args[0]);
-        return typeof def === "string" ? parseFloat(def) || 0 : _num(def, "input()");
+        if (fn === "input.text_area" || fn === "input.string") return typeof def === "string" ? def : String(def);
+        if (typeof def === "string") {
+          const n = parseFloat(def);
+          return isNaN(n) ? def : n;
+        }
+        return _num(def, "input()");
       }
       case "plot": {
         const value = _num(this._evalExpr(args[0]), "plot()");
         const idx = this._plotIdx++;
         if (idx >= this._plotSeries.length) {
           this._plotSeries.push(new Series2(1e3));
+          const na = expr.namedArgs;
+          const title = na?.get("title") ? String(this._evalExpr(na.get("title"))) : `Plot ${idx}`;
+          const color = na?.get("color") ? String(this._evalExpr(na.get("color"))) : void 0;
+          const linewidth = na?.get("linewidth") ? _num(this._evalExpr(na.get("linewidth")), "plot linewidth") : void 0;
+          const style = na?.get("style") ? String(this._evalExpr(na.get("style"))) : "line";
+          const meta = { title, style };
+          if (color !== void 0) meta.color = color;
+          if (linewidth !== void 0) meta.linewidth = linewidth;
+          this._plotMetas.push(meta);
         }
         this._plotSeries[idx].push(value);
         return value;
@@ -6691,14 +7662,74 @@ var TScriptRuntime = class {
         return this._ta_change(args);
       case "atr":
         return this._ta_atr(args);
+      case "rsi":
+        return this._ta_rsi(args);
       case "crossover":
         return this._ta_crossover(args);
       case "crossunder":
         return this._ta_crossunder(args);
+      case "cross":
+        return this._ta_cross(args);
       case "barssince":
         return this._ta_barssince(args);
-      default:
-        throw new ReferenceError(`[TScript] Unknown function '${fn}'`);
+      // New TA functions (flat-call form)
+      case "macd":
+        return this._ta_macd(args);
+      case "bb":
+        return this._ta_bb(args);
+      case "stoch":
+        return this._ta_stoch(args);
+      case "obv":
+        return this._ta_obv(args);
+      case "correlation":
+        return this._ta_correlation(args);
+      case "dev":
+        return this._ta_dev(args);
+      case "variance":
+        return this._ta_variance(args);
+      case "cum":
+        return this._ta_cum(args);
+      case "sum":
+        return this._ta_sum(args);
+      case "valuewhen":
+        return this._ta_valuewhen(args);
+      case "pivothigh":
+        return this._ta_pivothigh(args);
+      case "pivotlow":
+        return this._ta_pivotlow(args);
+      case "tr":
+        return this._ta_tr(args);
+      case "swma":
+        return this._ta_swma(args);
+      case "vwma":
+        return this._ta_vwma(args);
+      case "rising":
+        return this._ta_rising(args);
+      case "falling":
+        return this._ta_falling(args);
+      case "exp":
+        return Math.exp(_num(this._evalExpr(args[0]), "exp()"));
+      // ── Output functions ──────────────────────────────────────────────────
+      case "plotshape":
+        return this._callPlotshape(expr);
+      case "plotchar":
+        return this._callPlotshape(expr);
+      // same output type
+      case "plotarrow":
+        return this._callPlotarrow(expr);
+      case "hline":
+        return this._callHline(expr);
+      case "fill":
+        return this._callFill(expr);
+      case "bgcolor":
+        return this._callBgcolor(expr);
+      case "barcolor":
+        return this._callBarcolor(expr);
+      default: {
+        const fnDecl = this._functions.get(fn);
+        if (fnDecl) return this._callUserFunction(fnDecl, args);
+        throw new ReferenceError(`[ForgeScript] Unknown function '${fn}'`);
+      }
     }
   }
   // ─── TA helpers ──────────────────────────────────────────────────────────────
@@ -6711,11 +7742,42 @@ var TScriptRuntime = class {
       s.push(v);
       return s;
     }
-    throw new TypeError(`[TScript] ${ctx}: expected a series`);
+    throw new TypeError(`[ForgeScript] ${ctx}: expected a series`);
   }
   _argInt(arg, ctx) {
     return Math.round(_num(this._evalExpr(arg), ctx));
   }
+  _ta_rsi(args) {
+    const src = this._argSeries(args[0], "rsi(src)");
+    const period = this._argInt(args[1], "rsi(length)");
+    if (src.length <= period) return NaN;
+    const gainKey = `__rsi_gain_${args[0].kind}_${period}`;
+    const lossKey = `__rsi_loss_${args[0].kind}_${period}`;
+    let prevGain = this._getInternalNum(gainKey);
+    let prevLoss = this._getInternalNum(lossKey);
+    const change = src.get(0) - src.get(1);
+    const gain = change > 0 ? change : 0;
+    const loss = change < 0 ? -change : 0;
+    let avgGain;
+    let avgLoss;
+    if (isNaN(prevGain)) {
+      let gSum = 0, lSum = 0;
+      for (let i = 0; i < period; i++) {
+        const d = src.get(i) - src.get(i + 1);
+        if (d > 0) gSum += d;
+        else lSum -= d;
+      }
+      avgGain = gSum / period;
+      avgLoss = lSum / period;
+    } else {
+      avgGain = (prevGain * (period - 1) + gain) / period;
+      avgLoss = (prevLoss * (period - 1) + loss) / period;
+    }
+    this._setInternal(gainKey, avgGain);
+    this._setInternal(lossKey, avgLoss);
+    if (avgLoss === 0) return 100;
+    return 100 - 100 / (1 + avgGain / avgLoss);
+  }
   _ta_sma(args) {
     const src = this._argSeries(args[0], "sma(src)");
     const period = this._argInt(args[1], "sma(length)");
@@ -6820,6 +7882,541 @@ var TScriptRuntime = class {
     }
     return NaN;
   }
+  // ─── Additional TA functions ─────────────────────────────────────────────────
+  /** ta.cross(a, b) — true when a crosses b in either direction */
+  _ta_cross(args) {
+    const a = this._argSeries(args[0], "cross(a)");
+    const b = this._argSeries(args[1], "cross(b)");
+    return a.get(0) > b.get(0) && a.get(1) <= b.get(1) || a.get(0) < b.get(0) && a.get(1) >= b.get(1);
+  }
+  /** ta.macd(src, fast, slow, signal) — returns [macd, signal, hist] via internal series */
+  _ta_macd(args) {
+    const src = this._argSeries(args[0], "macd(src)");
+    const fast = this._argInt(args[1], "macd(fastlen)");
+    const slow = this._argInt(args[2], "macd(slowlen)");
+    const signal = this._argInt(args[3], "macd(signallen)");
+    const fastKey = `__macd_fast_${args[0].kind}_${fast}`;
+    const slowKey = `__macd_slow_${args[0].kind}_${slow}`;
+    const sigKey = `__macd_sig_${args[0].kind}_${fast}_${slow}_${signal}`;
+    const cur = src.get(0);
+    const kFast = 2 / (fast + 1);
+    const kSlow = 2 / (slow + 1);
+    const kSig = 2 / (signal + 1);
+    let prevFast = this._getInternalNum(fastKey);
+    let prevSlow = this._getInternalNum(slowKey);
+    let prevSig = this._getInternalNum(sigKey);
+    const fastEMA = isNaN(prevFast) ? src.length >= fast ? this._smaOfSeries(src, fast) : NaN : cur * kFast + prevFast * (1 - kFast);
+    const slowEMA = isNaN(prevSlow) ? src.length >= slow ? this._smaOfSeries(src, slow) : NaN : cur * kSlow + prevSlow * (1 - kSlow);
+    this._setInternal(fastKey, fastEMA);
+    this._setInternal(slowKey, slowEMA);
+    const macdLine = fastEMA - slowEMA;
+    const sigLine = isNaN(prevSig) ? macdLine : macdLine * kSig + prevSig * (1 - kSig);
+    this._setInternal(sigKey, sigLine);
+    const hist = macdLine - sigLine;
+    this._pushBuiltin("__macd_line", macdLine);
+    this._pushBuiltin("__macd_signal", sigLine);
+    this._pushBuiltin("__macd_hist", hist);
+    return macdLine;
+  }
+  /** ta.bb(src, length, mult) — returns middle band; stores upper/lower in named series */
+  _ta_bb(args) {
+    const src = this._argSeries(args[0], "bb(src)");
+    const period = this._argInt(args[1], "bb(length)");
+    const mult = _num(this._evalExpr(args[2]), "bb(mult)");
+    if (src.length < period) return NaN;
+    const middle = this._smaOfSeries(src, period);
+    let variance = 0;
+    for (let i = 0; i < period; i++) {
+      const d = src.get(i) - middle;
+      variance += d * d;
+    }
+    const stdevVal = Math.sqrt(variance / period);
+    const upper = middle + mult * stdevVal;
+    const lower = middle - mult * stdevVal;
+    this._pushBuiltin("__bb_upper", upper);
+    this._pushBuiltin("__bb_middle", middle);
+    this._pushBuiltin("__bb_lower", lower);
+    return middle;
+  }
+  /** ta.stoch(source, high, low, length) — %K */
+  _ta_stoch(args) {
+    const src = this._argSeries(args[0], "stoch(src)");
+    const hi = this._argSeries(args[1], "stoch(high)");
+    const lo = this._argSeries(args[2], "stoch(low)");
+    const period = this._argInt(args[3], "stoch(length)");
+    if (hi.length < period || lo.length < period) return NaN;
+    let hh = -Infinity, ll = Infinity;
+    for (let i = 0; i < period; i++) {
+      hh = Math.max(hh, hi.get(i));
+      ll = Math.min(ll, lo.get(i));
+    }
+    const denom = hh - ll;
+    return denom === 0 ? 50 : 100 * (src.get(0) - ll) / denom;
+  }
+  /** ta.obv — On Balance Volume */
+  _ta_obv(_args) {
+    const close = this._scope.get("close");
+    const volume = this._scope.get("volume");
+    if (!(close instanceof Series2) || !(volume instanceof Series2)) return NaN;
+    if (close.length < 2) return volume.get(0);
+    const stateKey = "__obv";
+    const prev = this._getInternalNum(stateKey);
+    const prevOBV = isNaN(prev) ? 0 : prev;
+    const diff = close.get(0) - close.get(1);
+    const result = diff > 0 ? prevOBV + volume.get(0) : diff < 0 ? prevOBV - volume.get(0) : prevOBV;
+    this._setInternal(stateKey, result);
+    return result;
+  }
+  /** ta.correlation(src1, src2, length) — Pearson r */
+  _ta_correlation(args) {
+    const a = this._argSeries(args[0], "correlation(src1)");
+    const b = this._argSeries(args[1], "correlation(src2)");
+    const period = this._argInt(args[2], "correlation(length)");
+    if (a.length < period || b.length < period) return NaN;
+    let sumA = 0, sumB = 0, sumAB = 0, sumA2 = 0, sumB2 = 0;
+    for (let i = 0; i < period; i++) {
+      const av = a.get(i), bv = b.get(i);
+      sumA += av;
+      sumB += bv;
+      sumAB += av * bv;
+      sumA2 += av * av;
+      sumB2 += bv * bv;
+    }
+    const n = period;
+    const denom = Math.sqrt((n * sumA2 - sumA * sumA) * (n * sumB2 - sumB * sumB));
+    return denom === 0 ? 0 : (n * sumAB - sumA * sumB) / denom;
+  }
+  /** ta.dev(src, length) — mean absolute deviation */
+  _ta_dev(args) {
+    const src = this._argSeries(args[0], "dev(src)");
+    const period = this._argInt(args[1], "dev(length)");
+    if (src.length < period) return NaN;
+    const mean = this._smaOfSeries(src, period);
+    let sum = 0;
+    for (let i = 0; i < period; i++) sum += Math.abs(src.get(i) - mean);
+    return sum / period;
+  }
+  /** ta.variance(src, length) */
+  _ta_variance(args) {
+    const src = this._argSeries(args[0], "variance(src)");
+    const period = this._argInt(args[1], "variance(length)");
+    if (src.length < period) return NaN;
+    const mean = this._smaOfSeries(src, period);
+    let sum = 0;
+    for (let i = 0; i < period; i++) {
+      const d = src.get(i) - mean;
+      sum += d * d;
+    }
+    return sum / period;
+  }
+  /** ta.cum(src) — cumulative sum */
+  _ta_cum(args) {
+    const v = _num(this._evalExpr(args[0]), "cum(src)");
+    const key = "__cum";
+    const prev = this._getInternalNum(key);
+    const result = (isNaN(prev) ? 0 : prev) + (isNaN(v) ? 0 : v);
+    this._setInternal(key, result);
+    return result;
+  }
+  /** ta.sum(src, length) — rolling sum */
+  _ta_sum(args) {
+    const src = this._argSeries(args[0], "sum(src)");
+    const period = this._argInt(args[1], "sum(length)");
+    if (src.length < period) return NaN;
+    let sum = 0;
+    for (let i = 0; i < period; i++) sum += src.get(i);
+    return sum;
+  }
+  /** ta.valuewhen(condition, source, occurrence) */
+  _ta_valuewhen(args) {
+    const cond = this._argSeries(args[0], "valuewhen(cond)");
+    const src = this._argSeries(args[1], "valuewhen(src)");
+    const occ = args.length > 2 ? this._argInt(args[2], "valuewhen(occurrence)") : 0;
+    let count = 0;
+    for (let i = 0; i < cond.length; i++) {
+      if (_bool(cond.get(i))) {
+        if (count === occ) return src.get(i);
+        count++;
+      }
+    }
+    return NaN;
+  }
+  /** ta.pivothigh(src, leftbars, rightbars) */
+  _ta_pivothigh(args) {
+    const src = this._argSeries(args[0], "pivothigh(src)");
+    const left = this._argInt(args[1], "pivothigh(leftbars)");
+    const right = this._argInt(args[2], "pivothigh(rightbars)");
+    if (src.length < left + right + 1) return NaN;
+    const pivotIdx = right;
+    const pivotVal = src.get(pivotIdx);
+    for (let i = 1; i <= left; i++) {
+      if (src.get(pivotIdx + i) >= pivotVal) return NaN;
+    }
+    for (let i = 1; i <= right; i++) {
+      if (src.get(pivotIdx - i) >= pivotVal) return NaN;
+    }
+    return pivotVal;
+  }
+  /** ta.pivotlow(src, leftbars, rightbars) */
+  _ta_pivotlow(args) {
+    const src = this._argSeries(args[0], "pivotlow(src)");
+    const left = this._argInt(args[1], "pivotlow(leftbars)");
+    const right = this._argInt(args[2], "pivotlow(rightbars)");
+    if (src.length < left + right + 1) return NaN;
+    const pivotIdx = right;
+    const pivotVal = src.get(pivotIdx);
+    for (let i = 1; i <= left; i++) {
+      if (src.get(pivotIdx + i) <= pivotVal) return NaN;
+    }
+    for (let i = 1; i <= right; i++) {
+      if (src.get(pivotIdx - i) <= pivotVal) return NaN;
+    }
+    return pivotVal;
+  }
+  /** ta.tr(handleNa?) — True Range */
+  _ta_tr(_args) {
+    const high = this._scope.get("high");
+    const low = this._scope.get("low");
+    const close = this._scope.get("close");
+    if (!(high instanceof Series2) || !(low instanceof Series2) || !(close instanceof Series2)) return NaN;
+    if (close.length < 2) return high.get(0) - low.get(0);
+    const h = high.get(0);
+    const l = low.get(0);
+    const pc = close.get(1);
+    return Math.max(h - l, Math.abs(h - pc), Math.abs(l - pc));
+  }
+  /** ta.swma(src) — Symmetrically Weighted MA with fixed period 4 */
+  _ta_swma(args) {
+    const src = this._argSeries(args[0], "swma(src)");
+    if (src.length < 4) return NaN;
+    return (src.get(3) * 1 + src.get(2) * 3 + src.get(1) * 3 + src.get(0) * 1) / 8;
+  }
+  /** ta.vwma(src, length) — Volume Weighted MA */
+  _ta_vwma(args) {
+    const src = this._argSeries(args[0], "vwma(src)");
+    const period = this._argInt(args[1], "vwma(length)");
+    const volume = this._scope.get("volume");
+    if (!(volume instanceof Series2)) return this._smaOfSeries(src, period);
+    if (src.length < period || volume.length < period) return NaN;
+    let sumSV = 0, sumV = 0;
+    for (let i = 0; i < period; i++) {
+      const v = volume.get(i);
+      sumSV += src.get(i) * v;
+      sumV += v;
+    }
+    return sumV === 0 ? NaN : sumSV / sumV;
+  }
+  /** ta.rising(src, length) */
+  _ta_rising(args) {
+    const src = this._argSeries(args[0], "rising(src)");
+    const period = this._argInt(args[1], "rising(length)");
+    if (src.length <= period) return false;
+    for (let i = 0; i < period; i++) {
+      if (src.get(i) <= src.get(i + 1)) return false;
+    }
+    return true;
+  }
+  /** ta.falling(src, length) */
+  _ta_falling(args) {
+    const src = this._argSeries(args[0], "falling(src)");
+    const period = this._argInt(args[1], "falling(length)");
+    if (src.length <= period) return false;
+    for (let i = 0; i < period; i++) {
+      if (src.get(i) >= src.get(i + 1)) return false;
+    }
+    return true;
+  }
+  // ─── Output function implementations ─────────────────────────────────────────
+  _callPlotshape(expr) {
+    const args = expr.args;
+    const na = expr.namedArgs;
+    const cond = args.length > 0 ? _bool(this._evalExpr(args[0])) : true;
+    if (!cond || !this._currentBar) return NaN;
+    const style = na?.get("style") ? String(this._evalExpr(na.get("style"))) : "xcross";
+    const location = na?.get("location") ? String(this._evalExpr(na.get("location"))) : "abovebar";
+    const color = na?.get("color") ? String(this._evalExpr(na.get("color"))) : "#FF0000";
+    const text = na?.get("text") ? String(this._evalExpr(na.get("text"))) : void 0;
+    const title = na?.get("title") ? String(this._evalExpr(na.get("title"))) : void 0;
+    const shape = { time: this._currentBar.time, style, location, color };
+    if (text !== void 0) shape.text = text;
+    if (title !== void 0) shape.title = title;
+    this._shapes.push(shape);
+    return NaN;
+  }
+  _callPlotarrow(expr) {
+    const args = expr.args;
+    const na = expr.namedArgs;
+    const value = _num(this._evalExpr(args[0]), "plotarrow()");
+    if (isNaN(value) || !this._currentBar) return NaN;
+    const colorUp = na?.get("colorup") ? String(this._evalExpr(na.get("colorup"))) : "#00FF00";
+    const colorDown = na?.get("colordown") ? String(this._evalExpr(na.get("colordown"))) : "#FF0000";
+    this._shapes.push({
+      time: this._currentBar.time,
+      style: value > 0 ? "arrowup" : "arrowdown",
+      location: value > 0 ? "abovebar" : "belowbar",
+      color: value > 0 ? colorUp : colorDown
+    });
+    return value;
+  }
+  _callHline(expr) {
+    const args = expr.args;
+    const na = expr.namedArgs;
+    const price = _num(this._evalExpr(args[0]), "hline()");
+    const title = na?.get("title") ? String(this._evalExpr(na.get("title"))) : void 0;
+    const color = na?.get("color") ? String(this._evalExpr(na.get("color"))) : "#787B86";
+    const lineStyle = na?.get("linestyle") ? String(this._evalExpr(na.get("linestyle"))) : "dashed";
+    const lineWidth = na?.get("linewidth") ? _num(this._evalExpr(na.get("linewidth")), "hline linewidth") : 1;
+    const id = `hline_${price}`;
+    if (!this._hlines.some((h) => h.price === price)) {
+      const hline = { id, price, color, lineStyle, lineWidth };
+      if (title !== void 0) hline.title = title;
+      this._hlines.push(hline);
+    }
+    return price;
+  }
+  _callFill(expr) {
+    const args = expr.args;
+    const na = expr.namedArgs;
+    const id1 = String(this._evalExpr(args[0]));
+    const id2 = String(this._evalExpr(args[1]));
+    const color = na?.get("color") ? String(this._evalExpr(na.get("color"))) : args.length > 2 ? String(this._evalExpr(args[2])) : "#00000020";
+    const title = na?.get("title") ? String(this._evalExpr(na.get("title"))) : void 0;
+    const fill = { id1, id2, color };
+    if (title !== void 0) fill.title = title;
+    this._fills.push(fill);
+    return NaN;
+  }
+  _callBgcolor(expr) {
+    const args = expr.args;
+    const color = String(this._evalExpr(args[0]));
+    if (!this._currentBar) return NaN;
+    this._bgcolors.push({ time: this._currentBar.time, color });
+    return NaN;
+  }
+  _callBarcolor(expr) {
+    const args = expr.args;
+    const color = String(this._evalExpr(args[0]));
+    if (!this._currentBar) return NaN;
+    this._barcolors.push({ time: this._currentBar.time, color });
+    return NaN;
+  }
+  // ─── Array namespace ──────────────────────────────────────────────────────
+  _evalArrayCall(method, args) {
+    switch (method) {
+      case "new_float":
+      case "new_int":
+      case "new_bool":
+      case "new_string":
+      case "new": {
+        const size = args.length > 0 ? Math.trunc(_num(this._evalExpr(args[0]), "array.new() size")) : 0;
+        const fill = args.length > 1 ? this._evalExpr(args[1]) : NaN;
+        return new TArray(Array(size).fill(fill));
+      }
+      case "from": {
+        return new TArray(args.map((a) => this._evalExpr(a)));
+      }
+      case "size": {
+        const arr = this._evalExpr(args[0]);
+        if (!(arr instanceof TArray)) throw new TypeError("[ForgeScript] array.size() expects an array");
+        return arr.size();
+      }
+      case "get": {
+        const arr = this._evalExpr(args[0]);
+        if (!(arr instanceof TArray)) throw new TypeError("[ForgeScript] array.get() expects an array");
+        return arr.get(Math.trunc(_num(this._evalExpr(args[1]), "array.get() index")));
+      }
+      case "set": {
+        const arr = this._evalExpr(args[0]);
+        if (!(arr instanceof TArray)) throw new TypeError("[ForgeScript] array.set() expects an array");
+        arr.set(
+          Math.trunc(_num(this._evalExpr(args[1]), "array.set() index")),
+          this._evalExpr(args[2])
+        );
+        return NaN;
+      }
+      case "push": {
+        const arr = this._evalExpr(args[0]);
+        if (!(arr instanceof TArray)) throw new TypeError("[ForgeScript] array.push() expects an array");
+        arr.push(this._evalExpr(args[1]));
+        return NaN;
+      }
+      case "pop": {
+        const arr = this._evalExpr(args[0]);
+        if (!(arr instanceof TArray)) throw new TypeError("[ForgeScript] array.pop() expects an array");
+        return arr.pop();
+      }
+      case "remove": {
+        const arr = this._evalExpr(args[0]);
+        if (!(arr instanceof TArray)) throw new TypeError("[ForgeScript] array.remove() expects an array");
+        return arr.remove(Math.trunc(_num(this._evalExpr(args[1]), "array.remove() index")));
+      }
+      case "clear": {
+        const arr = this._evalExpr(args[0]);
+        if (!(arr instanceof TArray)) throw new TypeError("[ForgeScript] array.clear() expects an array");
+        arr.clear();
+        return NaN;
+      }
+      case "includes": {
+        const arr = this._evalExpr(args[0]);
+        if (!(arr instanceof TArray)) throw new TypeError("[ForgeScript] array.includes() expects an array");
+        return arr.includes(this._evalExpr(args[1]));
+      }
+      case "indexof": {
+        const arr = this._evalExpr(args[0]);
+        if (!(arr instanceof TArray)) throw new TypeError("[ForgeScript] array.indexof() expects an array");
+        return arr.indexOf(this._evalExpr(args[1]));
+      }
+      case "slice": {
+        const arr = this._evalExpr(args[0]);
+        if (!(arr instanceof TArray)) throw new TypeError("[ForgeScript] array.slice() expects an array");
+        const start = Math.trunc(_num(this._evalExpr(args[1]), "array.slice() start"));
+        const end = args.length > 2 ? Math.trunc(_num(this._evalExpr(args[2]), "array.slice() end")) : void 0;
+        return arr.slice(start, end);
+      }
+      case "join": {
+        const arr = this._evalExpr(args[0]);
+        if (!(arr instanceof TArray)) throw new TypeError("[ForgeScript] array.join() expects an array");
+        const sep = args.length > 1 ? String(this._evalExpr(args[1])) : ",";
+        return arr.join(sep);
+      }
+      case "sort": {
+        const arr = this._evalExpr(args[0]);
+        if (!(arr instanceof TArray)) throw new TypeError("[ForgeScript] array.sort() expects an array");
+        arr.items.sort((a, b) => _num(a, "sort") - _num(b, "sort"));
+        return NaN;
+      }
+      case "reverse": {
+        const arr = this._evalExpr(args[0]);
+        if (!(arr instanceof TArray)) throw new TypeError("[ForgeScript] array.reverse() expects an array");
+        arr.items.reverse();
+        return NaN;
+      }
+      case "avg": {
+        const arr = this._evalExpr(args[0]);
+        if (!(arr instanceof TArray)) throw new TypeError("[ForgeScript] array.avg() expects an array");
+        if (arr.size() === 0) return NaN;
+        let sum = 0;
+        for (const v of arr.items) sum += _num(v, "array.avg()");
+        return sum / arr.size();
+      }
+      case "sum": {
+        const arr = this._evalExpr(args[0]);
+        if (!(arr instanceof TArray)) throw new TypeError("[ForgeScript] array.sum() expects an array");
+        let sum = 0;
+        for (const v of arr.items) sum += _num(v, "array.sum()");
+        return sum;
+      }
+      case "min": {
+        const arr = this._evalExpr(args[0]);
+        if (!(arr instanceof TArray)) throw new TypeError("[ForgeScript] array.min() expects an array");
+        if (arr.size() === 0) return NaN;
+        let m = Infinity;
+        for (const v of arr.items) m = Math.min(m, _num(v, "array.min()"));
+        return m;
+      }
+      case "max": {
+        const arr = this._evalExpr(args[0]);
+        if (!(arr instanceof TArray)) throw new TypeError("[ForgeScript] array.max() expects an array");
+        if (arr.size() === 0) return NaN;
+        let m = -Infinity;
+        for (const v of arr.items) m = Math.max(m, _num(v, "array.max()"));
+        return m;
+      }
+      default:
+        throw new ReferenceError(`[ForgeScript] Unknown array function 'array.${method}'`);
+    }
+  }
+  // ─── Input namespace (input.text_area, input.string) ─────────────────────
+  _evalInputNsCall(fn, args) {
+    if (args.length === 0) return fn === "text_area" || fn === "string" ? "" : 0;
+    const def = this._evalExpr(args[0]);
+    if (fn === "text_area" || fn === "string") return typeof def === "string" ? def : String(def);
+    if (typeof def === "boolean") return def;
+    if (typeof def === "string") {
+      const n = parseFloat(def);
+      return isNaN(n) ? def : n;
+    }
+    return _num(def, `input.${fn}()`);
+  }
+  // ─── Table namespace ────────────────────────────────────────────────────────
+  _tableCounter = 0;
+  _evalTableCall(method, args, namedArgs) {
+    switch (method) {
+      case "new": {
+        const position = args.length > 0 ? String(this._evalExpr(args[0])) : "top_right";
+        const cols = args.length > 1 ? Math.trunc(_num(this._evalExpr(args[1]), "table.new() columns")) : 1;
+        const rows = args.length > 2 ? Math.trunc(_num(this._evalExpr(args[2]), "table.new() rows")) : 1;
+        const bgColor = args.length > 3 ? String(this._evalExpr(args[3])) : namedArgs?.get("bgcolor") ? String(this._evalExpr(namedArgs.get("bgcolor"))) : "transparent";
+        const borderColor = args.length > 4 ? String(this._evalExpr(args[4])) : namedArgs?.get("border_color") ? String(this._evalExpr(namedArgs.get("border_color"))) : "transparent";
+        const borderWidth = namedArgs?.get("border_width") ? _num(this._evalExpr(namedArgs.get("border_width")), "table.new() border_width") : 0;
+        const frameColor = namedArgs?.get("frame_color") ? String(this._evalExpr(namedArgs.get("frame_color"))) : args.length > 5 ? String(this._evalExpr(args[5])) : "transparent";
+        const frameWidth = namedArgs?.get("frame_width") ? _num(this._evalExpr(namedArgs.get("frame_width")), "table.new() frame_width") : args.length > 6 ? Math.trunc(_num(this._evalExpr(args[6]), "table.new() frame_width")) : 0;
+        const id = `__table_${this._tableCounter++}`;
+        this._tables.push({ id, position, rows, cols, cells: [], bgColor, borderColor, borderWidth, frameColor, frameWidth });
+        return id;
+      }
+      case "cell": {
+        const tableId = String(this._evalExpr(args[0]));
+        const col = Math.trunc(_num(this._evalExpr(args[1]), "table.cell() column"));
+        const row = Math.trunc(_num(this._evalExpr(args[2]), "table.cell() row"));
+        const text = args.length > 3 ? String(this._evalExpr(args[3])) : namedArgs?.get("text") ? String(this._evalExpr(namedArgs.get("text"))) : "";
+        const textColor = namedArgs?.get("text_color") ? String(this._evalExpr(namedArgs.get("text_color"))) : "#FFFFFF";
+        const bgColor = namedArgs?.get("bgcolor") ? String(this._evalExpr(namedArgs.get("bgcolor"))) : "transparent";
+        const textSize = namedArgs?.get("text_size") ? String(this._evalExpr(namedArgs.get("text_size"))) : "normal";
+        const textHAlign = namedArgs?.get("text_halign") ? String(this._evalExpr(namedArgs.get("text_halign"))) : "center";
+        const textVAlign = namedArgs?.get("text_valign") ? String(this._evalExpr(namedArgs.get("text_valign"))) : "center";
+        const table = this._tables.find((t) => t.id === tableId);
+        if (table) {
+          const existing = table.cells.findIndex((c) => c.row === row && c.col === col);
+          const cell = { row, col, text, textColor, bgColor, textSize, textHAlign, textVAlign };
+          if (existing >= 0) table.cells[existing] = cell;
+          else table.cells.push(cell);
+        }
+        return NaN;
+      }
+      case "clear": {
+        const tableId = String(this._evalExpr(args[0]));
+        const col = Math.trunc(_num(this._evalExpr(args[1]), "table.clear() column"));
+        const row = Math.trunc(_num(this._evalExpr(args[2]), "table.clear() row"));
+        const table = this._tables.find((t) => t.id === tableId);
+        if (table) {
+          const idx = table.cells.findIndex((c) => c.row === row && c.col === col);
+          if (idx >= 0) table.cells.splice(idx, 1);
+        }
+        return NaN;
+      }
+      case "delete": {
+        const tableId = String(this._evalExpr(args[0]));
+        const idx = this._tables.findIndex((t) => t.id === tableId);
+        if (idx >= 0) this._tables.splice(idx, 1);
+        return NaN;
+      }
+      default:
+        throw new ReferenceError(`[ForgeScript] Unknown table function 'table.${method}'`);
+    }
+  }
+  // ─── User-defined function calls ────────────────────────────────────────────
+  _callUserFunction(fnDecl, callArgs) {
+    const savedParams = fnDecl.params.map((p) => this._scope.get(p));
+    for (let i = 0; i < fnDecl.params.length; i++) {
+      const val = i < callArgs.length ? this._evalExpr(callArgs[i]) : NaN;
+      this._scope.set(fnDecl.params[i], val);
+    }
+    let result = NaN;
+    for (const stmt of fnDecl.body) {
+      if (stmt.kind === "ExprStmt") {
+        result = this._evalExpr(stmt.expr);
+      } else {
+        this._execStmt(stmt);
+      }
+    }
+    for (let i = 0; i < fnDecl.params.length; i++) {
+      const saved = savedParams[i];
+      if (saved === void 0) this._scope.delete(fnDecl.params[i]);
+      else this._scope.set(fnDecl.params[i], saved);
+    }
+    return result;
+  }
   // ─── Internal state helpers ──────────────────────────────────────────────────
   /** Persistent scalar state for stateful TA functions (EMA, RMA, ATR). */
   _internalState = /* @__PURE__ */ new Map();
@@ -6846,15 +8443,24 @@ var TScriptRuntime = class {
   }
 };
 
-// src/tscript/TScriptIndicator.ts
-var TScriptIndicator = class {
+// src/forgescript/ForgeScriptIndicator.ts
+var ForgeScriptIndicator = class _ForgeScriptIndicator {
   _runtime;
   /** Title from the `indicator("...")` declaration, or `'Script'` if absent. */
   title;
   constructor(src) {
-    this._runtime = new TScriptRuntime(src);
+    this._runtime = new ForgeScriptRuntime(_ForgeScriptIndicator._dedent(src));
     this.title = this._runtime.title;
   }
+  /** Strip common leading whitespace from template-literal source. */
+  static _dedent(s) {
+    const lines = s.split("\n");
+    while (lines.length && !lines[0].trim()) lines.shift();
+    while (lines.length && !lines[lines.length - 1].trim()) lines.pop();
+    const min = lines.filter((l) => l.trim().length > 0).reduce((m, l) => Math.min(m, l.search(/\S/)), Infinity);
+    if (!isFinite(min) || min === 0) return lines.join("\n");
+    return lines.map((l) => l.slice(min)).join("\n");
+  }
   /**
    * Execute the script over the full bar history.
    *
@@ -6867,6 +8473,25 @@ var TScriptIndicator = class {
   run(bars) {
     return this._runtime.run(bars);
   }
+  /**
+   * Return the full ScriptResult from the most recent `run()` or `runFull()`.
+   * Must be called after `run()` — otherwise returns empty data.
+   */
+  getLastResult(bars) {
+    return this._runtime.getResult(bars);
+  }
+  /**
+   * Execute the script and return the full result including shapes, hlines,
+   * fills, bgcolors, barcolors, and plot metadata.
+   */
+  runFull(bars) {
+    this._runtime.reset();
+    this._runtime.setTotalBars(bars.length);
+    for (let i = 0; i < bars.length; i++) {
+      this._runtime.execBar(bars[i], i);
+    }
+    return this._runtime.getResult(bars);
+  }
   /**
    * Reset all persistent series state (ring buffers) without re-parsing.
    * Call when the chart symbol or timeframe changes.
@@ -7085,10 +8710,11 @@ var IndicatorDAG = class {
         const src = node.config.script;
         if (!src) return { kind: "series", points: [] };
         if (!node.scriptRuntime) {
-          node.scriptRuntime = new TScriptIndicator(src);
+          node.scriptRuntime = new ForgeScriptIndicator(src);
         }
         const plots = node.scriptRuntime.run(bars);
-        return { kind: "series", points: plots[0] ?? [] };
+        const scriptResult = node.scriptRuntime.getLastResult(bars);
+        return { kind: "series", points: plots[0] ?? [], scriptResult };
       }
       default:
         return { kind: "series", points: [...input] };
@@ -7136,7 +8762,7 @@ var IndicatorDAG = class {
   }
 };
 
-// src/pine/pine-lexer.ts
+// src/forgescript/pine/pine-lexer.ts
 var PineLexer = class {
   _src;
   _pos = 0;
@@ -7362,7 +8988,7 @@ var PineLexer = class {
   }
 };
 
-// src/pine/pine-parser.ts
+// src/forgescript/pine/pine-parser.ts
 var PineParser = class {
   _tokens;
   _pos = 0;
@@ -7392,6 +9018,39 @@ var PineParser = class {
     if (t.kind === "IDENT" && t.value === "if") {
       return this._ifStmt();
     }
+    if (t.kind === "IDENT" && t.value === "switch") {
+      return this._switchStmt();
+    }
+    if (t.kind === "IDENT" && t.value === "while") {
+      return this._whileStmt();
+    }
+    if (t.kind === "IDENT" && t.value === "for") {
+      return this._forInStmt();
+    }
+    if (t.kind === "IDENT" && t.value === "type") {
+      return this._typeDefStmt();
+    }
+    if (t.kind === "IDENT" && t.value === "import") {
+      return this._importStmt();
+    }
+    if (t.kind === "IDENT" && t.value === "export") {
+      this._skipToNL();
+      this._skipBlock();
+      return null;
+    }
+    if (t.kind === "IDENT" && t.value === "method") {
+      this._skipToNL();
+      this._skipBlock();
+      return null;
+    }
+    if (t.kind === "IDENT" && t.value === "enum") {
+      this._skipToNL();
+      this._skipBlock();
+      return null;
+    }
+    if (t.kind === "IDENT" && this._peekKind(1) === "LPAREN" && this._looksLikeFuncDef()) {
+      return this._funcDefStmt();
+    }
     if (t.kind === "IDENT") {
       const p1 = this._peekKind(1);
       const p2 = this._peekKind(2);
@@ -7415,11 +9074,16 @@ var PineParser = class {
     let typeHint;
     if (this._check("IDENT") && this._peekKind(1) === "ASSIGN") {
       const maybeType = this._cur().value;
-      if (["float", "int", "bool", "string", "color", "series", "simple", "const"].includes(maybeType)) {
+      if (["float", "int", "bool", "string", "color", "series", "simple", "const", "label", "line", "box", "table"].includes(maybeType)) {
         typeHint = maybeType;
         this._advance();
       }
     }
+    if (typeHint !== void 0 && this._check("LBRACKET")) {
+      this._advance();
+      if (this._check("RBRACKET")) this._advance();
+      typeHint += "[]";
+    }
     const name = this._consume("IDENT", "Expected variable name after 'var'").value;
     this._consume("ASSIGN", "Expected '=' in var declaration");
     const value = this._expr();
@@ -7463,22 +9127,208 @@ var PineParser = class {
     if (this._check("IDENT") && this._cur().value === "else") {
       this._advance();
       this._consumeNLorEOF();
-      else_.push(...this._indentedBlock());
+      else_.push(...this._indentedBlock());
+    }
+    return { kind: "PineIf", condition, then, else_, loc };
+  }
+  _indentedBlock() {
+    const stmts = [];
+    if (!this._check("INDENT")) return stmts;
+    this._advance();
+    this._skipNL();
+    while (!this._check("DEDENT") && !this._check("EOF")) {
+      const s = this._stmt();
+      if (s !== null) stmts.push(s);
+      this._skipNL();
+    }
+    if (this._check("DEDENT")) this._advance();
+    return stmts;
+  }
+  // ─── Pine v6 statements ──────────────────────────────────────────────────────
+  /**
+   * switch expr
+   *   val1 => body          ← single-line
+   *   val2 =>               ← multi-line
+   *     stmt1
+   *   => defaultBody        ← default / else (no condition)
+   *
+   * OR boolean-style (no subject):
+   *   switch
+   *     cond1 => body
+   *     cond2 => body
+   *     => defaultBody
+   */
+  _switchStmt() {
+    const tok = this._advance();
+    const loc = { line: tok.line, col: tok.col };
+    let subject = null;
+    if (!this._check("NEWLINE") && !this._check("EOF")) {
+      subject = this._expr();
+    }
+    this._consumeNLorEOF();
+    const cases = [];
+    if (!this._check("INDENT")) {
+      return { kind: "PineSwitch", subject, cases, loc };
+    }
+    this._advance();
+    this._skipNL();
+    while (!this._check("DEDENT") && !this._check("EOF")) {
+      if (this._check("ARROW")) {
+        this._advance();
+        const body2 = this._singleLineOrBlock();
+        cases.push({ condition: null, body: body2 });
+        break;
+      }
+      const condition = this._expr();
+      this._consume("ARROW", "Expected '=>' in switch case");
+      const body = this._singleLineOrBlock();
+      cases.push({ condition, body });
+      this._skipNL();
+    }
+    if (this._check("DEDENT")) this._advance();
+    return { kind: "PineSwitch", subject, cases, loc };
+  }
+  /** Parse single-line body (after =>) OR consume NL and parse an indented block. */
+  _singleLineOrBlock() {
+    if (!this._check("NEWLINE") && !this._check("EOF")) {
+      const loc = this._locOfCur();
+      const expr = this._expr();
+      this._consumeNLorEOF();
+      return [{ kind: "PineExprStmt", expr, loc }];
+    }
+    this._consumeNLorEOF();
+    return this._indentedBlock();
+  }
+  _whileStmt() {
+    const tok = this._advance();
+    const loc = { line: tok.line, col: tok.col };
+    const condition = this._expr();
+    this._consumeNLorEOF();
+    const body = this._indentedBlock();
+    return { kind: "PineWhile", condition, body, loc };
+  }
+  _forInStmt() {
+    const tok = this._advance();
+    const loc = { line: tok.line, col: tok.col };
+    const varName = this._consume("IDENT", "Expected variable name in 'for' loop").value;
+    if (this._check("ASSIGN") || this._check("REASSIGN")) {
+      this._skipToNL();
+      this._skipBlock();
+      const placeholder = { kind: "PineNumberLit", value: 0, loc };
+      return { kind: "PineForIn", varName, iterable: placeholder, body: [], loc };
+    }
+    if (this._check("IDENT") && this._cur().value === "in") {
+      this._advance();
+    } else {
+      this._skipToNL();
+      this._skipBlock();
+      const placeholder = { kind: "PineNumberLit", value: 0, loc };
+      return { kind: "PineForIn", varName, iterable: placeholder, body: [], loc };
+    }
+    const iterable = this._expr();
+    this._consumeNLorEOF();
+    const body = this._indentedBlock();
+    return { kind: "PineForIn", varName, iterable, body, loc };
+  }
+  /**
+   * type MyType
+   *   float field1 = 0
+   *   int   field2 = 0
+   *
+   * We parse the name and skip the indented field block.
+   */
+  _typeDefStmt() {
+    const tok = this._advance();
+    const loc = { line: tok.line, col: tok.col };
+    const name = this._check("IDENT") ? this._advance().value : "__unknown__";
+    this._consumeNLorEOF();
+    this._skipBlock();
+    return { kind: "PineTypeDef", name, loc };
+  }
+  /**
+   * import username/libraryname/version as alias
+   */
+  _importStmt() {
+    const tok = this._advance();
+    const loc = { line: tok.line, col: tok.col };
+    let path = "";
+    while (!this._check("NEWLINE") && !this._check("EOF") && !(this._check("IDENT") && this._cur().value === "as")) {
+      path += this._advance().value;
+    }
+    let alias = "";
+    if (this._check("IDENT") && this._cur().value === "as") {
+      this._advance();
+      if (this._check("IDENT")) alias = this._advance().value;
+    }
+    this._consumeNLorEOF();
+    return { kind: "PineImport", path: path.trim(), alias, loc };
+  }
+  // ─── Block-skip helpers ──────────────────────────────────────────────────────
+  /**
+   * Returns true if the current position looks like a user-defined function
+   * declaration: `IDENT '(' ... ')' '=>'`.
+   * Scans forward to find the matching RPAREN, then checks for ARROW.
+   */
+  _looksLikeFuncDef() {
+    let i = this._pos + 1;
+    if (this._tokens[i]?.kind !== "LPAREN") return false;
+    i++;
+    let depth = 1;
+    while (i < this._tokens.length && depth > 0) {
+      const k = this._tokens[i].kind;
+      if (k === "LPAREN") depth++;
+      else if (k === "RPAREN") depth--;
+      else if (k === "EOF" || k === "NEWLINE") return false;
+      i++;
+    }
+    return this._tokens[i]?.kind === "ARROW";
+  }
+  /**
+   * Skip a user-defined function declaration and its body.
+   *
+   *   funcname(param, ...) =>
+   *     body
+   *
+   * OR single-line:
+   *   funcname(params) => expr
+   *
+   * Emits no output — user-defined functions are unsupported in ForgeScript.
+   */
+  _funcDefStmt() {
+    this._advance();
+    this._advance();
+    let depth = 1;
+    while (depth > 0 && !this._check("EOF")) {
+      if (this._check("LPAREN")) depth++;
+      else if (this._check("RPAREN")) depth--;
+      this._advance();
+    }
+    if (this._check("ARROW")) this._advance();
+    if (!this._check("NEWLINE") && !this._check("EOF")) {
+      this._skipToNL();
+    } else {
+      this._consumeNLorEOF();
+      this._skipBlock();
     }
-    return { kind: "PineIf", condition, then, else_, loc };
+    return null;
   }
-  _indentedBlock() {
-    const stmts = [];
-    if (!this._check("INDENT")) return stmts;
+  /** Skip to end of current line (consumes any tokens before NEWLINE/EOF). */
+  _skipToNL() {
+    while (!this._check("NEWLINE") && !this._check("EOF")) {
+      this._advance();
+    }
+    this._consumeNLorEOF();
+  }
+  /** Skip a full INDENT…DEDENT block, handling nesting. Does nothing if no INDENT. */
+  _skipBlock() {
+    if (!this._check("INDENT")) return;
     this._advance();
-    this._skipNL();
-    while (!this._check("DEDENT") && !this._check("EOF")) {
-      const s = this._stmt();
-      if (s !== null) stmts.push(s);
-      this._skipNL();
+    let depth = 1;
+    while (depth > 0 && !this._check("EOF")) {
+      if (this._check("INDENT")) depth++;
+      else if (this._check("DEDENT")) depth--;
+      this._advance();
     }
-    if (this._check("DEDENT")) this._advance();
-    return stmts;
   }
   // ─── Expressions ────────────────────────────────────────────────────────────
   _expr() {
@@ -7649,6 +9499,20 @@ var PineParser = class {
         const node2 = { kind: "PineNsCall", namespace: ns, fn: member, args, namedArgs, loc };
         return node2;
       }
+      if (this._check("LT")) {
+        this._advance();
+        while (!this._check("GT") && !this._check("EOF") && !this._check("NEWLINE")) {
+          this._advance();
+        }
+        if (this._check("GT")) this._advance();
+        if (this._check("LPAREN")) {
+          this._advance();
+          const { args, namedArgs } = this._argList();
+          this._consume("RPAREN", "Expected ')'");
+          const node2 = { kind: "PineNsCall", namespace: ns, fn: member, args, namedArgs, loc };
+          return node2;
+        }
+      }
       const node = { kind: "PineMember", object: ns, prop: member, loc };
       return node;
     }
@@ -7672,6 +9536,20 @@ var PineParser = class {
       this._consume("RPAREN", "Expected ')'");
       return inner;
     }
+    if (t.kind === "LBRACKET") {
+      this._advance();
+      if (this._check("RBRACKET")) {
+        this._advance();
+        return { kind: "PineNumberLit", value: 0, loc };
+      }
+      const first = this._expr();
+      while (this._match("COMMA")) {
+        if (this._check("RBRACKET")) break;
+        this._expr();
+      }
+      if (this._check("RBRACKET")) this._advance();
+      return first;
+    }
     throw new SyntaxError(`[Pine] Unexpected token '${t.value}' (${t.kind}) at ${t.line}:${t.col}`);
   }
   // ─── Arg list helper ────────────────────────────────────────────────────────
@@ -7744,7 +9622,7 @@ var PineParser = class {
   }
 };
 
-// src/pine/pine-transpiler.ts
+// src/forgescript/pine/pine-transpiler.ts
 var TA_MAP = {
   sma: "sma",
   ema: "ema",
@@ -7759,7 +9637,25 @@ var TA_MAP = {
   atr: "atr",
   crossover: "crossover",
   crossunder: "crossunder",
-  barssince: "barssince"
+  cross: "cross",
+  barssince: "barssince",
+  macd: "macd",
+  bb: "bb",
+  stoch: "stoch",
+  obv: "obv",
+  correlation: "correlation",
+  dev: "dev",
+  variance: "variance",
+  cum: "cum",
+  sum: "sum",
+  valuewhen: "valuewhen",
+  pivothigh: "pivothigh",
+  pivotlow: "pivotlow",
+  tr: "tr",
+  swma: "swma",
+  vwma: "vwma",
+  rising: "rising",
+  falling: "falling"
 };
 var MATH_MAP = {
   abs: "abs",
@@ -7770,9 +9666,21 @@ var MATH_MAP = {
   ceil: "ceil",
   sqrt: "sqrt",
   log: "log",
+  log10: "log10",
   pow: "pow",
   sign: "sign",
-  exp: "exp"
+  exp: "exp",
+  avg: "avg",
+  sum: "sum",
+  sin: "sin",
+  cos: "cos",
+  tan: "tan",
+  asin: "asin",
+  acos: "acos",
+  atan: "atan",
+  random: "random",
+  todegrees: "todegrees",
+  toradians: "toradians"
 };
 var COLOR_MAP = {
   red: '"#f23645"',
@@ -7794,21 +9702,25 @@ var COLOR_MAP = {
   fuchsia: '"#ff00ff"'
 };
 var UNSUPPORTED_FN = /* @__PURE__ */ new Set([
-  "plotshape",
-  "plotarrow",
   "plotbar",
   "plotcandle",
-  "barcolor",
-  "bgcolor",
   "alertcondition",
   "alert",
   "strategy",
   "label",
   "line",
   "box",
-  "table",
   "request"
 ]);
+var OUTPUT_FN = /* @__PURE__ */ new Set([
+  "plotshape",
+  "plotchar",
+  "plotarrow",
+  "hline",
+  "fill",
+  "bgcolor",
+  "barcolor"
+]);
 var PineTranspiler = class {
   _diag;
   _indent = 0;
@@ -7837,18 +9749,32 @@ var PineTranspiler = class {
         return this._exprStmt(s);
       case "PineIf":
         return this._ifStmt(s);
+      case "PineSwitch":
+        return this._switchStmt(s);
+      case "PineWhile":
+        return this._whileStmt(s);
+      case "PineForIn":
+        return this._forInStmt(s);
+      case "PineTypeDef":
+        return;
+      // silently skipped — diagnostic added at parse time
+      case "PineImport":
+        return;
     }
   }
   _indicatorDecl(s) {
     const title = s.args[0];
     const titleStr = title ? this._expr(title) : '"Script"';
-    this._line(`indicator(${titleStr})`);
+    const overlay = s.namedArgs?.get("overlay");
+    const overlayStr = overlay ? `, overlay=${this._expr(overlay)}` : "";
+    this._line(`indicator(${titleStr}${overlayStr})`);
   }
   _varDecl(s) {
-    this._line(`${s.name} = ${this._expr(s.value)}`);
+    const mod = s.modifier === "varip" ? "varip " : s.modifier === "var" ? "var " : "";
+    this._line(`${mod}${s.name} = ${this._expr(s.value)}`);
   }
   _assign(s) {
-    this._line(`${s.name} = ${this._expr(s.value)}`);
+    this._line(`${s.name} := ${this._expr(s.value)}`);
   }
   _exprStmt(s) {
     const expr = s.expr;
@@ -7873,6 +9799,38 @@ var PineTranspiler = class {
       this._indent--;
     }
   }
+  _switchStmt(s) {
+    let first = true;
+    for (const c of s.cases) {
+      if (c.condition === null) {
+        this._line(first ? "if true" : "else");
+      } else {
+        const condStr = s.subject !== null ? `(${this._expr(s.subject)} == ${this._expr(c.condition)})` : this._expr(c.condition);
+        this._line(first ? `if ${condStr}` : `else if ${condStr}`);
+      }
+      this._indent++;
+      for (const st of c.body) this._stmt(st);
+      if (c.body.length === 0) this._line("0");
+      this._indent--;
+      first = false;
+    }
+  }
+  _whileStmt(s) {
+    this._line(`while ${this._expr(s.condition)}`);
+    this._indent++;
+    for (const st of s.body) this._stmt(st);
+    if (s.body.length === 0) this._line("0");
+    this._indent--;
+  }
+  _forInStmt(s) {
+    this._diag.add(
+      "warning",
+      `'for...in' loops are not supported and will be skipped`,
+      s.loc,
+      "PINE_UNSUPPORTED_FN"
+    );
+    this._line(`// for ${s.varName} in ... (for..in not supported)`);
+  }
   // ─── Expressions ────────────────────────────────────────────────────────────
   _expr(e) {
     switch (e.kind) {
@@ -7931,7 +9889,32 @@ var PineTranspiler = class {
     if (ns === "input") {
       return this._inputNsCall(e);
     }
-    if (ns === "strategy" || ns === "label" || ns === "line" || ns === "box" || ns === "table" || ns === "request") {
+    if (ns === "str") {
+      return this._strNsCall(e);
+    }
+    if (ns === "array") {
+      const args = this._positionalArgs(e.args);
+      const namedParts = [];
+      for (const [key, val] of e.namedArgs) namedParts.push(`${key}=${this._expr(val)}`);
+      const allArgs = [args, ...namedParts].filter(Boolean).join(", ");
+      return `array.${fn}(${allArgs})`;
+    }
+    if (ns === "matrix" || ns === "map") {
+      this._diag.add("warning", `'${ns}.${fn}()' is not supported (no collection types in ForgeScript)`, e.loc, "PINE_UNSUPPORTED_FN");
+      return `/* ${ns}.${fn} not supported */ 0`;
+    }
+    if (ns === "ticker") {
+      this._diag.add("warning", `'ticker.${fn}()' is not supported`, e.loc, "PINE_UNSUPPORTED_FN");
+      return `/* ticker.${fn} not supported */ 0`;
+    }
+    if (ns === "table") {
+      const args = this._positionalArgs(e.args);
+      const namedParts = [];
+      for (const [key, val] of e.namedArgs) namedParts.push(`${key}=${this._expr(val)}`);
+      const allArgs = [args, ...namedParts].filter(Boolean).join(", ");
+      return `table.${fn}(${allArgs})`;
+    }
+    if (ns === "strategy" || ns === "label" || ns === "line" || ns === "box" || ns === "request") {
       this._diag.add("warning", `'${ns}.${fn}()' is not supported`, e.loc, "PINE_UNSUPPORTED_FN");
       return `/* ${ns}.${fn} not supported */ 0`;
     }
@@ -7942,14 +9925,46 @@ var PineTranspiler = class {
     if (e.fn === "source") {
       return e.args[0] ? this._expr(e.args[0]) : "close";
     }
+    if (e.fn === "text_area" || e.fn === "string") {
+      const defVal2 = e.args[0] ?? e.namedArgs.get("defval");
+      return defVal2 ? `input.${e.fn}(${this._expr(defVal2)})` : `input.${e.fn}("")`;
+    }
     const defVal = e.args[0] ?? e.namedArgs.get("defval");
     return defVal ? `input(${this._expr(defVal)})` : "input(0)";
   }
+  _strNsCall(e) {
+    const SUPPORTED = {
+      tostring: "tostring",
+      tonumber: "tonumber",
+      length: "length",
+      trim: "trim",
+      contains: "contains",
+      substring: "substring",
+      replace_all: "replace_all",
+      upper: "upper",
+      lower: "lower",
+      split: "split"
+    };
+    const mapped = SUPPORTED[e.fn];
+    if (mapped) {
+      const args = this._positionalArgs(e.args);
+      return `str.${mapped}(${args})`;
+    }
+    if (e.fn === "format") {
+      const args = this._positionalArgs(e.args);
+      return `str.format(${args})`;
+    }
+    this._diag.add("info", `'str.${e.fn}()' is not supported and will return 0`, e.loc, "PINE_UNSUPPORTED_FN");
+    return `/* str.${e.fn} not supported */ 0`;
+  }
   _call(e) {
     if (UNSUPPORTED_FN.has(e.fn)) {
       this._diag.add("warning", `'${e.fn}()' is not supported and will be ignored`, e.loc, "PINE_UNSUPPORTED_FN");
       return `/* ${e.fn} not supported */ 0`;
     }
+    if (OUTPUT_FN.has(e.fn)) {
+      return this._outputFnCall(e);
+    }
     if (e.fn === "input") {
       const defVal = e.args[0] ?? e.namedArgs.get("defval");
       return defVal ? `input(${this._expr(defVal)})` : "input(0)";
@@ -7960,15 +9975,29 @@ var PineTranspiler = class {
     if (e.fn === "indicator") {
       const title = e.args[0];
       const titleStr = title ? this._expr(title) : '"Script"';
-      return `indicator(${titleStr})`;
+      const overlay = e.namedArgs.get("overlay");
+      const overlayStr = overlay ? `, overlay=${this._expr(overlay)}` : "";
+      return `indicator(${titleStr}${overlayStr})`;
     }
     const args = this._positionalArgs(e.args);
     return `${e.fn}(${args})`;
   }
+  /** Transpile supported output functions, preserving named args */
+  _outputFnCall(e) {
+    const parts = e.args.map((a) => this._expr(a));
+    for (const [key, val] of e.namedArgs) {
+      parts.push(`${key}=${this._expr(val)}`);
+    }
+    return `${e.fn}(${parts.join(", ")})`;
+  }
   _plotCall(e) {
     const series = e.args[0];
     if (!series) return "/* plot() missing series */";
-    return `plot(${this._expr(series)})`;
+    const parts = [this._expr(series)];
+    for (const [key, val] of e.namedArgs) {
+      parts.push(`${key}=${this._expr(val)}`);
+    }
+    return `plot(${parts.join(", ")})`;
   }
   _member(e) {
     if (e.object === "color") {
@@ -7980,7 +10009,19 @@ var PineTranspiler = class {
     if (e.object === "line" || e.object === "label" || e.object === "box") {
       return `"${e.prop}"`;
     }
-    if (e.object === "timeframe" || e.object === "syminfo" || e.object === "session") {
+    if (e.object === "shape" || e.object === "location" || e.object === "position" || e.object === "size") {
+      return `"${e.prop}"`;
+    }
+    if (e.object === "text") {
+      return `"${e.prop.replace(/^align_/, "")}"`;
+    }
+    if (e.object === "plot") {
+      return `"${e.prop.replace(/^style_/, "")}"`;
+    }
+    if (e.object === "timeframe" || e.object === "syminfo" || e.object === "barstate") {
+      return `${e.object}.${e.prop}`;
+    }
+    if (e.object === "session") {
       this._diag.add("info", `'${e.object}.${e.prop}' is not supported`, e.loc, "PINE_UNSUPPORTED_FN");
       return "0";
     }
@@ -8006,7 +10047,7 @@ var PineTranspiler = class {
   }
 };
 
-// src/pine/diagnostics.ts
+// src/forgescript/pine/diagnostics.ts
 var DiagnosticBag = class {
   _diags = [];
   add(severity, message, loc, code) {
@@ -8020,16 +10061,32 @@ var DiagnosticBag = class {
   }
 };
 
-// src/pine/PineCompiler.ts
+// src/forgescript/pine/PineCompiler.ts
 var PineCompiler = class _PineCompiler {
   /**
-   * Compile Pine Script source to TScript.
+   * Compile Pine Script source to ForgeScript.
    * Parse errors throw a `SyntaxError`; semantic problems populate diagnostics.
    */
   compile(pineSource) {
     const diag = new DiagnosticBag();
     const parser = new PineParser(pineSource);
     const program = parser.parse();
+    const ver = program.version;
+    if (ver < 5) {
+      diag.add(
+        "warning",
+        `Pine v${ver} is a legacy version; some syntax may not transpile correctly`,
+        { line: 1, col: 1 },
+        "PINE_VERSION_LEGACY"
+      );
+    } else if (ver > 6) {
+      diag.add(
+        "warning",
+        `Pine v${ver} is not fully supported; features beyond v6 may not transpile correctly`,
+        { line: 1, col: 1 },
+        "PINE_VERSION_UNSUPPORTED"
+      );
+    }
     const transpiler = new PineTranspiler(diag);
     const tscript = transpiler.transpile(program);
     return {
@@ -8048,12 +10105,1055 @@ var PineCompiler = class _PineCompiler {
     if (!result.ok) {
       return { plots: [], diagnostics: result.diagnostics };
     }
-    const indicator = new TScriptIndicator(result.tscript);
+    const indicator = new ForgeScriptIndicator(result.tscript);
     const plots = indicator.run(bars);
     return { plots, diagnostics: result.diagnostics };
   }
 };
 
+// src/forgescript/conversion/language-detector.ts
+var RULES = [
+  // ── Pine Script ───────────────────────────────────────────────────────────
+  { pattern: /\/\/@version\s*=\s*\d/, score: 50, language: "pine" },
+  { pattern: /\bindicator\s*\(/, score: 20, language: "pine" },
+  { pattern: /\bstrategy\s*\(/, score: 20, language: "pine" },
+  { pattern: /\bta\.(sma|ema|rsi|atr|macd)\b/, score: 15, language: "pine" },
+  { pattern: /\bcolor\.(red|green|blue|new)\b/, score: 10, language: "pine" },
+  { pattern: /\bplot(shape|char|arrow)?\s*\(/, score: 10, language: "pine" },
+  { pattern: /\bsyminfo\.\w+/, score: 10, language: "pine" },
+  { pattern: /\brequest\.security\s*\(/, score: 15, language: "pine" },
+  { pattern: /\bvar\s+\w+\s*=/, score: 5, language: "pine" },
+  { pattern: /\bvarip\s+\w+\s*=/, score: 15, language: "pine" },
+  { pattern: /:=/, score: 8, language: "pine" },
+  // ── Python ────────────────────────────────────────────────────────────────
+  { pattern: /\bdef\s+\w+\s*\(/, score: 25, language: "python" },
+  { pattern: /\bimport\s+(numpy|pandas|ta|talib|yfinance)\b/, score: 30, language: "python" },
+  { pattern: /\bfrom\s+\w+\s+import\b/, score: 15, language: "python" },
+  { pattern: /\bclass\s+\w+(\s*\(.*\))?\s*:/, score: 15, language: "python" },
+  { pattern: /\bprint\s*\(/, score: 5, language: "python" },
+  { pattern: /\bself\.\w+/, score: 10, language: "python" },
+  { pattern: /\bif\s+.*:\s*$/m, score: 10, language: "python" },
+  { pattern: /\belif\b/, score: 15, language: "python" },
+  { pattern: /\bfor\s+\w+\s+in\b/, score: 10, language: "python" },
+  { pattern: /^\s*#[^!]/m, score: 3, language: "python" },
+  { pattern: /\bnp\.\w+/, score: 15, language: "python" },
+  { pattern: /\bpd\.DataFrame\b/, score: 20, language: "python" },
+  // ── JavaScript / TypeScript ───────────────────────────────────────────────
+  { pattern: /\bfunction\s+\w+\s*\(/, score: 20, language: "javascript" },
+  { pattern: /\bconst\s+\w+\s*=/, score: 10, language: "javascript" },
+  { pattern: /\blet\s+\w+\s*=/, score: 10, language: "javascript" },
+  { pattern: /=>\s*[{(]/, score: 15, language: "javascript" },
+  { pattern: /\bconsole\.(log|warn|error)\s*\(/, score: 15, language: "javascript" },
+  { pattern: /\brequire\s*\(/, score: 15, language: "javascript" },
+  { pattern: /\bmodule\.exports\b/, score: 15, language: "javascript" },
+  { pattern: /\bimport\s+.*\s+from\s+['"]/, score: 15, language: "javascript" },
+  { pattern: /\bexport\s+(default\s+)?(function|class|const)\b/, score: 15, language: "javascript" },
+  { pattern: /\basync\s+function\b/, score: 10, language: "javascript" },
+  { pattern: /\bawait\s+/, score: 8, language: "javascript" },
+  { pattern: /\bnew\s+Promise\b/, score: 10, language: "javascript" },
+  { pattern: /\.then\s*\(/, score: 8, language: "javascript" },
+  // ── ForgeScript (already canonical) ───────────────────────────────────────
+  { pattern: /\bindicator\s*\("/, score: 10, language: "forgescript" },
+  { pattern: /\bsma\s*\(close\b/, score: 10, language: "forgescript" }
+];
+var CONFIDENCE_THRESHOLDS = {
+  HIGH: 40,
+  MEDIUM: 20};
+function detectLanguage(source) {
+  const scores = {
+    pine: 0,
+    python: 0,
+    javascript: 0,
+    forgescript: 0,
+    unknown: 0
+  };
+  for (const rule of RULES) {
+    if (rule.pattern.test(source)) {
+      scores[rule.language] += rule.score;
+    }
+  }
+  let best = "unknown";
+  let bestScore = 0;
+  for (const [lang, score] of Object.entries(scores)) {
+    if (lang === "unknown") continue;
+    if (score > bestScore) {
+      bestScore = score;
+      best = lang;
+    }
+  }
+  let confidence = "LOW";
+  if (bestScore >= CONFIDENCE_THRESHOLDS.HIGH) confidence = "HIGH";
+  else if (bestScore >= CONFIDENCE_THRESHOLDS.MEDIUM) confidence = "MEDIUM";
+  if (bestScore === 0) {
+    best = "unknown";
+    confidence = "LOW";
+  }
+  const reason = bestScore === 0 ? "No recognisable language patterns detected" : `Matched ${best} patterns with score ${bestScore}`;
+  return { language: best, confidence, reason, scores };
+}
+async function detectLanguageWithFallback(source, aiClassifier) {
+  const heuristic = detectLanguage(source);
+  if (heuristic.language !== "unknown" || !aiClassifier) return heuristic;
+  return aiClassifier(source);
+}
+
+// src/forgescript/conversion/validation.ts
+var BUILTIN_SERIES = /* @__PURE__ */ new Set([
+  "open",
+  "high",
+  "low",
+  "close",
+  "volume",
+  "time",
+  "hl2",
+  "hlc3",
+  "ohlc4",
+  "bar_index"
+]);
+var BUILTIN_FUNCTIONS = /* @__PURE__ */ new Set([
+  // Utility
+  "input",
+  "plot",
+  "na",
+  "nz",
+  // Math (flat)
+  "abs",
+  "max",
+  "min",
+  "round",
+  "floor",
+  "ceil",
+  "sqrt",
+  "log",
+  "exp",
+  "pow",
+  "sign",
+  "sin",
+  "cos",
+  "tan",
+  "asin",
+  "acos",
+  "atan",
+  "todegrees",
+  "toradians",
+  // TA (flat)
+  "sma",
+  "ema",
+  "wma",
+  "rma",
+  "rsi",
+  "stdev",
+  "atr",
+  "highest",
+  "lowest",
+  "change",
+  "mom",
+  "crossover",
+  "crossunder",
+  "cross",
+  "macd",
+  "bb",
+  "stoch",
+  "obv",
+  "correlation",
+  "dev",
+  "variance",
+  "cum",
+  "sum",
+  "valuewhen",
+  "barssince",
+  "pivothigh",
+  "pivotlow",
+  "tr",
+  "swma",
+  "vwma",
+  "rising",
+  "falling",
+  // Output
+  "plotshape",
+  "plotchar",
+  "plotarrow",
+  "hline",
+  "fill",
+  "bgcolor",
+  "barcolor"
+]);
+var NAMESPACE_FUNCTIONS = {
+  ta: /* @__PURE__ */ new Set([
+    "sma",
+    "ema",
+    "wma",
+    "rma",
+    "rsi",
+    "stdev",
+    "atr",
+    "highest",
+    "lowest",
+    "change",
+    "mom",
+    "crossover",
+    "crossunder",
+    "cross",
+    "macd",
+    "bb",
+    "stoch",
+    "obv",
+    "correlation",
+    "dev",
+    "variance",
+    "cum",
+    "sum",
+    "valuewhen",
+    "barssince",
+    "pivothigh",
+    "pivotlow",
+    "tr",
+    "swma",
+    "vwma",
+    "rising",
+    "falling"
+  ]),
+  math: /* @__PURE__ */ new Set([
+    "abs",
+    "max",
+    "min",
+    "round",
+    "floor",
+    "ceil",
+    "sqrt",
+    "log",
+    "exp",
+    "pow",
+    "sign",
+    "sin",
+    "cos",
+    "tan",
+    "asin",
+    "acos",
+    "atan",
+    "todegrees",
+    "toradians",
+    "avg",
+    "sum",
+    "random",
+    "log10"
+  ]),
+  color: /* @__PURE__ */ new Set(["new", "rgb"]),
+  str: /* @__PURE__ */ new Set(["tostring", "format"])
+};
+var NAMESPACE_MEMBERS = {
+  color: /* @__PURE__ */ new Set([
+    "red",
+    "green",
+    "blue",
+    "orange",
+    "yellow",
+    "purple",
+    "white",
+    "black",
+    "gray",
+    "silver",
+    "maroon",
+    "navy",
+    "teal",
+    "aqua",
+    "lime",
+    "fuchsia",
+    "olive"
+  ]),
+  syminfo: /* @__PURE__ */ new Set(["tickerid", "ticker", "mintick", "pointvalue", "currency", "type"]),
+  timeframe: /* @__PURE__ */ new Set([
+    "period",
+    "multiplier",
+    "isintraday",
+    "isdaily",
+    "isweekly",
+    "ismonthly"
+  ])
+};
+var BUILTIN_CONSTANTS = /* @__PURE__ */ new Set(["true", "false", "na"]);
+function validateForgeScript(source) {
+  const issues = [];
+  let program;
+  try {
+    const lexer = new Lexer(source);
+    const tokens = lexer.tokenize();
+    const parser = new Parser(source);
+    void tokens;
+    program = parser.parse();
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    issues.push({
+      severity: "error",
+      code: "SYNTAX_ERROR",
+      message: msg
+    });
+    return { ok: false, issues };
+  }
+  const declaredVars = /* @__PURE__ */ new Set();
+  function walkStmt(stmt) {
+    switch (stmt.kind) {
+      case "IndicatorDecl":
+        break;
+      case "AssignStmt":
+        declaredVars.add(stmt.name);
+        walkExpr(stmt.value);
+        break;
+      case "VarDeclStmt":
+        declaredVars.add(stmt.name);
+        walkExpr(stmt.value);
+        break;
+      case "ReassignStmt":
+        if (!declaredVars.has(stmt.name) && !BUILTIN_SERIES.has(stmt.name)) {
+          issues.push({
+            severity: "warning",
+            code: "REASSIGN_UNDECLARED",
+            message: `Reassigning undeclared variable '${stmt.name}' \u2014 may fail at runtime`
+          });
+        }
+        walkExpr(stmt.value);
+        break;
+      case "ExprStmt":
+        walkExpr(stmt.expr);
+        break;
+      case "IfStmt":
+        walkExpr(stmt.condition);
+        stmt.then.forEach(walkStmt);
+        stmt.else_?.forEach(walkStmt);
+        break;
+      case "WhileStmt":
+        walkExpr(stmt.condition);
+        stmt.body.forEach(walkStmt);
+        break;
+      case "ForStmt":
+        declaredVars.add(stmt.name);
+        walkExpr(stmt.start);
+        walkExpr(stmt.end);
+        if (stmt.step) walkExpr(stmt.step);
+        stmt.body.forEach(walkStmt);
+        break;
+    }
+  }
+  function walkExpr(expr) {
+    switch (expr.kind) {
+      case "CallExpr":
+        validateCall(expr);
+        expr.args.forEach(walkExpr);
+        if (expr.namedArgs) {
+          for (const v of expr.namedArgs.values()) walkExpr(v);
+        }
+        break;
+      case "NsCallExpr":
+        validateNsCall(expr);
+        expr.args.forEach(walkExpr);
+        if (expr.namedArgs) {
+          for (const v of expr.namedArgs.values()) walkExpr(v);
+        }
+        break;
+      case "MemberExpr":
+        validateMember(expr);
+        break;
+      case "Identifier": {
+        const name = expr.name;
+        if (!declaredVars.has(name) && !BUILTIN_SERIES.has(name) && !BUILTIN_CONSTANTS.has(name) && !BUILTIN_FUNCTIONS.has(name)) {
+          issues.push({
+            severity: "warning",
+            code: "UNKNOWN_IDENT",
+            message: `Unknown identifier '${name}' \u2014 may fail at runtime`
+          });
+        }
+        break;
+      }
+      case "BinaryExpr":
+        walkExpr(expr.left);
+        walkExpr(expr.right);
+        break;
+      case "UnaryExpr":
+        walkExpr(expr.operand);
+        break;
+      case "TernaryExpr":
+        walkExpr(expr.condition);
+        walkExpr(expr.consequent);
+        walkExpr(expr.alternate);
+        break;
+      case "LogicalExpr":
+        walkExpr(expr.left);
+        walkExpr(expr.right);
+        break;
+      case "IndexExpr":
+        walkExpr(expr.series);
+        walkExpr(expr.index);
+        break;
+    }
+  }
+  function validateCall(expr) {
+    if (!BUILTIN_FUNCTIONS.has(expr.callee)) {
+      issues.push({
+        severity: "error",
+        code: "UNKNOWN_FUNCTION",
+        message: `Unknown function '${expr.callee}()' \u2014 not a ForgeScript built-in`
+      });
+    }
+  }
+  function validateNsCall(expr) {
+    const ns = expr.namespace;
+    const fn = expr.fn;
+    const allowed = NAMESPACE_FUNCTIONS[ns];
+    if (!allowed) {
+      issues.push({
+        severity: "error",
+        code: "UNKNOWN_NAMESPACE",
+        message: `Unknown namespace '${ns}' \u2014 ForgeScript supports ta, math, color, str`
+      });
+      return;
+    }
+    if (!allowed.has(fn)) {
+      issues.push({
+        severity: "error",
+        code: "UNKNOWN_NS_FUNCTION",
+        message: `Unknown function '${ns}.${fn}()' \u2014 not a supported ${ns}.* built-in`
+      });
+    }
+  }
+  function validateMember(expr) {
+    const obj = expr.object;
+    const prop = expr.prop;
+    const allowed = NAMESPACE_MEMBERS[obj];
+    if (!allowed) {
+      return;
+    }
+    if (!allowed.has(prop)) {
+      issues.push({
+        severity: "error",
+        code: "UNKNOWN_MEMBER",
+        message: `Unknown member '${obj}.${prop}' \u2014 not a recognised property`
+      });
+    }
+  }
+  for (const stmt of program.stmts) {
+    walkStmt(stmt);
+  }
+  const hasErrors = issues.some((i) => i.severity === "error");
+  return { ok: !hasErrors, issues };
+}
+
+// src/forgescript/conversion/sandbox.ts
+function generateSyntheticBars(count) {
+  const bars = [];
+  let close = 100;
+  for (let i = 0; i < count; i++) {
+    const change = (Math.sin(i * 0.1) + Math.cos(i * 0.07)) * 2;
+    close = Math.max(1, close + change);
+    const high = close + Math.abs(Math.sin(i * 0.3)) * 3;
+    const low = close - Math.abs(Math.cos(i * 0.3)) * 3;
+    const open = close + (Math.sin(i * 0.2) - 0.5) * 2;
+    bars.push({
+      time: 1609459200 + i * 60,
+      // 2021-01-01 + 1min bars
+      open: Math.max(low, Math.min(high, open)),
+      high,
+      low,
+      close,
+      volume: 1e3 + Math.floor(Math.abs(Math.sin(i * 0.5)) * 5e3)
+    });
+  }
+  return bars;
+}
+var SANDBOX_BARS = generateSyntheticBars(200);
+var MAX_EXECUTION_MS = 5e3;
+function runSandbox(source, bars) {
+  const testBars = bars ?? SANDBOX_BARS;
+  let indicator;
+  try {
+    indicator = new ForgeScriptIndicator(source);
+  } catch (err) {
+    return {
+      ok: false,
+      plotCount: 0,
+      barCount: testBars.length,
+      error: `Compile error: ${err instanceof Error ? err.message : String(err)}`,
+      preview: []
+    };
+  }
+  const start = Date.now();
+  try {
+    const result = indicator.runFull(testBars);
+    const elapsed = Date.now() - start;
+    if (elapsed > MAX_EXECUTION_MS) {
+      return {
+        ok: false,
+        plotCount: result.plots.length,
+        barCount: testBars.length,
+        error: `Execution exceeded ${MAX_EXECUTION_MS}ms timeout (took ${elapsed}ms)`,
+        preview: []
+      };
+    }
+    const preview = result.plots.map((plot, i) => {
+      const last = plot.length > 0 ? plot[plot.length - 1] : null;
+      return {
+        title: result.plotMetas[i]?.title ?? `Plot ${i + 1}`,
+        lastValue: last?.value ?? NaN
+      };
+    });
+    return {
+      ok: true,
+      plotCount: result.plots.length,
+      barCount: testBars.length,
+      preview
+    };
+  } catch (err) {
+    return {
+      ok: false,
+      plotCount: 0,
+      barCount: testBars.length,
+      error: `Runtime error: ${err instanceof Error ? err.message : String(err)}`,
+      preview: []
+    };
+  }
+}
+
+// src/forgescript/conversion/save-gate.ts
+function evaluateSaveGate(params) {
+  const { validation, sandbox, warnings, warningsAcknowledged, userConfirmed } = params;
+  const blockers = [];
+  const warningsToAcknowledge = [];
+  if (!validation.ok) {
+    const errors = validation.issues.filter((i) => i.severity === "error");
+    blockers.push(
+      `Validation failed with ${errors.length} error(s): ${errors.map((e) => e.message).join("; ")}`
+    );
+  }
+  if (sandbox !== null && !sandbox.ok) {
+    blockers.push(`Sandbox execution failed: ${sandbox.error ?? "unknown error"}`);
+  }
+  const significantWarnings = warnings.filter((w) => w.severity === "warning" || w.severity === "error");
+  if (significantWarnings.length > 0) {
+    for (const w of significantWarnings) {
+      warningsToAcknowledge.push(w.message);
+    }
+    if (!warningsAcknowledged) {
+      blockers.push(`${significantWarnings.length} warning(s) must be acknowledged before saving`);
+    }
+  }
+  if (!userConfirmed) {
+    blockers.push("User has not confirmed save");
+  }
+  return {
+    canSave: blockers.length === 0,
+    blockers,
+    warningsToAcknowledge
+  };
+}
+
+// src/forgescript/conversion/prompts/index.ts
+var FORGESCRIPT_REFERENCE = `
+## ForgeScript Language Reference
+
+ForgeScript is a domain-specific language for financial technical indicators.
+It uses a bar-by-bar execution model with persistent series state.
+
+### Data Series (always available)
+open, high, low, close, volume, time, hl2, hlc3, ohlc4, bar_index
+
+### Bar State
+barstate.islast, barstate.isfirst, barstate.isconfirmed, barstate.isnew,
+barstate.isrealtime (always false), barstate.ishistory (always true)
+
+### Syntax
+
+CRITICAL \u2014 Assignment vs Reassignment:
+- First assignment MUST use = (equals sign):  length = input(14)
+- Reassignment of an existing variable uses := (colon-equals):  length := length + 1
+- NEVER use := to declare a variable for the first time \u2014 this is a runtime error
+- var (init-once per symbol): var x = 0   (uses = for the initial declaration)
+- varip (init-once per session): varip x = 0   (uses = for the initial declaration)
+- if/else (using indented blocks)
+- for i = start to end [by step] (indented block)
+- while condition (indented block)
+- Ternary: condition ? then : else
+- Index lookback: series[n] \u2014 access n bars ago
+- Named arguments: plot(val, title="EMA", color=#FF0000)
+
+### Built-in Functions
+
+#### Technical Analysis (flat or ta.* namespace)
+sma, ema, wma, rma, rsi, stdev, atr, highest, lowest, change, mom,
+crossover, crossunder, cross, macd, bb, stoch, obv, correlation,
+dev, variance, cum, sum, valuewhen, barssince, pivothigh, pivotlow,
+tr, swma, vwma, rising, falling
+
+#### Math (flat or math.* namespace)
+abs, max, min, round, floor, ceil, sqrt, log, exp, pow, sign,
+sin, cos, tan, asin, acos, atan, todegrees, toradians, avg, sum, random, log10
+
+#### Color
+17 named constants: color.red, color.green, color.blue, etc.
+color.new(r, g, b, a), color.rgb(r, g, b, a)
+Hex literals: #RRGGBB or #RRGGBBAA
+
+#### String
+str.tostring(value), str.tonumber(value), str.format(template, args...),
+str.length(s), str.trim(s), str.contains(s, sub), str.substring(s, start, end),
+str.replace_all(s, target, replacement), str.upper(s), str.lower(s),
+str.split(s, separator) \u2192 returns an array
+
+#### Arrays
+array.new_float(size, initial_value), array.new_int(size, initial_value),
+array.new_string(size, initial_value), array.new_bool(size, initial_value),
+array.from(val1, val2, ...) \u2014 create array from values
+array.size(arr), array.get(arr, index), array.set(arr, index, value),
+array.push(arr, value), array.pop(arr), array.remove(arr, index),
+array.clear(arr), array.includes(arr, value), array.indexof(arr, value),
+array.slice(arr, start, end), array.join(arr, separator),
+array.sort(arr), array.reverse(arr),
+array.avg(arr), array.sum(arr), array.min(arr), array.max(arr)
+
+#### Tables (screen-positioned text panels)
+table.new(position, columns, rows, bgcolor=, border_color=, border_width=, frame_color=, frame_width=) \u2014 returns table id
+table.cell(table_id, column, row, text, text_color=, bgcolor=, text_size=, text_halign=, text_valign=)
+table.clear(table_id, column, row) \u2014 remove a single cell
+table.delete(table_id) \u2014 remove the entire table
+Position values: "top_right", "top_left", "bottom_right", "bottom_left", etc.
+Alignment: text.align_left \u2192 "left", text.align_center \u2192 "center", text.align_right \u2192 "right"
+           text.align_top \u2192 "top", text.align_bottom \u2192 "bottom"
+
+#### User-defined Functions
+name(param1, param2) => expression
+name(param1, param2) =>
+  statement1
+  statement2
+  result_expression
+
+#### Output
+plot(value, title=, color=, linewidth=, style=)
+plotshape(condition, style=, location=, color=, text=, title=)
+plotchar, plotarrow, hline(price), fill, bgcolor(color), barcolor(color)
+
+#### Pine Enum Constants (pass through as strings)
+shape.*  \u2192 "circle", "triangleup", "arrowup", etc.
+location.*  \u2192 "abovebar", "belowbar", "top", "bottom", "absolute"
+plot.style_*  \u2192 "line", "histogram", "area", "columns"
+position.*  \u2192 "top_right", "top_left", "bottom_right", "bottom_left", etc.
+size.*  \u2192 "auto", "tiny", "small", "normal", "large", "huge"
+text.align_*  \u2192 "left", "center", "right", "top", "bottom"
+
+#### Utility
+input(defval, title=), input.text_area(defval), input.string(defval), na, nz(value, replacement)
+
+### NOT SUPPORTED (do NOT use these)
+- strategy.*, alertcondition, alert
+- label, line, box, matrix
+- import/export/module/library
+- Classes or OOP constructs
+- Async/await, promises, callbacks
+- File I/O, network requests
+- request.security (stub only \u2014 returns 0)
+`.trim();
+var PINE_SYSTEM_PROMPT = `
+You are a Pine Script to ForgeScript converter.
+
+IMPORTANT RULES:
+1. ForgeScript is very similar to Pine Script but NOT identical
+2. Remove //@version=N annotations \u2014 ForgeScript does not use them
+3. Convert ta.* calls \u2014 they work the same in ForgeScript
+4. Convert color.* constants \u2014 ForgeScript uses the same naming
+5. Keep indicator() declaration \u2014 this is required
+6. Preserve var/varip semantics exactly
+7. CRITICAL: Use = for first assignment, := ONLY for reassignment of existing variables
+   - CORRECT:   length = input(14)    src = close    value = rsi(src, length)
+   - WRONG:     length := input(14)   src := close   value := rsi(src, length)
+   - := is ONLY for updating a variable that was already declared with = or var/varip
+8. If the script uses strategy.*, you CANNOT convert it \u2014 report it as unsupported
+9. If the script uses request.security(), warn that it returns 0 in ForgeScript
+10. Remove type annotations (int, float, string, bool prefixes on variable declarations)
+11. Convert for..in loops to standard for loops where possible
+12. Keep plot(), plotshape(), bgcolor(), barcolor() \u2014 they are supported
+13. Convert shape.* constants to plain strings: shape.circle \u2192 "circle", shape.triangleup \u2192 "triangleup", shape.arrowup \u2192 "arrowup", etc.
+14. Convert location.* constants to plain strings: location.abovebar \u2192 "abovebar", location.belowbar \u2192 "belowbar", location.top \u2192 "top", location.bottom \u2192 "bottom", location.absolute \u2192 "absolute"
+15. Convert plot.style_* constants to plain strings: plot.style_line \u2192 "line", plot.style_histogram \u2192 "histogram", plot.style_area \u2192 "area", plot.style_columns \u2192 "columns"
+16. Pine v6 features: type/method/enum/import/export declarations are NOT supported \u2014 remove them and approximate the logic inline
+17. Convert barstate.* properties \u2014 they are directly supported in ForgeScript (barstate.islast, barstate.isfirst, barstate.isconfirmed, barstate.isnew, barstate.isrealtime, barstate.ishistory)
+18. Convert position.* constants to plain strings: position.top_right \u2192 "top_right", position.bottom_left \u2192 "bottom_left", etc.
+19. Convert size.* constants to plain strings: size.large \u2192 "large", size.small \u2192 "small", size.auto \u2192 "auto", etc.
+20. str.length(s), str.trim(s), str.contains(s, sub), str.substring(s, start, end), str.replace_all(s, target, rep), str.upper(s), str.lower(s) are all supported
+21. array.* functions are supported \u2014 convert Pine array operations directly (array.new_float, array.push, array.get, array.size, etc.)
+22. table.* functions are supported \u2014 convert Pine table operations directly (table.new, table.cell, table.clear, table.delete). Preserve frame_color, frame_width, border_color, border_width named args. Preserve text_halign and text_valign named args in table.cell().
+23. str.split(s, separator) is supported \u2014 it returns a ForgeScript array
+24. User-defined functions use => syntax: myFunc(a, b) => a + b \u2014 convert Pine functions to this form
+25. Convert text.align_* constants to plain strings: text.align_left \u2192 "left", text.align_center \u2192 "center", text.align_right \u2192 "right", text.align_top \u2192 "top", text.align_bottom \u2192 "bottom"
+26. input.text_area(defval) and input.string(defval) are supported \u2014 they return string values. Convert Pine input.text_area() and input.string() with their default values.
+27. input.string() with options= parameter: the options list is informational only \u2014 convert to input.string(defval) keeping just the default value
+
+${FORGESCRIPT_REFERENCE}
+`.trim();
+var PYTHON_SYSTEM_PROMPT = `
+You are a Python to ForgeScript converter.
+
+IMPORTANT RULES:
+1. ForgeScript is a bar-by-bar DSL, NOT a general-purpose language
+2. Python pandas/numpy operations must be decomposed into per-bar logic
+3. Rolling window operations (df.rolling()) map to ForgeScript built-ins (sma, ema, etc.)
+4. Python def functions \u2192 convert to ForgeScript => syntax: myFunc(a, b) => a + b
+5. Python classes are NOT supported
+6. Python list comprehensions \u2192 for loops or array.* functions
+7. np.mean over a window \u2192 sma()
+8. talib.RSI \u2192 rsi()
+9. Any file I/O, HTTP requests, or database calls \u2192 UNSUPPORTED
+10. matplotlib/plotly plotting \u2192 plot() calls
+11. All state must use var/varip or direct assignment \u2014 no global dicts
+12. Convert common ta-lib function names to ForgeScript equivalents:
+    - talib.SMA \u2192 sma, talib.EMA \u2192 ema, talib.RSI \u2192 rsi
+    - talib.BBANDS \u2192 bb, talib.MACD \u2192 macd, talib.STOCH \u2192 stoch
+    - talib.ATR \u2192 atr, talib.OBV \u2192 obv
+13. CRITICAL: Use = for first assignment, := ONLY for reassignment of existing variables
+
+${FORGESCRIPT_REFERENCE}
+`.trim();
+var JAVASCRIPT_SYSTEM_PROMPT = `
+You are a JavaScript/TypeScript to ForgeScript converter.
+
+IMPORTANT RULES:
+1. ForgeScript is a bar-by-bar DSL \u2014 no event loops, callbacks, or async
+2. Convert for/while loops that iterate over bars into per-bar logic with lookback
+3. Array.reduce, .map, .filter operations \u2192 for loops, array.* functions, or built-in aggregates
+4. Function declarations \u2192 convert to ForgeScript => syntax: myFunc(a, b) => a + b
+5. Classes \u2192 NOT SUPPORTED
+6. Promises, async/await \u2192 NOT SUPPORTED
+7. DOM manipulation \u2192 NOT SUPPORTED
+8. console.log \u2192 remove or convert to plot()
+9. Convert any technical indicator library calls to ForgeScript equivalents
+10. Module imports/exports \u2192 NOT SUPPORTED
+11. JSON, fetch, XMLHttpRequest \u2192 NOT SUPPORTED
+12. Math.* maps directly to ForgeScript math.* or flat functions
+13. CRITICAL: Use = for first assignment, := ONLY for reassignment of existing variables
+
+${FORGESCRIPT_REFERENCE}
+`.trim();
+var GENERIC_SYSTEM_PROMPT = `
+You are a script converter that translates arbitrary scripting code into ForgeScript.
+
+IMPORTANT RULES:
+1. First identify what the script is trying to compute (technical indicator, signal, etc.)
+2. Re-implement the logic using only ForgeScript constructs
+3. Do NOT try to transliterate line-by-line \u2014 understand the intent first
+4. Use only supported ForgeScript built-in functions
+5. If the script uses concepts that don't map to bar-by-bar execution, report them as unsupported
+6. Be conservative \u2014 when in doubt, mark as unsupported rather than guessing
+7. CRITICAL: Use = for first assignment, := ONLY for reassignment of existing variables
+
+${FORGESCRIPT_REFERENCE}
+`.trim();
+function getSystemPrompt(language) {
+  switch (language) {
+    case "pine":
+      return PINE_SYSTEM_PROMPT;
+    case "python":
+      return PYTHON_SYSTEM_PROMPT;
+    case "javascript":
+      return JAVASCRIPT_SYSTEM_PROMPT;
+    case "forgescript":
+      return PINE_SYSTEM_PROMPT;
+    // reuse Pine rules — they're closest
+    default:
+      return GENERIC_SYSTEM_PROMPT;
+  }
+}
+function buildConversionPrompt(sourceLanguage, sourceCode) {
+  const langLabel = sourceLanguage === "unknown" ? "an unknown language" : sourceLanguage;
+  return [
+    `Convert the following ${langLabel} script to valid ForgeScript.`,
+    `Use = for new variable declarations, := only for reassignment of existing variables.`,
+    "",
+    "```",
+    sourceCode,
+    "```"
+  ].join("\n");
+}
+
+// src/forgescript/conversion/ai-conversion-agent.ts
+var SECTION_HEADER = /^###\s+SECTION\s+(\d+)\s*[—–-]\s*(.*)/im;
+function parseAIResponse(raw) {
+  const sections = splitSections(raw);
+  const codeBlock = sections[1] ?? "";
+  const forgeScript = extractCodeBlock(codeBlock);
+  const warnings = parseBullets(sections[2] ?? "").map((msg) => ({
+    severity: "warning",
+    category: categoriseWarning(msg),
+    message: msg
+  }));
+  const assumptions = parseBullets(sections[3] ?? "").map((d) => ({ description: d }));
+  const reviewChecklist = parseBullets(sections[4] ?? "").map((d) => ({ description: d }));
+  const unsupportedFeatures = parseBullets(sections[5] ?? "");
+  const { confidence, explanation } = parseConfidence(sections[6] ?? "");
+  return {
+    forgeScript,
+    warnings,
+    assumptions,
+    reviewChecklist,
+    unsupportedFeatures,
+    confidence,
+    confidenceExplanation: explanation
+  };
+}
+async function runAIConversion(source, language, llm) {
+  const systemPrompt = getSystemPrompt(language);
+  const userMessage = buildConversionPrompt(language, source);
+  const messages = [
+    { role: "system", content: systemPrompt },
+    { role: "user", content: userMessage }
+  ];
+  const raw = await llm(messages);
+  if (raw === null) return null;
+  try {
+    const parsed = JSON.parse(raw);
+    if (typeof parsed.forgeScript === "string" && Array.isArray(parsed.warnings)) {
+      return parseStructuredJSON(parsed);
+    }
+  } catch {
+  }
+  return parseAIResponse(raw);
+}
+function parseStructuredJSON(obj) {
+  const VALID_SEVERITIES = /* @__PURE__ */ new Set(["info", "warning", "error"]);
+  const VALID_CATEGORIES = /* @__PURE__ */ new Set(["approximation", "unsupported", "semantic_risk", "hallucination", "general"]);
+  const VALID_CONFIDENCE = /* @__PURE__ */ new Set(["HIGH", "MEDIUM", "LOW"]);
+  const rawWarnings = Array.isArray(obj.warnings) ? obj.warnings : [];
+  const warnings = rawWarnings.filter((w) => w !== null && typeof w === "object").map((w) => ({
+    severity: VALID_SEVERITIES.has(String(w.severity)) ? String(w.severity) : "warning",
+    category: VALID_CATEGORIES.has(String(w.category)) ? String(w.category) : "general",
+    message: String(w.message ?? "")
+  }));
+  const toDescList = (arr) => (Array.isArray(arr) ? arr : []).filter((v) => v !== null && typeof v === "object").map((v) => ({ description: String(v.description ?? "") }));
+  const confidence = VALID_CONFIDENCE.has(String(obj.confidence)) ? String(obj.confidence) : "LOW";
+  return {
+    forgeScript: String(obj.forgeScript ?? ""),
+    warnings,
+    assumptions: toDescList(obj.assumptions),
+    reviewChecklist: toDescList(obj.reviewChecklist),
+    unsupportedFeatures: Array.isArray(obj.unsupportedFeatures) ? obj.unsupportedFeatures.map(String) : [],
+    confidence,
+    confidenceExplanation: String(obj.confidenceExplanation ?? "No explanation provided")
+  };
+}
+function splitSections(raw) {
+  const out = {};
+  const parts = raw.split(SECTION_HEADER);
+  for (let i = 1; i < parts.length; i += 3) {
+    const num = parseInt(parts[i], 10);
+    const body = (parts[i + 2] ?? "").trim();
+    if (!isNaN(num)) out[num] = body;
+  }
+  if (Object.keys(out).length === 0) {
+    out[1] = raw;
+  }
+  return out;
+}
+function extractCodeBlock(text) {
+  const match = text.match(/```(?:forgescript)?\s*\n([\s\S]*?)```/);
+  if (match) return match[1].trim();
+  return text.trim();
+}
+function parseBullets(text) {
+  if (text.toLowerCase().trim() === "none") return [];
+  return text.split("\n").map((l) => l.replace(/^[-*•]\s*/, "").trim()).filter((l) => l.length > 0 && l.toLowerCase() !== "none");
+}
+function categoriseWarning(msg) {
+  const lower = msg.toLowerCase();
+  if (lower.includes("approximat")) return "approximation";
+  if (lower.includes("unsupported") || lower.includes("not supported")) return "unsupported";
+  if (lower.includes("semantic") || lower.includes("risk") || lower.includes("different")) return "semantic_risk";
+  return "general";
+}
+function parseConfidence(text) {
+  const lines = text.split("\n").filter((l) => l.trim().length > 0);
+  let confidence = "LOW";
+  let explanation = "No confidence information provided";
+  for (const line of lines) {
+    const upper = line.trim().toUpperCase();
+    if (upper.startsWith("HIGH")) {
+      confidence = "HIGH";
+      explanation = line.trim().replace(/^HIGH\s*/i, "");
+    } else if (upper.startsWith("MEDIUM")) {
+      confidence = "MEDIUM";
+      explanation = line.trim().replace(/^MEDIUM\s*/i, "");
+    } else if (upper.startsWith("LOW")) {
+      confidence = "LOW";
+      explanation = line.trim().replace(/^LOW\s*/i, "");
+    } else if (!explanation || explanation === "No confidence information provided") {
+      explanation = line.trim();
+    }
+  }
+  return { confidence, explanation: explanation || "No explanation provided" };
+}
+
+// src/forgescript/conversion/telemetry.ts
+var listeners = [];
+function onConversionEvent(listener) {
+  listeners.push(listener);
+  return () => {
+    const idx = listeners.indexOf(listener);
+    if (idx >= 0) listeners.splice(idx, 1);
+  };
+}
+function emitConversionEvent(event) {
+  for (const listener of listeners) {
+    try {
+      listener(event);
+    } catch {
+    }
+  }
+}
+function buildTelemetryEvent(params) {
+  return { timestamp: Date.now(), ...params };
+}
+function clearTelemetryListeners() {
+  listeners.length = 0;
+}
+
+// src/forgescript/conversion/conversion-orchestrator.ts
+async function convertScript(source, options = {}) {
+  const {
+    llmProvider,
+    skipSandbox = false,
+    acknowledgeWarnings = false,
+    confirmSave = false,
+    forceAI = false
+  } = options;
+  const detectedLanguage = options.sourceLanguage ?? (options.aiClassifier ? (await detectLanguageWithFallback(source, options.aiClassifier)).language : detectLanguage(source).language);
+  let forgeScript = "";
+  let conversionPath = "passthrough";
+  let warnings = [];
+  let assumptions = [];
+  let reviewChecklist = [];
+  let unsupportedFeatures = [];
+  let confidence = "HIGH";
+  let confidenceExplanation = "Source is already ForgeScript";
+  let deterministicOutput;
+  if (detectedLanguage === "forgescript") {
+    forgeScript = source;
+    conversionPath = "passthrough";
+  } else if (detectedLanguage === "pine" && !forceAI) {
+    conversionPath = "deterministic";
+    try {
+      const compiler = new PineCompiler();
+      const result2 = compiler.compile(source);
+      forgeScript = result2.tscript;
+      deterministicOutput = result2.tscript;
+      for (const d of result2.diagnostics) {
+        warnings.push({
+          severity: d.severity === "error" ? "error" : "warning",
+          category: d.code === "PINE_UNSUPPORTED_FN" ? "unsupported" : "general",
+          message: `[Pine] ${d.message}`
+        });
+      }
+      confidence = result2.ok ? "HIGH" : "MEDIUM";
+      confidenceExplanation = result2.ok ? "Deterministic Pine\u2192ForgeScript conversion completed without errors" : "Deterministic conversion completed with warnings \u2014 review recommended";
+      if (llmProvider && !result2.ok) {
+        const aiResult = await runAIConversion(source, "pine", llmProvider);
+        if (aiResult && aiResult.forgeScript.trim().length > 0) {
+          conversionPath = "hybrid";
+          forgeScript = aiResult.forgeScript;
+          warnings = [...warnings, ...aiResult.warnings];
+          assumptions = aiResult.assumptions;
+          reviewChecklist = aiResult.reviewChecklist;
+          unsupportedFeatures = aiResult.unsupportedFeatures;
+          confidence = aiResult.confidence;
+          confidenceExplanation = `Hybrid: deterministic conversion had issues, AI refinement applied. ${aiResult.confidenceExplanation}`;
+        }
+      }
+    } catch (err) {
+      const errMsg = err instanceof Error ? err.message : String(err);
+      warnings.push({
+        severity: "warning",
+        category: "general",
+        message: `Deterministic Pine conversion failed: ${errMsg}`
+      });
+      if (llmProvider) {
+        const aiResult = await runAIConversion(source, "pine", llmProvider);
+        if (aiResult) {
+          conversionPath = "ai";
+          forgeScript = aiResult.forgeScript;
+          warnings = [...warnings, ...aiResult.warnings];
+          assumptions = aiResult.assumptions;
+          reviewChecklist = aiResult.reviewChecklist;
+          unsupportedFeatures = aiResult.unsupportedFeatures;
+          confidence = aiResult.confidence;
+          confidenceExplanation = aiResult.confidenceExplanation;
+        }
+      }
+    }
+  } else {
+    conversionPath = "ai";
+    if (!llmProvider) {
+      warnings.push({
+        severity: "error",
+        category: "general",
+        message: `AI conversion required for ${detectedLanguage} but no LLM provider configured`
+      });
+      confidence = "LOW";
+      confidenceExplanation = "No LLM provider available for non-Pine conversion";
+    } else {
+      const aiResult = await runAIConversion(source, detectedLanguage, llmProvider);
+      if (aiResult) {
+        forgeScript = aiResult.forgeScript;
+        warnings = aiResult.warnings;
+        assumptions = aiResult.assumptions;
+        reviewChecklist = aiResult.reviewChecklist;
+        unsupportedFeatures = aiResult.unsupportedFeatures;
+        confidence = aiResult.confidence;
+        confidenceExplanation = aiResult.confidenceExplanation;
+      } else {
+        warnings.push({
+          severity: "error",
+          category: "general",
+          message: "AI conversion returned no result \u2014 LLM may be unavailable"
+        });
+        confidence = "LOW";
+        confidenceExplanation = "AI conversion failed";
+      }
+    }
+  }
+  const validation = forgeScript.trim().length > 0 ? validateForgeScript(forgeScript) : { ok: false, issues: [{ severity: "error", code: "EMPTY_SCRIPT", message: "No ForgeScript produced" }] };
+  const sandbox = !skipSandbox && validation.ok ? runSandbox(forgeScript) : null;
+  const saveGate = evaluateSaveGate({
+    validation,
+    sandbox,
+    warnings,
+    warningsAcknowledged: acknowledgeWarnings,
+    userConfirmed: confirmSave
+  });
+  emitConversionEvent(buildTelemetryEvent({
+    sourceLanguage: detectedLanguage,
+    detectionConfidence: confidence,
+    conversionPath,
+    validationOk: validation.ok,
+    sandboxOk: sandbox?.ok ?? null,
+    savedByUser: null,
+    // set by the caller after save
+    errorCount: validation.issues.filter((i) => i.severity === "error").length,
+    warningCount: warnings.length,
+    unsupportedCount: unsupportedFeatures.length
+  }));
+  const result = {
+    sourceLanguage: detectedLanguage,
+    conversionPath,
+    forgeScript,
+    validation,
+    sandbox,
+    saveGate,
+    warnings,
+    assumptions,
+    reviewChecklist,
+    unsupportedFeatures,
+    confidence,
+    confidenceExplanation
+  };
+  if (deterministicOutput !== void 0) {
+    result.deterministicOutput = deterministicOutput;
+  }
+  return result;
+}
+
 // src/api/drawing tools/pointers menu/cursor.ts
 var CURSOR_LABEL = "Arrow";
 var CURSOR_STYLE = "default";
@@ -8096,6 +11196,6 @@ var demonstrationTool = {
   cursorStyle: DEMONSTRATION_STYLE
 };
 
-export { CROSSHAIR_LABEL, CROSSHAIR_STYLE, CURSOR_LABEL, CURSOR_STYLE, CandleEngine, ChartRuntimeResolver, CoordTransform, DEMONSTRATION_COLOR, DEMONSTRATION_FILL, DEMONSTRATION_LABEL, DEMONSTRATION_RADIUS, DEMONSTRATION_STROKE, DEMONSTRATION_STYLE, DOT_COLOR, DOT_LABEL, DOT_RADIUS, DOT_STYLE, DatafeedConnector, DiagnosticBag, IndicatorDAG, LicenseManager, ManagedTradingController, PaneManager, PineCompiler, ReferenceAPI, TChart, TScriptIndicator, TScriptRuntime, Series2 as TScriptSeries, TradingOverlayStore, UnmanagedIngestion, assertCanPlaceOrders, assertCanUseBrackets, assertCanUseDraggableOrders, assertCanUseManagedTrading, assertManagedMode, canPlaceBrackets, canPlaceOrders, canRenderBracketControls, canRenderBuySellButtons, canRenderCandles, canRenderDrawings, canRenderExternalOverlayOnlyMode, canRenderFills, canRenderIndicators, canRenderManagedTradingControls, canRenderOrderEntry, canRenderOrderModificationControls, canRenderOrderTicket, canRenderOverlays, canRenderPositions, canUseBracketOrders, canUseDraggable, canUseDraggableOrders, canUseExternalIngestion, canUseIndicators, canUseManagedTrading, canUseManagedTradingHook, canUseOrderEntry, computeEMA, computeEMAFromSeries, computeMACD, computeRSI, computeSMA, computeSMAFromSeries, computeVolume, computeWMAFromSeries, createChart, crosshairTool, cursorTool, demonstrationTool, dotTool, extractField, getBucketStart2 as getBucketStart, getCapabilities, getMissingBarCount, isManagedCapable, isManagedMode, isUnmanagedMode, mergeBars, timeframeToMs2 as timeframeToMs };
+export { CROSSHAIR_LABEL, CROSSHAIR_STYLE, CURSOR_LABEL, CURSOR_STYLE, CandleEngine, ChartRuntimeResolver, CoordTransform, DEMONSTRATION_COLOR, DEMONSTRATION_FILL, DEMONSTRATION_LABEL, DEMONSTRATION_RADIUS, DEMONSTRATION_STROKE, DEMONSTRATION_STYLE, DOT_COLOR, DOT_LABEL, DOT_RADIUS, DOT_STYLE, DatafeedConnector, DiagnosticBag, FORGESCRIPT_REFERENCE, ForgeScriptIndicator, ForgeScriptRuntime, Series2 as ForgeScriptSeries, IndicatorDAG, LicenseManager, ManagedTradingController, PaneManager, PineCompiler, ReferenceAPI, TChart, TradingOverlayStore, UnmanagedIngestion, assertCanPlaceOrders, assertCanUseBrackets, assertCanUseDraggableOrders, assertCanUseManagedTrading, assertManagedMode, buildConversionPrompt, canPlaceBrackets, canPlaceOrders, canRenderBracketControls, canRenderBuySellButtons, canRenderCandles, canRenderDrawings, canRenderExternalOverlayOnlyMode, canRenderFills, canRenderIndicators, canRenderManagedTradingControls, canRenderOrderEntry, canRenderOrderModificationControls, canRenderOrderTicket, canRenderOverlays, canRenderPositions, canUseBracketOrders, canUseDraggable, canUseDraggableOrders, canUseExternalIngestion, canUseIndicators, canUseManagedTrading, canUseManagedTradingHook, canUseOrderEntry, clearTelemetryListeners, computeEMA, computeEMAFromSeries, computeMACD, computeRSI, computeSMA, computeSMAFromSeries, computeVolume, computeWMAFromSeries, convertScript, createChart, crosshairTool, cursorTool, demonstrationTool, detectLanguage, detectLanguageWithFallback, dotTool, evaluateSaveGate, exchangeNow, extractField, getBucketStart2 as getBucketStart, getCapabilities, getMissingBarCount, getSystemPrompt, initServerClock, isManagedCapable, isManagedMode, isUnmanagedMode, mergeBars, onConversionEvent, parseAIResponse, runAIConversion, runSandbox, serverClockOffset, serverNow, timeframeToMs2 as timeframeToMs, validateForgeScript };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map