@ggterm/core 0.2.17 → 0.3.0

package/dist/cli-plot.js

@@ -3708,6 +3708,96 @@ function renderGeomVolcano(data, geom, aes, scales, canvas) {
   }
   if (nLabels > 0 && aes.label) {
     const significantPoints = points.filter((p) => p.status !== "ns" && p.label).sort((a, b) => b.significance - a.significance).slice(0, nLabels);
+    const labelColor = { r: 255, g: 255, b: 255, a: 1 };
+    for (const point of significantPoints) {
+      const cx = Math.round(scales.x.map(point.x));
+      const cy = Math.round(scales.y.map(point.y));
+      const label = point.label;
+      const labelX = cx + 1;
+      const labelY = cy;
+      for (let i = 0;i < label.length; i++) {
+        canvas.drawChar(labelX + i, labelY, label[i], labelColor);
+      }
+    }
+  }
+}
+function renderGeomMA(data, geom, aes, scales, canvas) {
+  const fcThreshold = geom.params.fc_threshold ?? 1;
+  const pThreshold = geom.params.p_threshold ?? 0.05;
+  const pCol = geom.params.p_col;
+  const xIsLog2 = geom.params.x_is_log2 ?? false;
+  const upColor = parseColorToRgba(geom.params.up_color ?? "#e41a1c");
+  const downColor = parseColorToRgba(geom.params.down_color ?? "#377eb8");
+  const nsColor = parseColorToRgba(geom.params.ns_color ?? "#999999");
+  const showBaseline = geom.params.show_baseline ?? true;
+  const showThresholds = geom.params.show_thresholds ?? true;
+  const nLabels = geom.params.n_labels ?? 0;
+  const pointChar = geom.params.point_char ?? "●";
+  const points = [];
+  for (const row of data) {
+    let xVal = Number(row[aes.x]);
+    const yVal = Number(row[aes.y]);
+    if (isNaN(xVal) || isNaN(yVal))
+      continue;
+    if (xVal <= 0)
+      continue;
+    if (!xIsLog2) {
+      xVal = Math.log2(xVal);
+    }
+    let status = "ns";
+    const passesFcThreshold = Math.abs(yVal) >= fcThreshold;
+    let passesPThreshold = true;
+    if (pCol && row[pCol] !== undefined) {
+      const pVal = Number(row[pCol]);
+      passesPThreshold = !isNaN(pVal) && pVal < pThreshold;
+    }
+    if (passesFcThreshold && passesPThreshold) {
+      status = yVal > 0 ? "up" : "down";
+    }
+    const label = aes.label ? String(row[aes.label] ?? "") : undefined;
+    points.push({
+      row,
+      x: xVal,
+      y: yVal,
+      absM: Math.abs(yVal),
+      status,
+      label
+    });
+  }
+  const lineColor = { r: 150, g: 150, b: 150, a: 0.7 };
+  const startX = Math.round(scales.x.range[0]);
+  const endX = Math.round(scales.x.range[1]);
+  if (showBaseline) {
+    const cy = Math.round(scales.y.map(0));
+    for (let x = startX;x <= endX; x++) {
+      canvas.drawChar(x, cy, "─", lineColor);
+    }
+  }
+  if (showThresholds) {
+    const cyUp = Math.round(scales.y.map(fcThreshold));
+    const cyDown = Math.round(scales.y.map(-fcThreshold));
+    for (let x = startX;x <= endX; x += 2) {
+      canvas.drawChar(x, cyUp, "─", lineColor);
+      canvas.drawChar(x, cyDown, "─", lineColor);
+    }
+  }
+  for (const point of points) {
+    if (point.status === "ns") {
+      const cx = Math.round(scales.x.map(point.x));
+      const cy = Math.round(scales.y.map(point.y));
+      canvas.drawPoint(cx, cy, nsColor, pointChar);
+    }
+  }
+  for (const point of points) {
+    if (point.status !== "ns") {
+      const cx = Math.round(scales.x.map(point.x));
+      const cy = Math.round(scales.y.map(point.y));
+      const color = point.status === "up" ? upColor : downColor;
+      canvas.drawPoint(cx, cy, color, pointChar);
+    }
+  }
+  if (nLabels > 0 && aes.label) {
+    const significantPoints = points.filter((p) => p.status !== "ns" && p.label).sort((a, b) => b.absM - a.absM).slice(0, nLabels);
     const labelColor = { r: 50, g: 50, b: 50, a: 1 };
     for (const point of significantPoints) {
       const cx = Math.round(scales.x.map(point.x));
@@ -3721,6 +3811,1385 @@ function renderGeomVolcano(data, geom, aes, scales, canvas) {
     }
   }
 }
+function renderGeomManhattan(data, geom, aes, scales, canvas) {
+  const params = geom.params || {};
+  const suggestiveThreshold = Number(params.suggestive_threshold ?? 0.00001);
+  const genomeWideThreshold = Number(params.genome_wide_threshold ?? 0.00000005);
+  const yIsNegLog10 = Boolean(params.y_is_neglog10 ?? false);
+  const chrColors = params.chr_colors ?? ["#1f78b4", "#a6cee3"];
+  const highlightColor = String(params.highlight_color ?? "#e41a1c");
+  const suggestiveColor = String(params.suggestive_color ?? "#ff7f00");
+  const showThresholds = Boolean(params.show_thresholds ?? true);
+  const nLabels = Number(params.n_labels ?? 0);
+  const pointChar = String(params.point_char ?? "●");
+  const chrGap = Number(params.chr_gap ?? 0.02);
+  if (!Array.isArray(data) || data.length === 0)
+    return;
+  const parseHex = (hex) => {
+    const r = parseInt(hex.slice(1, 3), 16);
+    const g = parseInt(hex.slice(3, 5), 16);
+    const b = parseInt(hex.slice(5, 7), 16);
+    return { r, g, b, a: 1 };
+  };
+  const chrColorsParsed = chrColors.map((c) => parseHex(c));
+  const highlightColorParsed = parseHex(highlightColor);
+  const suggestiveColorParsed = parseHex(suggestiveColor);
+  const suggestiveLine = -Math.log10(suggestiveThreshold);
+  const genomeWideLine = -Math.log10(genomeWideThreshold);
+  const xField = aes.x;
+  const yField = aes.y;
+  const labelField = aes.label;
+  const points = [];
+  const chrMap = new Map;
+  for (const row of data) {
+    let chr;
+    let pos;
+    const rawX = row[xField];
+    const rawY = row[yField];
+    if (typeof rawX === "string" && rawX.includes(":")) {
+      const parts = rawX.split(":");
+      chr = parts[0];
+      pos = parseFloat(parts[1]);
+    } else {
+      chr = aes.color ? String(row[aes.color] ?? "1") : "1";
+      pos = typeof rawX === "number" ? rawX : parseFloat(String(rawX));
+    }
+    const pval = typeof rawY === "number" ? rawY : parseFloat(String(rawY));
+    if (isNaN(pos) || isNaN(pval) || pval <= 0)
+      continue;
+    const negLogP = yIsNegLog10 ? pval : -Math.log10(pval);
+    const label = labelField ? String(row[labelField] ?? "") : undefined;
+    const point = {
+      chr,
+      pos,
+      pval: yIsNegLog10 ? Math.pow(10, -pval) : pval,
+      negLogP,
+      cumPos: 0,
+      label,
+      chrIndex: 0
+    };
+    if (!chrMap.has(chr)) {
+      chrMap.set(chr, []);
+    }
+    chrMap.get(chr).push(point);
+    points.push(point);
+  }
+  if (points.length === 0)
+    return;
+  const chrOrder = Array.from(chrMap.keys()).sort((a, b) => {
+    const aNum = parseInt(String(a).replace(/^chr/i, ""));
+    const bNum = parseInt(String(b).replace(/^chr/i, ""));
+    if (!isNaN(aNum) && !isNaN(bNum))
+      return aNum - bNum;
+    if (!isNaN(aNum))
+      return -1;
+    if (!isNaN(bNum))
+      return 1;
+    return String(a).localeCompare(String(b));
+  });
+  let cumOffset = 0;
+  const chrOffsets = new Map;
+  for (let i = 0;i < chrOrder.length; i++) {
+    const chr = chrOrder[i];
+    chrOffsets.set(chr, cumOffset);
+    const chrPoints = chrMap.get(chr);
+    const maxPos = Math.max(...chrPoints.map((p) => p.pos));
+    for (const point of chrPoints) {
+      point.cumPos = cumOffset + point.pos;
+      point.chrIndex = i;
+    }
+    cumOffset += maxPos * (1 + chrGap);
+  }
+  const minX = Math.min(...points.map((p) => p.cumPos));
+  const maxX = Math.max(...points.map((p) => p.cumPos));
+  const minY = 0;
+  const maxY = Math.max(...points.map((p) => p.negLogP)) * 1.1;
+  const plotLeft = Math.round(scales.x.range[0]);
+  const plotRight = Math.round(scales.x.range[1]);
+  const plotTop = Math.round(scales.y.range[1]);
+  const plotBottom = Math.round(scales.y.range[0]);
+  const mapX = (v) => plotLeft + (v - minX) / (maxX - minX) * (plotRight - plotLeft);
+  const mapY = (v) => plotBottom - (v - minY) / (maxY - minY) * (plotBottom - plotTop);
+  if (showThresholds) {
+    const lineColor = { r: 150, g: 150, b: 150, a: 1 };
+    if (suggestiveLine <= maxY) {
+      const sy = Math.round(mapY(suggestiveLine));
+      for (let x = plotLeft;x <= plotRight; x += 2) {
+        canvas.drawChar(x, sy, "─", lineColor);
+      }
+    }
+    if (genomeWideLine <= maxY) {
+      const gy = Math.round(mapY(genomeWideLine));
+      for (let x = plotLeft;x <= plotRight; x += 2) {
+        canvas.drawChar(x, gy, "─", highlightColorParsed);
+      }
+    }
+  }
+  for (const point of points) {
+    if (point.pval >= suggestiveThreshold) {
+      const cx = Math.round(mapX(point.cumPos));
+      const cy = Math.round(mapY(point.negLogP));
+      const color = chrColorsParsed[point.chrIndex % chrColorsParsed.length];
+      canvas.drawPoint(cx, cy, color, pointChar);
+    }
+  }
+  for (const point of points) {
+    if (point.pval < suggestiveThreshold && point.pval >= genomeWideThreshold) {
+      const cx = Math.round(mapX(point.cumPos));
+      const cy = Math.round(mapY(point.negLogP));
+      canvas.drawPoint(cx, cy, suggestiveColorParsed, pointChar);
+    }
+  }
+  for (const point of points) {
+    if (point.pval < genomeWideThreshold) {
+      const cx = Math.round(mapX(point.cumPos));
+      const cy = Math.round(mapY(point.negLogP));
+      canvas.drawPoint(cx, cy, highlightColorParsed, pointChar);
+    }
+  }
+  if (nLabels > 0) {
+    const labelColor = { r: 50, g: 50, b: 50, a: 1 };
+    const topPoints = points.filter((p) => p.label && p.pval < suggestiveThreshold).sort((a, b) => a.pval - b.pval).slice(0, nLabels);
+    for (const point of topPoints) {
+      const cx = Math.round(mapX(point.cumPos));
+      const cy = Math.round(mapY(point.negLogP));
+      const label = point.label;
+      for (let i = 0;i < label.length; i++) {
+        canvas.drawChar(cx + 1 + i, cy, label[i], labelColor);
+      }
+    }
+  }
+}
+function renderGeomHeatmap(data, geom, aes, scales, canvas) {
+  const params = geom.params || {};
+  const valueCol = String(params.value_col ?? "value");
+  const lowColor = String(params.low_color ?? "#313695");
+  const midColor = String(params.mid_color ?? "#ffffbf");
+  const highColor = String(params.high_color ?? "#a50026");
+  const naColor = String(params.na_color ?? "#808080");
+  const clusterRows = Boolean(params.cluster_rows ?? false);
+  const clusterCols = Boolean(params.cluster_cols ?? false);
+  const showRowLabels = Boolean(params.show_row_labels ?? true);
+  const showColLabels = Boolean(params.show_col_labels ?? true);
+  const cellChar = String(params.cell_char ?? "█");
+  const scaleMethod = String(params.scale ?? "none");
+  if (!Array.isArray(data) || data.length === 0)
+    return;
+  const xField = typeof aes.x === "string" ? aes.x : "x";
+  const yField = typeof aes.y === "string" ? aes.y : "y";
+  const fillField = typeof aes.fill === "string" ? aes.fill : valueCol;
+  const parseHex = (hex) => {
+    const r = parseInt(hex.slice(1, 3), 16);
+    const g = parseInt(hex.slice(3, 5), 16);
+    const b = parseInt(hex.slice(5, 7), 16);
+    return { r, g, b, a: 1 };
+  };
+  const lowRgb = parseHex(lowColor);
+  const midRgb = parseHex(midColor);
+  const highRgb = parseHex(highColor);
+  const naRgb = parseHex(naColor);
+  const rowSet = new Set;
+  const colSet = new Set;
+  const valueMap = new Map;
+  for (const row of data) {
+    const rowKey = String(row[yField] ?? "");
+    const colKey = String(row[xField] ?? "");
+    const val = row[fillField];
+    if (rowKey && colKey) {
+      rowSet.add(rowKey);
+      colSet.add(colKey);
+      if (typeof val === "number" && !isNaN(val)) {
+        valueMap.set(`${rowKey}|${colKey}`, val);
+      }
+    }
+  }
+  let rowKeys = Array.from(rowSet);
+  let colKeys = Array.from(colSet);
+  if (rowKeys.length === 0 || colKeys.length === 0)
+    return;
+  const clusterOrder = (keys, getDistance) => {
+    if (keys.length <= 2)
+      return keys;
+    const remaining = [...keys];
+    const result = [];
+    let minAvg = Infinity;
+    let startIdx = 0;
+    for (let i = 0;i < remaining.length; i++) {
+      let sum = 0;
+      for (let j = 0;j < remaining.length; j++) {
+        if (i !== j)
+          sum += getDistance(remaining[i], remaining[j]);
+      }
+      const avg = sum / (remaining.length - 1);
+      if (avg < minAvg) {
+        minAvg = avg;
+        startIdx = i;
+      }
+    }
+    result.push(remaining.splice(startIdx, 1)[0]);
+    while (remaining.length > 0) {
+      let minDist = Infinity;
+      let minIdx = 0;
+      for (let i = 0;i < remaining.length; i++) {
+        const dist = getDistance(result[result.length - 1], remaining[i]);
+        if (dist < minDist) {
+          minDist = dist;
+          minIdx = i;
+        }
+      }
+      result.push(remaining.splice(minIdx, 1)[0]);
+    }
+    return result;
+  };
+  if (clusterRows) {
+    const rowDistance = (a, b) => {
+      let sum = 0;
+      let count = 0;
+      for (const col of colKeys) {
+        const va = valueMap.get(`${a}|${col}`);
+        const vb = valueMap.get(`${b}|${col}`);
+        if (va !== undefined && vb !== undefined) {
+          sum += (va - vb) ** 2;
+          count++;
+        }
+      }
+      return count > 0 ? Math.sqrt(sum / count) : Infinity;
+    };
+    rowKeys = clusterOrder(rowKeys, rowDistance);
+  }
+  if (clusterCols) {
+    const colDistance = (a, b) => {
+      let sum = 0;
+      let count = 0;
+      for (const row of rowKeys) {
+        const va = valueMap.get(`${row}|${a}`);
+        const vb = valueMap.get(`${row}|${b}`);
+        if (va !== undefined && vb !== undefined) {
+          sum += (va - vb) ** 2;
+          count++;
+        }
+      }
+      return count > 0 ? Math.sqrt(sum / count) : Infinity;
+    };
+    colKeys = clusterOrder(colKeys, colDistance);
+  }
+  const values = Array.from(valueMap.values());
+  let minVal = Math.min(...values);
+  let maxVal = Math.max(...values);
+  const scaledValues = new Map;
+  if (scaleMethod === "row") {
+    for (const rowKey of rowKeys) {
+      const rowVals = colKeys.map((c) => valueMap.get(`${rowKey}|${c}`)).filter((v) => v !== undefined);
+      if (rowVals.length > 0) {
+        const mean = rowVals.reduce((a, b) => a + b, 0) / rowVals.length;
+        const std = Math.sqrt(rowVals.reduce((a, b) => a + (b - mean) ** 2, 0) / rowVals.length) || 1;
+        for (const colKey of colKeys) {
+          const v = valueMap.get(`${rowKey}|${colKey}`);
+          if (v !== undefined) {
+            scaledValues.set(`${rowKey}|${colKey}`, (v - mean) / std);
+          }
+        }
+      }
+    }
+  } else if (scaleMethod === "column") {
+    for (const colKey of colKeys) {
+      const colVals = rowKeys.map((r) => valueMap.get(`${r}|${colKey}`)).filter((v) => v !== undefined);
+      if (colVals.length > 0) {
+        const mean = colVals.reduce((a, b) => a + b, 0) / colVals.length;
+        const std = Math.sqrt(colVals.reduce((a, b) => a + (b - mean) ** 2, 0) / colVals.length) || 1;
+        for (const rowKey of rowKeys) {
+          const v = valueMap.get(`${rowKey}|${colKey}`);
+          if (v !== undefined) {
+            scaledValues.set(`${rowKey}|${colKey}`, (v - mean) / std);
+          }
+        }
+      }
+    }
+  }
+  const finalValues = scaleMethod === "none" ? valueMap : scaledValues;
+  if (scaleMethod !== "none") {
+    const scaled = Array.from(finalValues.values());
+    minVal = Math.min(...scaled);
+    maxVal = Math.max(...scaled);
+  }
+  const interpolateColor2 = (val) => {
+    if (isNaN(val))
+      return naRgb;
+    const t = (val - minVal) / (maxVal - minVal || 1);
+    if (t <= 0.5) {
+      const t2 = t * 2;
+      return {
+        r: Math.round(lowRgb.r + (midRgb.r - lowRgb.r) * t2),
+        g: Math.round(lowRgb.g + (midRgb.g - lowRgb.g) * t2),
+        b: Math.round(lowRgb.b + (midRgb.b - lowRgb.b) * t2),
+        a: 1
+      };
+    } else {
+      const t2 = (t - 0.5) * 2;
+      return {
+        r: Math.round(midRgb.r + (highRgb.r - midRgb.r) * t2),
+        g: Math.round(midRgb.g + (highRgb.g - midRgb.g) * t2),
+        b: Math.round(midRgb.b + (highRgb.b - midRgb.b) * t2),
+        a: 1
+      };
+    }
+  };
+  const plotLeft = Math.round(scales.x.range[0]);
+  const plotRight = Math.round(scales.x.range[1]);
+  const plotTop = Math.round(scales.y.range[1]);
+  const plotBottom = Math.round(scales.y.range[0]);
+  const labelWidth = showRowLabels ? Math.min(10, Math.max(...rowKeys.map((k) => k.length))) + 1 : 0;
+  const labelHeight = showColLabels ? 1 : 0;
+  const availWidth = plotRight - plotLeft - labelWidth;
+  const availHeight = plotBottom - plotTop - labelHeight;
+  const cellWidth = Math.max(1, Math.floor(availWidth / colKeys.length));
+  const cellHeight = Math.max(1, Math.floor(availHeight / rowKeys.length));
+  for (let ri = 0;ri < rowKeys.length; ri++) {
+    const rowKey = rowKeys[ri];
+    const baseY = plotTop + labelHeight + ri * cellHeight;
+    for (let ci = 0;ci < colKeys.length; ci++) {
+      const colKey = colKeys[ci];
+      const baseX = plotLeft + labelWidth + ci * cellWidth;
+      const val = finalValues.get(`${rowKey}|${colKey}`);
+      const color = val !== undefined ? interpolateColor2(val) : naRgb;
+      for (let dy = 0;dy < cellHeight; dy++) {
+        for (let dx = 0;dx < cellWidth; dx++) {
+          canvas.drawChar(baseX + dx, baseY + dy, cellChar, color);
+        }
+      }
+    }
+  }
+  if (showRowLabels) {
+    const labelColor = { r: 180, g: 180, b: 180, a: 1 };
+    for (let ri = 0;ri < rowKeys.length; ri++) {
+      const label = rowKeys[ri].slice(0, labelWidth - 1);
+      const y = plotTop + labelHeight + ri * cellHeight + Math.floor(cellHeight / 2);
+      for (let i = 0;i < label.length; i++) {
+        canvas.drawChar(plotLeft + i, y, label[i], labelColor);
+      }
+    }
+  }
+  if (showColLabels) {
+    const labelColor = { r: 180, g: 180, b: 180, a: 1 };
+    for (let ci = 0;ci < colKeys.length; ci++) {
+      const label = colKeys[ci].slice(0, cellWidth);
+      const x = plotLeft + labelWidth + ci * cellWidth + Math.floor(cellWidth / 2);
+      for (let i = 0;i < Math.min(label.length, 1); i++) {
+        canvas.drawChar(x, plotTop + i, label[i], labelColor);
+      }
+    }
+  }
+}
+function renderGeomBiplot(data, geom, aes, scales, canvas) {
+  const params = geom.params || {};
+  const pc1Col = params.pc1_col ?? "PC1";
+  const pc2Col = params.pc2_col ?? "PC2";
+  const loadings = params.loadings;
+  const showScores = params.show_scores ?? true;
+  const scoreChar = String(params.score_char ?? "●");
+  const showScoreLabels = params.show_score_labels ?? false;
+  const showLoadings = params.show_loadings ?? true;
+  const loadingColor = String(params.loading_color ?? "#e41a1c");
+  const loadingScale = params.loading_scale;
+  const showLoadingLabels = params.show_loading_labels ?? true;
+  const showOrigin = params.show_origin ?? true;
+  const originColor = String(params.origin_color ?? "#999999");
+  if (!Array.isArray(data) || data.length === 0)
+    return;
+  const parseHex = (hex) => {
+    const r = parseInt(hex.slice(1, 3), 16);
+    const g = parseInt(hex.slice(3, 5), 16);
+    const b = parseInt(hex.slice(5, 7), 16);
+    return { r, g, b, a: 1 };
+  };
+  const loadingColorParsed = parseHex(loadingColor);
+  const originColorParsed = parseHex(originColor);
+  const scores = [];
+  const xField = typeof aes.x === "string" ? aes.x : pc1Col;
+  const yField = typeof aes.y === "string" ? aes.y : pc2Col;
+  const labelField = typeof aes.label === "string" ? aes.label : undefined;
+  const colorField = typeof aes.color === "string" ? aes.color : undefined;
+  for (const row of data) {
+    const rawPc1 = row[xField];
+    const rawPc2 = row[yField];
+    const pc1 = typeof rawPc1 === "number" ? rawPc1 : parseFloat(String(rawPc1));
+    const pc2 = typeof rawPc2 === "number" ? rawPc2 : parseFloat(String(rawPc2));
+    if (!isNaN(pc1) && !isNaN(pc2)) {
+      const point = { pc1, pc2 };
+      if (labelField)
+        point.label = String(row[labelField] ?? "");
+      if (colorField && scales.color) {
+        point.color = scales.color.map(row[colorField]);
+      }
+      scores.push(point);
+    }
+  }
+  if (scores.length === 0)
+    return;
+  let minX = Math.min(...scores.map((s) => s.pc1));
+  let maxX = Math.max(...scores.map((s) => s.pc1));
+  let minY = Math.min(...scores.map((s) => s.pc2));
+  let maxY = Math.max(...scores.map((s) => s.pc2));
+  let actualLoadingScale = loadingScale;
+  if (loadings && loadings.length > 0 && !actualLoadingScale) {
+    const maxLoading = Math.max(...loadings.map((l) => Math.sqrt(l.pc1 ** 2 + l.pc2 ** 2)));
+    const maxScore = Math.max(Math.abs(minX), Math.abs(maxX), Math.abs(minY), Math.abs(maxY));
+    actualLoadingScale = maxScore * 0.8 / (maxLoading || 1);
+  }
+  if (loadings && actualLoadingScale) {
+    for (const l of loadings) {
+      const lx = l.pc1 * actualLoadingScale;
+      const ly = l.pc2 * actualLoadingScale;
+      minX = Math.min(minX, lx);
+      maxX = Math.max(maxX, lx);
+      minY = Math.min(minY, ly);
+      maxY = Math.max(maxY, ly);
+    }
+  }
+  const rangeX = maxX - minX || 1;
+  const rangeY = maxY - minY || 1;
+  minX -= rangeX * 0.1;
+  maxX += rangeX * 0.1;
+  minY -= rangeY * 0.1;
+  maxY += rangeY * 0.1;
+  const plotLeft = Math.round(scales.x.range[0]);
+  const plotRight = Math.round(scales.x.range[1]);
+  const plotTop = Math.round(scales.y.range[1]);
+  const plotBottom = Math.round(scales.y.range[0]);
+  const mapX = (v) => plotLeft + (v - minX) / (maxX - minX) * (plotRight - plotLeft);
+  const mapY = (v) => plotBottom - (v - minY) / (maxY - minY) * (plotBottom - plotTop);
+  if (showOrigin && minX <= 0 && maxX >= 0 && minY <= 0 && maxY >= 0) {
+    const originX = Math.round(mapX(0));
+    const originY = Math.round(mapY(0));
+    for (let x = plotLeft;x <= plotRight; x++) {
+      canvas.drawChar(x, originY, "─", originColorParsed);
+    }
+    for (let y = plotTop;y <= plotBottom; y++) {
+      canvas.drawChar(originX, y, "│", originColorParsed);
+    }
+    canvas.drawChar(originX, originY, "┼", originColorParsed);
+  }
+  if (showLoadings && loadings && actualLoadingScale) {
+    for (const loading of loadings) {
+      const endX = loading.pc1 * actualLoadingScale;
+      const endY = loading.pc2 * actualLoadingScale;
+      const sx = Math.round(mapX(0));
+      const sy = Math.round(mapY(0));
+      const ex = Math.round(mapX(endX));
+      const ey = Math.round(mapY(endY));
+      const steps = Math.max(Math.abs(ex - sx), Math.abs(ey - sy));
+      for (let i = 0;i <= steps; i++) {
+        const t = steps > 0 ? i / steps : 0;
+        const px = Math.round(sx + (ex - sx) * t);
+        const py = Math.round(sy + (ey - sy) * t);
+        const dx = ex - sx;
+        const dy = ey - sy;
+        let char = "·";
+        if (Math.abs(dx) > Math.abs(dy) * 2) {
+          char = dx > 0 ? "─" : "─";
+        } else if (Math.abs(dy) > Math.abs(dx) * 2) {
+          char = "│";
+        } else if (dx > 0 && dy < 0 || dx < 0 && dy > 0) {
+          char = "/";
+        } else {
+          char = "\\";
+        }
+        canvas.drawChar(px, py, char, loadingColorParsed);
+      }
+      const angle = Math.atan2(ey - sy, ex - sx);
+      let arrowChar = "→";
+      if (angle > Math.PI * 3 / 4 || angle < -Math.PI * 3 / 4)
+        arrowChar = "←";
+      else if (angle > Math.PI / 4)
+        arrowChar = "↓";
+      else if (angle < -Math.PI / 4)
+        arrowChar = "↑";
+      canvas.drawChar(ex, ey, arrowChar, loadingColorParsed);
+      if (showLoadingLabels) {
+        const labelX = ex + (ex >= sx ? 1 : -loading.variable.length);
+        for (let i = 0;i < loading.variable.length; i++) {
+          canvas.drawChar(labelX + i, ey, loading.variable[i], loadingColorParsed);
+        }
+      }
+    }
+  }
+  if (showScores) {
+    const defaultColor = { r: 31, g: 120, b: 180, a: 1 };
+    for (const score of scores) {
+      const cx = Math.round(mapX(score.pc1));
+      const cy = Math.round(mapY(score.pc2));
+      const color = score.color ?? defaultColor;
+      canvas.drawPoint(cx, cy, color, scoreChar);
+      if (showScoreLabels && score.label) {
+        const labelColor = { r: 50, g: 50, b: 50, a: 1 };
+        for (let i = 0;i < score.label.length; i++) {
+          canvas.drawChar(cx + 1 + i, cy, score.label[i], labelColor);
+        }
+      }
+    }
+  }
+}
+function renderGeomKaplanMeier(data, geom, aes, scales, canvas) {
+  const params = geom.params || {};
+  const showCensored = Boolean(params.show_censored ?? true);
+  const censorChar = String(params.censor_char ?? "+");
+  const showMedian = Boolean(params.show_median ?? false);
+  if (!Array.isArray(data) || data.length === 0)
+    return;
+  const xField = typeof aes.x === "string" ? aes.x : "time";
+  const yField = typeof aes.y === "string" ? aes.y : "status";
+  const colorField = typeof aes.color === "string" ? aes.color : undefined;
+  const groups = new Map;
+  for (const row of data) {
+    const time = Number(row[xField] ?? 0);
+    const status = Number(row[yField] ?? 0);
+    const group = colorField ? String(row[colorField] ?? "default") : "default";
+    if (!groups.has(group))
+      groups.set(group, []);
+    groups.get(group).push({ time, status });
+  }
+  const colors = [
+    { r: 31, g: 119, b: 180, a: 1 },
+    { r: 255, g: 127, b: 14, a: 1 },
+    { r: 44, g: 160, b: 44, a: 1 },
+    { r: 214, g: 39, b: 40, a: 1 },
+    { r: 148, g: 103, b: 189, a: 1 }
+  ];
+  const plotLeft = Math.round(scales.x.range[0]);
+  const plotRight = Math.round(scales.x.range[1]);
+  const plotTop = Math.round(scales.y.range[1]);
+  const plotBottom = Math.round(scales.y.range[0]);
+  let maxTime = 0;
+  for (const [, events] of groups) {
+    for (const e of events) {
+      if (e.time > maxTime)
+        maxTime = e.time;
+    }
+  }
+  const mapX = (t) => plotLeft + t / maxTime * (plotRight - plotLeft);
+  const mapY = (s) => plotBottom - s * (plotBottom - plotTop);
+  let colorIndex = 0;
+  for (const [, events] of groups) {
+    const color = colors[colorIndex % colors.length];
+    colorIndex++;
+    events.sort((a, b) => a.time - b.time);
+    const n = events.length;
+    let survival = 1;
+    let atRisk = n;
+    const survivalCurve = [];
+    survivalCurve.push({ time: 0, survival: 1, censored: false });
+    for (const event of events) {
+      if (event.status === 1) {
+        survival *= (atRisk - 1) / atRisk;
+        survivalCurve.push({ time: event.time, survival, censored: false });
+      } else {
+        survivalCurve.push({ time: event.time, survival, censored: true });
+      }
+      atRisk--;
+    }
+    for (let i = 0;i < survivalCurve.length; i++) {
+      const point = survivalCurve[i];
+      const x = Math.round(mapX(point.time));
+      const y = Math.round(mapY(point.survival));
+      if (i > 0) {
+        const prevPoint = survivalCurve[i - 1];
+        const px = Math.round(mapX(prevPoint.time));
+        const py = Math.round(mapY(prevPoint.survival));
+        for (let hx = px;hx <= x; hx++) {
+          canvas.drawChar(hx, py, "─", color);
+        }
+        if (py !== y) {
+          for (let vy = Math.min(py, y);vy <= Math.max(py, y); vy++) {
+            canvas.drawChar(x, vy, "│", color);
+          }
+        }
+      }
+      if (point.censored && showCensored) {
+        canvas.drawChar(x, y, censorChar, color);
+      }
+    }
+    if (showMedian) {
+      const medianY = mapY(0.5);
+      for (let mx = plotLeft;mx <= plotRight; mx += 2) {
+        canvas.drawChar(mx, Math.round(medianY), "·", { r: 150, g: 150, b: 150, a: 1 });
+      }
+    }
+  }
+}
+function renderGeomForest(data, geom, aes, scales, canvas) {
+  const params = geom.params || {};
+  const nullLine = Number(params.null_line ?? 1);
+  const logScale = Boolean(params.log_scale ?? false);
+  const nullLineColor = String(params.null_line_color ?? "#888888");
+  const pointChar = String(params.point_char ?? "■");
+  if (!Array.isArray(data) || data.length === 0)
+    return;
+  const parseHex = (hex) => {
+    const r = parseInt(hex.slice(1, 3), 16);
+    const g = parseInt(hex.slice(3, 5), 16);
+    const b = parseInt(hex.slice(5, 7), 16);
+    return { r, g, b, a: 1 };
+  };
+  const nullColor = parseHex(nullLineColor);
+  const xField = typeof aes.x === "string" ? aes.x : "estimate";
+  const yField = typeof aes.y === "string" ? aes.y : "study";
+  const xminField = typeof aes.xmin === "string" ? aes.xmin : "ci_lower";
+  const xmaxField = typeof aes.xmax === "string" ? aes.xmax : "ci_upper";
+  const sizeField = typeof aes.size === "string" ? aes.size : undefined;
+  const rows = [];
+  let minWeight = Infinity;
+  let maxWeight = -Infinity;
+  for (const row of data) {
+    const estimate = Number(row[xField] ?? 0);
+    const ci_lower = Number(row[xminField] ?? estimate);
+    const ci_upper = Number(row[xmaxField] ?? estimate);
+    const study = String(row[yField] ?? "");
+    const weight = sizeField ? Number(row[sizeField] ?? 1) : 1;
+    if (weight < minWeight)
+      minWeight = weight;
+    if (weight > maxWeight)
+      maxWeight = weight;
+    rows.push({ study, estimate, ci_lower, ci_upper, weight });
+  }
+  const plotLeft = Math.round(scales.x.range[0]);
+  const plotRight = Math.round(scales.x.range[1]);
+  const plotTop = Math.round(scales.y.range[1]);
+  const plotBottom = Math.round(scales.y.range[0]);
+  let xMin = Math.min(...rows.map((r) => r.ci_lower), nullLine);
+  let xMax = Math.max(...rows.map((r) => r.ci_upper), nullLine);
+  if (logScale) {
+    xMin = Math.log10(Math.max(xMin, 0.001));
+    xMax = Math.log10(Math.max(xMax, 0.001));
+  }
+  const mapX = (v) => {
+    const val = logScale ? Math.log10(Math.max(v, 0.001)) : v;
+    return plotLeft + (val - xMin) / (xMax - xMin) * (plotRight - plotLeft);
+  };
+  const nullX = Math.round(mapX(nullLine));
+  for (let y = plotTop;y <= plotBottom; y++) {
+    if ((y - plotTop) % 2 === 0) {
+      canvas.drawChar(nullX, y, "│", nullColor);
+    }
+  }
+  const rowHeight = (plotBottom - plotTop) / rows.length;
+  const pointColor = { r: 31, g: 119, b: 180, a: 1 };
+  const ciColor = { r: 80, g: 80, b: 80, a: 1 };
+  for (let i = 0;i < rows.length; i++) {
+    const row = rows[i];
+    const y = Math.round(plotTop + (i + 0.5) * rowHeight);
+    const x1 = Math.round(mapX(row.ci_lower));
+    const x2 = Math.round(mapX(row.ci_upper));
+    for (let x = x1;x <= x2; x++) {
+      canvas.drawChar(x, y, "─", ciColor);
+    }
+    canvas.drawChar(x1, y, "├", ciColor);
+    canvas.drawChar(x2, y, "┤", ciColor);
+    const px = Math.round(mapX(row.estimate));
+    canvas.drawChar(px, y, pointChar, pointColor);
+    const label = row.study;
+    const labelColor = { r: 200, g: 200, b: 200, a: 1 };
+    const labelEnd = plotLeft - 1;
+    const labelStart = labelEnd - label.length;
+    for (let c = 0;c < label.length; c++) {
+      const charX = labelStart + c;
+      if (charX >= 0) {
+        canvas.drawChar(charX, y, label[c], labelColor);
+      }
+    }
+  }
+}
+function renderGeomRoc(data, geom, aes, scales, canvas) {
+  const params = geom.params || {};
+  const showDiagonal = Boolean(params.show_diagonal ?? true);
+  const diagonalColor = String(params.diagonal_color ?? "#888888");
+  const showAuc = Boolean(params.show_auc ?? true);
+  const showOptimal = Boolean(params.show_optimal ?? false);
+  const optimalChar = String(params.optimal_char ?? "●");
+  if (!Array.isArray(data) || data.length === 0)
+    return;
+  const parseHex = (hex) => {
+    const r = parseInt(hex.slice(1, 3), 16);
+    const g = parseInt(hex.slice(3, 5), 16);
+    const b = parseInt(hex.slice(5, 7), 16);
+    return { r, g, b, a: 1 };
+  };
+  const diagColor = parseHex(diagonalColor);
+  const xField = typeof aes.x === "string" ? aes.x : "fpr";
+  const yField = typeof aes.y === "string" ? aes.y : "tpr";
+  const colorField = typeof aes.color === "string" ? aes.color : undefined;
+  const groups = new Map;
+  for (const row of data) {
+    const fpr = Number(row[xField] ?? 0);
+    const tpr = Number(row[yField] ?? 0);
+    const group = colorField ? String(row[colorField] ?? "default") : "default";
+    if (!groups.has(group))
+      groups.set(group, []);
+    groups.get(group).push({ fpr, tpr });
+  }
+  const plotLeft = Math.round(scales.x.range[0]);
+  const plotRight = Math.round(scales.x.range[1]);
+  const plotTop = Math.round(scales.y.range[1]);
+  const plotBottom = Math.round(scales.y.range[0]);
+  const mapX = (v) => plotLeft + v * (plotRight - plotLeft);
+  const mapY = (v) => plotBottom - v * (plotBottom - plotTop);
+  if (showDiagonal) {
+    const steps = plotRight - plotLeft;
+    for (let i = 0;i <= steps; i += 2) {
+      const t = i / steps;
+      const x = Math.round(mapX(t));
+      const y = Math.round(mapY(t));
+      canvas.drawChar(x, y, "·", diagColor);
+    }
+  }
+  const colors = [
+    { r: 31, g: 119, b: 180, a: 1 },
+    { r: 255, g: 127, b: 14, a: 1 },
+    { r: 44, g: 160, b: 44, a: 1 },
+    { r: 214, g: 39, b: 40, a: 1 }
+  ];
+  let colorIndex = 0;
+  for (const [, points] of groups) {
+    const color = colors[colorIndex % colors.length];
+    colorIndex++;
+    points.sort((a, b) => a.fpr - b.fpr);
+    let auc = 0;
+    for (let i = 1;i < points.length; i++) {
+      const dx = points[i].fpr - points[i - 1].fpr;
+      const avgY = (points[i].tpr + points[i - 1].tpr) / 2;
+      auc += dx * avgY;
+    }
+    let optimalPoint = points[0];
+    let maxJ = -Infinity;
+    for (const p of points) {
+      const j = p.tpr - p.fpr;
+      if (j > maxJ) {
+        maxJ = j;
+        optimalPoint = p;
+      }
+    }
+    for (let i = 0;i < points.length; i++) {
+      const p = points[i];
+      const x = Math.round(mapX(p.fpr));
+      const y = Math.round(mapY(p.tpr));
+      if (i > 0) {
+        const prev = points[i - 1];
+        const px = Math.round(mapX(prev.fpr));
+        const py = Math.round(mapY(prev.tpr));
+        const steps = Math.max(Math.abs(x - px), Math.abs(y - py));
+        for (let s = 0;s <= steps; s++) {
+          const t = steps > 0 ? s / steps : 0;
+          const lx = Math.round(px + (x - px) * t);
+          const ly = Math.round(py + (y - py) * t);
+          canvas.drawChar(lx, ly, "─", color);
+        }
+      }
+      canvas.drawChar(x, y, "●", color);
+    }
+    if (showOptimal) {
+      const ox = Math.round(mapX(optimalPoint.fpr));
+      const oy = Math.round(mapY(optimalPoint.tpr));
+      canvas.drawChar(ox, oy, optimalChar, { r: 255, g: 0, b: 0, a: 1 });
+    }
+    if (showAuc && colorIndex === 1) {
+      const aucText = `AUC=${auc.toFixed(3)}`;
+      const labelColor = { r: 100, g: 100, b: 100, a: 1 };
+      for (let i = 0;i < aucText.length; i++) {
+        canvas.drawChar(plotRight - aucText.length + i, plotTop + 1, aucText[i], labelColor);
+      }
+    }
+  }
+}
+function renderGeomBlandAltman(data, geom, aes, scales, canvas) {
+  const params = geom.params || {};
+  const showLimits = Boolean(params.show_limits ?? true);
+  const showBias = Boolean(params.show_bias ?? true);
+  const limitMultiplier = Number(params.limit_multiplier ?? 1.96);
+  const biasColor = String(params.bias_color ?? "#0000ff");
+  const limitColor = String(params.limit_color ?? "#ff0000");
+  const pointChar = String(params.point_char ?? "●");
+  const precomputed = Boolean(params.precomputed ?? false);
+  if (!Array.isArray(data) || data.length === 0)
+    return;
+  const parseHex = (hex) => {
+    const r = parseInt(hex.slice(1, 3), 16);
+    const g = parseInt(hex.slice(3, 5), 16);
+    const b = parseInt(hex.slice(5, 7), 16);
+    return { r, g, b, a: 1 };
+  };
+  const biasColorParsed = parseHex(biasColor);
+  const limitColorParsed = parseHex(limitColor);
+  const xField = typeof aes.x === "string" ? aes.x : "method1";
+  const yField = typeof aes.y === "string" ? aes.y : "method2";
+  const points = [];
+  if (precomputed) {
+    for (const row of data) {
+      const mean = Number(row[xField] ?? 0);
+      const diff = Number(row[yField] ?? 0);
+      points.push({ mean, diff });
+    }
+  } else {
+    for (const row of data) {
+      const m1 = Number(row[xField] ?? 0);
+      const m2 = Number(row[yField] ?? 0);
+      const mean = (m1 + m2) / 2;
+      const diff = m1 - m2;
+      points.push({ mean, diff });
+    }
+  }
+  if (points.length === 0)
+    return;
+  const diffs = points.map((p) => p.diff);
+  const bias = diffs.reduce((a, b) => a + b, 0) / diffs.length;
+  const variance = diffs.reduce((a, b) => a + Math.pow(b - bias, 2), 0) / (diffs.length - 1);
+  const sd = Math.sqrt(variance);
+  const upperLimit = bias + limitMultiplier * sd;
+  const lowerLimit = bias - limitMultiplier * sd;
+  const plotLeft = Math.round(scales.x.range[0]);
+  const plotRight = Math.round(scales.x.range[1]);
+  const plotTop = Math.round(scales.y.range[1]);
+  const plotBottom = Math.round(scales.y.range[0]);
+  const minMean = Math.min(...points.map((p) => p.mean));
+  const maxMean = Math.max(...points.map((p) => p.mean));
+  const minDiff = Math.min(...points.map((p) => p.diff), lowerLimit);
+  const maxDiff = Math.max(...points.map((p) => p.diff), upperLimit);
+  const mapX = (v) => plotLeft + (v - minMean) / (maxMean - minMean) * (plotRight - plotLeft);
+  const mapY = (v) => plotBottom - (v - minDiff) / (maxDiff - minDiff) * (plotBottom - plotTop);
+  if (showBias) {
+    const biasY = Math.round(mapY(bias));
+    for (let x = plotLeft;x <= plotRight; x++) {
+      canvas.drawChar(x, biasY, "─", biasColorParsed);
+    }
+  }
+  if (showLimits) {
+    const upperY = Math.round(mapY(upperLimit));
+    const lowerY = Math.round(mapY(lowerLimit));
+    for (let x = plotLeft;x <= plotRight; x += 2) {
+      canvas.drawChar(x, upperY, "─", limitColorParsed);
+      canvas.drawChar(x, lowerY, "─", limitColorParsed);
+    }
+  }
+  const pointColor = { r: 31, g: 119, b: 180, a: 1 };
+  for (const p of points) {
+    const x = Math.round(mapX(p.mean));
+    const y = Math.round(mapY(p.diff));
+    canvas.drawChar(x, y, pointChar, pointColor);
+  }
+}
+function renderGeomQQ(data, geom, aes, scales, canvas) {
+  const params = geom.params || {};
+  const showLine = params.show_line ?? true;
+  const lineColor = params.line_color ?? "#ff0000";
+  const pointChar = params.point_char ?? "●";
+  const standardize = params.standardize ?? true;
+  const parseHex = (hex) => {
+    const r = parseInt(hex.slice(1, 3), 16);
+    const g = parseInt(hex.slice(3, 5), 16);
+    const b = parseInt(hex.slice(5, 7), 16);
+    return { r, g, b, a: 1 };
+  };
+  const lineColorParsed = parseHex(lineColor);
+  const sampleField = typeof aes.x === "string" ? aes.x : "x";
+  const values = [];
+  for (const row of data) {
+    const v = Number(row[sampleField]);
+    if (!isNaN(v))
+      values.push(v);
+  }
+  if (values.length === 0)
+    return;
+  values.sort((a, b) => a - b);
+  const n = values.length;
+  const mean = values.reduce((a, b) => a + b, 0) / n;
+  const variance = values.reduce((a, b) => a + Math.pow(b - mean, 2), 0) / (n - 1);
+  const sd = Math.sqrt(variance);
+  const qnorm = (p) => {
+    if (p <= 0)
+      return -Infinity;
+    if (p >= 1)
+      return Infinity;
+    if (p === 0.5)
+      return 0;
+    const a = [
+      -39.69683028665376,
+      220.9460984245205,
+      -275.9285104469687,
+      138.357751867269,
+      -30.66479806614716,
+      2.506628277459239
+    ];
+    const b = [
+      -54.47609879822406,
+      161.5858368580409,
+      -155.6989798598866,
+      66.80131188771972,
+      -13.28068155288572
+    ];
+    const c = [
+      -0.007784894002430293,
+      -0.3223964580411365,
+      -2.400758277161838,
+      -2.549732539343734,
+      4.374664141464968,
+      2.938163982698783
+    ];
+    const d = [
+      0.007784695709041462,
+      0.3224671290700398,
+      2.445134137142996,
+      3.754408661907416
+    ];
+    const pLow = 0.02425;
+    const pHigh = 1 - pLow;
+    let q;
+    if (p < pLow) {
+      q = Math.sqrt(-2 * Math.log(p));
+      return (((((c[0] * q + c[1]) * q + c[2]) * q + c[3]) * q + c[4]) * q + c[5]) / ((((d[0] * q + d[1]) * q + d[2]) * q + d[3]) * q + 1);
+    } else if (p <= pHigh) {
+      q = p - 0.5;
+      const r = q * q;
+      return (((((a[0] * r + a[1]) * r + a[2]) * r + a[3]) * r + a[4]) * r + a[5]) * q / (((((b[0] * r + b[1]) * r + b[2]) * r + b[3]) * r + b[4]) * r + 1);
+    } else {
+      q = Math.sqrt(-2 * Math.log(1 - p));
+      return -(((((c[0] * q + c[1]) * q + c[2]) * q + c[3]) * q + c[4]) * q + c[5]) / ((((d[0] * q + d[1]) * q + d[2]) * q + d[3]) * q + 1);
+    }
+  };
+  const points = [];
+  for (let i = 0;i < n; i++) {
+    const p = (i + 0.5) / n;
+    const theoretical = qnorm(p);
+    const sample = standardize ? (values[i] - mean) / sd : values[i];
+    points.push({ theoretical, sample });
+  }
+  const plotLeft = Math.round(scales.x.range[0]);
+  const plotRight = Math.round(scales.x.range[1]);
+  const plotTop = Math.round(scales.y.range[1]);
+  const plotBottom = Math.round(scales.y.range[0]);
+  const minT = Math.min(...points.map((p) => p.theoretical));
+  const maxT = Math.max(...points.map((p) => p.theoretical));
+  const minS = Math.min(...points.map((p) => p.sample));
+  const maxS = Math.max(...points.map((p) => p.sample));
+  const minVal = Math.min(minT, minS);
+  const maxVal = Math.max(maxT, maxS);
+  const mapX = (v) => plotLeft + (v - minVal) / (maxVal - minVal) * (plotRight - plotLeft);
+  const mapY = (v) => plotBottom - (v - minVal) / (maxVal - minVal) * (plotBottom - plotTop);
+  if (showLine) {
+    const steps = plotRight - plotLeft;
+    for (let i = 0;i <= steps; i++) {
+      const v = minVal + i / steps * (maxVal - minVal);
+      const x = Math.round(mapX(v));
+      const y = Math.round(mapY(v));
+      if (y >= plotTop && y <= plotBottom) {
+        canvas.drawChar(x, y, "─", lineColorParsed);
+      }
+    }
+  }
+  const pointColor = { r: 31, g: 119, b: 180, a: 1 };
+  for (const p of points) {
+    const x = Math.round(mapX(p.theoretical));
+    const y = Math.round(mapY(p.sample));
+    canvas.drawChar(x, y, pointChar, pointColor);
+  }
+}
+function renderGeomECDF(data, geom, aes, scales, canvas) {
+  const params = geom.params || {};
+  const complement = params.complement ?? false;
+  const showPoints = params.show_points ?? false;
+  const xField = typeof aes.x === "string" ? aes.x : "x";
+  const colorField = typeof aes.color === "string" ? aes.color : null;
+  const groups = new Map;
+  for (const row of data) {
+    const v = Number(row[xField]);
+    if (isNaN(v))
+      continue;
+    const groupKey = colorField ? String(row[colorField] ?? "default") : "default";
+    if (!groups.has(groupKey))
+      groups.set(groupKey, []);
+    groups.get(groupKey).push(v);
+  }
+  if (groups.size === 0)
+    return;
+  const plotLeft = Math.round(scales.x.range[0]);
+  const plotRight = Math.round(scales.x.range[1]);
+  const plotTop = Math.round(scales.y.range[1]);
+  const plotBottom = Math.round(scales.y.range[0]);
+  let globalMin = Infinity;
+  let globalMax = -Infinity;
+  for (const values of groups.values()) {
+    globalMin = Math.min(globalMin, ...values);
+    globalMax = Math.max(globalMax, ...values);
+  }
+  const mapX = (v) => plotLeft + (v - globalMin) / (globalMax - globalMin) * (plotRight - plotLeft);
+  const mapY = (v) => {
+    const ecdf = complement ? 1 - v : v;
+    return plotBottom - ecdf * (plotBottom - plotTop);
+  };
+  const colors = [
+    { r: 31, g: 119, b: 180, a: 1 },
+    { r: 255, g: 127, b: 14, a: 1 },
+    { r: 44, g: 160, b: 44, a: 1 },
+    { r: 214, g: 39, b: 40, a: 1 },
+    { r: 148, g: 103, b: 189, a: 1 }
+  ];
+  let colorIdx = 0;
+  for (const [, values] of groups) {
+    const color = colors[colorIdx % colors.length];
+    colorIdx++;
+    const sorted = [...values].sort((a, b) => a - b);
+    const n = sorted.length;
+    let prevX = plotLeft;
+    let prevY = Math.round(mapY(0));
+    for (let i = 0;i < n; i++) {
+      const ecdfVal = (i + 1) / n;
+      const x = Math.round(mapX(sorted[i]));
+      const y = Math.round(mapY(ecdfVal));
+      for (let px = prevX;px <= x; px++) {
+        canvas.drawChar(px, prevY, "─", color);
+      }
+      const stepDir = y < prevY ? -1 : 1;
+      for (let py = prevY;stepDir > 0 ? py <= y : py >= y; py += stepDir) {
+        canvas.drawChar(x, py, "│", color);
+      }
+      if (showPoints) {
+        canvas.drawChar(x, y, "●", color);
+      }
+      prevX = x;
+      prevY = y;
+    }
+    for (let px = prevX;px <= plotRight; px++) {
+      canvas.drawChar(px, prevY, "─", color);
+    }
+  }
+}
+function renderGeomFunnel(data, geom, aes, scales, canvas) {
+  const params = geom.params || {};
+  const showContours = params.show_contours ?? true;
+  const showSummaryLine = params.show_summary_line ?? true;
+  const summaryEffect = params.summary_effect;
+  const pointChar = params.point_char ?? "●";
+  const contourColor = params.contour_color ?? "#888888";
+  const invertY = params.invert_y ?? true;
+  const parseHex = (hex) => {
+    const r = parseInt(hex.slice(1, 3), 16);
+    const g = parseInt(hex.slice(3, 5), 16);
+    const b = parseInt(hex.slice(5, 7), 16);
+    return { r, g, b, a: 1 };
+  };
+  const contourColorParsed = parseHex(contourColor);
+  const xField = typeof aes.x === "string" ? aes.x : "effect";
+  const yField = typeof aes.y === "string" ? aes.y : "se";
+  const points = [];
+  for (const row of data) {
+    const effect = Number(row[xField]);
+    const se = Number(row[yField]);
+    if (!isNaN(effect) && !isNaN(se)) {
+      points.push({ effect, se });
+    }
+  }
+  if (points.length === 0)
+    return;
+  const summary = summaryEffect ?? points.reduce((a, b) => a + b.effect, 0) / points.length;
+  const plotLeft = Math.round(scales.x.range[0]);
+  const plotRight = Math.round(scales.x.range[1]);
+  const plotTop = Math.round(scales.y.range[1]);
+  const plotBottom = Math.round(scales.y.range[0]);
+  const minEffect = Math.min(...points.map((p) => p.effect));
+  const maxEffect = Math.max(...points.map((p) => p.effect));
+  const maxSE = Math.max(...points.map((p) => p.se));
+  const effectPad = (maxEffect - minEffect) * 0.2;
+  const effectMin = minEffect - effectPad;
+  const effectMax = maxEffect + effectPad;
+  const mapX = (v) => plotLeft + (v - effectMin) / (effectMax - effectMin) * (plotRight - plotLeft);
+  const mapY = (v) => {
+    if (invertY) {
+      return plotTop + v / maxSE * (plotBottom - plotTop);
+    }
+    return plotBottom - v / maxSE * (plotBottom - plotTop);
+  };
+  if (showContours) {
+    const z = 1.96;
+    for (let se = 0;se <= maxSE; se += maxSE / 40) {
+      const leftBound = summary - z * se;
+      const rightBound = summary + z * se;
+      const y = Math.round(mapY(se));
+      const leftX = Math.round(mapX(leftBound));
+      const rightX = Math.round(mapX(rightBound));
+      if (leftX >= plotLeft && leftX <= plotRight) {
+        canvas.drawChar(leftX, y, "·", contourColorParsed);
+      }
+      if (rightX >= plotLeft && rightX <= plotRight) {
+        canvas.drawChar(rightX, y, "·", contourColorParsed);
+      }
+    }
+  }
+  if (showSummaryLine) {
+    const summaryX = Math.round(mapX(summary));
+    for (let y = plotTop;y <= plotBottom; y += 2) {
+      canvas.drawChar(summaryX, y, "│", contourColorParsed);
+    }
+  }
+  const pointColor = { r: 31, g: 119, b: 180, a: 1 };
+  for (const p of points) {
+    const x = Math.round(mapX(p.effect));
+    const y = Math.round(mapY(p.se));
+    canvas.drawChar(x, y, pointChar, pointColor);
+  }
+}
+function renderGeomControl(data, geom, aes, scales, canvas) {
+  const params = geom.params || {};
+  const sigma = params.sigma ?? 3;
+  const showCenter = params.show_center ?? true;
+  const showUCL = params.show_ucl ?? true;
+  const showLCL = params.show_lcl ?? true;
+  const showWarning = params.show_warning ?? false;
+  const customCenter = params.center;
+  const customUCL = params.ucl;
+  const customLCL = params.lcl;
+  const centerColor = params.center_color ?? "#0000ff";
+  const limitColor = params.limit_color ?? "#ff0000";
+  const warningColor = params.warning_color ?? "#ffa500";
+  const connectPoints = params.connect_points ?? true;
+  const highlightOOC = params.highlight_ooc ?? true;
+  const oocChar = params.ooc_char ?? "◆";
+  const pointChar = params.point_char ?? "●";
+  const parseHex = (hex) => {
+    const r = parseInt(hex.slice(1, 3), 16);
+    const g = parseInt(hex.slice(3, 5), 16);
+    const b = parseInt(hex.slice(5, 7), 16);
+    return { r, g, b, a: 1 };
+  };
+  const centerColorParsed = parseHex(centerColor);
+  const limitColorParsed = parseHex(limitColor);
+  const warningColorParsed = parseHex(warningColor);
+  const xField = typeof aes.x === "string" ? aes.x : "x";
+  const yField = typeof aes.y === "string" ? aes.y : "y";
+  const points = [];
+  for (const row of data) {
+    const x = Number(row[xField]);
+    const y = Number(row[yField]);
+    if (!isNaN(x) && !isNaN(y)) {
+      points.push({ x, y });
+    }
+  }
+  if (points.length === 0)
+    return;
+  points.sort((a, b) => a.x - b.x);
+  const yValues = points.map((p) => p.y);
+  const mean = customCenter ?? yValues.reduce((a, b) => a + b, 0) / yValues.length;
+  let sigmaEst;
+  if (points.length > 1) {
+    const movingRanges = [];
+    for (let i = 1;i < points.length; i++) {
+      movingRanges.push(Math.abs(points[i].y - points[i - 1].y));
+    }
+    const avgMR = movingRanges.reduce((a, b) => a + b, 0) / movingRanges.length;
+    sigmaEst = avgMR / 1.128;
+  } else {
+    const variance = yValues.reduce((a, b) => a + Math.pow(b - mean, 2), 0) / (yValues.length - 1);
+    sigmaEst = Math.sqrt(variance);
+  }
+  const ucl = customUCL ?? mean + sigma * sigmaEst;
+  const lcl = customLCL ?? mean - sigma * sigmaEst;
+  const uwl = mean + 2 * sigmaEst;
+  const lwl = mean - 2 * sigmaEst;
+  const plotLeft = Math.round(scales.x.range[0]);
+  const plotRight = Math.round(scales.x.range[1]);
+  const plotTop = Math.round(scales.y.range[1]);
+  const plotBottom = Math.round(scales.y.range[0]);
+  const minX = Math.min(...points.map((p) => p.x));
+  const maxX = Math.max(...points.map((p) => p.x));
+  const minY = Math.min(...points.map((p) => p.y), lcl);
+  const maxY = Math.max(...points.map((p) => p.y), ucl);
+  const mapX = (v) => plotLeft + (v - minX) / (maxX - minX) * (plotRight - plotLeft);
+  const mapY = (v) => plotBottom - (v - minY) / (maxY - minY) * (plotBottom - plotTop);
+  if (showCenter) {
+    const centerY = Math.round(mapY(mean));
+    for (let x = plotLeft;x <= plotRight; x++) {
+      canvas.drawChar(x, centerY, "─", centerColorParsed);
+    }
+  }
+  if (showUCL) {
+    const uclY = Math.round(mapY(ucl));
+    for (let x = plotLeft;x <= plotRight; x += 2) {
+      canvas.drawChar(x, uclY, "─", limitColorParsed);
+    }
+  }
+  if (showLCL) {
+    const lclY = Math.round(mapY(lcl));
+    for (let x = plotLeft;x <= plotRight; x += 2) {
+      canvas.drawChar(x, lclY, "─", limitColorParsed);
+    }
+  }
+  if (showWarning) {
+    const uwlY = Math.round(mapY(uwl));
+    const lwlY = Math.round(mapY(lwl));
+    for (let x = plotLeft;x <= plotRight; x += 3) {
+      canvas.drawChar(x, uwlY, "·", warningColorParsed);
+      canvas.drawChar(x, lwlY, "·", warningColorParsed);
+    }
+  }
+  if (connectPoints && points.length > 1) {
+    const lineColor = { r: 100, g: 100, b: 100, a: 1 };
+    for (let i = 1;i < points.length; i++) {
+      const x1 = Math.round(mapX(points[i - 1].x));
+      const y1 = Math.round(mapY(points[i - 1].y));
+      const x2 = Math.round(mapX(points[i].x));
+      const y2 = Math.round(mapY(points[i].y));
+      const dx = Math.abs(x2 - x1);
+      const dy = Math.abs(y2 - y1);
+      const sx = x1 < x2 ? 1 : -1;
+      const sy = y1 < y2 ? 1 : -1;
+      let err = dx - dy;
+      let x = x1;
+      let y = y1;
+      while (true) {
+        canvas.drawChar(x, y, "·", lineColor);
+        if (x === x2 && y === y2)
+          break;
+        const e2 = 2 * err;
+        if (e2 > -dy) {
+          err -= dy;
+          x += sx;
+        }
+        if (e2 < dx) {
+          err += dx;
+          y += sy;
+        }
+      }
+    }
+  }
+  const inControlColor = { r: 31, g: 119, b: 180, a: 1 };
+  const oocColor = { r: 214, g: 39, b: 40, a: 1 };
+  for (const p of points) {
+    const x = Math.round(mapX(p.x));
+    const y = Math.round(mapY(p.y));
+    const isOOC = p.y > ucl || p.y < lcl;
+    if (highlightOOC && isOOC) {
+      canvas.drawChar(x, y, oocChar, oocColor);
+    } else {
+      canvas.drawChar(x, y, pointChar, inControlColor);
+    }
+  }
+}
+function renderGeomScree(data, geom, aes, scales, canvas) {
+  const params = geom.params || {};
+  const showCumulative = params.show_cumulative ?? false;
+  const showKaiser = params.show_kaiser ?? false;
+  const connectPoints = params.connect_points ?? true;
+  const showBars = params.show_bars ?? false;
+  const pointChar = params.point_char ?? "●";
+  const cumulativeColor = params.cumulative_color ?? "#ff0000";
+  const kaiserColor = params.kaiser_color ?? "#888888";
+  const threshold = params.threshold;
+  const thresholdColor = params.threshold_color ?? "#00aa00";
+  const parseHex = (hex) => {
+    const r = parseInt(hex.slice(1, 3), 16);
+    const g = parseInt(hex.slice(3, 5), 16);
+    const b = parseInt(hex.slice(5, 7), 16);
+    return { r, g, b, a: 1 };
+  };
+  const cumulativeColorParsed = parseHex(cumulativeColor);
+  const kaiserColorParsed = parseHex(kaiserColor);
+  const thresholdColorParsed = parseHex(thresholdColor);
+  const xField = typeof aes.x === "string" ? aes.x : "component";
+  const yField = typeof aes.y === "string" ? aes.y : "variance";
+  const points = [];
+  for (const row of data) {
+    const component = Number(row[xField]);
+    const variance = Number(row[yField]);
+    if (!isNaN(component) && !isNaN(variance)) {
+      points.push({ component, variance });
+    }
+  }
+  if (points.length === 0)
+    return;
+  points.sort((a, b) => a.component - b.component);
+  const total = points.reduce((a, b) => a + b.variance, 0);
+  let cumSum = 0;
+  const cumulativePoints = points.map((p) => {
+    cumSum += p.variance;
+    return { component: p.component, cumulative: cumSum / total };
+  });
+  const plotLeft = Math.round(scales.x.range[0]);
+  const plotRight = Math.round(scales.x.range[1]);
+  const plotTop = Math.round(scales.y.range[1]);
+  const plotBottom = Math.round(scales.y.range[0]);
+  const minX = Math.min(...points.map((p) => p.component));
+  const maxX = Math.max(...points.map((p) => p.component));
+  const maxY = Math.max(...points.map((p) => p.variance));
+  const yMax = showCumulative ? Math.max(maxY, total) : maxY;
+  const mapX = (v) => plotLeft + (v - minX) / (maxX - minX) * (plotRight - plotLeft);
+  const mapY = (v) => plotBottom - v / yMax * (plotBottom - plotTop);
+  const mapYCumulative = (v) => plotBottom - v * (plotBottom - plotTop);
+  if (showKaiser) {
+    const kaiserY = Math.round(mapY(1));
+    if (kaiserY >= plotTop && kaiserY <= plotBottom) {
+      for (let x = plotLeft;x <= plotRight; x += 2) {
+        canvas.drawChar(x, kaiserY, "─", kaiserColorParsed);
+      }
+    }
+  }
+  if (threshold !== undefined) {
+    const thresholdY = Math.round(mapYCumulative(threshold));
+    for (let x = plotLeft;x <= plotRight; x += 2) {
+      canvas.drawChar(x, thresholdY, "─", thresholdColorParsed);
+    }
+  }
+  if (showBars) {
+    const barColor = { r: 180, g: 180, b: 180, a: 1 };
+    const barWidth = Math.max(1, Math.floor((plotRight - plotLeft) / points.length / 2));
+    for (const p of points) {
+      const x = Math.round(mapX(p.component));
+      const y = Math.round(mapY(p.variance));
+      for (let bx = x - barWidth;bx <= x + barWidth; bx++) {
+        for (let by = y;by <= plotBottom; by++) {
+          canvas.drawChar(bx, by, "░", barColor);
+        }
+      }
+    }
+  }
+  if (connectPoints && points.length > 1) {
+    const lineColor = { r: 31, g: 119, b: 180, a: 1 };
+    for (let i = 1;i < points.length; i++) {
+      const x1 = Math.round(mapX(points[i - 1].component));
+      const y1 = Math.round(mapY(points[i - 1].variance));
+      const x2 = Math.round(mapX(points[i].component));
+      const y2 = Math.round(mapY(points[i].variance));
+      const steps = Math.max(Math.abs(x2 - x1), 1);
+      for (let s = 0;s <= steps; s++) {
+        const t = s / steps;
+        const x = Math.round(x1 + t * (x2 - x1));
+        const y = Math.round(y1 + t * (y2 - y1));
+        canvas.drawChar(x, y, "─", lineColor);
+      }
+    }
+  }
+  if (showCumulative && cumulativePoints.length > 1) {
+    for (let i = 1;i < cumulativePoints.length; i++) {
+      const x1 = Math.round(mapX(cumulativePoints[i - 1].component));
+      const y1 = Math.round(mapYCumulative(cumulativePoints[i - 1].cumulative));
+      const x2 = Math.round(mapX(cumulativePoints[i].component));
+      const y2 = Math.round(mapYCumulative(cumulativePoints[i].cumulative));
+      const steps = Math.max(Math.abs(x2 - x1), 1);
+      for (let s = 0;s <= steps; s++) {
+        const t = s / steps;
+        const x = Math.round(x1 + t * (x2 - x1));
+        const y = Math.round(y1 + t * (y2 - y1));
+        canvas.drawChar(x, y, "─", cumulativeColorParsed);
+      }
+    }
+    for (const p of cumulativePoints) {
+      const x = Math.round(mapX(p.component));
+      const y = Math.round(mapYCumulative(p.cumulative));
+      canvas.drawChar(x, y, "○", cumulativeColorParsed);
+    }
+  }
+  const pointColor = { r: 31, g: 119, b: 180, a: 1 };
+  for (const p of points) {
+    const x = Math.round(mapX(p.component));
+    const y = Math.round(mapY(p.variance));
+    canvas.drawChar(x, y, pointChar, pointColor);
+  }
+}
 function renderGeom(data, geom, aes, scales, canvas, coordType) {
   switch (geom.type) {
     case "point":
@@ -3849,10 +5318,455 @@ function renderGeom(data, geom, aes, scales, canvas, coordType) {
     case "volcano":
       renderGeomVolcano(data, geom, aes, scales, canvas);
       break;
+    case "ma":
+      renderGeomMA(data, geom, aes, scales, canvas);
+      break;
+    case "manhattan":
+      renderGeomManhattan(data, geom, aes, scales, canvas);
+      break;
+    case "heatmap":
+      renderGeomHeatmap(data, geom, aes, scales, canvas);
+      break;
+    case "biplot":
+      renderGeomBiplot(data, geom, aes, scales, canvas);
+      break;
+    case "kaplan_meier":
+      renderGeomKaplanMeier(data, geom, aes, scales, canvas);
+      break;
+    case "forest":
+      renderGeomForest(data, geom, aes, scales, canvas);
+      break;
+    case "roc":
+      renderGeomRoc(data, geom, aes, scales, canvas);
+      break;
+    case "bland_altman":
+      renderGeomBlandAltman(data, geom, aes, scales, canvas);
+      break;
+    case "qq":
+      renderGeomQQ(data, geom, aes, scales, canvas);
+      break;
+    case "ecdf":
+      renderGeomECDF(data, geom, aes, scales, canvas);
+      break;
+    case "funnel":
+      renderGeomFunnel(data, geom, aes, scales, canvas);
+      break;
+    case "control":
+      renderGeomControl(data, geom, aes, scales, canvas);
+      break;
+    case "scree":
+      renderGeomScree(data, geom, aes, scales, canvas);
+      break;
+    case "upset":
+      renderGeomUpset(data, geom, aes, scales, canvas);
+      break;
+    case "dendrogram":
+      renderGeomDendrogram(data, geom, aes, scales, canvas);
+      break;
     default:
       break;
   }
 }
+function renderGeomUpset(data, geom, aes, scales, canvas) {
+  const params = geom.params || {};
+  const sets = params.sets;
+  const minSize = params.min_size ?? 1;
+  const maxIntersections = params.max_intersections ?? 20;
+  const sortBy = params.sort_by ?? "size";
+  const sortOrder = params.sort_order ?? "desc";
+  const showSetSizes = params.show_set_sizes ?? true;
+  const dotChar = params.dot_char ?? "●";
+  const emptyChar = params.empty_char ?? "○";
+  const lineChar = params.line_char ?? "│";
+  const barChar = params.bar_char ?? "█";
+  let setNames = [];
+  if (sets && sets.length > 0) {
+    setNames = sets;
+  } else if (data.length > 0) {
+    const firstRow = data[0];
+    for (const key of Object.keys(firstRow)) {
+      const values = data.map((row) => row[key]);
+      const isBinary = values.every((v) => v === 0 || v === 1 || v === "0" || v === "1");
+      if (isBinary && key !== "id" && key !== "name" && key !== "element") {
+        setNames.push(key);
+      }
+    }
+    if (setNames.length === 0) {
+      const setsField2 = typeof aes.x === "string" ? aes.x : "sets";
+      const allSets = new Set;
+      for (const row of data) {
+        const val = row[setsField2];
+        if (typeof val === "string") {
+          val.split(",").forEach((s) => allSets.add(s.trim()));
+        }
+      }
+      setNames = Array.from(allSets).sort();
+    }
+  }
+  if (setNames.length === 0)
+    return;
+  const intersectionMap = new Map;
+  const setsField = typeof aes.x === "string" ? aes.x : "sets";
+  const hasListFormat = data.length > 0 && typeof data[0][setsField] === "string";
+  for (const row of data) {
+    let memberSets;
+    if (hasListFormat) {
+      const val = row[setsField];
+      memberSets = typeof val === "string" ? val.split(",").map((s) => s.trim()).filter((s) => setNames.includes(s)) : [];
+    } else {
+      memberSets = setNames.filter((s) => {
+        const v = row[s];
+        return v === 1 || v === "1";
+      });
+    }
+    if (memberSets.length > 0) {
+      const key = memberSets.sort().join("|");
+      intersectionMap.set(key, (intersectionMap.get(key) || 0) + 1);
+    }
+  }
+  let intersections = Array.from(intersectionMap.entries()).map(([key, count]) => ({
+    sets: new Set(key.split("|")),
+    count,
+    key
+  })).filter((i) => i.count >= minSize);
+  if (sortBy === "size") {
+    intersections.sort((a, b) => sortOrder === "desc" ? b.count - a.count : a.count - b.count);
+  } else if (sortBy === "degree") {
+    intersections.sort((a, b) => sortOrder === "desc" ? b.sets.size - a.sets.size : a.sets.size - b.sets.size);
+  }
+  intersections = intersections.slice(0, maxIntersections);
+  if (intersections.length === 0)
+    return;
+  const plotLeft = Math.round(scales.x.range[0]);
+  const plotRight = Math.round(scales.x.range[1]);
+  const plotTop = Math.round(scales.y.range[1]);
+  const plotBottom = Math.round(scales.y.range[0]);
+  const plotWidth = plotRight - plotLeft;
+  const plotHeight = plotBottom - plotTop;
+  const matrixHeight = Math.min(setNames.length * 2 + 2, Math.floor(plotHeight * 0.4));
+  const barHeight = plotHeight - matrixHeight - 2;
+  const barTop = plotTop;
+  const barBottom = plotTop + barHeight;
+  const matrixTop = barBottom + 2;
+  const setLabelWidth = showSetSizes ? Math.max(...setNames.map((s) => s.length)) + 8 : 0;
+  const colWidth = Math.max(2, Math.floor((plotWidth - setLabelWidth) / intersections.length));
+  const maxCount = Math.max(...intersections.map((i) => i.count));
+  const barColor = { r: 31, g: 119, b: 180, a: 1 };
+  const dotColor = { r: 50, g: 50, b: 50, a: 1 };
+  const lineColor = { r: 100, g: 100, b: 100, a: 1 };
+  const labelColor = { r: 150, g: 150, b: 150, a: 1 };
+  for (let i = 0;i < intersections.length; i++) {
+    const inter = intersections[i];
+    const x = plotLeft + setLabelWidth + i * colWidth + Math.floor(colWidth / 2);
+    const barHeightPx = Math.round(inter.count / maxCount * barHeight);
+    for (let y = barBottom - barHeightPx;y <= barBottom; y++) {
+      canvas.drawChar(x, y, barChar, barColor);
+    }
+    const countStr = inter.count.toString();
+    const labelY = barBottom - barHeightPx - 1;
+    if (labelY >= barTop) {
+      for (let ci = 0;ci < countStr.length; ci++) {
+        canvas.drawChar(x - Math.floor(countStr.length / 2) + ci, labelY, countStr[ci], labelColor);
+      }
+    }
+  }
+  const rowSpacing = Math.max(1, Math.floor(matrixHeight / setNames.length));
+  if (showSetSizes) {
+    for (let si = 0;si < setNames.length; si++) {
+      const setName = setNames[si];
+      const y = matrixTop + si * rowSpacing + 1;
+      let setSize = 0;
+      for (const row of data) {
+        if (hasListFormat) {
+          const val = row[setsField];
+          if (typeof val === "string" && val.split(",").map((s) => s.trim()).includes(setName)) {
+            setSize++;
+          }
+        } else {
+          const v = row[setName];
+          if (v === 1 || v === "1")
+            setSize++;
+        }
+      }
+      const label = `${setName.substring(0, 6)}`;
+      for (let ci = 0;ci < label.length; ci++) {
+        canvas.drawChar(plotLeft + ci, y, label[ci], labelColor);
+      }
+      const sizeBarLen = Math.max(1, Math.round(setSize / data.length * 5));
+      for (let bi = 0;bi < sizeBarLen; bi++) {
+        canvas.drawChar(plotLeft + label.length + 1 + bi, y, "▪", barColor);
+      }
+    }
+  }
+  for (let i = 0;i < intersections.length; i++) {
+    const inter = intersections[i];
+    const x = plotLeft + setLabelWidth + i * colWidth + Math.floor(colWidth / 2);
+    const activeRows = [];
+    for (let si = 0;si < setNames.length; si++) {
+      const setName = setNames[si];
+      const y = matrixTop + si * rowSpacing + 1;
+      const isActive = inter.sets.has(setName);
+      if (isActive) {
+        canvas.drawChar(x, y, dotChar, dotColor);
+        activeRows.push(y);
+      } else {
+        canvas.drawChar(x, y, emptyChar, { r: 200, g: 200, b: 200, a: 1 });
+      }
+    }
+    if (activeRows.length > 1) {
+      const minY = Math.min(...activeRows);
+      const maxY = Math.max(...activeRows);
+      for (let y = minY + 1;y < maxY; y++) {
+        if (!activeRows.includes(y)) {
+          canvas.drawChar(x, y, lineChar, lineColor);
+        }
+      }
+    }
+  }
+}
+function renderGeomDendrogram(data, geom, _aes, scales, canvas) {
+  const params = geom.params || {};
+  const orientation = params.orientation ?? "vertical";
+  const labels = params.labels;
+  const showLabels = params.show_labels ?? true;
+  const hang = params.hang ?? false;
+  const hConnector = params.h_connector ?? "─";
+  const vConnector = params.v_connector ?? "│";
+  const cornerTR = params.corner_tr ?? "┐";
+  const cornerBL = params.corner_bl ?? "└";
+  const cornerBR = params.corner_br ?? "┘";
+  const leafChar = params.leaf_char ?? "○";
+  const parentCol = params.parent_col ?? "parent";
+  const heightCol = params.height_col ?? "height";
+  const idCol = params.id_col ?? "id";
+  const plotLeft = Math.round(scales.x.range[0]);
+  const plotRight = Math.round(scales.x.range[1]);
+  const plotTop = Math.round(scales.y.range[1]);
+  const plotBottom = Math.round(scales.y.range[0]);
+  const plotWidth = plotRight - plotLeft;
+  const plotHeight = plotBottom - plotTop;
+  const lineColor = { r: 50, g: 50, b: 50, a: 1 };
+  const leafColor = { r: 31, g: 119, b: 180, a: 1 };
+  const labelColor = { r: 100, g: 100, b: 100, a: 1 };
+  const hasLinkageFormat = data.length > 0 && (("merge1" in data[0]) || ("merge_1" in data[0]));
+  if (hasLinkageFormat) {
+    const linkage = data.map((row) => ({
+      merge1: Number(row["merge1"] ?? row["merge_1"]),
+      merge2: Number(row["merge2"] ?? row["merge_2"]),
+      height: Number(row[heightCol] ?? row["height"]),
+      size: Number(row["size"] ?? 2)
+    }));
+    if (linkage.length === 0)
+      return;
+    const n = linkage.length + 1;
+    const nodes = new Map;
+    for (let i = 0;i < n; i++) {
+      nodes.set(i, {
+        id: i,
+        height: 0,
+        label: labels?.[i] ?? `${i}`
+      });
+    }
+    for (let i = 0;i < linkage.length; i++) {
+      const row = linkage[i];
+      const newId = n + i;
+      const leftNode = nodes.get(row.merge1 < n ? row.merge1 : row.merge1);
+      const rightNode = nodes.get(row.merge2 < n ? row.merge2 : row.merge2);
+      nodes.set(newId, {
+        id: newId,
+        left: leftNode,
+        right: rightNode,
+        height: row.height
+      });
+    }
+    const root = nodes.get(n + linkage.length - 1);
+    if (!root)
+      return;
+    let xPos = 0;
+    const assignX = (node) => {
+      if (!node.left && !node.right) {
+        node.x = xPos++;
+      } else {
+        if (node.left)
+          assignX(node.left);
+        if (node.right)
+          assignX(node.right);
+        const leftX = node.left?.x ?? 0;
+        const rightX = node.right?.x ?? 0;
+        node.x = (leftX + rightX) / 2;
+      }
+    };
+    assignX(root);
+    const maxHeight = root.height;
+    const leafCount = xPos;
+    const mapX = (x) => {
+      if (orientation === "vertical") {
+        return plotLeft + x / (leafCount - 1 || 1) * plotWidth;
+      } else {
+        return plotBottom - x / (leafCount - 1 || 1) * plotHeight;
+      }
+    };
+    const mapY = (h) => {
+      if (orientation === "vertical") {
+        return plotTop + (1 - h / maxHeight) * (plotHeight - 3);
+      } else {
+        return plotLeft + h / maxHeight * plotWidth;
+      }
+    };
+    const drawNode = (node) => {
+      if (node.x === undefined)
+        return;
+      if (node.left && node.right) {
+        const nodeY = mapY(node.height);
+        const leftX = mapX(node.left.x);
+        const leftY = mapY(node.left.height);
+        const rightX = mapX(node.right.x);
+        const rightY = mapY(node.right.height);
+        if (orientation === "vertical") {
+          const hLineY = Math.round(nodeY);
+          const leftXRound = Math.round(leftX);
+          const rightXRound = Math.round(rightX);
+          for (let x = Math.min(leftXRound, rightXRound);x <= Math.max(leftXRound, rightXRound); x++) {
+            canvas.drawChar(x, hLineY, hConnector, lineColor);
+          }
+          canvas.drawChar(leftXRound, hLineY, cornerBL, lineColor);
+          canvas.drawChar(rightXRound, hLineY, cornerBR, lineColor);
+          const leftYRound = Math.round(leftY);
+          const rightYRound = Math.round(rightY);
+          for (let y = hLineY + 1;y < leftYRound; y++) {
+            canvas.drawChar(leftXRound, y, vConnector, lineColor);
+          }
+          for (let y = hLineY + 1;y < rightYRound; y++) {
+            canvas.drawChar(rightXRound, y, vConnector, lineColor);
+          }
+        } else {
+          const hLineX = Math.round(nodeY);
+          const leftYRound = Math.round(leftX);
+          const rightYRound = Math.round(rightX);
+          for (let y = Math.min(leftYRound, rightYRound);y <= Math.max(leftYRound, rightYRound); y++) {
+            canvas.drawChar(hLineX, y, vConnector, lineColor);
+          }
+          canvas.drawChar(hLineX, leftYRound, cornerTR, lineColor);
+          canvas.drawChar(hLineX, rightYRound, cornerBR, lineColor);
+          const leftXRound = Math.round(mapY(node.left.height));
+          const rightXRound = Math.round(mapY(node.right.height));
+          for (let x = hLineX + 1;x < leftXRound; x++) {
+            canvas.drawChar(x, leftYRound, hConnector, lineColor);
+          }
+          for (let x = hLineX + 1;x < rightXRound; x++) {
+            canvas.drawChar(x, rightYRound, hConnector, lineColor);
+          }
+        }
+        drawNode(node.left);
+        drawNode(node.right);
+      } else {
+        if (orientation === "vertical") {
+          const x = Math.round(mapX(node.x));
+          const y = hang ? plotBottom - 2 : Math.round(mapY(0));
+          canvas.drawChar(x, y, leafChar, leafColor);
+          if (showLabels && node.label) {
+            const label = node.label.substring(0, 4);
+            for (let ci = 0;ci < label.length; ci++) {
+              canvas.drawChar(x - Math.floor(label.length / 2) + ci, y + 1, label[ci], labelColor);
+            }
+          }
+        } else {
+          const y = Math.round(mapX(node.x));
+          const x = Math.round(mapY(0));
+          canvas.drawChar(x, y, leafChar, leafColor);
+          if (showLabels && node.label) {
+            const label = node.label.substring(0, 6);
+            for (let ci = 0;ci < label.length; ci++) {
+              canvas.drawChar(x + 2 + ci, y, label[ci], labelColor);
+            }
+          }
+        }
+      }
+    };
+    drawNode(root);
+  } else {
+    const nodeMap = new Map;
+    for (const row of data) {
+      const id = String(row[idCol] ?? "");
+      const parent = row[parentCol];
+      const height = Number(row[heightCol] ?? 0);
+      nodeMap.set(id, {
+        id,
+        parent: parent === null || parent === "" || parent === "null" ? null : String(parent),
+        height,
+        children: []
+      });
+    }
+    let root = null;
+    for (const node of nodeMap.values()) {
+      if (node.parent === null) {
+        root = node;
+      } else {
+        const parentNode = nodeMap.get(node.parent);
+        if (parentNode) {
+          parentNode.children.push(node);
+        }
+      }
+    }
+    if (!root)
+      return;
+    let xPos = 0;
+    const assignX = (node) => {
+      if (node.children.length === 0) {
+        node.x = xPos++;
+      } else {
+        for (const child of node.children) {
+          assignX(child);
+        }
+        const childXs = node.children.map((c) => c.x ?? 0);
+        node.x = childXs.reduce((a, b) => a + b, 0) / childXs.length;
+      }
+    };
+    assignX(root);
+    const findMaxHeight = (node) => {
+      if (node.children.length === 0)
+        return node.height;
+      return Math.max(node.height, ...node.children.map(findMaxHeight));
+    };
+    const maxHeight = findMaxHeight(root) || 1;
+    const leafCount = xPos || 1;
+    const mapX = (x) => plotLeft + x / (leafCount - 1 || 1) * plotWidth;
+    const mapY = (h) => plotTop + (1 - h / maxHeight) * (plotHeight - 3);
+    const drawNode = (node) => {
+      if (node.x === undefined)
+        return;
+      if (node.children.length > 0) {
+        const nodeY = Math.round(mapY(node.height));
+        const childXs = node.children.map((c) => Math.round(mapX(c.x ?? 0)));
+        const minX = Math.min(...childXs);
+        const maxX = Math.max(...childXs);
+        for (let x = minX;x <= maxX; x++) {
+          canvas.drawChar(x, nodeY, hConnector, lineColor);
+        }
+        for (const child of node.children) {
+          const childX = Math.round(mapX(child.x ?? 0));
+          const childY = Math.round(mapY(child.height));
+          canvas.drawChar(childX, nodeY, child === node.children[0] ? cornerBL : child === node.children[node.children.length - 1] ? cornerBR : "┴", lineColor);
+          for (let y = nodeY + 1;y < childY; y++) {
+            canvas.drawChar(childX, y, vConnector, lineColor);
+          }
+          drawNode(child);
+        }
+      } else {
+        const x = Math.round(mapX(node.x));
+        const y = hang ? plotBottom - 2 : Math.round(mapY(node.height));
+        canvas.drawChar(x, y, leafChar, leafColor);
+        if (showLabels) {
+          const label = node.id.substring(0, 4);
+          for (let ci = 0;ci < label.length; ci++) {
+            canvas.drawChar(x - Math.floor(label.length / 2) + ci, y + 1, label[ci], labelColor);
+          }
+        }
+      }
+    };
+    drawNode(root);
+  }
+}
 var POINT_SHAPES, SIZE_CHARS;
 var init_render_geoms = __esm(() => {
   init_scales();
@@ -6003,11 +7917,23 @@ function calculateLayout(spec, options) {
   } else if (hasY2) {
     rightMargin = 8 + (hasY2Label ? 2 : 0);
   }
+  let forestLabelWidth = 0;
+  const isForestPlot = spec.geoms.some((g) => g.type === "forest");
+  if (isForestPlot && Array.isArray(spec.data) && spec.data.length > 0) {
+    const yField = typeof spec.aes.y === "string" ? spec.aes.y : "study";
+    for (const row of spec.data) {
+      const label = String(row[yField] ?? "");
+      if (label.length > forestLabelWidth)
+        forestLabelWidth = label.length;
+    }
+  }
+  const defaultLeft = 8 + (hasYLabel ? 2 : 0);
+  const neededLeft = forestLabelWidth > 0 ? forestLabelWidth + 2 : defaultLeft;
   const margins = {
     top: hasTitle ? 2 : 1,
     right: rightMargin,
     bottom: 2 + (hasXLabel ? 1 : 0) + (hasLegend && legendPosition === "bottom" ? 2 : 0),
-    left: 8 + (hasYLabel ? 2 : 0)
+    left: Math.max(defaultLeft, neededLeft)
   };
   const plotArea = {
     x: margins.left,
@@ -6221,7 +8147,9 @@ function renderToCanvas(spec, options) {
     renderTitle(canvas, spec.labels.title, layout.width, spec.theme);
   }
   renderGridLines(canvas, scales, layout.plotArea, spec.theme);
-  renderAxes(canvas, scales, layout.plotArea, spec.labels, spec.theme);
+  const isForest = spec.geoms.some((g) => g.type === "forest");
+  const axisLabels = isForest ? { ...spec.labels, y: undefined } : spec.labels;
+  renderAxes(canvas, scales, layout.plotArea, axisLabels, spec.theme);
   for (const geom of spec.geoms) {
     let geomData;
     let geomAes = spec.aes;
@@ -7170,28 +9098,17 @@ function geom_abline(options = {}) {
 // src/geoms/qq.ts
 function geom_qq(options = {}) {
   return {
-    type: "point",
-    stat: "qq",
-    params: {
-      distribution: options.distribution ?? "norm",
-      dparams: options.dparams,
-      size: options.size ?? 1,
-      shape: options.shape ?? "●",
-      color: options.color,
-      alpha: options.alpha ?? 1
-    }
-  };
-}
-function geom_qq_line(options = {}) {
-  return {
-    type: "segment",
-    stat: "qq_line",
+    type: "qq",
+    stat: "identity",
+    position: "identity",
     params: {
-      distribution: options.distribution ?? "norm",
-      dparams: options.dparams,
-      color: options.color ?? "gray",
-      linetype: options.linetype ?? "dashed",
-      alpha: options.alpha ?? 1
+      distribution: options.distribution ?? "normal",
+      show_line: options.show_line ?? true,
+      show_ci: options.show_ci ?? false,
+      conf_level: options.conf_level ?? 0.95,
+      line_color: options.line_color ?? "#ff0000",
+      point_char: options.point_char ?? "●",
+      standardize: options.standardize ?? true
     }
   };
 }
@@ -7366,131 +9283,477 @@ var init_braille = __esm(() => {
   ];
 });
 
-// src/geoms/calendar.ts
-function geom_calendar(options = {}) {
+// src/geoms/calendar.ts
+function geom_calendar(options = {}) {
+  return {
+    type: "calendar",
+    stat: "identity",
+    position: "identity",
+    params: {
+      cell_char: options.cell_char ?? "█",
+      empty_char: options.empty_char ?? "░",
+      empty_color: options.empty_color ?? "#161b22",
+      fill_color: options.fill_color ?? "#39d353",
+      show_months: options.show_months ?? true,
+      show_days: options.show_days ?? true,
+      week_start: options.week_start ?? 0,
+      levels: options.levels ?? 5
+    }
+  };
+}
+
+// src/geoms/flame.ts
+function geom_flame(options = {}) {
+  return {
+    type: "flame",
+    stat: "identity",
+    position: "identity",
+    params: {
+      style: options.style ?? "flame",
+      palette: options.palette ?? "warm",
+      show_labels: options.show_labels ?? true,
+      min_label_width: options.min_label_width ?? 10,
+      sort: options.sort ?? "alpha",
+      bar_char: options.bar_char ?? "█"
+    }
+  };
+}
+function geom_icicle(options = {}) {
+  return geom_flame({ ...options, style: "icicle" });
+}
+
+// src/geoms/corrmat.ts
+function geom_corrmat(options = {}) {
+  return {
+    type: "corrmat",
+    stat: "identity",
+    position: "identity",
+    params: {
+      show_values: options.show_values ?? true,
+      decimals: options.decimals ?? 2,
+      show_significance: options.show_significance ?? false,
+      sig_threshold: options.sig_threshold ?? 0.05,
+      sig_marker: options.sig_marker ?? "*",
+      positive_color: options.positive_color ?? "#2166ac",
+      negative_color: options.negative_color ?? "#b2182b",
+      neutral_color: options.neutral_color ?? "#f7f7f7",
+      lower_triangle: options.lower_triangle ?? false,
+      upper_triangle: options.upper_triangle ?? false,
+      show_diagonal: options.show_diagonal ?? true,
+      method: options.method ?? "pearson"
+    }
+  };
+}
+
+// src/geoms/sankey.ts
+function geom_sankey(options = {}) {
+  return {
+    type: "sankey",
+    stat: "identity",
+    position: "identity",
+    params: {
+      node_width: options.node_width ?? 3,
+      node_padding: options.node_padding ?? 2,
+      node_char: options.node_char ?? "█",
+      flow_char: options.flow_char ?? "─",
+      show_labels: options.show_labels ?? true,
+      show_values: options.show_values ?? false,
+      align: options.align ?? "justify",
+      color_by: options.color_by ?? "auto",
+      min_flow_width: options.min_flow_width ?? 1,
+      flow_gap: options.flow_gap ?? 0
+    }
+  };
+}
+
+// src/geoms/treemap.ts
+function geom_treemap(options = {}) {
+  return {
+    type: "treemap",
+    stat: "identity",
+    position: "identity",
+    params: {
+      algorithm: options.algorithm ?? "squarify",
+      show_labels: options.show_labels ?? true,
+      show_values: options.show_values ?? false,
+      border: options.border ?? true,
+      padding: options.padding ?? 0,
+      min_label_size: options.min_label_size ?? 4,
+      color_by: options.color_by ?? "value",
+      fill_char: options.fill_char ?? "█",
+      max_depth: options.max_depth,
+      aspect_ratio: options.aspect_ratio ?? 1.618
+    }
+  };
+}
+
+// src/geoms/volcano.ts
+function geom_volcano(options = {}) {
+  return {
+    type: "volcano",
+    stat: "identity",
+    position: "identity",
+    params: {
+      fc_threshold: options.fc_threshold ?? 1,
+      p_threshold: options.p_threshold ?? 0.05,
+      y_is_neglog10: options.y_is_neglog10 ?? false,
+      up_color: options.up_color ?? "#e41a1c",
+      down_color: options.down_color ?? "#377eb8",
+      ns_color: options.ns_color ?? "#999999",
+      show_thresholds: options.show_thresholds ?? true,
+      threshold_linetype: options.threshold_linetype ?? "dashed",
+      n_labels: options.n_labels ?? 0,
+      size: options.size ?? 1,
+      alpha: options.alpha ?? 0.6,
+      point_char: options.point_char ?? "●",
+      show_legend: options.show_legend ?? true,
+      classify: options.classify
+    }
+  };
+}
+
+// src/geoms/ma.ts
+function geom_ma(options = {}) {
+  return {
+    type: "ma",
+    stat: "identity",
+    position: "identity",
+    params: {
+      fc_threshold: options.fc_threshold ?? 1,
+      p_threshold: options.p_threshold ?? 0.05,
+      p_col: options.p_col,
+      x_is_log2: options.x_is_log2 ?? false,
+      up_color: options.up_color ?? "#e41a1c",
+      down_color: options.down_color ?? "#377eb8",
+      ns_color: options.ns_color ?? "#999999",
+      show_baseline: options.show_baseline ?? true,
+      show_thresholds: options.show_thresholds ?? true,
+      linetype: options.linetype ?? "dashed",
+      n_labels: options.n_labels ?? 0,
+      size: options.size ?? 1,
+      alpha: options.alpha ?? 0.6,
+      point_char: options.point_char ?? "●",
+      show_smooth: options.show_smooth ?? false
+    }
+  };
+}
+
+// src/geoms/manhattan.ts
+function geom_manhattan(options = {}) {
+  return {
+    type: "manhattan",
+    stat: "identity",
+    position: "identity",
+    params: {
+      suggestive_threshold: options.suggestive_threshold ?? 0.00001,
+      genome_wide_threshold: options.genome_wide_threshold ?? 0.00000005,
+      chr_col: options.chr_col,
+      pos_col: options.pos_col,
+      p_col: options.p_col,
+      y_is_neglog10: options.y_is_neglog10 ?? false,
+      chr_colors: options.chr_colors ?? DEFAULT_CHR_COLORS,
+      highlight_color: options.highlight_color ?? "#e41a1c",
+      suggestive_color: options.suggestive_color ?? "#ff7f00",
+      show_thresholds: options.show_thresholds ?? true,
+      threshold_linetype: options.threshold_linetype ?? "dashed",
+      n_labels: options.n_labels ?? 0,
+      label_col: options.label_col,
+      size: options.size ?? 1,
+      alpha: options.alpha ?? 0.6,
+      point_char: options.point_char ?? "●",
+      chr_gap: options.chr_gap ?? 0.02
+    }
+  };
+}
+var DEFAULT_CHR_COLORS;
+var init_manhattan = __esm(() => {
+  DEFAULT_CHR_COLORS = ["#1f78b4", "#a6cee3"];
+});
+
+// src/geoms/heatmap.ts
+function geom_heatmap(options = {}) {
+  return {
+    type: "heatmap",
+    stat: "identity",
+    position: "identity",
+    params: {
+      x_col: options.x_col,
+      y_col: options.y_col,
+      value_col: options.value_col ?? "value",
+      low_color: options.low_color ?? "#313695",
+      mid_color: options.mid_color ?? "#ffffbf",
+      high_color: options.high_color ?? "#a50026",
+      na_color: options.na_color ?? "#808080",
+      midpoint: options.midpoint,
+      cluster_rows: options.cluster_rows ?? false,
+      cluster_cols: options.cluster_cols ?? false,
+      clustering_method: options.clustering_method ?? "complete",
+      clustering_distance: options.clustering_distance ?? "euclidean",
+      show_row_dendrogram: options.show_row_dendrogram ?? true,
+      show_col_dendrogram: options.show_col_dendrogram ?? true,
+      dendrogram_ratio: options.dendrogram_ratio ?? 0.15,
+      show_row_labels: options.show_row_labels ?? true,
+      show_col_labels: options.show_col_labels ?? true,
+      show_values: options.show_values ?? false,
+      value_format: options.value_format ?? ".2f",
+      cell_char: options.cell_char ?? "█",
+      border: options.border ?? false,
+      scale: options.scale ?? "none"
+    }
+  };
+}
+
+// src/geoms/biplot.ts
+function geom_biplot(options = {}) {
+  return {
+    type: "biplot",
+    stat: "identity",
+    position: "identity",
+    params: {
+      pc1_col: options.pc1_col ?? "PC1",
+      pc2_col: options.pc2_col ?? "PC2",
+      loadings: options.loadings,
+      var_explained: options.var_explained,
+      show_scores: options.show_scores ?? true,
+      score_color: options.score_color,
+      score_size: options.score_size ?? 1,
+      score_alpha: options.score_alpha ?? 0.8,
+      score_char: options.score_char ?? "●",
+      show_score_labels: options.show_score_labels ?? false,
+      show_loadings: options.show_loadings ?? true,
+      loading_color: options.loading_color ?? "#e41a1c",
+      loading_scale: options.loading_scale,
+      arrow_char: options.arrow_char ?? "→",
+      show_loading_labels: options.show_loading_labels ?? true,
+      show_origin: options.show_origin ?? true,
+      origin_color: options.origin_color ?? "#999999",
+      show_circle: options.show_circle ?? false,
+      circle_color: options.circle_color ?? "#cccccc"
+    }
+  };
+}
+
+// src/geoms/kaplan-meier.ts
+function geom_kaplan_meier(options = {}) {
+  return {
+    type: "kaplan_meier",
+    stat: "identity",
+    position: "identity",
+    params: {
+      show_ci: options.show_ci ?? false,
+      conf_level: options.conf_level ?? 0.95,
+      show_censored: options.show_censored ?? true,
+      censor_char: options.censor_char ?? "+",
+      show_risk_table: options.show_risk_table ?? false,
+      linetype: options.linetype ?? "solid",
+      show_median: options.show_median ?? false,
+      step_type: options.step_type ?? "post"
+    }
+  };
+}
+
+// src/geoms/forest.ts
+function geom_forest(options = {}) {
+  return {
+    type: "forest",
+    stat: "identity",
+    position: "identity",
+    params: {
+      null_line: options.null_line ?? 1,
+      log_scale: options.log_scale ?? false,
+      show_summary: options.show_summary ?? false,
+      summary_row: options.summary_row,
+      null_line_color: options.null_line_color ?? "#888888",
+      null_line_type: options.null_line_type ?? "dashed",
+      point_char: options.point_char ?? "■",
+      show_weights: options.show_weights ?? false,
+      min_size: options.min_size ?? 1,
+      max_size: options.max_size ?? 3
+    }
+  };
+}
+
+// src/geoms/roc.ts
+function geom_roc(options = {}) {
+  return {
+    type: "roc",
+    stat: "identity",
+    position: "identity",
+    params: {
+      show_diagonal: options.show_diagonal ?? true,
+      diagonal_color: options.diagonal_color ?? "#888888",
+      diagonal_type: options.diagonal_type ?? "dashed",
+      show_auc: options.show_auc ?? true,
+      show_optimal: options.show_optimal ?? false,
+      optimal_char: options.optimal_char ?? "●",
+      show_ci: options.show_ci ?? false,
+      conf_level: options.conf_level ?? 0.95,
+      fill_auc: options.fill_auc ?? false,
+      fill_alpha: options.fill_alpha ?? 0.3
+    }
+  };
+}
+
+// src/geoms/bland-altman.ts
+function geom_bland_altman(options = {}) {
+  return {
+    type: "bland_altman",
+    stat: "identity",
+    position: "identity",
+    params: {
+      show_limits: options.show_limits ?? true,
+      show_bias: options.show_bias ?? true,
+      limit_multiplier: options.limit_multiplier ?? 1.96,
+      bias_color: options.bias_color ?? "#0000ff",
+      limit_color: options.limit_color ?? "#ff0000",
+      linetype: options.linetype ?? "dashed",
+      show_ci: options.show_ci ?? false,
+      conf_level: options.conf_level ?? 0.95,
+      point_char: options.point_char ?? "●",
+      percent_diff: options.percent_diff ?? false,
+      precomputed: options.precomputed ?? false
+    }
+  };
+}
+
+// src/geoms/ecdf.ts
+function geom_ecdf(options = {}) {
   return {
-    type: "calendar",
+    type: "ecdf",
     stat: "identity",
     position: "identity",
     params: {
-      cell_char: options.cell_char ?? "█",
-      empty_char: options.empty_char ?? "░",
-      empty_color: options.empty_color ?? "#161b22",
-      fill_color: options.fill_color ?? "#39d353",
-      show_months: options.show_months ?? true,
-      show_days: options.show_days ?? true,
-      week_start: options.week_start ?? 0,
-      levels: options.levels ?? 5
+      pad: options.pad ?? true,
+      show_ci: options.show_ci ?? false,
+      conf_level: options.conf_level ?? 0.95,
+      step_type: options.step_type ?? "post",
+      show_points: options.show_points ?? false,
+      line_char: options.line_char ?? "─",
+      complement: options.complement ?? false
     }
   };
 }
 
-// src/geoms/flame.ts
-function geom_flame(options = {}) {
+// src/geoms/funnel.ts
+function geom_funnel(options = {}) {
   return {
-    type: "flame",
+    type: "funnel",
     stat: "identity",
     position: "identity",
     params: {
-      style: options.style ?? "flame",
-      palette: options.palette ?? "warm",
-      show_labels: options.show_labels ?? true,
-      min_label_width: options.min_label_width ?? 10,
-      sort: options.sort ?? "alpha",
-      bar_char: options.bar_char ?? "█"
+      show_contours: options.show_contours ?? true,
+      contour_levels: options.contour_levels ?? [0.95],
+      show_significance: options.show_significance ?? false,
+      summary_effect: options.summary_effect,
+      show_summary_line: options.show_summary_line ?? true,
+      y_is_se: options.y_is_se ?? true,
+      invert_y: options.invert_y ?? true,
+      point_char: options.point_char ?? "●",
+      contour_color: options.contour_color ?? "#888888"
     }
   };
 }
-function geom_icicle(options = {}) {
-  return geom_flame({ ...options, style: "icicle" });
-}
 
-// src/geoms/corrmat.ts
-function geom_corrmat(options = {}) {
+// src/geoms/control.ts
+function geom_control(options = {}) {
   return {
-    type: "corrmat",
+    type: "control",
     stat: "identity",
     position: "identity",
     params: {
-      show_values: options.show_values ?? true,
-      decimals: options.decimals ?? 2,
-      show_significance: options.show_significance ?? false,
-      sig_threshold: options.sig_threshold ?? 0.05,
-      sig_marker: options.sig_marker ?? "*",
-      positive_color: options.positive_color ?? "#2166ac",
-      negative_color: options.negative_color ?? "#b2182b",
-      neutral_color: options.neutral_color ?? "#f7f7f7",
-      lower_triangle: options.lower_triangle ?? false,
-      upper_triangle: options.upper_triangle ?? false,
-      show_diagonal: options.show_diagonal ?? true,
-      method: options.method ?? "pearson"
+      chart_type: options.chart_type ?? "i",
+      sigma: options.sigma ?? 3,
+      show_center: options.show_center ?? true,
+      show_ucl: options.show_ucl ?? true,
+      show_lcl: options.show_lcl ?? true,
+      show_warning: options.show_warning ?? false,
+      center: options.center,
+      ucl: options.ucl,
+      lcl: options.lcl,
+      center_color: options.center_color ?? "#0000ff",
+      limit_color: options.limit_color ?? "#ff0000",
+      warning_color: options.warning_color ?? "#ffa500",
+      connect_points: options.connect_points ?? true,
+      highlight_ooc: options.highlight_ooc ?? true,
+      ooc_char: options.ooc_char ?? "◆",
+      point_char: options.point_char ?? "●"
     }
   };
 }
 
-// src/geoms/sankey.ts
-function geom_sankey(options = {}) {
+// src/geoms/scree.ts
+function geom_scree(options = {}) {
   return {
-    type: "sankey",
+    type: "scree",
     stat: "identity",
     position: "identity",
     params: {
-      node_width: options.node_width ?? 3,
-      node_padding: options.node_padding ?? 2,
-      node_char: options.node_char ?? "█",
-      flow_char: options.flow_char ?? "─",
-      show_labels: options.show_labels ?? true,
-      show_values: options.show_values ?? false,
-      align: options.align ?? "justify",
-      color_by: options.color_by ?? "auto",
-      min_flow_width: options.min_flow_width ?? 1,
-      flow_gap: options.flow_gap ?? 0
+      show_cumulative: options.show_cumulative ?? false,
+      show_kaiser: options.show_kaiser ?? false,
+      show_elbow: options.show_elbow ?? false,
+      show_broken_stick: options.show_broken_stick ?? false,
+      connect_points: options.connect_points ?? true,
+      show_bars: options.show_bars ?? false,
+      point_char: options.point_char ?? "●",
+      color: options.color,
+      cumulative_color: options.cumulative_color ?? "#ff0000",
+      kaiser_color: options.kaiser_color ?? "#888888",
+      y_format: options.y_format ?? "percentage",
+      threshold: options.threshold,
+      threshold_color: options.threshold_color ?? "#00aa00"
     }
   };
 }
 
-// src/geoms/treemap.ts
-function geom_treemap(options = {}) {
+// src/geoms/upset.ts
+function geom_upset(options = {}) {
   return {
-    type: "treemap",
+    type: "upset",
     stat: "identity",
     position: "identity",
     params: {
-      algorithm: options.algorithm ?? "squarify",
-      show_labels: options.show_labels ?? true,
-      show_values: options.show_values ?? false,
-      border: options.border ?? true,
-      padding: options.padding ?? 0,
-      min_label_size: options.min_label_size ?? 4,
-      color_by: options.color_by ?? "value",
-      fill_char: options.fill_char ?? "█",
-      max_depth: options.max_depth,
-      aspect_ratio: options.aspect_ratio ?? 1.618
+      sets: options.sets,
+      min_size: options.min_size ?? 1,
+      max_intersections: options.max_intersections ?? 20,
+      sort_by: options.sort_by ?? "size",
+      sort_order: options.sort_order ?? "desc",
+      show_set_sizes: options.show_set_sizes ?? true,
+      dot_char: options.dot_char ?? "●",
+      empty_char: options.empty_char ?? "○",
+      line_char: options.line_char ?? "│",
+      bar_char: options.bar_char ?? "█",
+      color: options.color,
+      show_degree: options.show_degree ?? false
     }
   };
 }
 
-// src/geoms/volcano.ts
-function geom_volcano(options = {}) {
+// src/geoms/dendrogram.ts
+function geom_dendrogram(options = {}) {
   return {
-    type: "volcano",
+    type: "dendrogram",
     stat: "identity",
     position: "identity",
     params: {
-      fc_threshold: options.fc_threshold ?? 1,
-      p_threshold: options.p_threshold ?? 0.05,
-      y_is_neglog10: options.y_is_neglog10 ?? false,
-      up_color: options.up_color ?? "#e41a1c",
-      down_color: options.down_color ?? "#377eb8",
-      ns_color: options.ns_color ?? "#999999",
-      show_thresholds: options.show_thresholds ?? true,
-      threshold_linetype: options.threshold_linetype ?? "dashed",
-      n_labels: options.n_labels ?? 0,
-      size: options.size ?? 1,
-      alpha: options.alpha ?? 0.6,
-      point_char: options.point_char ?? "●",
-      show_legend: options.show_legend ?? true,
-      classify: options.classify
+      orientation: options.orientation ?? "vertical",
+      labels: options.labels,
+      show_labels: options.show_labels ?? true,
+      hang: options.hang ?? false,
+      cut_height: options.cut_height,
+      k: options.k,
+      branch_char: options.branch_char ?? "│",
+      h_connector: options.h_connector ?? "─",
+      v_connector: options.v_connector ?? "│",
+      corner_tl: options.corner_tl ?? "┌",
+      corner_tr: options.corner_tr ?? "┐",
+      corner_bl: options.corner_bl ?? "└",
+      corner_br: options.corner_br ?? "┘",
+      leaf_char: options.leaf_char ?? "○",
+      cluster_colors: options.cluster_colors,
+      line_style: options.line_style ?? "square",
+      parent_col: options.parent_col ?? "parent",
+      height_col: options.height_col ?? "height",
+      id_col: options.id_col ?? "id"
     }
   };
 }
@@ -7500,6 +9763,7 @@ var init_geoms = __esm(() => {
   init_ridgeline();
   init_sparkline();
   init_braille();
+  init_manhattan();
 });
 
 // src/stats/index.ts
@@ -12006,6 +14270,7 @@ __export(exports_src, {
   geom_volcano: () => geom_volcano,
   geom_vline: () => geom_vline,
   geom_violin: () => geom_violin,
+  geom_upset: () => geom_upset,
   geom_treemap: () => geom_treemap,
   geom_tile: () => geom_tile,
   geom_text: () => geom_text,
@@ -12013,36 +14278,46 @@ __export(exports_src, {
   geom_sparkline: () => geom_sparkline,
   geom_smooth: () => geom_smooth,
   geom_segment: () => geom_segment,
+  geom_scree: () => geom_scree,
   geom_sankey: () => geom_sankey,
   geom_rug: () => geom_rug,
+  geom_roc: () => geom_roc,
   geom_ridgeline: () => geom_ridgeline,
   geom_ribbon: () => geom_ribbon,
   geom_rect: () => geom_rect,
   geom_raster: () => geom_raster,
   geom_quasirandom: () => geom_quasirandom,
-  geom_qq_line: () => geom_qq_line,
   geom_qq: () => geom_qq,
   geom_pointrange: () => geom_pointrange,
   geom_point: () => geom_point,
   geom_path: () => geom_path,
+  geom_manhattan: () => geom_manhattan,
+  geom_ma: () => geom_ma,
   geom_lollipop: () => geom_lollipop,
   geom_linerange: () => geom_linerange,
   geom_line: () => geom_line,
   geom_label: () => geom_label,
+  geom_kaplan_meier: () => geom_kaplan_meier,
   geom_joy: () => geom_joy,
   geom_icicle: () => geom_icicle,
   geom_hline: () => geom_hline,
   geom_histogram: () => geom_histogram,
+  geom_heatmap: () => geom_heatmap,
+  geom_funnel: () => geom_funnel,
   geom_freqpoly: () => geom_freqpoly,
+  geom_forest: () => geom_forest,
   geom_flame: () => geom_flame,
   geom_errorbarh: () => geom_errorbarh,
   geom_errorbar: () => geom_errorbar,
+  geom_ecdf: () => geom_ecdf,
   geom_dumbbell: () => geom_dumbbell,
   geom_density_2d: () => geom_density_2d,
   geom_density: () => geom_density,
+  geom_dendrogram: () => geom_dendrogram,
   geom_curve: () => geom_curve,
   geom_crossbar: () => geom_crossbar,
   geom_corrmat: () => geom_corrmat,
+  geom_control: () => geom_control,
   geom_contour_filled: () => geom_contour_filled,
   geom_contour: () => geom_contour,
   geom_col: () => geom_col,
@@ -12050,6 +14325,8 @@ __export(exports_src, {
   geom_bullet: () => geom_bullet,
   geom_braille: () => geom_braille,
   geom_boxplot: () => geom_boxplot,
+  geom_bland_altman: () => geom_bland_altman,
+  geom_biplot: () => geom_biplot,
   geom_bin2d: () => geom_bin2d,
   geom_beeswarm: () => geom_beeswarm,
   geom_bar: () => geom_bar,
@@ -12159,11 +14436,6 @@ var init_src = __esm(() => {
   init_export();
 });
 
-// src/cli-plot.ts
-init_src();
-import { readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
-import { join as join3 } from "path";
-
 // src/history/index.ts
 import { existsSync, mkdirSync, readFileSync, writeFileSync, appendFileSync, readdirSync } from "fs";
 import { join } from "path";
@@ -12320,6 +14592,589 @@ function getLatestPlotId() {
   }
   return history[history.length - 1].id;
 }
+var init_history = () => {};
+
+// src/serve.ts
+var exports_serve = {};
+__export(exports_serve, {
+  handleServe: () => handleServe
+});
+import { watch, writeFileSync as writeFileSync3, unlinkSync } from "fs";
+import { join as join3 } from "path";
+function plotToVegaLite(plot) {
+  const geomTypes = plot._provenance.geomTypes;
+  const hasCompositeMark = geomTypes.some((t) => COMPOSITE_MARKS.has(t));
+  const spec = plotSpecToVegaLite(plot.spec, { interactive: !hasCompositeMark });
+  return { spec, provenance: plot._provenance };
+}
+function getLatestPayload() {
+  const id = getLatestPlotId();
+  if (!id)
+    return null;
+  const plot = loadPlotFromHistory(id);
+  if (!plot)
+    return null;
+  const { spec, provenance } = plotToVegaLite(plot);
+  return JSON.stringify({ type: "plot", spec, provenance });
+}
+function handleServe(port) {
+  const p = port || 4242;
+  ensureHistoryDirs();
+  const clients = new Set;
+  let debounceTimer = null;
+  const plotsDir = getPlotsDir();
+  watch(plotsDir, (_event, filename) => {
+    if (!filename || !filename.endsWith(".json"))
+      return;
+    if (debounceTimer)
+      clearTimeout(debounceTimer);
+    debounceTimer = setTimeout(() => {
+      const payload = getLatestPayload();
+      if (!payload)
+        return;
+      for (const client of clients) {
+        try {
+          client.send(payload);
+        } catch {
+          clients.delete(client);
+        }
+      }
+    }, 150);
+  });
+  const server = Bun.serve({
+    port: p,
+    fetch(req, server2) {
+      const url2 = new URL(req.url);
+      if (url2.pathname === "/ws") {
+        if (server2.upgrade(req))
+          return;
+        return new Response("WebSocket upgrade failed", { status: 400 });
+      }
+      if (url2.pathname === "/api/latest") {
+        const payload = getLatestPayload();
+        if (!payload)
+          return Response.json({ type: "empty" });
+        return new Response(payload, { headers: { "content-type": "application/json" } });
+      }
+      if (url2.pathname === "/api/history") {
+        const entries = getHistory().slice(-50);
+        return Response.json(entries);
+      }
+      if (url2.pathname.startsWith("/api/plot/")) {
+        const id = url2.pathname.slice("/api/plot/".length);
+        const plot = loadPlotFromHistory(id);
+        if (!plot)
+          return Response.json({ error: "not found" }, { status: 404 });
+        const { spec, provenance } = plotToVegaLite(plot);
+        return Response.json({ type: "plot", spec, provenance });
+      }
+      return new Response(CLIENT_HTML, {
+        headers: { "content-type": "text/html; charset=utf-8" }
+      });
+    },
+    websocket: {
+      open(ws) {
+        clients.add(ws);
+        const payload = getLatestPayload();
+        if (payload)
+          ws.send(payload);
+      },
+      close(ws) {
+        clients.delete(ws);
+      },
+      message() {}
+    }
+  });
+  const url = `http://localhost:${server.port}`;
+  console.log(`ggterm live viewer running at ${url}`);
+  const markerPath = join3(getGGTermDir(), "serve.json");
+  writeFileSync3(markerPath, JSON.stringify({ port: server.port, pid: process.pid }));
+  const cleanup = () => {
+    try {
+      unlinkSync(markerPath);
+    } catch {}
+  };
+  process.on("SIGINT", () => {
+    cleanup();
+    process.exit(0);
+  });
+  process.on("SIGTERM", () => {
+    cleanup();
+    process.exit(0);
+  });
+  process.on("exit", cleanup);
+  if (process.env.TERM_PROGRAM === "waveterm") {
+    Bun.spawn(["wsh", "web", "open", url]);
+    console.log(`Opened Wave panel`);
+  } else {
+    console.log(`Open in browser or Wave panel: wsh web open ${url}`);
+  }
+  console.log(`Watching ${plotsDir} for new plots...`);
+  console.log(`Press Ctrl+C to stop`);
+}
+var COMPOSITE_MARKS, CLIENT_HTML = `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>ggterm</title>
+<script src="https://cdn.jsdelivr.net/npm/vega@5"></script>
+<script src="https://cdn.jsdelivr.net/npm/vega-lite@5"></script>
+<script src="https://cdn.jsdelivr.net/npm/vega-embed@6"></script>
+<style>
+  * { margin: 0; padding: 0; box-sizing: border-box; }
+  body {
+    font-family: -apple-system, BlinkMacSystemFont, 'SF Mono', Menlo, monospace;
+    background: #0d1117;
+    color: #c9d1d9;
+    height: 100vh;
+    display: flex;
+    overflow: hidden;
+  }
+  #sidebar {
+    width: 260px;
+    background: #161b22;
+    border-right: 1px solid #30363d;
+    display: flex;
+    flex-direction: column;
+    flex-shrink: 0;
+    transform: translateX(-260px);
+    transition: transform 0.2s ease;
+    position: absolute;
+    top: 0;
+    left: 0;
+    bottom: 0;
+    z-index: 10;
+  }
+  #sidebar.open { transform: translateX(0); }
+  #sidebar-header {
+    padding: 12px;
+    border-bottom: 1px solid #30363d;
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    font-size: 12px;
+    font-weight: 600;
+    color: #c9d1d9;
+  }
+  #sidebar-header button {
+    background: none;
+    border: none;
+    color: #8b949e;
+    cursor: pointer;
+    font-size: 14px;
+    padding: 2px 6px;
+  }
+  #sidebar-header button:hover { color: #c9d1d9; }
+  #history-list {
+    flex: 1;
+    overflow-y: auto;
+    padding: 4px 0;
+  }
+  #history-list::-webkit-scrollbar { width: 6px; }
+  #history-list::-webkit-scrollbar-track { background: transparent; }
+  #history-list::-webkit-scrollbar-thumb { background: #30363d; border-radius: 3px; }
+  .history-item {
+    padding: 8px 12px;
+    cursor: pointer;
+    border-left: 2px solid transparent;
+    transition: background 0.1s;
+  }
+  .history-item:hover { background: #21262d; }
+  .history-item.active { background: #1c2128; border-left-color: #58a6ff; }
+  .history-item .hi-id { font-size: 11px; color: #58a6ff; font-weight: 600; }
+  .history-item .hi-desc { font-size: 11px; color: #8b949e; margin-top: 2px; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+  .history-item .hi-meta { font-size: 10px; color: #484f58; margin-top: 2px; display: flex; gap: 8px; }
+  .history-item .hi-geom {
+    background: #21262d;
+    border: 1px solid #30363d;
+    border-radius: 3px;
+    padding: 0 4px;
+    font-size: 10px;
+    color: #8b949e;
+  }
+  #main {
+    flex: 1;
+    display: flex;
+    flex-direction: column;
+    min-width: 0;
+  }
+  #vis {
+    flex: 1;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    padding: 16px;
+  }
+  #vis .vega-embed { width: 100%; }
+  #vis .vega-embed canvas,
+  #vis .vega-embed svg {
+    max-width: 100%;
+    max-height: calc(100vh - 80px);
+  }
+  #bar {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: 8px 16px;
+    background: #161b22;
+    border-top: 1px solid #30363d;
+    font-size: 12px;
+    gap: 12px;
+    min-height: 40px;
+  }
+  #meta { display: flex; gap: 16px; align-items: center; flex: 1; min-width: 0; }
+  #plot-id { color: #58a6ff; font-weight: 600; }
+  #plot-desc { color: #8b949e; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+  #plot-time { color: #484f58; }
+  #nav { display: flex; gap: 4px; align-items: center; }
+  .bar-btn {
+    background: #21262d;
+    border: 1px solid #30363d;
+    color: #c9d1d9;
+    border-radius: 4px;
+    padding: 4px 10px;
+    cursor: pointer;
+    font-size: 12px;
+    font-family: inherit;
+  }
+  .bar-btn:hover { background: #30363d; }
+  .bar-btn:disabled { opacity: 0.3; cursor: default; }
+  .bar-btn:disabled:hover { background: #21262d; }
+  .bar-btn.active { background: #30363d; border-color: #58a6ff; }
+  #actions { display: flex; gap: 4px; align-items: center; }
+  #actions button {
+    background: none;
+    border: 1px solid #30363d;
+    color: #8b949e;
+    border-radius: 4px;
+    padding: 4px 8px;
+    cursor: pointer;
+    font-size: 11px;
+    font-family: inherit;
+  }
+  #actions button:hover { color: #c9d1d9; border-color: #58a6ff; }
+  #status {
+    width: 8px; height: 8px;
+    border-radius: 50%;
+    background: #f85149;
+    flex-shrink: 0;
+  }
+  #status.connected { background: #3fb950; }
+  .waiting {
+    color: #484f58;
+    font-size: 14px;
+    text-align: center;
+  }
+  .waiting .hint { font-size: 12px; margin-top: 8px; color: #30363d; }
+  #shortcuts {
+    display: none;
+    position: fixed;
+    top: 50%;
+    left: 50%;
+    transform: translate(-50%, -50%);
+    background: #161b22;
+    border: 1px solid #30363d;
+    border-radius: 8px;
+    padding: 20px 24px;
+    z-index: 20;
+    font-size: 12px;
+    min-width: 220px;
+  }
+  #shortcuts.open { display: block; }
+  #shortcuts h3 { font-size: 13px; margin-bottom: 12px; color: #c9d1d9; }
+  .shortcut-row { display: flex; justify-content: space-between; padding: 4px 0; }
+  .shortcut-row kbd {
+    background: #21262d;
+    border: 1px solid #30363d;
+    border-radius: 3px;
+    padding: 1px 6px;
+    font-family: inherit;
+    font-size: 11px;
+    color: #c9d1d9;
+  }
+  .shortcut-row span { color: #8b949e; }
+  #overlay {
+    display: none;
+    position: fixed;
+    inset: 0;
+    background: rgba(0,0,0,0.5);
+    z-index: 15;
+  }
+  #overlay.open { display: block; }
+</style>
+</head>
+<body>
+<div id="sidebar">
+  <div id="sidebar-header">
+    <span>History</span>
+    <button onclick="toggleHistory()">&times;</button>
+  </div>
+  <div id="history-list"></div>
+</div>
+<div id="main">
+  <div id="vis">
+    <div class="waiting">
+      <div>waiting for plots...</div>
+      <div class="hint">create a plot in ggterm and it will appear here</div>
+    </div>
+  </div>
+  <div id="bar">
+    <div id="status"></div>
+    <div id="meta">
+      <span id="plot-id"></span>
+      <span id="plot-desc"></span>
+      <span id="plot-time"></span>
+    </div>
+    <div id="nav">
+      <button id="hist-btn" class="bar-btn" onclick="toggleHistory()" title="History (h)">H</button>
+      <button id="prev" class="bar-btn" disabled title="Previous plot (&larr;)">&larr;</button>
+      <button id="next" class="bar-btn" disabled title="Next plot (&rarr;)">&rarr;</button>
+    </div>
+    <div id="actions">
+      <button onclick="downloadSVG()" title="Download SVG (s)">SVG</button>
+      <button onclick="downloadPNG()" title="Download PNG (p)">PNG</button>
+      <button onclick="toggleShortcuts()" title="Keyboard shortcuts (?)">?</button>
+    </div>
+  </div>
+</div>
+<div id="overlay" onclick="closeOverlays()"></div>
+<div id="shortcuts">
+  <h3>Keyboard Shortcuts</h3>
+  <div class="shortcut-row"><span>Previous plot</span><kbd>&larr;</kbd></div>
+  <div class="shortcut-row"><span>Next plot</span><kbd>&rarr;</kbd></div>
+  <div class="shortcut-row"><span>Latest plot</span><kbd>End</kbd></div>
+  <div class="shortcut-row"><span>First plot</span><kbd>Home</kbd></div>
+  <div class="shortcut-row"><span>Toggle history</span><kbd>h</kbd></div>
+  <div class="shortcut-row"><span>Download SVG</span><kbd>s</kbd></div>
+  <div class="shortcut-row"><span>Download PNG</span><kbd>p</kbd></div>
+  <div class="shortcut-row"><span>Fullscreen</span><kbd>f</kbd></div>
+  <div class="shortcut-row"><span>Show shortcuts</span><kbd>?</kbd></div>
+  <div class="shortcut-row"><span>Close panel</span><kbd>Esc</kbd></div>
+</div>
+<script>
+const vis = document.getElementById('vis');
+const main = document.getElementById('main');
+const statusEl = document.getElementById('status');
+const idEl = document.getElementById('plot-id');
+const descEl = document.getElementById('plot-desc');
+const timeEl = document.getElementById('plot-time');
+const prevBtn = document.getElementById('prev');
+const nextBtn = document.getElementById('next');
+const histBtn = document.getElementById('hist-btn');
+const sidebar = document.getElementById('sidebar');
+const historyList = document.getElementById('history-list');
+const shortcutsEl = document.getElementById('shortcuts');
+const overlayEl = document.getElementById('overlay');
+
+let history = [];
+let historyIndex = {};
+let currentIdx = -1;
+let view = null;
+let ws = null;
+
+function updateMeta(prov) {
+  if (!prov) return;
+  idEl.textContent = prov.id;
+  descEl.textContent = prov.description || '';
+  timeEl.textContent = prov.timestamp ? new Date(prov.timestamp).toLocaleTimeString() : '';
+}
+
+function updateNav() {
+  prevBtn.disabled = currentIdx <= 0;
+  nextBtn.disabled = currentIdx >= history.length - 1;
+}
+
+function updateHistoryHighlight() {
+  historyList.querySelectorAll('.history-item').forEach((el, i) => {
+    el.classList.toggle('active', i === currentIdx);
+  });
+  const active = historyList.querySelector('.active');
+  if (active) active.scrollIntoView({ block: 'nearest' });
+}
+
+function addHistoryItem(data, idx) {
+  const prov = data.provenance;
+  if (!prov) return;
+  const div = document.createElement('div');
+  div.className = 'history-item' + (idx === currentIdx ? ' active' : '');
+  div.innerHTML =
+    '<div class="hi-id">' + prov.id + '</div>' +
+    '<div class="hi-desc">' + (prov.description || '') + '</div>' +
+    '<div class="hi-meta">' +
+      '<span class="hi-geom">' + (prov.geomTypes ? prov.geomTypes.join('+') : '') + '</span>' +
+      '<span>' + (prov.timestamp ? new Date(prov.timestamp).toLocaleTimeString() : '') + '</span>' +
+    '</div>';
+  div.onclick = () => navigate(idx);
+  historyList.appendChild(div);
+}
+
+function rebuildHistoryList() {
+  historyList.innerHTML = '';
+  history.forEach((data, i) => addHistoryItem(data, i));
+}
+
+const embedOpts = {
+  actions: false,
+  theme: 'dark',
+  renderer: 'svg',
+  config: {
+    background: '#0d1117',
+    axis: { domainColor: '#30363d', gridColor: '#21262d', tickColor: '#30363d', labelColor: '#8b949e', titleColor: '#c9d1d9' },
+    legend: { labelColor: '#c9d1d9', titleColor: '#c9d1d9' },
+    title: { color: '#c9d1d9', subtitleColor: '#8b949e' },
+    view: { stroke: null }
+  }
+};
+
+async function renderSpec(spec) {
+  vis.innerHTML = '';
+  const vegaSpec = { ...spec, width: 'container', height: 'container', autosize: { type: 'fit', contains: 'padding' } };
+  try {
+    const result = await vegaEmbed(vis, vegaSpec, embedOpts);
+    view = result.view;
+  } catch (e) {
+    // Retry without interactive params (composite marks like boxplot don't support selections)
+    console.warn('Render failed, retrying without params:', e.message);
+    const { params, ...cleanSpec } = vegaSpec;
+    const result = await vegaEmbed(vis, cleanSpec, embedOpts);
+    view = result.view;
+  }
+}
+
+async function showPlot(data) {
+  await renderSpec(data.spec);
+  updateMeta(data.provenance);
+}
+
+function navigate(idx) {
+  if (idx < 0 || idx >= history.length) return;
+  currentIdx = idx;
+  const data = history[idx];
+  if (data.spec) {
+    showPlot(data);
+  } else {
+    // Lazy-load full spec from server
+    fetch('/api/plot/' + data.provenance.id)
+      .then(r => r.json())
+      .then(full => {
+        history[idx] = full;
+        showPlot(full);
+      });
+  }
+  updateNav();
+  updateHistoryHighlight();
+}
+
+prevBtn.onclick = () => navigate(currentIdx - 1);
+nextBtn.onclick = () => navigate(currentIdx + 1);
+
+function toggleHistory() {
+  const open = sidebar.classList.toggle('open');
+  histBtn.classList.toggle('active', open);
+}
+
+function toggleShortcuts() {
+  const open = shortcutsEl.classList.toggle('open');
+  overlayEl.classList.toggle('open', open);
+}
+
+function closeOverlays() {
+  shortcutsEl.classList.remove('open');
+  overlayEl.classList.remove('open');
+}
+
+document.addEventListener('keydown', (e) => {
+  // Ignore when typing in an input
+  if (e.target.tagName === 'INPUT' || e.target.tagName === 'TEXTAREA') return;
+
+  switch (e.key) {
+    case 'ArrowLeft': navigate(currentIdx - 1); break;
+    case 'ArrowRight': navigate(currentIdx + 1); break;
+    case 'Home': e.preventDefault(); navigate(0); break;
+    case 'End': e.preventDefault(); navigate(history.length - 1); break;
+    case 'h': toggleHistory(); break;
+    case 's': downloadSVG(); break;
+    case 'p': downloadPNG(); break;
+    case 'f':
+      if (!document.fullscreenElement) {
+        document.documentElement.requestFullscreen();
+      } else {
+        document.exitFullscreen();
+      }
+      break;
+    case '?': toggleShortcuts(); break;
+    case 'Escape': closeOverlays(); if (sidebar.classList.contains('open')) toggleHistory(); break;
+  }
+});
+
+function downloadSVG() {
+  if (!view) return;
+  view.toSVG().then(svg => {
+    const a = document.createElement('a');
+    a.href = URL.createObjectURL(new Blob([svg], { type: 'image/svg+xml' }));
+    a.download = (idEl.textContent || 'plot') + '.svg';
+    a.click();
+  });
+}
+
+function downloadPNG() {
+  if (!view) return;
+  view.toCanvas(2).then(canvas => {
+    const a = document.createElement('a');
+    a.href = canvas.toDataURL('image/png');
+    a.download = (idEl.textContent || 'plot') + '.png';
+    a.click();
+  });
+}
+
+function connect() {
+  const proto = location.protocol === 'https:' ? 'wss:' : 'ws:';
+  ws = new WebSocket(proto + '//' + location.host + '/ws');
+
+  ws.onopen = () => { statusEl.classList.add('connected'); };
+  ws.onclose = () => {
+    statusEl.classList.remove('connected');
+    setTimeout(connect, 2000);
+  };
+  ws.onerror = () => ws.close();
+
+  ws.onmessage = (e) => {
+    const data = JSON.parse(e.data);
+    if (data.type === 'plot') {
+      history.push(data);
+      currentIdx = history.length - 1;
+      addHistoryItem(data, history.length - 1);
+      showPlot(data);
+      updateNav();
+      updateHistoryHighlight();
+    }
+  };
+}
+
+// Load initial history then connect
+fetch('/api/history')
+  .then(r => r.json())
+  .then(entries => {
+    // Populate history with provenance-only stubs (lazy-load specs on navigate)
+    history = entries.map(e => ({ provenance: e, spec: null }));
+    rebuildHistoryList();
+  })
+  .then(() => connect());
+</script>
+</body>
+</html>`;
+var init_serve = __esm(() => {
+  init_history();
+  init_export();
+  COMPOSITE_MARKS = new Set(["boxplot", "violin", "errorband", "errorbar"]);
+});
+
+// src/cli-plot.ts
+init_src();
+init_history();
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync4, existsSync as existsSync3 } from "fs";
+import { join as join4 } from "path";
 
 // src/init.ts
 import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync2, readFileSync as readFileSync2, existsSync as existsSync2, readdirSync as readdirSync2, statSync } from "fs";
@@ -12941,6 +15796,18 @@ function handleInit() {
 }
 
 // src/cli-plot.ts
+function isServeRunning() {
+  const markerPath = join4(getGGTermDir(), "serve.json");
+  if (!existsSync3(markerPath))
+    return false;
+  try {
+    const info = JSON.parse(readFileSync3(markerPath, "utf-8"));
+    process.kill(info.pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
 var GEOM_TYPES = [
   "point",
   "line",
@@ -12989,7 +15856,22 @@ var GEOM_TYPES = [
   "corrmat",
   "sankey",
   "treemap",
-  "volcano"
+  "volcano",
+  "ma",
+  "manhattan",
+  "heatmap",
+  "biplot",
+  "kaplan_meier",
+  "forest",
+  "roc",
+  "bland_altman",
+  "qq",
+  "ecdf",
+  "funnel",
+  "control",
+  "scree",
+  "upset",
+  "dendrogram"
 ];
 var datePattern = /^\d{4}-\d{2}-\d{2}/;
 function fileExists(path) {
@@ -13456,8 +16338,15 @@ Did you mean one of these commands?`);
     process.exit(1);
   }
   const [dataFile, x, y, color, title, geomSpec = "point", facetVar] = args;
-  const { headers, data } = loadData(dataFile);
+  let { headers, data } = loadData(dataFile);
   const { baseGeom: geomType, refLines } = parseGeomSpec(geomSpec);
+  if (geomType === "manhattan" && y && y !== "-") {
+    data = data.map((row) => {
+      const pval = Number(row[y]);
+      const negLogP = pval > 0 ? -Math.log10(pval) : 0;
+      return { ...row, [`_neglog10_${y}`]: negLogP };
+    });
+  }
   validateGeomType(geomType);
   validateColumn(x, headers, "x");
   if (y && y !== "-")
@@ -13477,8 +16366,11 @@ If you want a univariate plot, try: histogram, density, bar, qq, or freqpoly`);
     process.exit(1);
   }
   const aes = { x };
-  if (y && y !== "-")
+  if (geomType === "manhattan" && y && y !== "-") {
+    aes.y = `_neglog10_${y}`;
+  } else if (y && y !== "-") {
     aes.y = y;
+  }
   if (color && color !== "-") {
     if (geomType === "tile" || geomType === "raster" || geomType === "bin2d") {
       aes.fill = color;
@@ -13603,7 +16495,6 @@ If you want a univariate plot, try: histogram, density, bar, qq, or freqpoly`);
       break;
     case "qq":
       plot = plot.geom(geom_qq());
-      plot = plot.geom(geom_qq_line());
       break;
     case "calendar":
       plot = plot.geom(geom_calendar());
@@ -13626,6 +16517,51 @@ If you want a univariate plot, try: histogram, density, bar, qq, or freqpoly`);
     case "volcano":
       plot = plot.geom(geom_volcano());
       break;
+    case "ma":
+      plot = plot.geom(geom_ma());
+      break;
+    case "manhattan":
+      plot = plot.geom(geom_manhattan({ y_is_neglog10: true }));
+      break;
+    case "heatmap":
+      plot = plot.geom(geom_heatmap());
+      break;
+    case "biplot":
+      plot = plot.geom(geom_biplot());
+      break;
+    case "kaplan_meier":
+      plot = plot.geom(geom_kaplan_meier());
+      break;
+    case "forest":
+      plot = plot.geom(geom_forest());
+      break;
+    case "roc":
+      plot = plot.geom(geom_roc());
+      break;
+    case "bland_altman":
+      plot = plot.geom(geom_bland_altman());
+      break;
+    case "qq":
+      plot = plot.geom(geom_qq());
+      break;
+    case "ecdf":
+      plot = plot.geom(geom_ecdf());
+      break;
+    case "funnel":
+      plot = plot.geom(geom_funnel());
+      break;
+    case "control":
+      plot = plot.geom(geom_control());
+      break;
+    case "scree":
+      plot = plot.geom(geom_scree());
+      break;
+    case "upset":
+      plot = plot.geom(geom_upset());
+      break;
+    case "dendrogram":
+      plot = plot.geom(geom_dendrogram());
+      break;
     case "point":
     default:
       plot = plot.geom(geom_point());
@@ -13649,10 +16585,70 @@ If you want a univariate plot, try: histogram, density, bar, qq, or freqpoly`);
   if (geomType === "qq") {
     yLabel = "Sample Quantiles";
   }
+  if (geomType === "manhattan") {
+    yLabel = "-log10(p-value)";
+  }
+  if (geomType === "kaplan_meier") {
+    yLabel = "Survival Probability";
+  }
+  if (geomType === "roc") {
+    yLabel = "True Positive Rate (Sensitivity)";
+  }
+  if (geomType === "bland_altman") {
+    yLabel = "Difference (Method1 - Method2)";
+  }
+  if (geomType === "ecdf") {
+    yLabel = "Cumulative Probability";
+  }
+  if (geomType === "funnel") {
+    yLabel = "Standard Error";
+  }
+  if (geomType === "control") {
+    yLabel = "Measurement";
+  }
+  if (geomType === "scree") {
+    yLabel = "Variance Explained";
+  }
+  if (geomType === "upset") {
+    yLabel = "Intersection Size";
+  }
+  if (geomType === "dendrogram") {
+    yLabel = "Height";
+  }
   let xLabel = x;
   if (geomType === "qq") {
     xLabel = "Theoretical Quantiles";
   }
+  if (geomType === "manhattan") {
+    xLabel = "Chromosome";
+  }
+  if (geomType === "kaplan_meier") {
+    xLabel = "Time";
+  }
+  if (geomType === "roc") {
+    xLabel = "False Positive Rate (1 - Specificity)";
+  }
+  if (geomType === "bland_altman") {
+    xLabel = "Mean of Methods";
+  }
+  if (geomType === "forest") {
+    xLabel = "Effect Size";
+  }
+  if (geomType === "funnel") {
+    xLabel = "Effect Size";
+  }
+  if (geomType === "control") {
+    xLabel = "Sample Number";
+  }
+  if (geomType === "scree") {
+    xLabel = "Component";
+  }
+  if (geomType === "upset") {
+    xLabel = "Set Intersection";
+  }
+  if (geomType === "dendrogram") {
+    xLabel = "Cluster";
+  }
   if (title && title !== "-") {
     plot = plot.labs({ title, x: xLabel, y: yLabel });
   } else {
@@ -13661,15 +16657,22 @@ If you want a univariate plot, try: histogram, density, bar, qq, or freqpoly`);
   if (facetVar && facetVar !== "-") {
     plot = plot.facet(facet_wrap(facetVar));
   }
-  console.log(plot.render({ width: 70, height: 20, colorMode: "truecolor" }));
+  const serveActive = isServeRunning();
+  if (!serveActive) {
+    console.log(plot.render({ width: 70, height: 20, colorMode: "truecolor" }));
+  }
   const spec = plot.spec();
   const commandStr = `cli-plot.ts ${args.join(" ")}`;
   const plotId = savePlotToHistory(spec, {
     dataFile,
     command: commandStr
   });
-  console.log(`
+  if (serveActive) {
+    console.log(`[${plotId}] → live viewer`);
+  } else {
+    console.log(`
 [Saved as ${plotId}]`);
+  }
 }
 function handleHistory(searchQuery) {
   const entries = searchQuery ? searchHistory(searchQuery) : getHistory();
@@ -13748,7 +16751,7 @@ function handleExport(idOrFile, outputFile) {
   const spec = plotSpecToVegaLite2(plotSpec, {
     interactive: true
   });
-  writeFileSync3(join3(getGGTermDir(), "last-plot-vegalite.json"), JSON.stringify(spec, null, 2));
+  writeFileSync4(join4(getGGTermDir(), "last-plot-vegalite.json"), JSON.stringify(spec, null, 2));
   const title = typeof spec.title === "string" ? spec.title : spec.title?.text || "Plot";
   const output = outputFile || `${plotId}.html`;
   const html = `<!DOCTYPE html>
@@ -13805,7 +16808,7 @@ function handleExport(idOrFile, outputFile) {
   </script>
 </body>
 </html>`;
-  writeFileSync3(output, html);
+  writeFileSync4(output, html);
   console.log(`Created ${output} - open in browser to view and export`);
 }
 function printUsage() {
@@ -13819,6 +16822,7 @@ Commands:
   history [search]                            List all plots (optionally filter by search)
   show <id>                                   Re-render a plot from history
   export [id] [output.html]                   Export plot to HTML (latest or by ID)
+  serve [port]                                Start live plot viewer (default: 4242)
   <file> <x> <y> [color] [title] [geom] [facet]   Create a plot
 
 Supported formats: CSV, JSON, JSONL (auto-detected by extension)
@@ -13843,6 +16847,8 @@ Examples:
   ggterm-plot history
   ggterm-plot show 2024-01-26-001
   ggterm-plot export 2024-01-26-001 figure.html
+  ggterm-plot serve                           # Start live plot viewer
+  ggterm-plot serve 8080                      # Custom port
 `);
 }
 var args = process.argv.slice(2);
@@ -13875,6 +16881,10 @@ if (command === "init") {
   handleShow(args[1]);
 } else if (command === "export") {
   handleExport(args[1], args[2]);
+} else if (command === "serve") {
+  Promise.resolve().then(() => (init_serve(), exports_serve)).then(({ handleServe: handleServe2 }) => {
+    handleServe2(args[1] ? parseInt(args[1]) : undefined);
+  });
 } else if (command === "help" || command === "--help" || command === "-h") {
   printUsage();
 } else {