@ggterm/core 0.2.17 → 0.2.20

package/dist/cli-plot.js

@@ -3721,6 +3721,1465 @@ function renderGeomVolcano(data, geom, aes, scales, canvas) {
     }
   }
 }
+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));
+      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 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);
+  }
+}
+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 +5308,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();
@@ -7170,28 +9074,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
     }
   };
 }
@@ -7495,11 +9388,358 @@ function geom_volcano(options = {}) {
   };
 }
 
+// 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: "ecdf",
+    stat: "identity",
+    position: "identity",
+    params: {
+      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/funnel.ts
+function geom_funnel(options = {}) {
+  return {
+    type: "funnel",
+    stat: "identity",
+    position: "identity",
+    params: {
+      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"
+    }
+  };
+}
+
+// src/geoms/control.ts
+function geom_control(options = {}) {
+  return {
+    type: "control",
+    stat: "identity",
+    position: "identity",
+    params: {
+      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/scree.ts
+function geom_scree(options = {}) {
+  return {
+    type: "scree",
+    stat: "identity",
+    position: "identity",
+    params: {
+      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/upset.ts
+function geom_upset(options = {}) {
+  return {
+    type: "upset",
+    stat: "identity",
+    position: "identity",
+    params: {
+      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/dendrogram.ts
+function geom_dendrogram(options = {}) {
+  return {
+    type: "dendrogram",
+    stat: "identity",
+    position: "identity",
+    params: {
+      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"
+    }
+  };
+}
+
 // src/geoms/index.ts
 var init_geoms = __esm(() => {
   init_ridgeline();
   init_sparkline();
   init_braille();
+  init_manhattan();
 });
 
 // src/stats/index.ts
@@ -12006,6 +14246,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 +14254,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 +14301,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,
@@ -12989,7 +15242,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 +15724,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 +15752,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 +15881,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 +15903,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 +15971,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 {