@pixerate/editor 0.46.1 → 0.48.0

package/dist/chart/index.js

@@ -1,1677 +1,257 @@
 import {
-  parseCsv,
-  parseTsv
-} from "../chunk-664LQYFJ.js";
+  CATEGORY_REF,
+  CHART_UPDATE_PROPERTIES,
+  HEIGHT,
+  SERIES_PROPS,
+  SERIES_REF,
+  TRENDLINE_PROPS,
+  VALUE,
+  WIDTH
+} from "../chunk-HXUL3LS7.js";
+import {
+  CHART_OOXML_CONTENT_TYPE,
+  CHART_OOXML_NS,
+  CHART_OOXML_RELATIONSHIP,
+  chartFormatToCode,
+  chartFromOoxml,
+  chartToOoxml
+} from "../chunk-XUUD43OV.js";
 import {
-  HistoryManager
-} from "../chunk-QVZZGT4X.js";
+  CHART_AXIS_KINDS,
+  CHART_COLOR_SCHEMES,
+  CHART_CURVES,
+  CHART_DATE_STEPS,
+  CHART_LABEL_POSITIONS,
+  CHART_LAYOUT_PRESETS,
+  CHART_LEGEND_POSITIONS,
+  CHART_MARKERS,
+  CHART_MERMAID_META_PREFIX,
+  CHART_NUMBER_STYLES,
+  CHART_ORIENTATIONS,
+  CHART_PALETTE_SHADES,
+  CHART_SERIES_TYPES,
+  CHART_STACKINGS,
+  CHART_TRENDLINE_TYPES,
+  CHART_TYPES,
+  CHART_TYPE_LABELS,
+  CSS_VARIABLE_CHART_THEME,
+  ChartController,
+  DEFAULT_CHART_PALETTE,
+  DEFAULT_CHART_THEME,
+  MAX_CHART_DATA_LABELS,
+  MAX_CHART_LINE_POINTS,
+  MAX_CHART_MARKERS,
+  chartBoxStats,
+  chartColorDistance,
+  chartColorInputValue,
+  chartColorsByCategory,
+  chartContrastRatio,
+  chartDataFromTable,
+  chartDataToTable,
+  chartDateLabels,
+  chartDateToSerial,
+  chartFamily,
+  chartFromMermaid,
+  chartHistogram,
+  chartLuminance,
+  chartMermaidFamily,
+  chartMovingAverage,
+  chartPointColor,
+  chartPresetPatch,
+  chartQuantile,
+  chartRgbToHex,
+  chartRgbToOklab,
+  chartSceneToDomSpec,
+  chartSceneToSvg,
+  chartSerialToDate,
+  chartSeriesColor,
+  chartSeriesType,
+  chartSliceColor,
+  chartSquarify,
+  chartSupportsTrendlines,
+  chartTextBaseline,
+  chartTextOn,
+  chartTextTransform,
+  chartToMermaid,
+  chartToSvg,
+  chartTrendlineName,
+  chartValueAtPoint,
+  chartXAtPoint,
+  checkChartColors,
+  cloneChartSeries,
+  cloneChartSpec,
+  compileChartFormatCode,
+  contrastingTextColor,
+  createChartController,
+  createChartSpec,
+  cyclePaletteColor,
+  decimateChartPoints,
+  defaultChartAxis,
+  describeChart,
+  estimateChartTextWidth,
+  findMermaidCharts,
+  fitChartTrendline,
+  formatChartDate,
+  formatChartNumber,
+  formatChartValueWithCode,
+  isCartesianChart,
+  isXyChart,
+  layoutChart,
+  layoutSparkline,
+  linearMap,
+  monochromeChartPalette,
+  niceScale,
+  niceStep,
+  normalizeChartAxis,
+  normalizeChartSpec,
+  normalizeChartTrendline,
+  normalizeChartValues,
+  parseChartColor,
+  parseChartDate,
+  parseChartValue,
+  sameChartSelection,
+  shadeChartColor,
+  simulateChartVision,
+  snapChartValue,
+  sparklineToSvg,
+  stepDecimals,
+  summarizeChart,
+  summarizeChartSeries,
+  trendNumberText,
+  uniqueChartSeriesId
+} from "../chunk-LTUM52X6.js";
+import "../chunk-EKYHKQPG.js";
+import {
+  parseCsv
+} from "../chunk-664LQYFJ.js";
+import "../chunk-QVZZGT4X.js";
 
-// src/chart/spec.ts
-var CHART_TYPES = ["bar", "line", "area", "scatter", "pie", "donut"];
-var CHART_SERIES_TYPES = ["bar", "line", "area", "scatter"];
-var CHART_STACKINGS = ["none", "stacked", "percent"];
-var CHART_CURVES = ["linear", "smooth", "step"];
-var CHART_ORIENTATIONS = ["vertical", "horizontal"];
-var CHART_LEGEND_POSITIONS = ["top", "bottom", "left", "right"];
-var CHART_NUMBER_STYLES = ["number", "percent", "currency", "compact"];
-var CHART_TYPE_LABELS = {
-  bar: "Bar",
-  line: "Line",
-  area: "Area",
-  scatter: "Scatter",
-  pie: "Pie",
-  donut: "Donut"
-};
-var DEFAULT_CHART_PALETTE = ["#4269d0", "#efb118", "#ff725c", "#6cc5b0", "#3ca951", "#ff8ab7", "#a463f2", "#97bbf5", "#9c6b4e", "#9498a0"];
-var DEFAULT_CHART_THEME = {
-  background: "#ffffff",
-  surface: "#ffffff",
-  text: "#0f172a",
-  mutedText: "#64748b",
-  grid: "#e2e8f0",
-  axis: "#94a3b8",
-  selection: "#2563eb",
-  fontFamily: 'system-ui, -apple-system, "Segoe UI", sans-serif',
-  fontSize: 11,
-  titleSize: 15
-};
-var CSS_VARIABLE_CHART_THEME = {
-  ...DEFAULT_CHART_THEME,
-  background: "transparent",
-  surface: "var(--background, #ffffff)",
-  text: "var(--foreground, #0f172a)",
-  mutedText: "var(--muted-foreground, #64748b)",
-  grid: "var(--border, #e2e8f0)",
-  axis: "var(--muted-foreground, #94a3b8)",
-  selection: "var(--primary, #2563eb)",
-  fontFamily: "inherit"
-};
-function isCartesianChart(type) {
-  return type !== "pie" && type !== "donut";
-}
-function defaultChartAxis(value) {
-  return { show: true, title: "", min: null, max: null, gridlines: value, format: {} };
-}
-function createChartSpec(partial = {}) {
-  return normalizeChartSpec(partial).spec;
-}
-function chartSeriesColor(spec, seriesIndex) {
-  const series = spec.series[seriesIndex];
-  if (series?.color) return series.color;
-  const palette = spec.palette.length ? spec.palette : DEFAULT_CHART_PALETTE;
-  return palette[seriesIndex % palette.length];
-}
-function chartSliceColor(spec, index) {
-  const palette = spec.palette.length ? spec.palette : DEFAULT_CHART_PALETTE;
-  return palette[index % palette.length];
-}
-function chartSeriesType(spec, series) {
-  if (series.type) return series.type;
-  return isCartesianChart(spec.type) ? spec.type : "bar";
-}
-function uniqueChartSeriesId(series, base = "series") {
-  const used = new Set(series.map((s) => s.id));
-  for (let i = series.length + 1; ; i++) {
-    const id = `${base}-${i}`;
-    if (!used.has(id)) return id;
-  }
-}
-function parseChartValue(input) {
-  if (input === null || input === void 0) return null;
-  if (typeof input === "number") return Number.isFinite(input) ? input : void 0;
-  if (typeof input !== "string") return void 0;
-  let text2 = input.trim();
-  if (!text2 || text2 === "-" || text2 === "\u2014") return null;
-  let negative = false;
-  if (/^\(.*\)$/.test(text2)) {
-    negative = true;
-    text2 = text2.slice(1, -1).trim();
-  }
-  const percent = text2.endsWith("%");
-  if (percent) text2 = text2.slice(0, -1).trim();
-  text2 = text2.replace(/^[$€£¥]/, "").replace(/,/g, "").replace(/\s+/g, "");
-  if (!/^[-+]?(\d+\.?\d*|\.\d+)(e[-+]?\d+)?$/i.test(text2)) return void 0;
-  let value = Number(text2);
-  if (percent) value /= 100;
-  if (negative) value = -value;
-  return Number.isFinite(value) ? value : void 0;
-}
-var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-function pick(value, options, fallback, path, issues) {
-  if (value === void 0) return fallback;
-  if (typeof value === "string" && options.includes(value)) return value;
-  issues.push({ path, message: `${path} must be one of ${options.map((o) => `"${o}"`).join(", ")}; got ${JSON.stringify(value)}.` });
-  return fallback;
-}
-function text(value, fallback, path, issues) {
-  if (value === void 0 || value === null) return fallback;
-  if (typeof value === "string") return value;
-  if (typeof value === "number" || typeof value === "boolean") return String(value);
-  issues.push({ path, message: `${path} must be text.` });
-  return fallback;
-}
-function flag(value, fallback, path, issues) {
-  if (value === void 0) return fallback;
-  if (typeof value === "boolean") return value;
-  issues.push({ path, message: `${path} must be true or false.` });
-  return fallback;
-}
-function bound(value, path, issues) {
-  if (value === void 0 || value === null || value === "") return null;
-  const n = typeof value === "string" ? Number(value) : value;
-  if (typeof n === "number" && Number.isFinite(n)) return n;
-  issues.push({ path, message: `${path} must be a number or null.` });
-  return null;
-}
-function normalizeFormat(value, path, issues) {
-  if (value === void 0 || value === null) return {};
-  if (!isRecord(value)) {
-    issues.push({ path, message: `${path} must be an object.` });
-    return {};
-  }
-  const out = {};
-  if (value.style !== void 0) out.style = pick(value.style, CHART_NUMBER_STYLES, "number", `${path}.style`, issues);
-  if (value.decimals !== void 0) {
-    const d = Number(value.decimals);
-    if (Number.isInteger(d) && d >= 0 && d <= 10) out.decimals = d;
-    else issues.push({ path: `${path}.decimals`, message: `${path}.decimals must be a whole number from 0 to 10.` });
-  }
-  for (const key of ["currency", "prefix", "suffix"]) {
-    if (value[key] !== void 0) out[key] = text(value[key], "", `${path}.${key}`, issues);
-  }
-  return out;
-}
-function normalizeChartAxis(value, fallback, path, issues = []) {
-  if (value === void 0) return { ...fallback, format: { ...fallback.format } };
-  if (!isRecord(value)) {
-    issues.push({ path, message: `${path} must be an object.` });
-    return { ...fallback, format: { ...fallback.format } };
-  }
-  let min = "min" in value ? bound(value.min, `${path}.min`, issues) : fallback.min;
-  let max = "max" in value ? bound(value.max, `${path}.max`, issues) : fallback.max;
-  if (min !== null && max !== null && min >= max) {
-    issues.push({ path: `${path}.max`, message: `${path}.max (${max}) must be greater than ${path}.min (${min}).` });
-    min = fallback.min;
-    max = fallback.max;
-  }
-  return {
-    show: flag(value.show, fallback.show, `${path}.show`, issues),
-    title: text(value.title, fallback.title, `${path}.title`, issues),
-    min,
-    max,
-    gridlines: flag(value.gridlines, fallback.gridlines, `${path}.gridlines`, issues),
-    format: "format" in value ? normalizeFormat(value.format, `${path}.format`, issues) : { ...fallback.format }
-  };
-}
-function normalizeLegend(value, issues) {
-  const fallback = { show: true, position: "bottom" };
-  if (value === void 0) return fallback;
-  if (!isRecord(value)) {
-    issues.push({ path: "legend", message: "legend must be an object." });
-    return fallback;
-  }
-  return {
-    show: flag(value.show, fallback.show, "legend.show", issues),
-    position: pick(value.position, CHART_LEGEND_POSITIONS, fallback.position, "legend.position", issues)
-  };
-}
-function normalizeChartValues(value, length, path, issues = []) {
-  if (value === void 0) return length ? Array(length).fill(null) : [];
-  if (!Array.isArray(value)) {
-    issues.push({ path, message: `${path} must be an array of numbers.` });
-    return length ? Array(length).fill(null) : [];
-  }
-  const out = value.map((v, i) => {
-    const parsed = parseChartValue(v);
-    if (parsed === void 0) {
-      issues.push({ path: `${path}[${i}]`, message: `${path}[${i}] is not a number: ${JSON.stringify(v)}.` });
-      return null;
+// src/chart/recommend.ts
+var blank = (c) => c === null || c === void 0 || String(c).trim() === "";
+var isText = (c) => blank(c) || parseChartValue(c) === void 0;
+function analyzeChartTable(rows) {
+  const grid = rows.filter((r) => r.some((c) => !blank(c)));
+  const height = grid.length;
+  const width = Math.max(0, ...grid.map((r) => r.length));
+  const cell = (r, c) => grid[r]?.[c];
+  const headerRow = height > 1 && grid[0].some((c) => !blank(c) && isText(c)) && Array.from({ length: width - 1 }, (_, i) => i + 1).every((c) => isText(cell(0, c)));
+  const blankCorner = headerRow && blank(cell(0, 0));
+  const labelColumn = width > 1 && (blankCorner || Array.from({ length: height - (headerRow ? 1 : 0) }, (_, i) => i + (headerRow ? 1 : 0)).every((r) => isText(cell(r, 0))));
+  const byRows = width > height + 1;
+  const dataRows = height - (headerRow ? 1 : 0);
+  const dataCols = width - (labelColumn ? 1 : 0);
+  let anyNumber = false;
+  let nonNegative = true;
+  let anyNegative = false;
+  let anyPositive = false;
+  for (let r = headerRow ? 1 : 0; r < height; r++)
+    for (let c = labelColumn ? 1 : 0; c < width; c++) {
+      const v = parseChartValue(cell(r, c));
+      if (typeof v !== "number") continue;
+      anyNumber = true;
+      if (v < 0) {
+        nonNegative = false;
+        anyNegative = true;
+      } else if (v > 0) anyPositive = true;
     }
-    return parsed;
-  });
-  if (length === void 0) return out;
-  if (out.length > length) return out.slice(0, length);
-  while (out.length < length) out.push(null);
-  return out;
-}
-function normalizeSeries(value, length, used, index, issues) {
-  const path = `series[${index}]`;
-  if (!isRecord(value)) {
-    issues.push({ path, message: `${path} must be an object with a name and values.` });
-    return null;
-  }
-  let id = typeof value.id === "string" && value.id.trim() ? value.id.trim() : "";
-  if (!id || used.has(id)) {
-    if (id) issues.push({ path: `${path}.id`, message: `Series id "${id}" is used twice; the second was renamed.` });
-    for (let n = index + 1; ; n++) {
-      id = `series-${n}`;
-      if (!used.has(id)) break;
-    }
-  }
-  used.add(id);
-  const series = {
-    id,
-    name: text(value.name, `Series ${index + 1}`, `${path}.name`, issues),
-    values: normalizeChartValues(value.values, length, `${path}.values`, issues)
-  };
-  if (typeof value.color === "string" && value.color.trim()) series.color = value.color.trim();
-  if (value.type !== void 0 && value.type !== null) series.type = pick(value.type, CHART_SERIES_TYPES, "bar", `${path}.type`, issues);
-  if (value.hidden === true) series.hidden = true;
-  return series;
-}
-function normalizeChartSpec(input) {
-  const issues = [];
-  const value = isRecord(input) ? input : {};
-  if (input !== void 0 && !isRecord(input)) issues.push({ path: "", message: "A chart must be an object." });
-  const type = pick(value.type, CHART_TYPES, "bar", "type", issues);
-  const rawSeries = Array.isArray(value.series) ? value.series : [];
-  if (value.series !== void 0 && !Array.isArray(value.series)) issues.push({ path: "series", message: "series must be an array." });
-  let categories;
-  if (Array.isArray(value.categories)) categories = value.categories.map((c, i) => text(c, "", `categories[${i}]`, issues));
-  else {
-    if (value.categories !== void 0) issues.push({ path: "categories", message: "categories must be an array of labels." });
-    const longest = rawSeries.reduce((n, s) => Math.max(n, isRecord(s) && Array.isArray(s.values) ? s.values.length : 0), 0);
-    categories = Array.from({ length: longest }, (_, i) => `${i + 1}`);
-  }
-  const used = /* @__PURE__ */ new Set();
-  const series = rawSeries.map((s, i) => normalizeSeries(s, categories.length, used, i, issues)).filter((s) => s !== null);
-  let palette = [...DEFAULT_CHART_PALETTE];
-  if (Array.isArray(value.palette)) {
-    const colors = value.palette.filter((c) => typeof c === "string" && c.trim() !== "");
-    if (colors.length) palette = colors;
-    else issues.push({ path: "palette", message: "palette must list at least one colour." });
-  } else if (value.palette !== void 0) issues.push({ path: "palette", message: "palette must be an array of colours." });
-  let innerRadius = 0.55;
-  if (value.innerRadius !== void 0) {
-    const r = Number(value.innerRadius);
-    if (Number.isFinite(r) && r >= 0 && r <= 0.9) innerRadius = r;
-    else issues.push({ path: "innerRadius", message: "innerRadius must be a number from 0 to 0.9." });
-  }
-  const spec = {
-    version: 1,
-    type,
-    title: text(value.title, "", "title", issues),
-    subtitle: text(value.subtitle, "", "subtitle", issues),
-    categories,
-    series,
-    xAxis: normalizeChartAxis(value.xAxis, defaultChartAxis(false), "xAxis", issues),
-    yAxis: normalizeChartAxis(value.yAxis, defaultChartAxis(true), "yAxis", issues),
-    legend: normalizeLegend(value.legend, issues),
-    stacking: pick(value.stacking, CHART_STACKINGS, "none", "stacking", issues),
-    orientation: pick(value.orientation, CHART_ORIENTATIONS, "vertical", "orientation", issues),
-    curve: pick(value.curve, CHART_CURVES, "linear", "curve", issues),
-    points: flag(value.points, true, "points", issues),
-    dataLabels: flag(value.dataLabels, false, "dataLabels", issues),
-    palette,
-    innerRadius
-  };
-  return { spec, issues };
-}
-function cloneChartSpec(spec) {
+  const labels = byRows ? grid[0]?.slice(labelColumn ? 1 : 0) ?? [] : grid.slice(headerRow ? 1 : 0).map((r) => r[0]);
+  const dates = (byRows ? headerRow : labelColumn) && labels.length > 1 && labels.filter((l) => !blank(l) && parseChartDate(String(l)) !== null).length >= labels.length * 0.8;
   return {
-    ...spec,
-    categories: [...spec.categories],
-    series: spec.series.map(cloneChartSeries),
-    xAxis: { ...spec.xAxis, format: { ...spec.xAxis.format } },
-    yAxis: { ...spec.yAxis, format: { ...spec.yAxis.format } },
-    legend: { ...spec.legend },
-    palette: [...spec.palette]
+    headerRow,
+    labelColumn,
+    byRows,
+    series: Math.max(0, byRows ? dataRows : dataCols),
+    points: Math.max(0, byRows ? dataCols : dataRows),
+    anyNumber,
+    nonNegative,
+    mixedSigns: anyNegative && anyPositive,
+    dates
   };
 }
-function cloneChartSeries(series) {
-  return { ...series, values: [...series.values] };
-}
-function chartDataFromTable(rows, options = {}) {
-  const header = options.header ?? true;
-  let grid = rows.map((r) => [...r]).filter((r) => r.some((c) => c !== null && c !== void 0 && String(c).trim() !== ""));
-  if (options.seriesIn === "rows") {
-    const width2 = Math.max(0, ...grid.map((r) => r.length));
-    grid = Array.from({ length: width2 }, (_, c) => grid.map((r) => r[c]));
-  }
-  const issues = [];
-  if (!grid.length) return { categories: [], series: [], issues };
-  const width = Math.max(...grid.map((r) => r.length));
-  const names = header ? grid[0] : [];
-  const body = header ? grid.slice(1) : grid;
-  const categories = body.map((r, i) => {
-    const c = r[0];
-    return c === null || c === void 0 || String(c).trim() === "" ? `${i + 1}` : String(c).trim();
-  });
-  const series = [];
-  for (let col = 1; col < width; col++) {
-    const name = names[col] !== void 0 && String(names[col]).trim() ? String(names[col]).trim() : `Series ${col}`;
-    const values = body.map((r, i) => {
-      const parsed = parseChartValue(r[col] ?? null);
-      if (parsed === void 0) {
-        issues.push({ path: `${name}[${i}]`, message: `"${String(r[col])}" in ${name} (${categories[i]}) is not a number; it was left blank.` });
-        return null;
-      }
-      return parsed;
-    });
-    series.push({ id: `series-${col}`, name, values });
-  }
-  return { categories, series, issues };
-}
-function chartDataToTable(spec, options = {}) {
-  return [
-    [options.categoryHeader ?? "", ...spec.series.map((s) => s.name)],
-    ...spec.categories.map((category, i) => [category, ...spec.series.map((s) => s.values[i] ?? null)])
-  ];
-}
-function chartColorInputValue(color) {
-  if (/^#[0-9a-f]{6}$/i.test(color)) return color.toLowerCase();
-  if (/^#[0-9a-f]{3}$/i.test(color)) return `#${[...color.slice(1)].map((c) => c + c).join("")}`.toLowerCase();
-  return "#000000";
-}
-
-// src/chart/scale.ts
-function niceStep(span, count) {
-  if (!(span > 0) || !(count > 0)) return 1;
-  const raw = span / count;
-  const power = Math.pow(10, Math.floor(Math.log10(raw)));
-  const fraction = raw / power;
-  const nice = fraction <= 1 ? 1 : fraction <= 2 ? 2 : fraction <= 2.5 ? 2.5 : fraction <= 5 ? 5 : 10;
-  return nice * power;
-}
-var clean = (n) => Math.abs(n) < 1e-12 ? 0 : Number(n.toPrecision(12));
-function niceScale(min, max, count = 5, fixedMin = null, fixedMax = null) {
-  if (fixedMin !== null && !Number.isFinite(fixedMin)) fixedMin = null;
-  if (fixedMax !== null && !Number.isFinite(fixedMax)) fixedMax = null;
-  let lo = fixedMin ?? min;
-  let hi = fixedMax ?? max;
-  if (!Number.isFinite(lo) || !Number.isFinite(hi)) {
-    fixedMin = fixedMax = null;
-    lo = 0;
-    hi = 1;
-  }
-  if (lo > hi) [lo, hi] = [hi, lo];
-  if (lo === hi) {
-    const pad = lo === 0 ? 1 : Math.abs(lo) * 0.1;
-    if (fixedMin === null && lo !== 0) lo -= pad;
-    if (fixedMax === null || lo === hi) hi += pad;
-  }
-  const span = hi - lo;
-  const step = Number.isFinite(span) ? niceStep(span, count) : niceStep(hi / 2 - lo / 2, count) * 2;
-  const finiteOr = (n2, fallback) => Number.isFinite(n2) ? n2 : fallback;
-  const niceMin = fixedMin ?? finiteOr(snap(Math.floor(lo / step + 1e-9) * step, step), lo);
-  const niceMax = fixedMax ?? finiteOr(snap(Math.ceil(hi / step - 1e-9) * step, step), hi);
-  const firstIndex = Math.ceil(niceMin / step - 1e-9);
-  const lastIndex = Math.floor(niceMax / step + 1e-9);
-  const n = Math.min(999, Math.max(-1, lastIndex - firstIndex));
-  const ticks = [];
-  for (let i = 0; i <= n; i++) {
-    const t = snap((firstIndex + i) * step, step);
-    if (Number.isFinite(t) && t !== ticks[ticks.length - 1]) ticks.push(t);
-  }
-  return { min: niceMin, max: niceMax, step, ticks };
-}
-function snap(n, step) {
-  const c = clean(n);
-  return Math.abs(c - n) <= step * 1e-6 ? c : n;
-}
-function stepDecimals(step) {
-  if (!(step > 0) || !Number.isFinite(step)) return 0;
-  for (let d = 0; d < 6; d++) {
-    const scaled = step * Math.pow(10, d);
-    if (Math.abs(scaled - Math.round(scaled)) < 1e-9) return d;
-  }
-  return 6;
+function recommendChartTypes(rows) {
+  const shape = analyzeChartTable(rows);
+  if (!shape.anyNumber || !shape.series) return [];
+  return recommendForShape(shape);
 }
-function magnitudeDecimals(value) {
-  if (!(value > 0) || value >= 1) return 0;
-  return Math.min(6, Math.max(0, Math.ceil(-Math.log10(value) - 1e-9)));
-}
-var COMPACT = [
-  { value: 1e12, suffix: "T" },
-  { value: 1e9, suffix: "B" },
-  { value: 1e6, suffix: "M" },
-  { value: 1e3, suffix: "K" }
-];
-function grouped(value, decimals) {
-  const fixed = Math.abs(value).toFixed(decimals);
-  const [int, frac] = fixed.split(".");
-  const withCommas = int.replace(/\B(?=(\d{3})+(?!\d))/g, ",");
-  return `${value < 0 && Number(fixed) !== 0 ? "-" : ""}${withCommas}${frac ? `.${frac}` : ""}`;
-}
-var CURRENCY_SYMBOLS = { USD: "$", EUR: "\u20AC", GBP: "\xA3", JPY: "\xA5", CNY: "\xA5", INR: "\u20B9", AUD: "A$", CAD: "C$" };
-function formatChartNumber(value, format = {}, fallbackDecimals) {
-  if (value === null || value === void 0 || !Number.isFinite(value)) return "";
-  const style = format.style ?? "number";
-  let body;
-  const decimalsFor = (v) => {
-    if (format.decimals !== void 0) return format.decimals;
-    if (fallbackDecimals !== void 0) return fallbackDecimals;
-    return Number.isInteger(v) ? 0 : Math.abs(v) < 1 ? Math.min(4, Math.max(2, magnitudeDecimals(Math.abs(v)) + 1)) : 2;
-  };
-  const trim = (s) => format.decimals === void 0 && fallbackDecimals === void 0 && s.includes(".") ? s.replace(/\.?0+$/, "") : s;
-  if (style === "percent") {
-    const v = value * 100;
-    const d = format.decimals ?? (fallbackDecimals !== void 0 ? Math.max(0, fallbackDecimals - 2) : Number.isInteger(clean(v)) ? 0 : 1);
-    body = `${grouped(clean(v), d)}%`;
-  } else if (style === "compact") {
-    const unit = COMPACT.find((u) => Math.abs(value) >= u.value);
-    if (unit) {
-      const v = value / unit.value;
-      const d = format.decimals ?? (Math.abs(v) >= 100 || Number.isInteger(clean(v)) ? 0 : 1);
-      body = `${trim(grouped(v, d))}${unit.suffix}`;
-    } else body = trim(grouped(value, decimalsFor(value)));
-  } else if (style === "currency") {
-    const code = (format.currency || "USD").toUpperCase();
-    const symbol = CURRENCY_SYMBOLS[code] ?? `${code} `;
-    const d = format.decimals ?? (fallbackDecimals !== void 0 ? fallbackDecimals : Number.isInteger(value) ? 0 : 2);
-    const s = grouped(Math.abs(value), d);
-    body = `${value < 0 ? "-" : ""}${symbol}${s}`;
-  } else body = trim(grouped(value, decimalsFor(value)));
-  return `${format.prefix ?? ""}${body}${format.suffix ?? ""}`;
-}
-function linearMap(value, domain, range) {
-  const [d0, d1] = domain;
-  const [r0, r1] = range;
-  if (d1 === d0) return (r0 + r1) / 2;
-  return r0 + (value - d0) / (d1 - d0) * (r1 - r0);
-}
-
-// src/chart/layout.ts
-var estimateChartTextWidth = (text2, size, weight = 400) => text2.length * size * (weight >= 600 ? 0.6 : 0.56);
-function sameChartSelection(a, b) {
-  if (!a || !b || a.kind !== b.kind) return false;
-  switch (a.kind) {
-    case "axis":
-      return a.axis === b.axis;
-    case "series":
-      return a.seriesId === b.seriesId;
-    case "point":
-      return a.seriesId === b.seriesId && a.index === b.index;
-    case "category":
-      return a.index === b.index;
-    default:
-      return true;
-  }
-}
-function contrastingTextColor(fill) {
-  let rgb = null;
-  const hex = /^#([0-9a-f]{3}|[0-9a-f]{6})$/i.exec(fill.trim());
-  if (hex) {
-    const h = hex[1].length === 3 ? [...hex[1]].map((c) => c + c).join("") : hex[1];
-    rgb = [0, 2, 4].map((i) => parseInt(h.slice(i, i + 2), 16));
-  } else {
-    const fn = /^rgba?\(\s*([\d.]+)[\s,]+([\d.]+)[\s,]+([\d.]+)/i.exec(fill.trim());
-    if (fn) rgb = fn.slice(1, 4).map(Number);
-  }
-  if (!rgb) return "#ffffff";
-  const luminance = (0.299 * rgb[0] + 0.587 * rgb[1] + 0.114 * rgb[2]) / 255;
-  return luminance > 0.5 ? "#0f172a" : "#ffffff";
-}
-var r2 = (n) => Math.round(n * 100) / 100;
-function curvePath(points, curve, map, moveFirst = true) {
-  if (!points.length) return "";
-  const xy = points.map(map);
-  let d = `${moveFirst ? "M" : "L"}${r2(xy[0][0])},${r2(xy[0][1])}`;
-  if (points.length === 1) return d;
-  if (curve === "step") {
-    for (let i = 1; i < points.length; i++) {
-      const mid = (points[i - 1].c + points[i].c) / 2;
-      const a = map({ c: mid, v: points[i - 1].v });
-      const b = map({ c: mid, v: points[i].v });
-      d += `L${r2(a[0])},${r2(a[1])}L${r2(b[0])},${r2(b[1])}L${r2(xy[i][0])},${r2(xy[i][1])}`;
-    }
-    return d;
-  }
-  if (curve === "smooth" && points.length > 2) {
-    const n = points.length;
-    const dc = points.slice(1).map((p, i) => p.c - points[i].c);
-    const slope = points.slice(1).map((p, i) => dc[i] === 0 ? 0 : (p.v - points[i].v) / dc[i]);
-    const tangent = points.map((_, i) => {
-      if (i === 0) return slope[0];
-      if (i === n - 1) return slope[n - 2];
-      const a = slope[i - 1];
-      const b = slope[i];
-      if (a * b <= 0) return 0;
-      const wa = 2 * dc[i] + dc[i - 1];
-      const wb = dc[i] + 2 * dc[i - 1];
-      return (wa + wb) / (wa / a + wb / b);
-    });
-    for (let i = 1; i < n; i++) {
-      const h = dc[i - 1] / 3;
-      const p0 = points[i - 1];
-      const p1 = points[i];
-      const a = map({ c: p0.c + h, v: p0.v + tangent[i - 1] * h });
-      const b = map({ c: p1.c - h, v: p1.v - tangent[i] * h });
-      d += `C${r2(a[0])},${r2(a[1])} ${r2(b[0])},${r2(b[1])} ${r2(xy[i][0])},${r2(xy[i][1])}`;
-    }
-    return d;
-  }
-  for (let i = 1; i < xy.length; i++) d += `L${r2(xy[i][0])},${r2(xy[i][1])}`;
-  return d;
-}
-function arcPath(cx, cy, outer, inner, start, end) {
-  const full = end - start >= Math.PI * 2 - 1e-9;
-  if (full) end = start + Math.PI * 2 - 1e-4;
-  const p = (r, a) => `${r2(cx + r * Math.sin(a))},${r2(cy - r * Math.cos(a))}`;
-  const large = end - start > Math.PI ? 1 : 0;
-  let d = `M${p(outer, start)}A${r2(outer)},${r2(outer)} 0 ${large} 1 ${p(outer, end)}`;
-  if (inner > 0) d += `L${p(inner, end)}A${r2(inner)},${r2(inner)} 0 ${large} 0 ${p(inner, start)}Z`;
-  else d += `L${r2(cx)},${r2(cy)}Z`;
-  return d;
-}
-function layoutChart(spec, options) {
-  const width = Math.max(1, options.width);
-  const height = Math.max(1, options.height);
-  const theme = { ...DEFAULT_CHART_THEME, ...options.theme };
-  const measure = options.measureText ?? estimateChartTextWidth;
-  const selection = options.selection ?? null;
-  const fs = theme.fontSize;
-  const marks = [];
-  const isSelected = (target) => sameChartSelection(selection, target);
-  const seriesSelected = (id) => selection?.kind === "series" && selection.seriesId === id;
-  const pad = 12;
-  marks.push({ kind: "rect", key: "background", role: "background", x: 0, y: 0, width, height, fill: theme.background, target: { kind: "chart" } });
-  let top = pad;
-  const outline = (key, box) => marks.push({ kind: "rect", key, role: "selection", ...box, fill: "none", stroke: theme.selection, strokeWidth: 1, radius: 3 });
-  const titleMark = (kind, label, size, weight, fill) => {
-    const target = { kind };
-    const selected = isSelected(target);
-    marks.push({ kind: "text", key: kind, role: kind, x: width / 2, y: top, text: label, anchor: "middle", baseline: "top", size, weight, fill, target, selected });
-    if (selected) {
-      const w = measure(label, size, weight);
-      outline(`${kind}-selection`, { x: width / 2 - w / 2 - 4, y: top - 3, width: w + 8, height: size * 1.25 + 6 });
-    }
-    top += size * 1.35;
-  };
-  if (spec.title) titleMark("title", spec.title, theme.titleSize, 600, theme.text);
-  if (spec.subtitle) titleMark("subtitle", spec.subtitle, fs + 1, 400, theme.mutedText);
-  if (spec.title || spec.subtitle) top += 6;
-  const cartesian = isCartesianChart(spec.type);
-  const visible = spec.series.filter((s) => !s.hidden);
-  const legendItems = cartesian ? spec.series.map((s, i) => ({
-    label: s.name,
-    color: chartSeriesColor(spec, i),
-    target: { kind: "series", seriesId: s.id },
-    faded: !!s.hidden,
-    selected: seriesSelected(s.id),
-    shape: chartSeriesType(spec, s) === "line" ? "line" : "square"
-  })) : spec.categories.map((c, i) => ({
-    label: c,
-    color: chartSliceColor(spec, i),
-    target: { kind: "category", index: i },
-    faded: false,
-    selected: isSelected({ kind: "category", index: i }),
-    shape: "square"
-  }));
-  let area = { x: pad, y: top, width: width - pad * 2, height: height - top - pad };
-  const showLegend = spec.legend.show && legendItems.length > 0 && (!cartesian || spec.series.length > 1 || spec.series.some((s) => s.hidden));
-  if (showLegend) area = layoutLegend(legendItems, spec.legend.position, area, theme, measure, marks, isSelected({ kind: "legend" }));
-  const empty = (message) => {
-    marks.push({ kind: "text", key: "empty", role: "empty", x: area.x + area.width / 2, y: area.y + area.height / 2, text: message, anchor: "middle", baseline: "middle", size: fs + 1, fill: theme.mutedText });
-    return { width, height, plot: { x: area.x, y: area.y, width: 0, height: 0 }, marks, percent: false, theme };
-  };
-  const hasData = visible.some((s) => s.values.some((v) => v !== null));
-  if (!spec.categories.length || !visible.length || !hasData) return empty(options.emptyMessage ?? "No data");
-  if (!cartesian) return layoutPie(spec, visible[0], area, theme, marks, selection, width, height);
-  const horizontal = spec.orientation === "horizontal";
-  const n = spec.categories.length;
-  const types = new Map(visible.map((s) => [s.id, chartSeriesType(spec, s)]));
-  const stacked = spec.stacking !== "none";
-  const percent = spec.stacking === "percent";
-  const stacks = /* @__PURE__ */ new Map();
-  if (stacked) {
-    for (const kind of ["bar", "area"]) {
-      const group = visible.filter((s) => types.get(s.id) === kind);
-      if (!group.length) continue;
-      const totals = Array.from({ length: n }, (_, i) => group.reduce((t, s) => t + Math.abs(s.values[i] ?? 0), 0));
-      const pos = Array(n).fill(0);
-      const neg = Array(n).fill(0);
-      for (const s of group) {
-        const segments = s.values.map((raw, i) => {
-          if (raw === null && kind === "bar") return null;
-          let v = raw ?? 0;
-          if (percent) v = totals[i] ? v / totals[i] : 0;
-          const base = v >= 0 ? pos[i] : neg[i];
-          const seg = [base, base + v];
-          if (v >= 0) pos[i] += v;
-          else neg[i] += v;
-          return seg;
-        });
-        stacks.set(s.id, { segments });
-      }
-    }
-  }
-  let lo = Infinity;
-  let hi = -Infinity;
-  const see = (v) => {
-    lo = Math.min(lo, v);
-    hi = Math.max(hi, v);
-  };
-  for (const s of visible) {
-    const stack = stacks.get(s.id);
-    if (stack) stack.segments.forEach((seg) => seg && (see(seg[0]), see(seg[1])));
-    else s.values.forEach((v) => v !== null && see(v));
-  }
-  if (!Number.isFinite(lo)) {
-    lo = 0;
-    hi = 1;
-  }
-  if ([...types.values()].some((t) => t === "bar" || t === "area")) {
-    lo = Math.min(lo, 0);
-    hi = Math.max(hi, 0);
-  }
-  const valueFormat = percent && !spec.yAxis.format.style ? { ...spec.yAxis.format, style: "percent" } : spec.yAxis.format;
-  const xAxis = spec.xAxis;
-  const yAxis = spec.yAxis;
-  const titleBand = fs * 1.3 + 6;
-  const frozen = options.valueDomain;
-  const fixedMin = frozen && Number.isFinite(frozen.min) ? frozen.min : yAxis.min;
-  const fixedMax = frozen && Number.isFinite(frozen.max) ? frozen.max : yAxis.max;
-  const valueLen0 = horizontal ? area.width : area.height;
-  let scale = niceScale(lo, hi, Math.max(2, Math.min(10, Math.round(valueLen0 / 56))), fixedMin, fixedMax);
-  const tickText = (t) => formatChartNumber(t, valueFormat, valueFormat.decimals ?? stepDecimals(scale.step));
-  const valueLabelWidth = Math.max(0, ...scale.ticks.map((t) => measure(tickText(t), fs)));
-  const catLabelWidth = Math.max(0, ...spec.categories.map((c) => measure(c, fs)));
-  let left;
-  let bottom;
-  let rotate = 0;
-  if (horizontal) {
-    left = (xAxis.show ? Math.min(catLabelWidth, area.width * 0.35) + 8 : 2) + (xAxis.title ? titleBand : 0);
-    bottom = (yAxis.show ? fs * 1.6 : 2) + (yAxis.title ? titleBand : 0);
-  } else {
-    left = (yAxis.show ? valueLabelWidth + 8 : 2) + (yAxis.title ? titleBand : 0);
-    const band2 = (area.width - left - 8) / n;
-    if (xAxis.show && catLabelWidth > band2 * 0.92) rotate = -40;
-    const catHeight = rotate ? Math.min(catLabelWidth * Math.sin(Math.PI / 4.5) + fs, area.height * 0.4) : fs * 1.6;
-    bottom = (xAxis.show ? catHeight : 2) + (xAxis.title ? titleBand : 0);
-  }
-  const rightPad = horizontal ? Math.max(8, valueLabelWidth / 2) : 8;
-  const plot = {
-    x: area.x + left,
-    y: area.y + (horizontal ? 4 : fs / 2 + 2),
-    width: Math.max(1, area.width - left - rightPad),
-    height: Math.max(1, area.height - bottom - (horizontal ? 4 : fs / 2 + 2))
-  };
-  scale = niceScale(lo, hi, Math.max(2, Math.min(10, Math.round((horizontal ? plot.width : plot.height) / 56))), fixedMin, fixedMax);
-  const domain = [scale.min, scale.max];
-  const valueRange = horizontal ? [plot.x, plot.x + plot.width] : [plot.y + plot.height, plot.y];
-  const valuePx = (v) => linearMap(Math.min(scale.max, Math.max(scale.min, v)), domain, valueRange);
-  const catStart = horizontal ? plot.y : plot.x;
-  const catLen = horizontal ? plot.height : plot.width;
-  const band = catLen / n;
-  const catCenter = (i) => catStart + band * (i + 0.5);
-  const map = (p) => horizontal ? [p.v, p.c] : [p.c, p.v];
-  const zero = valuePx(Math.min(scale.max, Math.max(scale.min, 0)));
-  const axisSelected = (axis) => isSelected({ kind: "axis", axis });
-  if (yAxis.gridlines) {
-    scale.ticks.forEach((t, i) => {
-      const p = valuePx(t);
-      const [x1, y1] = map({ c: catStart, v: p });
-      const [x2, y2] = map({ c: catStart + catLen, v: p });
-      marks.push({ kind: "line", key: `grid-y-${i}`, role: "grid", x1, y1, x2, y2, stroke: theme.grid, strokeWidth: 1 });
-    });
-  }
-  if (xAxis.gridlines) {
-    for (let i = 1; i < n; i++) {
-      const c = catStart + band * i;
-      const [x1, y1] = map({ c, v: valueRange[0] });
-      const [x2, y2] = map({ c, v: valueRange[1] });
-      marks.push({ kind: "line", key: `grid-x-${i}`, role: "grid", x1, y1, x2, y2, stroke: theme.grid, strokeWidth: 1 });
-    }
-  }
-  const yTarget = { kind: "axis", axis: "y" };
-  const xTarget = { kind: "axis", axis: "x" };
-  if (yAxis.show) {
-    scale.ticks.forEach((t, i) => {
-      const p = valuePx(t);
-      const label = tickText(t);
-      if (horizontal)
-        marks.push({ kind: "text", key: `tick-y-${i}`, role: "tick-label", x: p, y: plot.y + plot.height + 6, text: label, anchor: "middle", baseline: "top", size: fs, fill: theme.mutedText, target: yTarget });
-      else marks.push({ kind: "text", key: `tick-y-${i}`, role: "tick-label", x: plot.x - 8, y: p, text: label, anchor: "end", baseline: "middle", size: fs, fill: theme.mutedText, target: yTarget });
-    });
-  }
-  if (xAxis.show) {
-    const [x1, y1] = map({ c: catStart, v: zero });
-    const [x2, y2] = map({ c: catStart + catLen, v: zero });
-    marks.push({ kind: "line", key: "axis-x", role: "axis", x1, y1, x2, y2, stroke: theme.axis, strokeWidth: 1, target: xTarget });
-    const every = horizontal ? Math.max(1, Math.ceil(fs * 1.3 / band)) : rotate ? Math.max(1, Math.ceil(fs * 1.4 / band)) : 1;
-    spec.categories.forEach((c, i) => {
-      if (i % every) return;
-      const target = { kind: "category", index: i };
-      const selected = isSelected(target);
-      const fill = selected ? theme.selection : theme.mutedText;
-      if (horizontal) {
-        const maxW = left - (xAxis.title ? titleBand : 0) - 8;
-        marks.push({ kind: "text", key: `tick-x-${i}`, role: "tick-label", x: plot.x - 8, y: catCenter(i), text: truncate(c, maxW, fs, measure), anchor: "end", baseline: "middle", size: fs, fill, target, selected });
-      } else if (rotate)
-        marks.push({ kind: "text", key: `tick-x-${i}`, role: "tick-label", x: catCenter(i), y: plot.y + plot.height + 8, text: c, anchor: "end", baseline: "middle", size: fs, fill, rotate, target, selected });
-      else marks.push({ kind: "text", key: `tick-x-${i}`, role: "tick-label", x: catCenter(i), y: plot.y + plot.height + 6, text: c, anchor: "middle", baseline: "top", size: fs, fill, target, selected });
-    });
-  }
-  const bottomTitle = horizontal ? yAxis.title : xAxis.title;
-  const leftTitle = horizontal ? xAxis.title : yAxis.title;
-  if (bottomTitle)
-    marks.push({ kind: "text", key: `axis-title-${horizontal ? "y" : "x"}`, role: "axis-title", x: plot.x + plot.width / 2, y: area.y + area.height, text: bottomTitle, anchor: "middle", baseline: "bottom", size: fs + 1, weight: 500, fill: theme.text, target: horizontal ? yTarget : xTarget });
-  if (leftTitle)
-    marks.push({ kind: "text", key: `axis-title-${horizontal ? "x" : "y"}`, role: "axis-title", x: area.x, y: plot.y + plot.height / 2, text: leftTitle, anchor: "middle", baseline: "top", size: fs + 1, weight: 500, fill: theme.text, rotate: -90, target: horizontal ? xTarget : yTarget });
-  for (const axis of ["x", "y"]) {
-    if (!axisSelected(axis)) continue;
-    const onLeft = axis === "y" !== horizontal;
-    const box = onLeft ? { x: area.x, y: plot.y - fs / 2, width: left - 2, height: plot.height + fs } : { x: plot.x - 4, y: plot.y + plot.height + 2, width: plot.width + 8, height: area.y + area.height - plot.y - plot.height - 2 };
-    outline(`axis-${axis}-selection`, box);
-  }
-  const bars = visible.filter((s) => types.get(s.id) === "bar");
-  const slots = stacked ? 1 : bars.length;
-  const groupWidth = band * (bars.length ? 0.72 : 0);
-  const barWidth = slots ? groupWidth / slots : 0;
-  const labelMarks = [];
-  const decimals = valueFormat.decimals ?? void 0;
-  const dataLabel = (v) => formatChartNumber(v, valueFormat, decimals);
-  const drawOrder = [...visible].sort((a, b) => order(types.get(a.id)) - order(types.get(b.id)));
-  for (const s of drawOrder) {
-    const si = spec.series.indexOf(s);
-    const color = chartSeriesColor(spec, si);
-    const type = types.get(s.id);
-    const stack = stacks.get(s.id);
-    const selSeries = seriesSelected(s.id);
-    const seriesTarget = { kind: "series", seriesId: s.id };
-    if (type === "bar") {
-      const slot = stacked ? 0 : bars.indexOf(s);
-      s.values.forEach((raw, i) => {
-        const seg = stack ? stack.segments[i] : raw === null ? null : [0, raw];
-        if (!seg || raw === null) return;
-        const a = valuePx(seg[0]);
-        const b = valuePx(seg[1]);
-        const c0 = catCenter(i) - groupWidth / 2 + slot * barWidth + barWidth * 0.06;
-        const cw = barWidth * 0.88;
-        const target = { kind: "point", seriesId: s.id, index: i };
-        const selected = isSelected(target);
-        const [x, y] = map({ c: c0, v: Math.min(a, b) });
-        const rect = horizontal ? { x: Math.min(a, b), y: c0, width: Math.abs(b - a), height: cw } : { x, y, width: cw, height: Math.abs(b - a) };
-        marks.push({
-          kind: "rect",
-          key: `bar-${s.id}-${i}`,
-          role: "bar",
-          ...rect,
-          fill: color,
-          radius: Math.min(2, cw / 4),
-          target,
-          selected: selected || selSeries,
-          ...selSeries ? { stroke: theme.selection, strokeWidth: 1.5 } : {}
-        });
-        if (selected) outline(`bar-${s.id}-${i}-selection`, { x: rect.x - 2, y: rect.y - 2, width: rect.width + 4, height: rect.height + 4 });
-        if (spec.dataLabels) {
-          const v = percent ? seg[1] - seg[0] : raw;
-          const text2 = dataLabel(v);
-          if (stacked && Math.abs(b - a) < (horizontal ? measure(text2, fs - 1) + 4 : fs + 1)) return;
-          const end = valuePx(seg[1]);
-          const outward = (seg[1] >= seg[0] ? 1 : -1) * (horizontal ? 1 : -1);
-          const [lx, ly] = map({ c: c0 + cw / 2, v: stacked ? (a + b) / 2 : end + outward * 4 });
-          labelMarks.push({
-            kind: "text",
-            key: `label-${s.id}-${i}`,
-            role: "data-label",
-            x: lx,
-            y: ly,
-            text: text2,
-            anchor: horizontal && !stacked ? outward > 0 ? "start" : "end" : "middle",
-            baseline: horizontal || stacked ? "middle" : outward < 0 ? "bottom" : "top",
-            size: fs - 1,
-            fill: stacked ? contrastingTextColor(color) : theme.text,
-            target
-          });
-        }
-      });
-      continue;
-    }
-    const pointValue = (i) => stack ? stack.segments[i]?.[1] ?? null : s.values[i];
-    const runs = [];
-    let run = [];
-    for (let i = 0; i < n; i++) {
-      const v = pointValue(i);
-      if (v === null) {
-        if (run.length) runs.push(run);
-        run = [];
-        continue;
-      }
-      run.push({ c: catCenter(i), v: valuePx(v) });
-    }
-    if (run.length) runs.push(run);
-    if (type === "area") {
-      const parts = runs.map((r) => {
-        const baseline = stack ? r.map((p) => ({ c: p.c, v: valuePx(stack.segments[Math.round((p.c - catStart) / band - 0.5)]?.[0] ?? 0) })).reverse() : [
-          { c: r[r.length - 1].c, v: zero },
-          { c: r[0].c, v: zero }
-        ];
-        return `${curvePath(r, spec.curve, map)}${stack ? curvePath(baseline, spec.curve, map, false) : baseline.map((p) => `L${map(p).map(r2).join(",")}`).join("")}Z`;
-      });
-      marks.push({ kind: "path", key: `area-${s.id}`, role: "area", d: parts.join(""), fill: color, opacity: 0.22, target: seriesTarget, selected: selSeries });
-    }
-    if (type === "line" || type === "area") {
-      marks.push({
-        kind: "path",
-        key: `line-${s.id}`,
-        role: "line",
-        d: runs.map((r) => curvePath(r, spec.curve, map)).join(""),
-        fill: "none",
-        stroke: color,
-        strokeWidth: selSeries ? 3.5 : 2,
-        target: seriesTarget,
-        selected: selSeries
-      });
-    }
-    const showDots = type === "scatter" || spec.points;
-    for (let i = 0; i < n; i++) {
-      const v = pointValue(i);
-      if (v === null || s.values[i] === null) continue;
-      const [cx, cy] = map({ c: catCenter(i), v: valuePx(v) });
-      const target = { kind: "point", seriesId: s.id, index: i };
-      const selected = isSelected(target);
-      const r = type === "scatter" ? 4.5 : 3.5;
-      marks.push({
-        kind: "circle",
-        key: `point-${s.id}-${i}`,
-        role: "point",
-        cx,
-        cy,
-        r: showDots ? r : 6,
-        fill: showDots ? type === "scatter" ? color : theme.surface : "transparent",
-        ...showDots ? { stroke: color, strokeWidth: 2 } : {},
-        opacity: type === "scatter" ? 0.85 : void 0,
-        target,
-        selected: selected || selSeries
-      });
-      if (selected) marks.push({ kind: "circle", key: `point-${s.id}-${i}-selection`, role: "selection", cx, cy, r: r + 3.5, fill: "none", stroke: theme.selection, strokeWidth: 1.5 });
-      if (spec.dataLabels) {
-        const raw = s.values[i];
-        const shown = percent && stack ? stack.segments[i][1] - stack.segments[i][0] : raw;
-        labelMarks.push({
-          kind: "text",
-          key: `label-${s.id}-${i}`,
-          role: "data-label",
-          x: horizontal ? cx + 8 : cx,
-          y: horizontal ? cy : cy - 8,
-          text: dataLabel(shown),
-          anchor: horizontal ? "start" : "middle",
-          baseline: horizontal ? "middle" : "bottom",
-          size: fs - 1,
-          fill: theme.text,
-          target
-        });
+function recommendForShape(shape) {
+  const out = [];
+  const add = (type, label, reason, stacking) => out.push({ type, label, reason, ...stacking ? { stacking } : {} });
+  if (shape.series === 2 && !shape.labelColumn && !shape.byRows) {
+    add("scatter", "Scatter", "Two numeric columns without labels: the first is x, the second y.");
+    add("line", "Line", "Shows the second column in order.");
+    add("bar", "Column", "Compares the values side by side.");
+    return out;
+  }
+  if (shape.series === 1 && !shape.labelColumn && shape.points > 20) {
+    add("histogram", "Histogram", "Many unlabelled values: shows how they are distributed.");
+    add("box", "Box plot", "Summarises the spread: quartiles, median and outliers.");
+    add("line", "Line", "Shows the values in order.");
+    return out;
+  }
+  if (shape.dates) {
+    add("line", "Line", "The categories are dates: a line shows change over time.");
+    add("area", "Area", "Shows change over time with volume.");
+    add("bar", "Column", "Compares each period.");
+    if (shape.series > 1) add("area", "Stacked area", "Shows how the parts add up over time.", "stacked");
+    return out;
+  }
+  if (shape.series === 1) {
+    if (shape.points > 12) {
+      add("line", "Line", "One long series: a line shows its shape.");
+      add("bar", "Column", "Compares every value.");
+      add("area", "Area", "Emphasises the volume under the series.");
+    } else {
+      add("bar", "Column", "One short series: columns compare the values.");
+      if (shape.mixedSigns) add("waterfall", "Waterfall", "Positive and negative values: shows how they add up to a total.");
+      add("bar", "Bar", "Horizontal bars fit long category names.");
+      if (shape.nonNegative && shape.points >= 2) {
+        add("pie", "Pie", "Shares of a whole (all values are positive).");
+        add("donut", "Donut", "Shares of a whole with the total in the middle.");
+        if (shape.points >= 5) add("treemap", "Treemap", "Compares many shares by area.");
+        add("funnel", "Funnel", "Shows stages that narrow down.");
       }
+      add("line", "Line", "Shows the values in order.");
     }
+    return out;
   }
-  marks.push(...labelMarks);
-  const valueScale = { axis: horizontal ? "x" : "y", domain, range: valueRange, ticks: scale.ticks };
-  return { width, height, plot, marks, valueScale, percent, theme };
-}
-var order = (t) => t === "area" ? 0 : t === "bar" ? 1 : t === "line" ? 2 : 3;
-function truncate(text2, maxWidth, size, measure) {
-  if (measure(text2, size) <= maxWidth) return text2;
-  let out = text2;
-  while (out.length > 1 && measure(`${out}\u2026`, size) > maxWidth) out = out.slice(0, -1);
-  return `${out}\u2026`;
-}
-function layoutLegend(items, position, area, theme, measure, marks, legendSelected) {
-  const fs = theme.fontSize;
-  const swatch = 10;
-  const rowH = fs * 1.7;
-  const itemW = (item) => swatch + 6 + measure(item.label, fs) + 14;
-  const placed = [];
-  let box;
-  let rest;
-  if (position === "left" || position === "right") {
-    const w = Math.min(area.width * 0.35, Math.max(...items.map(itemW)));
-    const h = Math.min(items.length * rowH, area.height);
-    const x = position === "left" ? area.x : area.x + area.width - w;
-    const y = area.y + (area.height - h) / 2;
-    items.forEach((item, i) => {
-      if ((i + 1) * rowH <= area.height + 0.5) placed.push({ item, x, y: y + i * rowH + rowH / 2 });
-    });
-    box = { x, y, width: w, height: h };
-    rest = position === "left" ? { ...area, x: area.x + w + 8, width: area.width - w - 8 } : { ...area, width: area.width - w - 8 };
+  if (shape.points > 12) {
+    add("line", "Line", "Several long series: lines keep them readable.");
+    add("bar", "Column", "Compares the series at each category.");
+    add("area", "Area", "Emphasises volume.");
+    add("bar", "Stacked column", "Shows how the series add up.", "stacked");
   } else {
-    const rows = [[]];
-    let used = 0;
-    for (const item of items) {
-      const w = itemW(item);
-      if (used + w > area.width && rows[rows.length - 1].length) {
-        rows.push([]);
-        used = 0;
-      }
-      rows[rows.length - 1].push(item);
-      used += w;
-    }
-    const shown = rows.slice(0, 3);
-    const h = shown.length * rowH;
-    const y0 = position === "top" ? area.y : area.y + area.height - h;
-    shown.forEach((row, r) => {
-      const total = row.reduce((t, item) => t + itemW(item), 0) - 14;
-      let x = area.x + (area.width - total) / 2;
-      for (const item of row) {
-        placed.push({ item, x, y: y0 + r * rowH + rowH / 2 });
-        x += itemW(item);
-      }
-    });
-    box = { x: area.x, y: y0, width: area.width, height: h };
-    rest = position === "top" ? { ...area, y: area.y + h + 6, height: area.height - h - 6 } : { ...area, height: area.height - h - 6 };
-  }
-  placed.forEach(({ item, x, y }, i) => {
-    const opacity = item.faded ? 0.4 : void 0;
-    if (item.shape === "line")
-      marks.push({ kind: "line", key: `legend-swatch-${i}`, role: "legend-swatch", x1: x, y1: y, x2: x + swatch, y2: y, stroke: item.color, strokeWidth: 2.5, opacity, target: item.target, selected: item.selected });
-    else
-      marks.push({ kind: "rect", key: `legend-swatch-${i}`, role: "legend-swatch", x, y: y - swatch / 2, width: swatch, height: swatch, radius: 2, fill: item.color, opacity, target: item.target, selected: item.selected });
-    marks.push({
-      kind: "text",
-      key: `legend-label-${i}`,
-      role: "legend-label",
-      x: x + swatch + 6,
-      y,
-      text: item.label,
-      anchor: "start",
-      baseline: "middle",
-      size: fs,
-      fill: item.selected ? theme.selection : theme.text,
-      weight: item.selected ? 600 : void 0,
-      opacity,
-      target: item.target,
-      selected: item.selected
-    });
-  });
-  if (legendSelected) marks.push({ kind: "rect", key: "legend-selection", role: "selection", x: box.x - 4, y: box.y - 2, width: box.width + 8, height: box.height + 4, fill: "none", stroke: theme.selection, strokeWidth: 1, radius: 3 });
-  return rest;
-}
-function layoutPie(spec, series, area, theme, marks, selection, width, height) {
-  const fs = theme.fontSize;
-  const values = spec.categories.map((_, i) => Math.max(0, series.values[i] ?? 0));
-  const total = values.reduce((a, b) => a + b, 0);
-  const labelRoom = spec.dataLabels ? fs * 2.2 : 4;
-  const outer = Math.max(4, Math.min(area.width, area.height) / 2 - labelRoom);
-  const inner = spec.type === "donut" ? outer * spec.innerRadius : 0;
-  const cx = area.x + area.width / 2;
-  const cy = area.y + area.height / 2;
-  const plot = { x: cx - outer, y: cy - outer, width: outer * 2, height: outer * 2 };
-  if (total <= 0) {
-    marks.push({ kind: "text", key: "empty", role: "empty", x: cx, y: cy, text: "No positive values", anchor: "middle", baseline: "middle", size: fs + 1, fill: theme.mutedText });
-    return { width, height, plot, marks, percent: false, theme };
-  }
-  let angle = 0;
-  const format = spec.yAxis.format;
-  values.forEach((v, i) => {
-    if (v <= 0) return;
-    const sweep = v / total * Math.PI * 2;
-    const start = angle;
-    const end = angle + sweep;
-    angle = end;
-    const target = { kind: "point", seriesId: series.id, index: i };
-    const selected = sameChartSelection(selection, target) || sameChartSelection(selection, { kind: "category", index: i });
-    const seriesSel = selection?.kind === "series" && selection.seriesId === series.id;
-    const mid = (start + end) / 2;
-    const off = selected ? 6 : 0;
-    const ox = cx + off * Math.sin(mid);
-    const oy = cy - off * Math.cos(mid);
-    marks.push({
-      kind: "path",
-      key: `slice-${i}`,
-      role: "slice",
-      d: arcPath(ox, oy, outer, inner, start, end),
-      fill: chartSliceColor(spec, i),
-      stroke: selected || seriesSel ? theme.selection : theme.surface,
-      strokeWidth: selected || seriesSel ? 2 : 1,
-      target,
-      selected: selected || seriesSel
-    });
-    if (spec.dataLabels && sweep > 0.12) {
-      const share = v / total;
-      const text2 = format.style ? formatChartNumber(v, format) : `${Math.round(share * 100)}%`;
-      const lr = outer + fs * 1.1;
-      const lx = ox + lr * Math.sin(mid);
-      const ly = oy - lr * Math.cos(mid);
-      const anchor = Math.abs(Math.sin(mid)) < 0.2 ? "middle" : Math.sin(mid) > 0 ? "start" : "end";
-      marks.push({ kind: "text", key: `label-slice-${i}`, role: "data-label", x: lx, y: ly, text: text2, anchor, baseline: "middle", size: fs, fill: theme.text, target });
-    }
-  });
-  if (spec.type === "donut" && inner > fs * 2) {
-    marks.push({ kind: "text", key: "donut-total", role: "data-label", x: cx, y: cy, text: formatChartNumber(total, format), anchor: "middle", baseline: "middle", size: Math.min(theme.titleSize + 4, inner / 2), weight: 600, fill: theme.text, target: { kind: "series", seriesId: series.id } });
-  }
-  return { width, height, plot, marks, percent: false, theme };
-}
-function chartValueAtPoint(scene, point) {
-  const scale = scene.valueScale;
-  if (!scale || scene.percent) return void 0;
-  const px = scale.axis === "y" ? point.y : point.x;
-  return linearMap(px, scale.range, scale.domain);
-}
-function snapChartValue(scene, value, step) {
-  const ticks = scene.valueScale?.ticks ?? [];
-  const unit = step ?? (ticks.length > 1 ? (ticks[1] - ticks[0]) / 10 : 1);
-  if (!(unit > 0)) return value;
-  const snapped = Math.round(value / unit) * unit;
-  return Number(snapped.toPrecision(12));
-}
-
-// src/chart/svg.ts
-function chartTextBaseline(baseline) {
-  return baseline === "top" ? "hanging" : baseline === "middle" ? "central" : "text-after-edge";
-}
-function chartTextTransform(mark) {
-  return mark.rotate ? `rotate(${mark.rotate} ${mark.x} ${mark.y})` : void 0;
-}
-var escape = (text2) => text2.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
-function attrs(values) {
-  return Object.entries(values).filter(([, v]) => v !== void 0 && v !== "").map(([k, v]) => ` ${k}="${escape(String(v))}"`).join("");
-}
-function markToSvg(mark, fontFamily) {
-  const common = { opacity: mark.opacity, "data-role": mark.role };
-  switch (mark.kind) {
-    case "rect":
-      return `<rect${attrs({ x: mark.x, y: mark.y, width: mark.width, height: mark.height, rx: mark.radius, fill: mark.fill, stroke: mark.stroke, "stroke-width": mark.strokeWidth, ...common })}/>`;
-    case "path":
-      return `<path${attrs({ d: mark.d, fill: mark.fill ?? "none", stroke: mark.stroke, "stroke-width": mark.strokeWidth, "stroke-dasharray": mark.dash, "stroke-linejoin": "round", "stroke-linecap": "round", ...common })}/>`;
-    case "circle":
-      return `<circle${attrs({ cx: mark.cx, cy: mark.cy, r: mark.r, fill: mark.fill, stroke: mark.stroke, "stroke-width": mark.strokeWidth, ...common })}/>`;
-    case "line":
-      return `<line${attrs({ x1: mark.x1, y1: mark.y1, x2: mark.x2, y2: mark.y2, stroke: mark.stroke, "stroke-width": mark.strokeWidth, "stroke-dasharray": mark.dash, ...common })}/>`;
-    case "text":
-      return `<text${attrs({
-        x: mark.x,
-        y: mark.y,
-        "text-anchor": mark.anchor,
-        "dominant-baseline": chartTextBaseline(mark.baseline),
-        "font-size": mark.size,
-        "font-weight": mark.weight,
-        "font-family": fontFamily,
-        fill: mark.fill,
-        transform: chartTextTransform(mark),
-        ...common
-      })}>${escape(mark.text)}</text>`;
-  }
-}
-function chartSceneToSvg(scene, options = {}) {
-  const hide = options.hideSelection ?? true;
-  const font = scene.theme.fontFamily;
-  const body = scene.marks.filter((m) => !(hide && m.role === "selection")).map((m) => markToSvg(m, font)).join("");
-  const label = options.ariaLabel;
-  return `<svg xmlns="http://www.w3.org/2000/svg" width="${scene.width}" height="${scene.height}" viewBox="0 0 ${scene.width} ${scene.height}" role="img"${label ? ` aria-label="${escape(label)}"` : ""}>${body}</svg>`;
-}
-function chartToSvg(spec, options) {
-  const scene = layoutChart(spec, { ...options, selection: null });
-  return chartSceneToSvg(scene, { ...options, ariaLabel: options.ariaLabel ?? (spec.title || void 0) });
-}
-
-// src/chart/controller.ts
-function sameChartJson(a, b) {
-  if (a === b) return true;
-  if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) return Number.isNaN(a) && Number.isNaN(b);
-  if (Array.isArray(a) !== Array.isArray(b)) return false;
-  if (Array.isArray(a)) {
-    const bb = b;
-    return a.length === bb.length && a.every((v, i) => sameChartJson(v, bb[i]));
-  }
-  const ao = a;
-  const bo = b;
-  const keys = Object.keys(ao).filter((k) => ao[k] !== void 0);
-  if (keys.length !== Object.keys(bo).filter((k) => bo[k] !== void 0).length) return false;
-  return keys.every((k) => Object.prototype.hasOwnProperty.call(bo, k) && sameChartJson(ao[k], bo[k]));
-}
-var fail = (message, issues) => ({ ok: false, message, ...issues ? { issues } : {} });
-var ChartController = class {
-  history;
-  spec;
-  selection = null;
-  issues = [];
-  gestureKey = null;
-  gestureCount = 0;
-  gestureStart = null;
-  revision = 0;
-  applying = false;
-  onChange;
-  listeners = /* @__PURE__ */ new Set();
-  unsubscribeHistory;
-  state;
-  constructor(options = {}) {
-    this.history = options.history ?? new HistoryManager();
-    this.onChange = options.onChange;
-    const { spec, issues } = normalizeChartSpec(options.spec ?? {});
-    this.spec = spec;
-    this.issues = issues;
-    this.state = this.computeState();
-    this.connect();
-  }
-  connect() {
-    this.unsubscribeHistory?.();
-    this.unsubscribeHistory = this.history.subscribe((h) => {
-      const s = this.state;
-      if (this.applying || s.canUndo === h.canUndo && s.canRedo === h.canRedo && s.undoLabel === h.undoName && s.redoLabel === h.redoName) return;
-      this.notify(false);
-    });
-  }
-  // -------------------------------------------------------------------------
-  // State
-  // -------------------------------------------------------------------------
-  /** The current snapshot (stable until the next change). */
-  getState = () => this.state;
-  /** Calls `listener` after every change. Returns an unsubscribe function. */
-  subscribe = (listener) => {
-    if (!this.unsubscribeHistory) this.connect();
-    this.listeners.add(listener);
-    return () => {
-      this.listeners.delete(listener);
-    };
-  };
-  /** The current spec (do not mutate; edit through the controller). */
-  getSpec() {
-    return this.spec;
-  }
-  getSeries(id) {
-    return this.spec.series.find((s) => s.id === id);
-  }
-  computeState() {
-    const h = this.history.getState();
-    const sel = this.selection;
-    const seriesId = sel?.kind === "series" || sel?.kind === "point" ? sel.seriesId : null;
-    return {
-      spec: this.spec,
-      selection: sel,
-      selectedSeries: seriesId ? this.spec.series.find((s) => s.id === seriesId) ?? null : null,
-      selectedIndex: sel?.kind === "point" || sel?.kind === "category" ? sel.index : null,
-      issues: this.issues,
-      gesture: this.gestureKey,
-      canUndo: h.canUndo,
-      canRedo: h.canRedo,
-      undoLabel: h.undoName,
-      redoLabel: h.redoName,
-      revision: this.revision
-    };
-  }
-  notify(specChanged) {
-    this.revision++;
-    this.state = this.computeState();
-    if (specChanged) this.onChange?.(this.spec);
-    const state = this.state;
-    this.listeners.forEach((listener) => {
-      try {
-        listener(state);
-      } catch (error) {
-        console.error("[ChartController] Error in state listener:", error);
-      }
-    });
-  }
-  // -------------------------------------------------------------------------
-  // Changes: every edit records a before / after snapshot of the spec
-  // -------------------------------------------------------------------------
-  /** Drops a selection that no longer points at anything. */
-  validSelection(sel, spec) {
-    if (!sel) return null;
-    switch (sel.kind) {
-      case "series":
-        return spec.series.some((s) => s.id === sel.seriesId) ? sel : null;
-      case "point":
-        return spec.series.some((s) => s.id === sel.seriesId) && sel.index < spec.categories.length ? sel : null;
-      case "category":
-        return sel.index < spec.categories.length ? sel : null;
-      case "title":
-        return spec.title ? sel : null;
-      case "subtitle":
-        return spec.subtitle ? sel : null;
-      default:
-        return sel;
-    }
-  }
-  applySpec(spec) {
-    this.applying = true;
-    try {
-      this.spec = spec;
-      this.selection = this.validSelection(this.selection, spec);
-    } finally {
-      this.applying = false;
-    }
-    this.notify(true);
-  }
-  commit(label, next, select) {
-    const before = this.spec;
-    const hadIssues = this.issues.length > 0;
-    this.issues = [];
-    if (sameChartJson(before, next)) {
-      const reselect = select !== void 0 && !sameChartSelection(this.selection, select) && !(select === null && this.selection === null);
-      if (reselect) this.selection = select;
-      if (reselect || hadIssues) this.notify(false);
-      return;
-    }
-    const command = {
-      name: label,
-      tag: "chart",
-      execute: () => this.applySpec(next),
-      undo: () => this.applySpec(before),
-      redo: () => this.applySpec(next)
-    };
-    if (select !== void 0) this.selection = select;
-    if (this.gestureKey !== null) this.history.executeMerged(command, { key: `chart.gesture:${this.gestureKey}:${this.gestureCount}` });
-    else this.history.execute(command);
-  }
-  reject(message, issues = []) {
-    this.issues = issues.length ? issues : [{ path: "", message }];
-    this.notify(false);
-    return fail(message, issues.length ? issues : void 0);
-  }
-  /** A copy of the spec with `edit` applied (series and categories copied as needed). */
-  edited(edit) {
-    const draft = cloneChartSpec(this.spec);
-    edit(draft);
-    return draft;
-  }
-  unknownSeries(id) {
-    const ids = this.spec.series.map((s) => `"${s.id}"`);
-    return fail(`There is no series "${id}"; ${ids.length ? `expected one of ${ids.join(", ")}` : "the chart has no series yet"}.`);
-  }
-  badIndex(index) {
-    const n = this.spec.categories.length;
-    return fail(n ? `Category index ${index} is out of range; expected 0 to ${n - 1}.` : "The chart has no categories yet.");
-  }
-  // -------------------------------------------------------------------------
-  // Presentation
-  // -------------------------------------------------------------------------
-  /**
-   * Changes any presentation or data fields as one undo step. All-or-nothing: if anything
-   * is invalid, nothing changes and every problem is returned (and shown in `state.issues`).
-   */
-  update(patch, options = {}) {
-    const s = this.spec;
-    const merged = {
-      ...s,
-      ...patch,
-      xAxis: patch.xAxis ? { ...s.xAxis, ...patch.xAxis } : s.xAxis,
-      yAxis: patch.yAxis ? { ...s.yAxis, ...patch.yAxis } : s.yAxis,
-      legend: patch.legend ? { ...s.legend, ...patch.legend } : s.legend,
-      version: 1
-    };
-    const { spec, issues } = normalizeChartSpec(merged);
-    if (issues.length) return this.reject(issues.map((i) => i.message).join(" "), issues);
-    if (JSON.stringify(spec) === JSON.stringify(s)) return { ok: true };
-    this.commit(options.label ?? updateLabel(patch), spec);
-    return { ok: true };
-  }
-  setType(type) {
-    return this.update({ type }, { label: `Change chart type` });
-  }
-  setTitle(title) {
-    return this.update({ title }, { label: "Edit title" });
-  }
-  setSubtitle(subtitle) {
-    return this.update({ subtitle }, { label: "Edit subtitle" });
-  }
-  /** Changes the category (`x`) or value (`y`) axis. */
-  setAxis(axis, patch) {
-    return this.update(axis === "x" ? { xAxis: patch } : { yAxis: patch }, { label: `Change ${axis === "x" ? "category" : "value"} axis` });
-  }
-  setLegend(patch) {
-    return this.update({ legend: patch }, { label: "Change legend" });
-  }
-  // -------------------------------------------------------------------------
-  // Data
-  // -------------------------------------------------------------------------
-  /**
-   * Replaces categories and / or series as one undo step. Values are validated and padded
-   * to the categories; all-or-nothing like `update`.
-   */
-  setData(data, options = {}) {
-    return this.update({ ...data.categories ? { categories: data.categories } : {}, ...data.series ? { series: data.series } : {} }, { label: options.label ?? "Edit chart data" });
-  }
-  /**
-   * Sets one value (numbers, numeric text such as `1,200` or `12%`, or blank for a gap).
-   * One undo step, or part of the current gesture.
-   */
-  setValue(seriesId, index, value, options = {}) {
-    const series = this.getSeries(seriesId);
-    if (!series) return this.unknownSeries(seriesId);
-    if (!Number.isInteger(index) || index < 0 || index >= this.spec.categories.length) return this.badIndex(index);
-    const parsed = parseChartValue(value);
-    if (parsed === void 0) return this.reject(`"${String(value)}" is not a number; enter a number or leave the cell blank.`, [{ path: `${seriesId}[${index}]`, message: `"${String(value)}" is not a number.` }]);
-    if (series.values[index] === parsed) {
-      if (this.issues.length) {
-        this.issues = [];
-        this.notify(false);
-      }
-      return { ok: true };
-    }
-    const next = this.edited((d) => {
-      d.series.find((s) => s.id === seriesId).values[index] = parsed;
-    });
-    this.commit(options.label ?? `Edit ${series.name} \xB7 ${this.spec.categories[index]}`, next);
-    return { ok: true };
-  }
-  /** Several values as one undo step (all-or-nothing). */
-  setValues(cells, options = {}) {
-    const issues = [];
-    const parsed = [];
-    for (const cell of cells) {
-      if (!this.getSeries(cell.seriesId)) issues.push({ path: cell.seriesId, message: this.unknownSeries(cell.seriesId).message });
-      else if (!Number.isInteger(cell.index) || cell.index < 0 || cell.index >= this.spec.categories.length) issues.push({ path: `${cell.seriesId}[${cell.index}]`, message: this.badIndex(cell.index).message });
-      else {
-        const value = parseChartValue(cell.value);
-        if (value === void 0) issues.push({ path: `${cell.seriesId}[${cell.index}]`, message: `"${String(cell.value)}" is not a number.` });
-        else parsed.push({ seriesId: cell.seriesId, index: cell.index, value });
-      }
-    }
-    if (issues.length) return this.reject(issues.map((i) => i.message).join(" "), issues);
-    const next = this.edited((d) => {
-      for (const cell of parsed) d.series.find((s) => s.id === cell.seriesId).values[cell.index] = cell.value;
-    });
-    if (JSON.stringify(next.series) !== JSON.stringify(this.spec.series)) this.commit(options.label ?? "Edit values", next);
-    return { ok: true };
-  }
-  /** Adds a series (values padded to the categories) and selects it. Returns its id. */
-  addSeries(input = {}, options = {}) {
-    const id = input.id && !this.getSeries(input.id) ? input.id : uniqueChartSeriesId(this.spec.series);
-    const name = input.name ?? `Series ${this.spec.series.length + 1}`;
-    const at = Math.max(0, Math.min(this.spec.series.length, options.at ?? this.spec.series.length));
-    const series = [...this.spec.series];
-    series.splice(at, 0, { ...input, id, name, values: input.values ?? [] });
-    const { spec, issues } = normalizeChartSpec({ ...this.spec, series });
-    if (issues.length) return this.reject(issues.map((i) => i.message).join(" "), issues);
-    this.commit(`Add series "${name}"`, spec, { kind: "series", seriesId: id });
-    return { ok: true, id };
-  }
-  removeSeries(id) {
-    const series = this.getSeries(id);
-    if (!series) return this.unknownSeries(id);
-    this.commit(
-      `Delete series "${series.name}"`,
-      this.edited((d) => {
-        d.series = d.series.filter((s) => s.id !== id);
-      })
-    );
-    return { ok: true };
-  }
-  updateSeries(id, patch) {
-    const series = this.getSeries(id);
-    if (!series) return this.unknownSeries(id);
-    const next = cloneChartSeries(series);
-    if (patch.name !== void 0) next.name = String(patch.name);
-    if (patch.color === null || patch.color === "") delete next.color;
-    else if (patch.color !== void 0) next.color = patch.color;
-    if (patch.type === null) delete next.type;
-    else if (patch.type !== void 0) next.type = patch.type;
-    if (patch.hidden !== void 0) {
-      if (patch.hidden) next.hidden = true;
-      else delete next.hidden;
-    }
-    const series2 = this.spec.series.map((s) => s.id === id ? next : s);
-    const { spec, issues } = normalizeChartSpec({ ...this.spec, series: series2 });
-    if (issues.length) return this.reject(issues.map((i) => i.message).join(" "), issues);
-    if (JSON.stringify(spec.series) === JSON.stringify(this.spec.series)) return { ok: true };
-    const label = patch.hidden !== void 0 && Object.keys(patch).length === 1 ? `${patch.hidden ? "Hide" : "Show"} "${series.name}"` : patch.name !== void 0 && Object.keys(patch).length === 1 ? "Rename series" : `Change series "${series.name}"`;
-    this.commit(label, spec);
-    return { ok: true };
-  }
-  toggleSeries(id) {
-    const series = this.getSeries(id);
-    if (!series) return this.unknownSeries(id);
-    return this.updateSeries(id, { hidden: !series.hidden });
-  }
-  /** Moves a series to position `to` (drawing and legend order). */
-  moveSeries(id, to) {
-    const from = this.spec.series.findIndex((s) => s.id === id);
-    if (from < 0) return this.unknownSeries(id);
-    const target = Math.max(0, Math.min(this.spec.series.length - 1, to));
-    if (target === from) return { ok: true };
-    this.commit(
-      "Reorder series",
-      this.edited((d) => {
-        const [s] = d.series.splice(from, 1);
-        d.series.splice(target, 0, s);
-      })
-    );
-    return { ok: true };
-  }
-  /** Inserts a category (with gaps in every series) at `at` (default: the end). Returns its index. */
-  addCategory(label, options = {}) {
-    const at = Math.max(0, Math.min(this.spec.categories.length, options.at ?? this.spec.categories.length));
-    const name = label ?? `${this.spec.categories.length + 1}`;
-    this.commit(
-      `Add category "${name}"`,
-      this.edited((d) => {
-        d.categories.splice(at, 0, name);
-        for (const s of d.series) s.values.splice(at, 0, null);
-      }),
-      { kind: "category", index: at }
-    );
-    return { ok: true, index: at };
-  }
-  removeCategory(index) {
-    if (!Number.isInteger(index) || index < 0 || index >= this.spec.categories.length) return this.badIndex(index);
-    this.commit(
-      `Delete category "${this.spec.categories[index]}"`,
-      this.edited((d) => {
-        d.categories.splice(index, 1);
-        for (const s of d.series) s.values.splice(index, 1);
-      })
-    );
-    return { ok: true };
-  }
-  renameCategory(index, label) {
-    if (!Number.isInteger(index) || index < 0 || index >= this.spec.categories.length) return this.badIndex(index);
-    if (this.spec.categories[index] === label) return { ok: true };
-    this.commit(
-      "Rename category",
-      this.edited((d) => {
-        d.categories[index] = String(label);
-      })
-    );
-    return { ok: true };
-  }
-  moveCategory(from, to) {
-    if (!Number.isInteger(from) || from < 0 || from >= this.spec.categories.length) return this.badIndex(from);
-    const target = Math.max(0, Math.min(this.spec.categories.length - 1, to));
-    if (target === from) return { ok: true };
-    const move = (list) => {
-      const [item] = list.splice(from, 1);
-      list.splice(target, 0, item);
-    };
-    this.commit(
-      "Reorder categories",
-      this.edited((d) => {
-        move(d.categories);
-        for (const s of d.series) move(s.values);
-      })
-    );
-    return { ok: true };
+    add("bar", "Column", "Several series: clustered columns compare them per category.");
+    add("bar", "Bar", "Horizontal bars fit long category names.");
+    add("bar", "Stacked column", "Shows how the series add up.", "stacked");
+    add("line", "Line", "Shows the series in order.");
+    if (shape.points >= 3 && shape.series <= 6) add("radar", "Radar", "Compares several measures across the series.");
   }
-  /**
-   * Pastes a block of cells (TSV / CSV text or rows) into the data grid with its top-left at
-   * `row` (category index) and `column` (series index; `-1` is the category column). The
-   * grid grows to fit. Non-numeric value cells become gaps and are reported in `issues`.
-   */
-  pasteCells(row, column, cells) {
-    const rows = typeof cells === "string" ? cells.includes("	") ? parseTsv(cells) : parseCsv(cells) : cells.map((r) => [...r]);
-    if (!rows.length) return { ok: true };
-    const issues = [];
-    const next = this.edited((d) => {
-      const width = Math.max(...rows.map((r) => r.length));
-      const lastSeries = column + width - 1;
-      while (d.series.length <= lastSeries) {
-        const id = uniqueChartSeriesId(d.series);
-        d.series.push({ id, name: `Series ${d.series.length + 1}`, values: d.categories.map(() => null) });
-      }
-      const lastRow = row + rows.length - 1;
-      while (d.categories.length <= lastRow) {
-        d.categories.push(`${d.categories.length + 1}`);
-        for (const s of d.series) s.values.push(null);
-      }
-      rows.forEach((cellsInRow, r) => {
-        cellsInRow.forEach((cell, c) => {
-          const col = column + c;
-          const index = row + r;
-          if (col < 0) d.categories[index] = cell === null || cell === void 0 ? "" : String(cell).trim();
-          else {
-            const parsed = parseChartValue(cell);
-            if (parsed === void 0) issues.push({ path: `${d.series[col].id}[${index}]`, message: `"${String(cell)}" is not a number; it was left blank.` });
-            d.series[col].values[index] = parsed ?? null;
-          }
-        });
-      });
-    });
-    this.commit("Paste cells", next);
-    if (issues.length) {
-      this.issues = issues;
-      this.notify(false);
-    }
-    return issues.length ? { ok: true, issues } : { ok: true };
-  }
-  /**
-   * Replaces the data with a grid of cells (see `chartDataFromTable`): one undo step. Series
-   * colours and types are kept by name.
-   */
-  importTable(rows, options = {}) {
-    const data = chartDataFromTable(rows, options);
-    if (!data.categories.length || !data.series.length) return this.reject("There is no data to import: expected a header row and at least one row of values.");
-    const byName = new Map(this.spec.series.map((s) => [s.name, s]));
-    const series = data.series.map((s) => {
-      const old = byName.get(s.name);
-      return { ...s, ...old?.color ? { color: old.color } : {}, ...old?.type ? { type: old.type } : {}, ...old ? { id: old.id } : {} };
-    });
-    const { spec } = normalizeChartSpec({ ...this.spec, categories: data.categories, series });
-    this.commit("Import data", spec);
-    if (data.issues.length) {
-      this.issues = data.issues;
-      this.notify(false);
-      return { ok: true, issues: data.issues };
-    }
-    return { ok: true };
-  }
-  /** Imports CSV (or TSV, detected by tabs) text; see `importTable`. */
-  importCsv(text2, options = {}) {
-    const delimiter = options.delimiter ?? (text2.includes("	") ? "	" : ",");
-    return this.importTable(parseCsv(text2, { delimiter }), options);
-  }
-  // -------------------------------------------------------------------------
-  // Selection and gestures
-  // -------------------------------------------------------------------------
-  /** Selects a chart element (view state; not an undo step). */
-  select(selection) {
-    const next = this.validSelection(selection, this.spec);
-    if (sameChartSelection(next, this.selection) || next === null && this.selection === null) return;
-    this.selection = next;
-    this.notify(false);
-  }
-  /**
-   * Deletes what is selected: a series or category is removed, a point becomes a gap, a
-   * title is cleared, the legend or an axis is hidden.
-   */
-  deleteSelection() {
-    const sel = this.selection;
-    if (!sel) return fail("Nothing is selected.");
-    switch (sel.kind) {
-      case "series":
-        return this.removeSeries(sel.seriesId);
-      case "category":
-        return this.removeCategory(sel.index);
-      case "point":
-        return this.setValue(sel.seriesId, sel.index, null, { label: "Clear value" });
-      case "title":
-        return this.setTitle("");
-      case "subtitle":
-        return this.setSubtitle("");
-      case "legend":
-        return this.setLegend({ show: false });
-      case "axis":
-        return this.setAxis(sel.axis, { show: false });
-      default:
-        return fail("The chart itself cannot be deleted.");
-    }
-  }
-  /** Adds `delta` to a value (a gap counts as 0). */
-  nudgeValue(seriesId, index, delta) {
-    const series = this.getSeries(seriesId);
-    if (!series) return this.unknownSeries(seriesId);
-    const current = series.values[index] ?? 0;
-    return this.setValue(seriesId, index, Number((current + delta).toPrecision(12)), { label: `Edit ${series.name} \xB7 ${this.spec.categories[index] ?? index}` });
-  }
-  /** Starts a continuous edit (a drag): every change until `endGesture()` is one undo step. */
-  beginGesture(key) {
-    if (this.gestureKey === key) return;
-    this.history.endGesture();
-    this.gestureKey = key;
-    this.gestureCount++;
-    this.gestureStart = { spec: this.spec, mark: this.history.mark() };
-    this.notify(false);
-  }
-  endGesture() {
-    if (this.gestureKey === null) return;
-    this.gestureKey = null;
-    this.history.endGesture();
-    const start = this.gestureStart;
-    this.gestureStart = null;
-    if (start && sameChartJson(start.spec, this.spec)) this.history.revertTo(start.mark);
-    this.notify(false);
-  }
-  // -------------------------------------------------------------------------
-  // Persistence and history
-  // -------------------------------------------------------------------------
-  /** The spec, for saving (a copy). */
-  toJSON() {
-    return cloneChartSpec(this.spec);
-  }
-  /**
-   * Replaces the chart without an undo step (e.g. when opening a document). Problems are
-   * fixed with defaults and reported in `state.issues` (and returned).
-   */
-  load(input, options = {}) {
-    const { spec, issues } = normalizeChartSpec(input);
-    this.spec = spec;
-    this.issues = issues;
-    this.selection = this.validSelection(this.selection, spec);
-    if (options.clearHistory) {
-      this.applying = true;
-      try {
-        this.history.clear();
-      } finally {
-        this.applying = false;
-      }
-    }
-    this.notify(true);
-    return issues;
-  }
-  undo() {
-    this.endGesture();
-    return this.history.undo();
-  }
-  redo() {
-    this.endGesture();
-    return this.history.redo();
-  }
-  /** Stops listening to the history (reconnected by the next `subscribe`). */
-  destroy() {
-    this.unsubscribeHistory?.();
-    this.unsubscribeHistory = void 0;
-    this.listeners.clear();
-  }
-};
-function createChartController(options = {}) {
-  return new ChartController(options);
+  return out;
 }
-function updateLabel(patch) {
-  const keys = Object.keys(patch);
-  if (keys.length !== 1) return "Change chart";
-  const labels = {
-    type: "Change chart type",
-    title: "Edit title",
-    subtitle: "Edit subtitle",
-    categories: "Edit categories",
-    series: "Edit series",
-    xAxis: "Change category axis",
-    yAxis: "Change value axis",
-    legend: "Change legend",
-    stacking: "Change stacking",
-    orientation: "Change orientation",
-    curve: "Change line style",
-    points: "Toggle points",
-    dataLabels: "Toggle data labels",
-    palette: "Change colours",
-    innerRadius: "Change donut hole"
-  };
-  return labels[keys[0]] ?? "Change chart";
+function chartFromTable(rows, options = {}) {
+  const shape = analyzeChartTable(rows);
+  const rec = (options.type ?? "auto") === "auto" ? recommendForShape(shape)[0] : void 0;
+  const type = rec?.type ?? (options.type === "auto" || !options.type ? "bar" : options.type);
+  const stacking = rec?.stacking ?? "none";
+  const grid = rows.filter((r) => r.some((c) => !blank(c))).map((r) => [...r]);
+  const width = Math.max(0, ...grid.map((r) => r.length));
+  let table = grid;
+  if (!shape.labelColumn) table = table.map((r, i) => [shape.headerRow && i === 0 ? "" : String(i + (shape.headerRow ? 0 : 1)), ...r]);
+  if (!shape.headerRow) table = [["", ...Array.from({ length: width }, (_, i) => `Series ${i + 1}`)], ...table];
+  const xFromFirst = type === "scatter" && !shape.labelColumn && !shape.byRows && shape.series > 1;
+  if (xFromFirst) {
+    table = table.map((r) => [r[1], ...r.slice(2)]);
+  }
+  const data = chartDataFromTable(table, { seriesIn: shape.byRows ? "rows" : "columns", header: true, xFromFirstColumn: xFromFirst });
+  return { type, stacking, categories: data.categories, series: data.series, issues: data.issues, shape };
 }
 
 // src/chart/commands.ts
-var fail2 = (message) => {
-  throw new Error(message);
-};
-var check = (result) => {
-  if (!result.ok) fail2(result.message ?? "The change was rejected.");
-};
-var VALUE = { type: ["number", "string", "null"], description: 'A number, numeric text ("1,200", "12%") or null for a gap.' };
-var FORMAT = {
-  type: "object",
-  properties: {
-    style: { type: "string", enum: [...CHART_NUMBER_STYLES] },
-    decimals: { type: "integer", minimum: 0, maximum: 10 },
-    currency: { type: "string", description: 'ISO code for style "currency", e.g. "EUR".' },
-    prefix: { type: "string" },
-    suffix: { type: "string" }
-  },
-  additionalProperties: false
-};
-var AXIS = {
-  type: "object",
-  properties: {
-    show: { type: "boolean" },
-    title: { type: "string" },
-    min: { type: ["number", "null"], description: "Fixed lower bound, or null for automatic." },
-    max: { type: ["number", "null"], description: "Fixed upper bound, or null for automatic." },
-    gridlines: { type: "boolean" },
-    format: FORMAT
-  },
-  additionalProperties: false
+var fail = (message) => {
+  throw new Error(message);
 };
-var SERIES = {
-  type: "object",
-  properties: {
-    id: { type: "string" },
-    name: { type: "string" },
-    values: { type: "array", items: VALUE, description: "One value per category." },
-    color: { type: "string", description: "CSS colour." },
-    type: { type: "string", enum: [...CHART_SERIES_TYPES], description: "Draw this series differently (combo charts)." },
-    hidden: { type: "boolean" }
-  },
-  required: ["name", "values"],
-  additionalProperties: false
+var check = (result) => {
+  if (!result.ok) fail(result.message ?? "The change was rejected.");
 };
 function createChartCommands(controller, options = {}) {
   const prefix = options.prefix ?? "chart.";
@@ -1680,53 +260,37 @@ function createChartCommands(controller, options = {}) {
   const resolveSeries = (ref) => {
     const spec = controller.getSpec();
     const series = spec.series.find((s) => s.id === ref) ?? spec.series.find((s) => s.name === ref);
-    if (!series) fail2(`There is no series "${ref}"; expected one of ${seriesIds().map((id) => `"${id}"`).join(", ") || "(none yet)"}.`);
+    if (!series) fail(`There is no series "${ref}"; expected one of ${seriesIds().map((id) => `"${id}"`).join(", ") || "(none yet)"}.`);
     return series;
   };
   const resolveCategory = (ref) => {
     const categories = controller.getSpec().categories;
     const index = typeof ref === "number" ? ref : categories.indexOf(ref);
-    if (index < 0 || index >= categories.length || !Number.isInteger(index)) fail2(`There is no category ${JSON.stringify(ref)}; expected an index from 0 to ${categories.length - 1} or one of the labels.`);
+    if (index < 0 || index >= categories.length || !Number.isInteger(index)) fail(`There is no category ${JSON.stringify(ref)}; expected an index from 0 to ${categories.length - 1} or one of the labels.`);
     return index;
   };
+  const object = (properties, required) => ({ type: "object", properties, ...required ? { required } : {}, additionalProperties: false });
   return [
     {
       ...base,
       id: `${prefix}describe`,
       label: "Describe Chart",
       readOnly: true,
-      keywords: ["chart", "data", "spec", "get"],
-      description: "Returns the chart spec (type, titles, axes, legend, options) and its data as a table with series names in the header row.",
-      run: () => {
+      keywords: ["chart", "data", "spec", "get", "summary"],
+      description: "Returns the chart spec, its data as a table (series names in the header row) and a summary: per-series min / max / mean / trend, axes as drawn, layout warnings and a colour check.",
+      params: object({ width: WIDTH, height: HEIGHT }),
+      run: (_ctx, params = {}) => {
         const spec = controller.getSpec();
-        return { spec: controller.toJSON(), table: chartDataToTable(spec), issues: controller.getState().issues };
+        return { spec: controller.toJSON(), table: chartDataToTable(spec), summary: summarizeChart(controller.toJSON(), { width: params?.width ?? 640, height: params?.height ?? 400 }), issues: controller.getState().issues };
       }
     },
     {
       ...base,
       id: `${prefix}update`,
       label: "Change Chart\u2026",
-      keywords: ["chart", "title", "axis", "legend", "stack", "style", "format"],
-      description: "Changes chart presentation as one undo step: type, titles, axes (x = categories, y = values), legend, stacking, orientation, curve, points, data labels, palette or donut hole. Invalid values change nothing and return why.",
-      params: {
-        type: "object",
-        properties: {
-          type: { type: "string", enum: [...CHART_TYPES] },
-          title: { type: "string" },
-          subtitle: { type: "string" },
-          xAxis: AXIS,
-          yAxis: AXIS,
-          legend: { type: "object", properties: { show: { type: "boolean" }, position: { type: "string", enum: [...CHART_LEGEND_POSITIONS] } }, additionalProperties: false },
-          stacking: { type: "string", enum: [...CHART_STACKINGS] },
-          orientation: { type: "string", enum: [...CHART_ORIENTATIONS] },
-          curve: { type: "string", enum: [...CHART_CURVES] },
-          points: { type: "boolean" },
-          dataLabels: { type: "boolean" },
-          palette: { type: "array", items: { type: "string" }, minItems: 1 },
-          innerRadius: { type: "number", minimum: 0, maximum: 0.9 }
-        },
-        additionalProperties: false
-      },
+      keywords: ["chart", "title", "axis", "legend", "stack", "style", "format", "type"],
+      description: "Changes chart presentation as one undo step: type, titles, axes (xAxis = categories, yAxis = values, yAxis2 = secondary values), legend, stacking, orientation, curve, points, data labels, palette, donut hole, bar spacing, histogram bins or waterfall total. Invalid values change nothing and return why.",
+      params: object(CHART_UPDATE_PROPERTIES),
       run: (_ctx, params) => {
         check(controller.update(params));
         return { spec: controller.toJSON() };
@@ -1738,14 +302,10 @@ function createChartCommands(controller, options = {}) {
       label: "Replace Chart Data\u2026",
       keywords: ["chart", "data", "series", "categories"],
       description: "Replaces the categories and series as one undo step. Each series has one value per category (padded with gaps).",
-      params: {
-        type: "object",
-        properties: {
-          categories: { type: "array", items: { type: "string" } },
-          series: { type: "array", items: SERIES }
-        },
-        additionalProperties: false
-      },
+      params: object({
+        categories: { type: "array", items: { type: "string" }, description: "Category labels in order." },
+        series: { type: "array", description: "The new series.", items: object({ id: { type: "string", description: "Stable id (optional)." }, ...SERIES_PROPS }, ["name", "values"]) }
+      }),
       run: (_ctx, params) => {
         check(controller.setData(params));
         return { table: chartDataToTable(controller.getSpec()) };
@@ -1757,22 +317,7 @@ function createChartCommands(controller, options = {}) {
       label: "Set Chart Values\u2026",
       keywords: ["chart", "value", "cell", "edit"],
       description: "Sets individual values as one undo step. Series by id or name; category by index or label.",
-      params: {
-        type: "object",
-        properties: {
-          cells: {
-            type: "array",
-            minItems: 1,
-            items: {
-              type: "object",
-              properties: { series: { type: "string" }, category: { type: ["string", "integer"] }, value: VALUE },
-              required: ["series", "category", "value"],
-              additionalProperties: false
-            }
-          }
-        },
-        required: ["cells"]
-      },
+      params: object({ cells: { type: "array", minItems: 1, description: "Values to set.", items: object({ series: SERIES_REF, category: CATEGORY_REF, value: VALUE }, ["series", "category", "value"]) } }, ["cells"]),
       run: (_ctx, params) => {
         check(controller.setValues(params.cells.map((c) => ({ seriesId: resolveSeries(c.series).id, index: resolveCategory(c.category), value: c.value }))));
         return { table: chartDataToTable(controller.getSpec()) };
@@ -1784,10 +329,11 @@ function createChartCommands(controller, options = {}) {
       label: "Add Series",
       keywords: ["chart", "series", "new"],
       description: "Adds a series (default: an empty one at the end). Returns its id.",
-      params: { type: "object", properties: { ...SERIES.properties, at: { type: "integer", minimum: 0 } }, additionalProperties: false },
+      params: object({ ...SERIES_PROPS, id: { type: "string", description: "Id to use (default series-N)." }, at: { type: "integer", minimum: 0, description: "Position (default: last)." } }),
       run: (_ctx, params = {}) => {
         const { at, ...input } = params ?? {};
-        const result = controller.addSeries(input, { at });
+        const clean = Object.fromEntries(Object.entries(input).filter(([, v]) => v !== null));
+        const result = controller.addSeries(clean, { at });
         check(result);
         return { id: result.id };
       }
@@ -1796,20 +342,9 @@ function createChartCommands(controller, options = {}) {
       ...base,
       id: `${prefix}updateSeries`,
       label: "Change Series\u2026",
-      keywords: ["chart", "series", "rename", "colour", "color", "hide"],
-      description: "Renames, recolours, hides or changes how a series is drawn (null colour / type resets it).",
-      params: {
-        type: "object",
-        properties: {
-          series: { type: "string", description: "Series id or name." },
-          name: { type: "string" },
-          color: { type: ["string", "null"] },
-          type: { type: ["string", "null"], enum: [...CHART_SERIES_TYPES, null] },
-          hidden: { type: "boolean" }
-        },
-        required: ["series"],
-        additionalProperties: false
-      },
+      keywords: ["chart", "series", "rename", "colour", "color", "hide", "axis", "marker"],
+      description: "Renames, recolours, hides, moves to the secondary axis or changes how a series is drawn (null resets a field).",
+      params: object({ series: SERIES_REF, ...Object.fromEntries(Object.entries(SERIES_PROPS).filter(([k]) => k !== "values")) }, ["series"]),
       run: (_ctx, params) => {
         const { series, ...patch } = params;
         const id = resolveSeries(series).id;
@@ -1823,7 +358,7 @@ function createChartCommands(controller, options = {}) {
       label: "Delete Series",
       keywords: ["chart", "series", "remove"],
       description: "Deletes a series by id or name.",
-      params: { type: "object", properties: { series: { type: "string" } }, required: ["series"], additionalProperties: false },
+      params: object({ series: SERIES_REF }, ["series"]),
       run: (_ctx, params) => {
         check(controller.removeSeries(resolveSeries(params.series).id));
         return { series: seriesIds() };
@@ -1835,7 +370,7 @@ function createChartCommands(controller, options = {}) {
       label: "Add Category",
       keywords: ["chart", "category", "row", "label"],
       description: "Inserts a category (gaps in every series) at `at` (default: the end).",
-      params: { type: "object", properties: { label: { type: "string" }, at: { type: "integer", minimum: 0 } }, additionalProperties: false },
+      params: object({ label: { type: "string", description: "Category label (default: its number)." }, at: { type: "integer", minimum: 0, description: "Index to insert at (default: the end)." } }),
       run: (_ctx, params = {}) => controller.addCategory(params?.label, { at: params?.at })
     },
     {
@@ -1844,46 +379,156 @@ function createChartCommands(controller, options = {}) {
       label: "Delete Category",
       keywords: ["chart", "category", "row", "remove"],
       description: "Deletes a category (and its values) by index or label.",
-      params: { type: "object", properties: { category: { type: ["string", "integer"] } }, required: ["category"], additionalProperties: false },
+      params: object({ category: CATEGORY_REF }, ["category"]),
       run: (_ctx, params) => {
         check(controller.removeCategory(resolveCategory(params.category)));
         return { categories: controller.getSpec().categories };
       }
     },
+    {
+      ...base,
+      id: `${prefix}addTrendline`,
+      label: "Add Trendline\u2026",
+      keywords: ["chart", "trend", "regression", "fit", "forecast", "moving average"],
+      description: "Fits a trendline to a series (linear, exponential, logarithmic, power, polynomial or moving average). Returns its index and the fit.",
+      params: object({ series: SERIES_REF, ...TRENDLINE_PROPS }, ["series", "type"]),
+      run: (_ctx, params) => {
+        const { series, ...line } = params;
+        const result = controller.addTrendline(resolveSeries(series).id, line);
+        check(result);
+        const ok = result;
+        return { index: ok.index, ...ok.fit ? { coefficients: ok.fit.coefficients, r2: ok.fit.r2, equation: ok.fit.equation } : {} };
+      }
+    },
+    {
+      ...base,
+      id: `${prefix}removeTrendline`,
+      label: "Delete Trendline",
+      keywords: ["chart", "trend", "remove"],
+      description: "Deletes a trendline from a series.",
+      params: object({ series: SERIES_REF, index: { type: "integer", minimum: 0, description: "Trendline index (0 = first)." } }, ["series", "index"]),
+      run: (_ctx, params) => {
+        check(controller.removeTrendline(resolveSeries(params.series).id, params.index));
+        return { trendlines: controller.getSeries(resolveSeries(params.series).id)?.trendlines ?? [] };
+      }
+    },
+    {
+      ...base,
+      id: `${prefix}applyPreset`,
+      label: "Apply Chart Style\u2026",
+      keywords: ["chart", "quick layout", "style", "colours", "colors", "monochrome", "theme"],
+      description: "Applies a quick layout and / or colour scheme as one undo step.",
+      params: object({
+        layout: { type: "string", enum: CHART_LAYOUT_PRESETS.map((p) => p.id), description: "Quick layout id." },
+        colors: { type: "string", enum: CHART_COLOR_SCHEMES.map((p) => p.id), description: "Colour scheme id." }
+      }),
+      run: (_ctx, params = {}) => {
+        check(controller.applyPreset(params ?? {}));
+        return { spec: controller.toJSON() };
+      }
+    },
+    {
+      ...base,
+      id: `${prefix}transpose`,
+      label: "Switch Rows and Columns",
+      keywords: ["chart", "transpose", "swap", "rows", "columns", "series"],
+      description: "Swaps series and categories as one undo step.",
+      run: () => {
+        check(controller.transpose());
+        return { table: chartDataToTable(controller.getSpec()) };
+      }
+    },
     {
       ...base,
       id: `${prefix}importCsv`,
       label: "Import Chart Data from CSV\u2026",
       keywords: ["chart", "csv", "tsv", "paste", "import"],
       description: "Replaces the data with CSV / TSV text: by default the first column holds categories and the first row series names.",
-      params: {
-        type: "object",
-        properties: {
-          csv: { type: "string" },
-          seriesIn: { type: "string", enum: ["columns", "rows"] },
-          header: { type: "boolean" }
+      params: object(
+        {
+          csv: { type: "string", description: "CSV or TSV text." },
+          seriesIn: { type: "string", enum: ["columns", "rows"], description: "Series run down columns (default) or along rows." },
+          header: { type: ["boolean", "string"], enum: [true, false, "auto"], description: "The first row holds series names (default true)." }
         },
-        required: ["csv"],
-        additionalProperties: false
-      },
+        ["csv"]
+      ),
       run: (_ctx, params) => {
         const result = controller.importCsv(params.csv, { seriesIn: params.seriesIn, header: params.header });
         check(result);
         return { table: chartDataToTable(controller.getSpec()), issues: result.issues ?? [] };
       }
     },
+    {
+      ...base,
+      id: `${prefix}importMermaid`,
+      label: "Import Mermaid Chart\u2026",
+      keywords: ["chart", "mermaid", "markdown", "xychart", "pie", "radar", "import"],
+      description: "Replaces the chart with Mermaid xychart-beta, pie or radar-beta text (one undo step). Unreadable lines are listed with line numbers.",
+      params: object({ mermaid: { type: "string", description: "Mermaid text." } }, ["mermaid"]),
+      run: (_ctx, params) => {
+        const read = chartFromMermaid(params.mermaid);
+        if (!read.family) fail(read.issues.map((i) => i.message).join(" ") || "Expected Mermaid starting with xychart-beta, pie or radar-beta.");
+        check(controller.update({ ...read.spec }, { label: "Import Mermaid chart" }));
+        return { spec: controller.toJSON(), issues: read.issues };
+      }
+    },
+    {
+      ...base,
+      id: `${prefix}exportMermaid`,
+      label: "Copy Chart as Mermaid",
+      readOnly: true,
+      keywords: ["chart", "mermaid", "markdown", "export"],
+      description: "Returns the chart as Mermaid text (with a round-trip comment unless meta is false).",
+      params: object({ meta: { type: "boolean", description: "Include the %% @pixerate round-trip comment (default true)." } }),
+      run: (_ctx, params = {}) => ({ mermaid: chartToMermaid(controller.toJSON(), { meta: params?.meta }) })
+    },
+    {
+      ...base,
+      id: `${prefix}exportOoxml`,
+      label: "Export Chart as Office XML",
+      readOnly: true,
+      keywords: ["chart", "office", "word", "powerpoint", "docx", "pptx", "xml", "export"],
+      description: "Returns the chart as a DrawingML chart part (c:chartSpace) and what could not be written.",
+      run: () => chartToOoxml(controller.toJSON())
+    },
     {
       ...base,
       id: `${prefix}exportSvg`,
       label: "Export Chart as SVG",
       readOnly: true,
       keywords: ["chart", "svg", "export", "image"],
-      description: "Returns the chart drawn as a standalone SVG string.",
-      params: { type: "object", properties: { width: { type: "number", minimum: 50 }, height: { type: "number", minimum: 50 } }, additionalProperties: false },
+      description: "Returns the chart drawn as a standalone, accessible SVG string (with <title> and <desc>).",
+      params: object({ width: WIDTH, height: HEIGHT }),
+      run: (_ctx, params = {}) => ({
+        svg: chartToSvg(controller.toJSON(), { width: params?.width ?? 640, height: params?.height ?? 400 })
+      })
+    },
+    {
+      ...base,
+      id: `${prefix}recommend`,
+      label: "Recommend Chart Types",
+      readOnly: true,
+      keywords: ["chart", "recommend", "suggest", "type"],
+      description: "Suggests chart types for the current data (or CSV), best first, each with a reason.",
+      params: object({ csv: { type: "string", description: "CSV text to analyse instead of the current data." } }),
       run: (_ctx, params = {}) => ({
-        svg: chartToSvg(controller.getSpec(), { width: params?.width ?? 640, height: params?.height ?? 400 })
+        recommendations: recommendChartTypes(params?.csv !== void 0 ? parseCsv(params.csv) : chartDataToTable(controller.getSpec()))
       })
     },
+    {
+      ...base,
+      id: `${prefix}checkColors`,
+      label: "Check Chart Colours",
+      readOnly: true,
+      keywords: ["chart", "colour", "color", "accessibility", "colour-blind", "contrast"],
+      description: "Checks that the series colours can be told apart (including with colour-blindness) and stand out from the background.",
+      run: () => {
+        const s = controller.getSpec();
+        const visible = s.series.filter((x) => !x.hidden);
+        const colors = chartColorsByCategory(s.type) ? s.categories.map((_, i) => visible[0]?.pointColors?.[i] || chartSliceColor(s, i)) : visible.map((x) => chartSeriesColor(s, s.series.indexOf(x)));
+        return { colors, ...checkChartColors(colors) };
+      }
+    },
     {
       ...base,
       id: `${prefix}undo`,
@@ -1912,50 +557,122 @@ function chartClientToScene(scene, box, clientX, clientY) {
 function canDragChartPoint(controller, scene, target) {
   if (target?.kind !== "point" || !scene.valueScale || scene.percent) return false;
   const spec = controller.getSpec();
-  if (!isCartesianChart(spec.type)) return false;
+  const family = chartFamily(spec);
+  if (family !== "cartesian" && family !== "xy" && family !== "waterfall") return false;
   const series = controller.getSeries(target.seriesId);
   return !!series && !series.hidden && series.values[target.index] !== null;
 }
+function snapChartDragValue(scene, value, options = {}) {
+  const scale = options.scale ?? scene.valueScale;
+  const tolerance = options.tolerancePx ?? 6;
+  if (scale) {
+    const px = (v) => linearMap(v, scale.domain, scale.range);
+    const at = px(value);
+    let best = null;
+    let bestDist = tolerance;
+    for (const c of [...options.candidates ?? [], ...scale.ticks]) {
+      if (!Number.isFinite(c)) continue;
+      const d = Math.abs(px(c) - at);
+      if (d <= bestDist) {
+        best = c;
+        bestDist = d;
+      }
+    }
+    if (best !== null) return best;
+  }
+  return snapChartValue(scene, value, options.step, scale?.ticks);
+}
 function startChartPointDrag(controller, scene, target, start, options = {}) {
   if (!canDragChartPoint(controller, scene, target)) return null;
   const { seriesId, index } = target;
-  const startValue = controller.getSeries(seriesId).values[index] ?? 0;
-  const startAt = chartValueAtPoint(scene, start);
+  const spec = controller.getSpec();
+  const series = controller.getSeries(seriesId);
+  const secondary = series.axis === "secondary" && !!scene.valueScale2;
+  const scale = secondary ? scene.valueScale2 : scene.valueScale;
+  const xy = chartFamily(spec) === "xy" && !!scene.xScale;
+  const startValue = series.values[index] ?? 0;
+  const startX = series.x?.[index] ?? null;
+  const startAt = chartValueAtPoint(scene, start, secondary);
+  const startAtX = xy ? chartXAtPoint(scene, start) : void 0;
   if (startAt === void 0) return null;
+  const candidates = [0, startValue];
+  if (!xy) {
+    for (const s of spec.series) if (s.id !== seriesId && !s.hidden && s.axis === "secondary" === secondary) candidates.push(s.values[index] ?? NaN);
+    candidates.push(series.values[index - 1] ?? NaN, series.values[index + 1] ?? NaN);
+  }
   controller.beginGesture(`drag:${seriesId}:${index}`);
   let ended = false;
   const [min, max] = scene.valueScale.domain;
+  const label = `Drag ${series.name}`;
   return {
     valueDomain: { min, max },
-    move(point) {
+    ...scene.valueScale2 ? { valueDomain2: { min: scene.valueScale2.domain[0], max: scene.valueScale2.domain[1] } } : {},
+    ...xy ? { xDomain: { min: scene.xScale.domain[0], max: scene.xScale.domain[1] } } : {},
+    target: { seriesId, index },
+    move(point, moveOptions = {}) {
       if (ended) return;
-      const at = chartValueAtPoint(scene, point);
+      const at = chartValueAtPoint(scene, point, secondary);
       if (at === void 0) return;
-      controller.setValue(seriesId, index, snapChartValue(scene, startValue + (at - startAt), options.step), { label: `Drag ${controller.getSeries(seriesId)?.name ?? "value"}` });
+      const factor = moveOptions.fine ? 0.1 : 1;
+      let dy = (at - startAt) * factor;
+      let dx = 0;
+      if (xy && startX !== null && startAtX !== void 0) {
+        const atX = chartXAtPoint(scene, point);
+        if (atX !== void 0) dx = (atX - startAtX) * factor;
+        if (moveOptions.lockAxis) {
+          if (Math.abs(point.x - start.x) >= Math.abs(point.y - start.y)) dy = 0;
+          else dx = 0;
+        }
+      }
+      const snap = (v, s, c) => {
+        if (moveOptions.noSnap) return Number(v.toPrecision(12));
+        if (moveOptions.fine) {
+          const unit = options.step ? options.step / 10 : s.ticks.length > 1 ? (s.ticks[1] - s.ticks[0]) / 100 : void 0;
+          return snapChartValue(scene, v, unit, s.ticks);
+        }
+        return snapChartDragValue(scene, v, { candidates: c, tolerancePx: options.tolerancePx, step: options.step, scale: s });
+      };
+      const y = snap(startValue + dy, scale, candidates);
+      if (xy && startX !== null) {
+        const x = dx !== 0 ? snap(startX + dx, scene.xScale, [0, startX]) : startX;
+        const xs = [...series.x ?? []];
+        xs[index] = x;
+        controller.setValue(seriesId, index, y, { label });
+        if (x !== controller.getSeries(seriesId)?.x?.[index]) controller.updateSeries(seriesId, { x: xs });
+      } else controller.setValue(seriesId, index, y, { label });
     },
     end() {
       if (ended) return;
       ended = true;
       controller.endGesture();
+    },
+    cancel() {
+      if (ended) return;
+      ended = true;
+      controller.cancelGesture();
     }
   };
 }
 function handleChartKey(controller, scene, event) {
-  if (event.metaKey || event.ctrlKey || event.altKey) return false;
-  const { selection, spec } = controller.getState();
+  if (event.metaKey || event.ctrlKey) return false;
+  const { selection, spec, gesture } = controller.getState();
   switch (event.key) {
     case "Escape":
+      if (gesture) {
+        controller.cancelGesture();
+        return true;
+      }
       if (!selection) return false;
       controller.select(null);
       return true;
     case "Delete":
     case "Backspace":
-      if (!selection || selection.kind === "chart") return false;
+      if (event.altKey || !selection || selection.kind === "chart") return false;
       controller.deleteSelection();
       return true;
     case "ArrowLeft":
     case "ArrowRight": {
-      if (selection?.kind !== "point" && selection?.kind !== "category") return false;
+      if (event.altKey || selection?.kind !== "point" && selection?.kind !== "category") return false;
       const n = spec.categories.length;
       const index = Math.max(0, Math.min(n - 1, selection.index + (event.key === "ArrowRight" ? 1 : -1)));
       controller.select({ ...selection, index });
@@ -1964,10 +681,11 @@ function handleChartKey(controller, scene, event) {
     case "ArrowUp":
     case "ArrowDown": {
       if (selection?.kind !== "point" || scene?.percent) return false;
-      const ticks = scene?.valueScale?.ticks ?? [];
+      const secondary = controller.getSeries(selection.seriesId)?.axis === "secondary";
+      const ticks = (secondary ? scene?.valueScale2 : null)?.ticks ?? scene?.valueScale?.ticks ?? [];
       const step = ticks.length > 1 ? ticks[1] - ticks[0] : 1;
-      const delta = (event.shiftKey ? step : step / 10) * (event.key === "ArrowUp" ? 1 : -1);
-      controller.nudgeValue(selection.seriesId, selection.index, delta);
+      const amount = event.shiftKey ? step : event.altKey ? step / 100 : step / 10;
+      controller.nudgeValue(selection.seriesId, selection.index, amount * (event.key === "ArrowUp" ? 1 : -1));
       return true;
     }
     default:
@@ -1987,68 +705,1097 @@ function describeChartSelection(controller, selection = controller.getState().se
     case "legend":
       return "Legend";
     case "axis":
-      return selection.axis === "x" ? "Category axis" : "Value axis";
+      return selection.axis === "x" ? chartFamily(spec) === "xy" ? "X axis" : "Category axis" : selection.axis === "y" ? "Value axis" : "Secondary value axis";
     case "series":
       return `Series "${controller.getSeries(selection.seriesId)?.name ?? selection.seriesId}"`;
     case "category":
       return `Category "${spec.categories[selection.index] ?? selection.index}"`;
+    case "trendline": {
+      const series = controller.getSeries(selection.seriesId);
+      const line = series?.trendlines?.[selection.index];
+      return `${line ? line.type.replace("-", " ") : "Trendline"} trendline on "${series?.name ?? selection.seriesId}"`;
+    }
     case "point": {
       const series = controller.getSeries(selection.seriesId);
       const value = series?.values[selection.index];
+      const x = series?.x?.[selection.index];
+      if (x !== void 0 && x !== null && chartFamily(spec) === "xy") return `${series?.name ?? selection.seriesId}: (${x}, ${value ?? "blank"})`;
       return `${series?.name ?? selection.seriesId} \xB7 ${spec.categories[selection.index] ?? selection.index}: ${value ?? "blank"}`;
     }
   }
 }
+function chartHitTest(scene, point, measure = (t, s, w = 400) => t.length * s * (w >= 600 ? 0.6 : 0.56)) {
+  for (let i = scene.marks.length - 1; i >= 0; i--) {
+    const m = scene.marks[i];
+    if (!m.target || m.role === "selection" || m.role === "background") continue;
+    let hit = false;
+    switch (m.kind) {
+      case "rect":
+        hit = point.x >= m.x && point.x <= m.x + m.width && point.y >= m.y && point.y <= m.y + m.height;
+        break;
+      case "circle":
+        hit = Math.hypot(point.x - m.cx, point.y - m.cy) <= Math.max(m.r, 4) + 2;
+        break;
+      case "line": {
+        const dx = m.x2 - m.x1;
+        const dy = m.y2 - m.y1;
+        const len2 = dx * dx + dy * dy;
+        const t = len2 ? Math.max(0, Math.min(1, ((point.x - m.x1) * dx + (point.y - m.y1) * dy) / len2)) : 0;
+        hit = Math.hypot(point.x - (m.x1 + t * dx), point.y - (m.y1 + t * dy)) <= 4;
+        break;
+      }
+      case "text": {
+        if (m.rotate) break;
+        const w = measure(m.text, m.size, m.weight);
+        const x0 = m.anchor === "start" ? m.x : m.anchor === "end" ? m.x - w : m.x - w / 2;
+        const y0 = m.baseline === "top" ? m.y : m.baseline === "bottom" ? m.y - m.size : m.y - m.size / 2;
+        hit = point.x >= x0 - 2 && point.x <= x0 + w + 2 && point.y >= y0 - 2 && point.y <= y0 + m.size + 2;
+        break;
+      }
+      default:
+        break;
+    }
+    if (hit) return m.target;
+  }
+  return point.x >= 0 && point.y >= 0 && point.x <= scene.width && point.y <= scene.height ? { kind: "chart" } : null;
+}
+
+// src/chart/tools.ts
+var READ = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false };
+var WRITE = { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false };
+var WRITE_IDEMPOTENT = { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false };
+var DESTRUCTIVE = { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false };
+var fail2 = (message) => {
+  throw new Error(message);
+};
+function resolve(result) {
+  if (!result.ok) fail2(result.message ?? "The change was rejected.");
+  return result;
+}
+function createChartToolProvider(controller, options = {}) {
+  const size = options.size ?? { width: 640, height: 400 };
+  const readOnlyReason = () => {
+    const r = typeof options.readOnly === "function" ? options.readOnly() : options.readOnly;
+    if (!r) return null;
+    return typeof r === "string" ? r : "This chart is read-only.";
+  };
+  const spec = () => controller.getSpec();
+  const seriesById = (ref) => {
+    const s = spec().series.find((x) => x.id === ref) ?? spec().series.find((x) => x.name === ref);
+    if (!s) fail2(`There is no series "${ref}"; expected one of ${spec().series.map((x) => `"${x.id}" (${x.name})`).join(", ") || "(none yet; add one with add_chart_series)"}.`);
+    return s;
+  };
+  const categoryIndex = (ref) => {
+    const categories = spec().categories;
+    const index = typeof ref === "number" ? ref : categories.indexOf(ref);
+    if (!Number.isInteger(index) || index < 0 || index >= categories.length)
+      fail2(`There is no category ${JSON.stringify(ref)}; expected an index from 0 to ${categories.length - 1} or one of ${categories.slice(0, 20).map((c) => JSON.stringify(c)).join(", ")}.`);
+    return index;
+  };
+  const table = () => chartDataToTable(spec());
+  const Parser = () => options.DOMParser ?? globalThis.DOMParser;
+  const getChart = {
+    name: "get_chart",
+    title: "Read the chart",
+    description: "Returns the chart spec (type, titles, axes, legend, series with ids and settings), its data as a table (header row of series names, then one row per category), the current selection, and a summary at the given size: per-series min / max / mean / trend, the axes as drawn, layout warnings (hidden labels, thinned lines), a colour check and a plain-language description. Use the series ids and category indexes it returns with the write tools.",
+    inputSchema: { type: "object", properties: { width: WIDTH, height: HEIGHT }, additionalProperties: false },
+    annotations: { title: "Read the chart", ...READ },
+    handler: ({ width = size.width, height = size.height }) => {
+      const reason = readOnlyReason();
+      return {
+        spec: controller.toJSON(),
+        table: table(),
+        selection: controller.getState().selection,
+        summary: summarizeChart(controller.toJSON(), { width, height }),
+        issues: controller.getState().issues,
+        ...reason ? { readOnly: reason } : {}
+      };
+    }
+  };
+  const renderChart = {
+    name: "render_chart",
+    title: "Render the chart",
+    description: 'Draws the chart without changing it, to check it visually: SVG text by default, or a PNG image (format "png") when the host can rasterize. Look for overlapping or hidden labels; get_chart lists layout warnings without a render.',
+    inputSchema: {
+      type: "object",
+      properties: { width: WIDTH, height: HEIGHT, format: { type: "string", enum: ["svg", "png"], description: "svg (default) or png (only when the host supports it)." } },
+      additionalProperties: false
+    },
+    annotations: { title: "Render the chart", ...READ },
+    handler: async ({ width = size.width, height = size.height, format = "svg" }) => {
+      const svg = chartToSvg(controller.toJSON(), { width, height });
+      if (format === "png") {
+        if (!options.rasterize) fail2('This host cannot rasterize charts; call render_chart with format "svg".');
+        const image = await options.rasterize(svg, { width, height });
+        return { content: [{ type: "image", data: image.data, mimeType: image.mimeType }], structuredContent: { width, height, mimeType: image.mimeType } };
+      }
+      return { svg, width, height };
+    }
+  };
+  const checkColors = {
+    name: "check_chart_colors",
+    title: "Check chart colours",
+    description: "Checks that colours can be told apart with normal vision and with protanopia, deuteranopia and tritanopia (OKLab distance after simulation), and that they stand out from the background. Checks the chart's own series (or slice) colours unless colours are given. Returns the closest pair per vision, contrast ratios and problems as sentences.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        colors: { type: "array", items: { type: "string" }, minItems: 1, description: "Colours to check instead of the chart's (hex or rgb())." },
+        surface: { type: "string", description: "Background colour (default white)." }
+      },
+      additionalProperties: false
+    },
+    annotations: { title: "Check chart colours", ...READ },
+    handler: ({ colors, surface }) => {
+      const s = spec();
+      const visible = s.series.filter((x) => !x.hidden);
+      const own = chartColorsByCategory(s.type) ? s.categories.map((_, i) => visible[0]?.pointColors?.[i] || chartSliceColor(s, i)) : visible.map((x) => chartSeriesColor(s, s.series.indexOf(x)));
+      return { colors: colors ?? own, ...checkChartColors(colors ?? own, { surface }) };
+    }
+  };
+  const recommend = {
+    name: "recommend_chart",
+    title: "Recommend chart types",
+    description: "Suggests chart types for data, best first, each with a reason: from CSV text when given, else from the chart's current data. Uses the shape of the data (series count, points, dates, negative values).",
+    inputSchema: { type: "object", properties: { csv: { type: "string", description: "CSV or TSV text to analyse instead of the current data (first row may be series names, first column categories)." } }, additionalProperties: false },
+    annotations: { title: "Recommend chart types", ...READ },
+    handler: ({ csv }) => {
+      const rows = csv !== void 0 ? parseCsv(csv, { delimiter: csv.includes("	") ? "	" : "," }) : table();
+      const recommendations = recommendChartTypes(rows);
+      if (!recommendations.length) fail2("There are no numbers to chart: give CSV with at least one numeric column.");
+      return { recommendations };
+    }
+  };
+  const getTrendline = {
+    name: "get_chart_trendline",
+    title: "Read a trendline fit",
+    description: "Returns a trendline's fitted coefficients (in x for category charts, x = 1, 2, 3, \u2026), R\xB2, equation and the number of points, or the moving-average points.",
+    inputSchema: {
+      type: "object",
+      properties: { series: SERIES_REF, index: { type: "integer", minimum: 0, description: "Trendline index on the series (0 = first)." } },
+      required: ["series", "index"],
+      additionalProperties: false
+    },
+    annotations: { title: "Read a trendline fit", ...READ },
+    handler: ({ series, index }) => {
+      const s = seriesById(series);
+      const line = s.trendlines?.[index];
+      if (!line) fail2(`"${s.name}" has no trendline ${index}; it has ${s.trendlines?.length ?? 0}.`);
+      if (line.type === "moving-average") return { trendline: line, points: controller.trendlineMovingAverage(s.id, index) };
+      const fit = controller.trendlineFit(s.id, index);
+      if (!fit) fail2(`The ${line.type} trendline on "${s.name}" cannot be fitted: it needs more points (and positive values for log, exponential and power fits).`);
+      return { trendline: line, coefficients: fit.coefficients, r2: fit.r2, equation: fit.equation, points: fit.points };
+    }
+  };
+  const listPresets = {
+    name: "list_chart_presets",
+    title: "List chart presets",
+    description: "Lists the quick layouts and colour schemes apply_chart_preset accepts, with what each changes.",
+    inputSchema: { type: "object", properties: {}, additionalProperties: false },
+    annotations: { title: "List chart presets", ...READ },
+    handler: () => ({
+      layouts: CHART_LAYOUT_PRESETS.map(({ id, label, description }) => ({ id, label, description })),
+      colorSchemes: CHART_COLOR_SCHEMES.map(({ id, label, description, palette }) => ({ id, label, description, palette }))
+    })
+  };
+  const exportMermaid = {
+    name: "export_chart_mermaid",
+    title: "Export chart as Mermaid",
+    description: 'Returns the chart as Mermaid text (xychart-beta, pie or radar-beta) for Markdown or chat. With meta (default true) one "%% @pixerate {\u2026}" comment keeps what Mermaid cannot express, so import_chart_mermaid gets the chart back exactly.',
+    inputSchema: { type: "object", properties: { meta: { type: "boolean", description: "Include the round-trip comment (default true)." } }, additionalProperties: false },
+    annotations: { title: "Export chart as Mermaid", ...READ },
+    handler: ({ meta = true }) => ({ mermaid: chartToMermaid(controller.toJSON(), { meta }) })
+  };
+  const exportOoxml = {
+    name: "export_chart_ooxml",
+    title: "Export chart as Office XML",
+    description: "Returns the chart as a DrawingML chart part (c:chartSpace) for Word or PowerPoint files, with what could not be written as sentences.",
+    inputSchema: { type: "object", properties: {}, additionalProperties: false },
+    annotations: { title: "Export chart as Office XML", ...READ },
+    handler: () => chartToOoxml(controller.toJSON())
+  };
+  const updateChart = {
+    name: "update_chart",
+    title: "Change chart presentation",
+    description: "Changes how the chart looks, as one undo step: type, titles, axes (xAxis = categories or numeric x, yAxis = values, yAxis2 = secondary values), legend, stacking, orientation, curve, points, data labels and their position, palette, donut hole, bar spacing, histogram bins, waterfall total. All-or-nothing: invalid values change nothing and come back as sentences. Returns the new spec.",
+    inputSchema: {
+      type: "object",
+      properties: CHART_UPDATE_PROPERTIES,
+      additionalProperties: false
+    },
+    annotations: { title: "Change chart presentation", ...WRITE_IDEMPOTENT },
+    handler: (args) => {
+      if (!Object.keys(args).length) fail2('Nothing to change: pass at least one field, e.g. {"type": "line"}.');
+      resolve(controller.update(args));
+      return { spec: controller.toJSON() };
+    }
+  };
+  const setData = {
+    name: "set_chart_data",
+    title: "Replace chart data",
+    description: "Replaces the categories and / or the series as one undo step. Each series has one value per category (padded with gaps). Returns the data table and the series ids.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        categories: { type: "array", items: { type: "string" }, description: "Category labels in order." },
+        series: {
+          type: "array",
+          description: "The new series (replaces all).",
+          items: { type: "object", properties: { id: { type: "string", description: "Stable id (optional)." }, ...SERIES_PROPS }, required: ["name", "values"], additionalProperties: false }
+        }
+      },
+      additionalProperties: false
+    },
+    annotations: { title: "Replace chart data", ...DESTRUCTIVE },
+    handler: (args) => {
+      if (!args.categories && !args.series) fail2("Pass categories, series or both.");
+      resolve(controller.setData(args));
+      return { table: table(), series: spec().series.map((s) => ({ id: s.id, name: s.name })) };
+    }
+  };
+  const setValues = {
+    name: "set_chart_values",
+    title: "Set chart values",
+    description: "Sets individual values as one undo step (all-or-nothing). Series by id or name, category by index or label. Returns the values as stored.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        cells: {
+          type: "array",
+          minItems: 1,
+          description: "Values to set.",
+          items: { type: "object", properties: { series: SERIES_REF, category: CATEGORY_REF, value: VALUE }, required: ["series", "category", "value"], additionalProperties: false }
+        }
+      },
+      required: ["cells"],
+      additionalProperties: false
+    },
+    annotations: { title: "Set chart values", ...WRITE_IDEMPOTENT },
+    handler: async ({ cells }) => {
+      const resolved = cells.map((c) => ({ seriesId: seriesById(c.series).id, index: categoryIndex(c.category), value: c.value }));
+      const parsed = resolved.map((c) => parseChartValue(c.value));
+      const bad = resolved.find((_, i) => parsed[i] === void 0);
+      if (bad) fail2(`"${String(bad.value)}" is not a number; pass a number, numeric text or null for a gap. Nothing was changed.`);
+      if (options.director && parsed.every((v) => typeof v === "number")) {
+        const results = await options.director.perform(options.actor ?? { id: "agent", name: "Agent" }, resolved.map((c, i) => ({ kind: "setValue", seriesId: c.seriesId, index: c.index, value: parsed[i] })));
+        const failed = results.find((r) => !r.ok);
+        if (failed && !failed.ok) fail2(failed.message);
+      } else resolve(controller.setValues(resolved));
+      return { cells: resolved.map((c) => ({ series: c.seriesId, category: spec().categories[c.index], index: c.index, value: controller.getSeries(c.seriesId).values[c.index] })) };
+    }
+  };
+  const addSeries = {
+    name: "add_chart_series",
+    title: "Add a series",
+    description: "Adds a series (values padded to the categories) and selects it. Returns its id and stored values.",
+    inputSchema: {
+      type: "object",
+      properties: { ...SERIES_PROPS, id: { type: "string", description: "Id to use (default: series-N)." }, at: { type: "integer", minimum: 0, description: "Position (default: last)." } },
+      required: ["name"],
+      additionalProperties: false
+    },
+    annotations: { title: "Add a series", ...WRITE },
+    handler: ({ at, ...input }) => {
+      const clean = Object.fromEntries(Object.entries(input).filter(([, v]) => v !== null));
+      const result = resolve(controller.addSeries(clean, { at }));
+      const s = controller.getSeries(result.id);
+      return { id: s.id, name: s.name, values: s.values };
+    }
+  };
+  const updateSeries = {
+    name: "update_chart_series",
+    title: "Change a series",
+    description: "Renames, recolours, hides, moves to the secondary axis or changes how a series is drawn (marker, curve, labels, format, x values, bubble sizes, point colours). null resets a field. Values change with set_chart_values. Returns the series.",
+    inputSchema: {
+      type: "object",
+      properties: { series: SERIES_REF, ...Object.fromEntries(Object.entries(SERIES_PROPS).filter(([k]) => k !== "values")) },
+      required: ["series"],
+      additionalProperties: false
+    },
+    annotations: { title: "Change a series", ...WRITE_IDEMPOTENT },
+    handler: ({ series, ...patch }) => {
+      const id = seriesById(series).id;
+      if (!Object.keys(patch).length) fail2('Nothing to change: pass a field such as {"color": "#e8710a"} or {"axis": "secondary"}.');
+      resolve(controller.updateSeries(id, patch));
+      return { series: controller.getSeries(id) };
+    }
+  };
+  const removeSeries = {
+    name: "remove_chart_series",
+    title: "Delete a series",
+    description: "Deletes a series and its values. Returns the remaining series ids.",
+    inputSchema: { type: "object", properties: { series: SERIES_REF }, required: ["series"], additionalProperties: false },
+    annotations: { title: "Delete a series", ...DESTRUCTIVE },
+    handler: ({ series }) => {
+      resolve(controller.removeSeries(seriesById(series).id));
+      return { series: spec().series.map((s) => ({ id: s.id, name: s.name })) };
+    }
+  };
+  const addCategory = {
+    name: "add_chart_category",
+    title: "Add a category",
+    description: "Inserts a category (a gap in every series) and returns its index.",
+    inputSchema: {
+      type: "object",
+      properties: { label: { type: "string", description: "Category label (default: its number)." }, at: { type: "integer", minimum: 0, description: "Index to insert at (default: the end)." } },
+      additionalProperties: false
+    },
+    annotations: { title: "Add a category", ...WRITE },
+    handler: ({ label, at }) => {
+      const result = controller.addCategory(label, { at });
+      return { index: result.index, categories: spec().categories };
+    }
+  };
+  const removeCategory = {
+    name: "remove_chart_category",
+    title: "Delete a category",
+    description: "Deletes a category and its value in every series. Returns the remaining categories.",
+    inputSchema: { type: "object", properties: { category: CATEGORY_REF }, required: ["category"], additionalProperties: false },
+    annotations: { title: "Delete a category", ...DESTRUCTIVE },
+    handler: ({ category }) => {
+      resolve(controller.removeCategory(categoryIndex(category)));
+      return { categories: spec().categories };
+    }
+  };
+  const importCsv = {
+    name: "import_chart_csv",
+    title: "Import chart data from CSV",
+    description: 'Replaces the data with CSV or TSV text as one undo step. By default the first row holds series names and the first column categories (detected when "auto"). chartType "auto" also picks the recommended chart type (two unlabelled numeric columns become a scatter of x against y). Returns the data table, the chart type and cells that were not numbers.',
+    inputSchema: {
+      type: "object",
+      properties: {
+        csv: { type: "string", description: "CSV or TSV text (tabs are detected)." },
+        seriesIn: { type: "string", enum: ["columns", "rows"], description: 'Series run down columns (default) or along rows. Ignored with chartType "auto".' },
+        header: { type: ["boolean", "string"], enum: [true, false, "auto"], description: 'The first row holds series names: true (default), false or "auto". Ignored with chartType "auto".' },
+        chartType: { type: "string", enum: ["keep", "auto"], description: '"keep" (default) keeps the chart type; "auto" reads the table shape and picks a type.' }
+      },
+      required: ["csv"],
+      additionalProperties: false
+    },
+    annotations: { title: "Import chart data from CSV", ...DESTRUCTIVE },
+    handler: ({ csv, seriesIn, header, chartType = "keep" }) => {
+      if (chartType === "auto") {
+        const rows = parseCsv(csv, { delimiter: csv.includes("	") ? "	" : "," });
+        const built = chartFromTable(rows);
+        if (!built.series.length || !built.categories.length) fail2("There is no data to import: expected at least one row of numbers.");
+        resolve(controller.update({ type: built.type, stacking: built.stacking, categories: built.categories, series: built.series }, { label: "Import data" }));
+        return { type: built.type, table: table(), issues: built.issues };
+      }
+      const result = resolve(controller.importCsv(csv, { seriesIn, header }));
+      return { type: spec().type, table: table(), issues: result.issues ?? [] };
+    }
+  };
+  const importMermaid = {
+    name: "import_chart_mermaid",
+    title: "Import a Mermaid chart",
+    description: 'Replaces the chart with Mermaid xychart-beta, pie or radar-beta text as one undo step (a "%% @pixerate" comment from export_chart_mermaid restores everything else). Lines that cannot be read are skipped and listed with their line numbers. Returns the spec.',
+    inputSchema: { type: "object", properties: { mermaid: { type: "string", description: "Mermaid text, optionally inside a ```mermaid fence." } }, required: ["mermaid"], additionalProperties: false },
+    annotations: { title: "Import a Mermaid chart", ...DESTRUCTIVE },
+    handler: ({ mermaid }) => {
+      const fenced = /```(?:mermaid)?\s*\n([\s\S]*?)```/.exec(mermaid);
+      const read = chartFromMermaid(fenced ? fenced[1] : mermaid);
+      if (!read.family) fail2(read.issues.map((i) => i.message).join(" ") || "Expected Mermaid starting with xychart-beta, pie or radar-beta.");
+      resolve(controller.update({ ...read.spec }, { label: "Import Mermaid chart" }));
+      return { spec: controller.toJSON(), issues: read.issues };
+    }
+  };
+  const importOoxml = {
+    name: "import_chart_ooxml",
+    title: "Import an Office chart",
+    description: "Replaces the chart with an Office chart part (DrawingML c:chartSpace, or chartex for waterfall, funnel, treemap, histogram and box charts) as one undo step. Returns the spec, problems, and the features the editor cannot hold.",
+    inputSchema: { type: "object", properties: { xml: { type: "string", description: "The chart part XML, e.g. word/charts/chart1.xml." } }, required: ["xml"], additionalProperties: false },
+    annotations: { title: "Import an Office chart", ...DESTRUCTIVE },
+    handler: ({ xml }) => {
+      const read = chartFromOoxml(xml, { DOMParser: Parser() });
+      if (read.issues.some((i) => i.path === "" || i.path === "plotArea")) fail2(read.issues.map((i) => i.message).join(" "));
+      resolve(controller.update({ ...read.spec }, { label: "Import Office chart" }));
+      return { spec: controller.toJSON(), issues: read.issues.map((i) => i.message), unsupported: read.unsupported, lossless: read.lossless };
+    }
+  };
+  const addTrendline = {
+    name: "add_chart_trendline",
+    title: "Add a trendline",
+    description: "Fits a trendline to a series and draws it (unstacked bar, line, area, scatter and bubble charts). Returns its index and the fit: coefficients, R\xB2 and equation.",
+    inputSchema: { type: "object", properties: { series: SERIES_REF, ...TRENDLINE_PROPS }, required: ["series", "type"], additionalProperties: false },
+    annotations: { title: "Add a trendline", ...WRITE },
+    handler: ({ series, ...line }) => {
+      const s = seriesById(series);
+      const result = resolve(controller.addTrendline(s.id, line));
+      return { series: s.id, index: result.index, ...result.fit ? { coefficients: result.fit.coefficients, r2: result.fit.r2, equation: result.fit.equation } : {} };
+    }
+  };
+  const removeTrendline = {
+    name: "remove_chart_trendline",
+    title: "Delete a trendline",
+    description: "Deletes a trendline from a series. Returns the series' remaining trendlines.",
+    inputSchema: {
+      type: "object",
+      properties: { series: SERIES_REF, index: { type: "integer", minimum: 0, description: "Trendline index on the series (0 = first)." } },
+      required: ["series", "index"],
+      additionalProperties: false
+    },
+    annotations: { title: "Delete a trendline", ...DESTRUCTIVE },
+    handler: ({ series, index }) => {
+      const s = seriesById(series);
+      resolve(controller.removeTrendline(s.id, index));
+      return { series: s.id, trendlines: controller.getSeries(s.id)?.trendlines ?? [] };
+    }
+  };
+  const applyPreset = {
+    name: "apply_chart_preset",
+    title: "Apply a chart style",
+    description: "Applies a quick layout (legend, labels and grid lines together) and / or a colour scheme as one undo step. See list_chart_presets for the names. Returns the new spec.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        layout: { type: "string", enum: CHART_LAYOUT_PRESETS.map((p) => p.id), description: "Quick layout id." },
+        colors: { type: "string", enum: CHART_COLOR_SCHEMES.map((p) => p.id), description: "Colour scheme id." }
+      },
+      additionalProperties: false
+    },
+    annotations: { title: "Apply a chart style", ...WRITE_IDEMPOTENT },
+    handler: ({ layout, colors }) => {
+      resolve(controller.applyPreset({ layout, colors }));
+      return { spec: controller.toJSON() };
+    }
+  };
+  const transpose = {
+    name: "transpose_chart",
+    title: "Switch rows and columns",
+    description: "Swaps series and categories (each category becomes a series) as one undo step. Per-series colours and settings are dropped. Returns the data table.",
+    inputSchema: { type: "object", properties: {}, additionalProperties: false },
+    annotations: { title: "Switch rows and columns", ...WRITE },
+    handler: () => {
+      resolve(controller.transpose());
+      return { table: table(), series: spec().series.map((s) => ({ id: s.id, name: s.name })) };
+    }
+  };
+  const select = {
+    name: "select_chart_element",
+    title: "Select a chart element",
+    description: 'Selects part of the chart (as a click would), for press_chart_key and for the user to see. kind "none" clears the selection. Returns the selection.',
+    inputSchema: {
+      type: "object",
+      properties: {
+        kind: { type: "string", enum: ["none", "chart", "title", "subtitle", "legend", "axis", "series", "point", "category", "trendline"], description: "What to select." },
+        series: { ...SERIES_REF, description: "Series id or name (series, point, trendline)." },
+        category: { ...CATEGORY_REF, description: "Category index or label (point, category)." },
+        axis: { type: "string", enum: ["x", "y", "y2"], description: "Axis (axis)." },
+        index: { type: "integer", minimum: 0, description: "Trendline index (trendline)." }
+      },
+      required: ["kind"],
+      additionalProperties: false
+    },
+    annotations: { title: "Select a chart element", ...WRITE_IDEMPOTENT },
+    handler: async ({ kind, series, category, axis, index }) => {
+      let sel;
+      const need = (v, what) => v === void 0 && fail2(`kind "${kind}" needs ${what}.`);
+      switch (kind) {
+        case "none":
+          sel = null;
+          break;
+        case "axis":
+          need(axis, "axis");
+          sel = { kind, axis };
+          break;
+        case "series":
+          need(series, "series");
+          sel = { kind, seriesId: seriesById(series).id };
+          break;
+        case "point":
+          need(series, "series");
+          need(category, "category");
+          sel = { kind, seriesId: seriesById(series).id, index: categoryIndex(category) };
+          break;
+        case "category":
+          need(category, "category");
+          sel = { kind, index: categoryIndex(category) };
+          break;
+        case "trendline":
+          need(series, "series");
+          need(index, "index");
+          sel = { kind, seriesId: seriesById(series).id, index };
+          break;
+        default:
+          sel = { kind };
+      }
+      if (options.director) await options.director.perform(options.actor ?? { id: "agent", name: "Agent" }, [{ kind: "select", selection: sel }]);
+      else controller.select(sel);
+      const now = controller.getState().selection;
+      if (sel && !now) fail2(`Nothing to select there (e.g. the chart has no ${kind} of that kind).`);
+      return { selection: now };
+    }
+  };
+  const drag = {
+    name: "drag_chart_point",
+    title: "Drag a chart point",
+    description: "Drags on the chart as a pointer would, through the same code as the mouse: from a bar or point to a new position, with the same snapping (to other values, zero and ticks), fine adjustment (fine: Alt) and axis lock on scatter charts (lockAxis: Shift). Positions are 0\u20131 fractions of the chart's width and height at the given size (use render_chart to see where marks are). One undo step. Returns what was dragged and the value before and after.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        from: { type: "object", description: "Start, as fractions of the chart (0,0 top-left).", properties: { x: { type: "number", minimum: 0, maximum: 1, description: "Fraction of the width." }, y: { type: "number", minimum: 0, maximum: 1, description: "Fraction of the height." } }, required: ["x", "y"], additionalProperties: false },
+        to: { type: "object", description: "End, as fractions of the chart.", properties: { x: { type: "number", minimum: 0, maximum: 1, description: "Fraction of the width." }, y: { type: "number", minimum: 0, maximum: 1, description: "Fraction of the height." } }, required: ["x", "y"], additionalProperties: false },
+        fine: { type: "boolean", description: "Move a tenth as far (Alt)." },
+        lockAxis: { type: "boolean", description: "Scatter charts: change only the axis moved along most (Shift)." },
+        width: WIDTH,
+        height: HEIGHT
+      },
+      required: ["from", "to"],
+      additionalProperties: false
+    },
+    annotations: { title: "Drag a chart point", ...WRITE },
+    handler: ({ from, to, fine, lockAxis, width = size.width, height = size.height }) => {
+      const scene = layoutChart(controller.toJSON(), { width, height });
+      const start = { x: from.x * width, y: from.y * height };
+      const target = chartHitTest(scene, start);
+      if (target?.kind !== "point") fail2(`There is no bar or point at (${from.x}, ${from.y}); ${target ? `that is the ${target.kind}` : "that is outside the chart"}. Use render_chart to find marks.`);
+      const t = target;
+      const before = controller.getSeries(t.seriesId)?.values[t.index] ?? null;
+      const session = startChartPointDrag(controller, scene, t, start);
+      if (!session) fail2("That point cannot be dragged here (percent-stacked charts, pies and gaps cannot be dragged).");
+      session.move({ x: to.x * width, y: to.y * height }, { fine, lockAxis });
+      session.end();
+      const s = controller.getSeries(t.seriesId);
+      return { series: s.id, category: spec().categories[t.index], index: t.index, before, after: s.values[t.index], ...s.x ? { x: s.x[t.index] } : {} };
+    }
+  };
+  const key = {
+    name: "press_chart_key",
+    title: "Press a key on the chart",
+    description: "Sends a key to the chart as the keyboard would, acting on the selection (select_chart_element first): \u2190 \u2192 move between categories, \u2191 \u2193 change the selected value by a tenth of a tick (shift: a whole tick, alt: a hundredth), Delete removes the selection, Escape clears it. Returns whether the key did anything and the new selection.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        key: { type: "string", enum: ["ArrowLeft", "ArrowRight", "ArrowUp", "ArrowDown", "Delete", "Backspace", "Escape"], description: "Key name." },
+        shift: { type: "boolean", description: "Hold Shift." },
+        alt: { type: "boolean", description: "Hold Alt / Option." }
+      },
+      required: ["key"],
+      additionalProperties: false
+    },
+    annotations: { title: "Press a key on the chart", ...DESTRUCTIVE },
+    handler: ({ key: k, shift, alt }) => {
+      const scene = layoutChart(controller.toJSON(), size);
+      const used = handleChartKey(controller, scene, { key: k, shiftKey: shift, altKey: alt });
+      const sel = controller.getState().selection;
+      const value = sel?.kind === "point" ? controller.getSeries(sel.seriesId)?.values[sel.index] ?? null : void 0;
+      return { used, selection: sel, ...value !== void 0 ? { value } : {} };
+    }
+  };
+  const undo = {
+    name: "undo_chart",
+    title: "Undo a chart edit",
+    description: "Undoes the last chart edit. Returns whether something was undone and what the next undo would be.",
+    inputSchema: { type: "object", properties: {}, additionalProperties: false },
+    annotations: { title: "Undo a chart edit", ...WRITE },
+    handler: () => {
+      const label = controller.getState().undoLabel;
+      const undone = controller.undo();
+      return { undone, ...undone ? { label } : {}, next: controller.getState().undoLabel || null };
+    }
+  };
+  const redo = {
+    name: "redo_chart",
+    title: "Redo a chart edit",
+    description: "Redoes the last undone chart edit. Returns whether something was redone.",
+    inputSchema: { type: "object", properties: {}, additionalProperties: false },
+    annotations: { title: "Redo a chart edit", ...WRITE },
+    handler: () => {
+      const label = controller.getState().redoLabel;
+      const redone = controller.redo();
+      return { redone, ...redone ? { label } : {} };
+    }
+  };
+  const reads = [getChart, renderChart, checkColors, recommend, getTrendline, listPresets, exportMermaid, exportOoxml];
+  const writes = [updateChart, setData, setValues, addSeries, updateSeries, removeSeries, addCategory, removeCategory, importCsv, importMermaid, addTrendline, removeTrendline, applyPreset, transpose, select, drag, key, undo, redo];
+  return {
+    id: options.id ?? "chart",
+    namespace: options.namespace,
+    tools: () => {
+      if (readOnlyReason()) return reads;
+      return [...reads, ...writes.slice(0, 10), ...Parser() ? [importOoxml] : [], ...writes.slice(10)];
+    },
+    subscribe: (notify) => {
+      let last = readOnlyReason();
+      return controller.subscribe(() => {
+        const now = readOnlyReason();
+        if (now !== last) {
+          last = now;
+          notify();
+        }
+      });
+    }
+  };
+}
+
+// src/chart/stream.ts
+function parsePartialChartJson(text) {
+  const src = text.trim();
+  if (!src) return void 0;
+  try {
+    return JSON.parse(src);
+  } catch {
+  }
+  const stack = [];
+  let inString = false;
+  let escaped = false;
+  let out = "";
+  for (const ch of src) {
+    out += ch;
+    if (inString) {
+      if (escaped) escaped = false;
+      else if (ch === "\\") escaped = true;
+      else if (ch === '"') inString = false;
+      continue;
+    }
+    if (ch === '"') inString = true;
+    else if (ch === "{" || ch === "[") stack.push(ch === "{" ? "}" : "]");
+    else if (ch === "}" || ch === "]") stack.pop();
+  }
+  if (inString) out += '"';
+  for (let attempt = 0; attempt < 6; attempt++) {
+    const trimmed = out.replace(/\s+$/, "");
+    const candidate = trimmed + [...stack].reverse().join("");
+    try {
+      return JSON.parse(candidate);
+    } catch {
+      const next = trimmed.replace(/,\s*$/, "").replace(/(?:,|\{)\s*"[^"]*"\s*:?\s*$/, (m) => m.trim().startsWith("{") ? "{" : "").replace(/:\s*$/, ": null").replace(/(?<=[\[,:]\s*)(-|tr?u?|fa?l?s?|nu?l?)$/, "").replace(/(?<=[\[,:]\s*)(-?\d+\.)$/, (m) => m.slice(0, -1));
+      if (next === trimmed) break;
+      out = next;
+    }
+  }
+  return void 0;
+}
+var ChartStream = class {
+  constructor(format = "auto") {
+    this.format = format;
+  }
+  format;
+  lo = Infinity;
+  hi = -Infinity;
+  last = null;
+  /** Reads the source so far. `complete` when nothing more will arrive. */
+  update(source, complete = false) {
+    const text = source.replace(/^\s*```(?:mermaid|json)?\s*\n?/, "").replace(/```\s*$/, "");
+    const format = this.format === "auto" ? /^\s*[[{]/.test(text) ? "json" : "mermaid" : this.format;
+    let spec = null;
+    let issues = [];
+    if (format === "json") {
+      const value = complete ? safeParse(text) : parsePartialChartJson(text);
+      if (value !== void 0) {
+        const read = normalizeChartSpec(value);
+        spec = read.spec;
+        issues = complete ? read.issues : [];
+      }
+    } else {
+      const read = chartFromMermaid(text, { partial: !complete });
+      if (read.family) {
+        spec = read.spec;
+        issues = complete ? read.issues : [];
+      }
+    }
+    if (spec && !spec.series.some((s) => s.values.some((v) => v !== null))) spec = complete ? spec : this.last;
+    if (spec) this.last = spec;
+    if (spec) {
+      for (const s of spec.series) for (const v of s.values) if (v !== null && Number.isFinite(v)) this.lo = Math.min(this.lo, v), this.hi = Math.max(this.hi, v);
+    }
+    const valueDomain = !complete && Number.isFinite(this.lo) && this.hi > this.lo ? { min: Math.min(0, this.lo), max: this.hi } : null;
+    return { spec, issues, valueDomain };
+  }
+  /** Forgets the axis bounds (a new source). */
+  reset() {
+    this.lo = Infinity;
+    this.hi = -Infinity;
+    this.last = null;
+  }
+};
+function safeParse(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return parsePartialChartJson(text);
+  }
+}
+var mix = (a, b, t) => a + (b - a) * t;
+function blendPath(a, b, t) {
+  const na = a.match(/-?\d*\.?\d+(?:e-?\d+)?/g);
+  const nb = b.match(/-?\d*\.?\d+(?:e-?\d+)?/g);
+  if (!na || !nb || na.length !== nb.length || a.replace(/-?\d*\.?\d+(?:e-?\d+)?/g, "#") !== b.replace(/-?\d*\.?\d+(?:e-?\d+)?/g, "#")) return t < 1 ? a : b;
+  let i = 0;
+  return b.replace(/-?\d*\.?\d+(?:e-?\d+)?/g, () => {
+    const v = mix(Number(na[i]), Number(nb[i]), t);
+    i++;
+    return String(Math.round(v * 100) / 100);
+  });
+}
+function blendChartScenes(from, to, t) {
+  if (!from || t >= 1) return to;
+  const k = Math.max(0, Math.min(1, t));
+  const before = new Map(from.marks.map((m) => [m.key, m]));
+  const marks = to.marks.map((m) => {
+    const a = before.get(m.key);
+    if (!a || a.kind !== m.kind) return { ...m, opacity: (m.opacity ?? 1) * k };
+    switch (m.kind) {
+      case "rect": {
+        const p = a;
+        return { ...m, x: mix(p.x, m.x, k), y: mix(p.y, m.y, k), width: mix(p.width, m.width, k), height: mix(p.height, m.height, k) };
+      }
+      case "circle": {
+        const p = a;
+        return { ...m, cx: mix(p.cx, m.cx, k), cy: mix(p.cy, m.cy, k), r: mix(p.r, m.r, k) };
+      }
+      case "line": {
+        const p = a;
+        return { ...m, x1: mix(p.x1, m.x1, k), y1: mix(p.y1, m.y1, k), x2: mix(p.x2, m.x2, k), y2: mix(p.y2, m.y2, k) };
+      }
+      case "text": {
+        const p = a;
+        return { ...m, x: mix(p.x, m.x, k), y: mix(p.y, m.y, k) };
+      }
+      case "path":
+        return { ...m, d: blendPath(a.d, m.d, k) };
+    }
+  });
+  return { ...to, marks };
+}
+var easeChartTween = (t) => 1 - Math.pow(1 - Math.max(0, Math.min(1, t)), 3);
+
+// src/chart/presence.ts
+var ChartPresence = class {
+  state = { actors: [] };
+  listeners = /* @__PURE__ */ new Set();
+  getState = () => this.state;
+  subscribe = (listener) => {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  };
+  /** Adds or changes an actor. */
+  set(actor) {
+    const current = this.state.actors.find((a) => a.id === actor.id);
+    const next = { name: actor.id, color: CHART_PRESENCE_COLORS[this.state.actors.length % CHART_PRESENCE_COLORS.length], x: 0, y: 0, pressed: false, ...current, ...actor };
+    this.state = { actors: current ? this.state.actors.map((a) => a.id === actor.id ? next : a) : [...this.state.actors, next] };
+    this.listeners.forEach((l) => l(this.state));
+  }
+  remove(id) {
+    if (!this.state.actors.some((a) => a.id === id)) return;
+    this.state = { actors: this.state.actors.filter((a) => a.id !== id) };
+    this.listeners.forEach((l) => l(this.state));
+  }
+};
+var CHART_PRESENCE_COLORS = ["#7c3aed", "#db2777", "#0891b2", "#ea580c", "#16a34a"];
+var realChartClock = {
+  now: () => Date.now(),
+  wait: (ms) => new Promise((resolve2) => setTimeout(resolve2, Math.max(0, ms)))
+};
+function createInstantChartClock(start = 0) {
+  let t = start;
+  return {
+    now: () => t,
+    wait: async (ms) => {
+      t += Math.max(0, ms);
+    },
+    elapsed: () => t - start
+  };
+}
+function chartPointAnchor(scene, seriesId, index) {
+  const mark = scene.marks.find((m) => (m.role === "bar" || m.role === "point") && m.target?.kind === "point" && m.target.seriesId === seriesId && m.target.index === index);
+  if (!mark) return null;
+  if (mark.kind === "rect") return { x: mark.x + mark.width / 2, y: mark.y };
+  if (mark.kind === "circle") return { x: mark.cx, y: mark.cy };
+  return null;
+}
+var anchorFor = (scene, role) => {
+  const m = scene.marks.find((x) => x.role === role);
+  if (!m) return null;
+  if (m.kind === "text") return { x: m.x, y: m.y };
+  if (m.kind === "rect") return { x: m.x + m.width / 2, y: m.y + m.height / 2 };
+  if (m.kind === "line") return { x: (m.x1 + m.x2) / 2, y: (m.y1 + m.y2) / 2 };
+  return null;
+};
+function planChartCommand(spec, scene, command, speed = 1) {
+  const ms = (n) => Math.round(n / Math.max(0.1, speed));
+  const steps = [];
+  const note = "note" in command && command.note ? command.note : void 0;
+  if (note) steps.push({ type: "say", text: note, ms: ms(500) });
+  switch (command.kind) {
+    case "say":
+      steps.push({ type: "say", text: command.text, ms: ms(900) });
+      return steps;
+    case "setValue": {
+      const at = chartPointAnchor(scene, command.seriesId, command.index);
+      const series = spec.series.find((s) => s.id === command.seriesId);
+      const from = series?.values[command.index] ?? 0;
+      const scale = series?.axis === "secondary" ? scene.valueScale2 ?? scene.valueScale : scene.valueScale;
+      if (at && scale) {
+        const px = linearMap(command.value, scale.domain, scale.range);
+        const to = scale.axis === "y" ? { x: at.x, y: px } : { x: px, y: at.y };
+        steps.push({ type: "move", to: at, ms: ms(380) }, { type: "press" }, { type: "drag", to, ms: ms(520), from, value: command.value }, { type: "release" });
+      } else steps.push({ type: "drag", to: { x: scene.plot.x + scene.plot.width / 2, y: scene.plot.y + scene.plot.height / 2 }, ms: ms(200), from, value: command.value });
+      steps.push({ type: "commit" });
+      return steps;
+    }
+    case "select": {
+      const sel = command.selection;
+      let to = null;
+      if (sel?.kind === "point") to = chartPointAnchor(scene, sel.seriesId, sel.index);
+      else if (sel) {
+        const m = scene.marks.find((x) => x.target && JSON.stringify(x.target) === JSON.stringify(sel));
+        if (m?.kind === "text") to = { x: m.x, y: m.y };
+        else if (m?.kind === "rect") to = { x: m.x + m.width / 2, y: m.y + m.height / 2 };
+        else if (m?.kind === "circle") to = { x: m.cx, y: m.cy };
+      }
+      if (to) steps.push({ type: "move", to, ms: ms(380) }, { type: "press" }, { type: "release" });
+      steps.push({ type: "commit" });
+      return steps;
+    }
+    case "update": {
+      const keys = Object.keys(command.patch);
+      const role = keys.includes("title") ? "title" : keys.includes("legend") ? "legend-label" : keys.some((k) => k === "xAxis") ? "axis" : keys.some((k) => k === "yAxis" || k === "yAxis2") ? "tick-label" : null;
+      const to = role && anchorFor(scene, role) || { x: scene.plot.x + scene.plot.width / 2, y: scene.plot.y + 12 };
+      steps.push({ type: "move", to, ms: ms(380) }, { type: "press" }, { type: "release" }, { type: "commit" });
+      return steps;
+    }
+  }
+}
+var ChartDirector = class {
+  constructor(controller, presence, options) {
+    this.controller = controller;
+    this.presence = presence;
+    this.options = options;
+    this.clock = options.clock ?? realChartClock;
+  }
+  controller;
+  presence;
+  options;
+  queues = /* @__PURE__ */ new Map();
+  clock;
+  calls = 0;
+  /** Acts out `commands` in order for `actor`. Resolves with one result per command. */
+  perform(actor, commands) {
+    const prev = this.queues.get(actor.id) ?? Promise.resolve();
+    const run = prev.then(async () => {
+      const results = [];
+      this.presence.set({ id: actor.id, ...actor.name ? { name: actor.name } : {}, ...actor.color ? { color: actor.color } : {} });
+      this.controller.beginGesture(`agent:${actor.id}:${++this.calls}`);
+      try {
+        for (const command of commands) results.push(await this.performOne(actor.id, command));
+      } finally {
+        this.controller.endGesture();
+        this.presence.set({ id: actor.id, message: void 0, pressed: false });
+      }
+      const linger = this.options.linger ?? 1500;
+      if (linger > 0) {
+        await this.clock.wait(linger);
+        if (this.queues.get(actor.id) === run) this.presence.remove(actor.id);
+      }
+      return results;
+    });
+    this.queues.set(actor.id, run.catch(() => void 0));
+    return run;
+  }
+  stale(command) {
+    const spec = this.controller.getSpec();
+    if (command.kind === "setValue") {
+      const s = spec.series.find((x) => x.id === command.seriesId);
+      if (!s) return `The series "${command.seriesId}" no longer exists.`;
+      if (command.index < 0 || command.index >= spec.categories.length) return `Category ${command.index} no longer exists.`;
+      if (!Number.isFinite(command.value)) return "The value must be a finite number.";
+    }
+    return null;
+  }
+  async move(id, from, to, ms, each) {
+    const frames = Math.max(1, Math.round(ms / 16));
+    for (let f = 1; f <= frames; f++) {
+      const t = f / frames;
+      const e = 1 - Math.pow(1 - t, 3);
+      this.presence.set({ id, x: from.x + (to.x - from.x) * e, y: from.y + (to.y - from.y) * e });
+      each?.(e);
+      await this.clock.wait(ms / frames);
+    }
+  }
+  async performOne(id, command) {
+    const stale = this.stale(command);
+    if (stale) return { ok: false, command, message: stale };
+    const steps = planChartCommand(this.controller.getSpec(), this.options.scene(), command, this.options.speed);
+    const where = () => {
+      const a = this.presence.getState().actors.find((x) => x.id === id);
+      return { x: a.x, y: a.y };
+    };
+    {
+      for (const step of steps) {
+        switch (step.type) {
+          case "say":
+            this.presence.set({ id, message: step.text });
+            await this.clock.wait(step.ms);
+            break;
+          case "move":
+            await this.move(id, where(), step.to, step.ms);
+            break;
+          case "press":
+            this.presence.set({ id, pressed: true });
+            break;
+          case "release":
+            this.presence.set({ id, pressed: false });
+            break;
+          case "drag": {
+            if (command.kind !== "setValue") break;
+            const stale2 = this.stale(command);
+            if (stale2) return { ok: false, command, message: stale2 };
+            const label = `${this.presence.getState().actors.find((a) => a.id === id)?.name ?? "Agent"}: edit value`;
+            await this.move(id, where(), step.to, step.ms, (e) => {
+              const v = step.from + (step.value - step.from) * e;
+              this.controller.setValue(command.seriesId, command.index, Number(v.toPrecision(12)), { label });
+            });
+            this.controller.setValue(command.seriesId, command.index, step.value, { label });
+            break;
+          }
+          case "commit": {
+            if (command.kind === "select") this.controller.select(command.selection);
+            else if (command.kind === "update") {
+              const result = this.controller.update(command.patch, command.label ? { label: command.label } : {});
+              if (!result.ok) return { ok: false, command, message: result.message };
+            }
+            break;
+          }
+        }
+      }
+      return { ok: true, command };
+    }
+  }
+};
 export {
+  CHART_AXIS_KINDS,
+  CHART_COLOR_SCHEMES,
   CHART_CURVES,
+  CHART_DATE_STEPS,
+  CHART_LABEL_POSITIONS,
+  CHART_LAYOUT_PRESETS,
   CHART_LEGEND_POSITIONS,
+  CHART_MARKERS,
+  CHART_MERMAID_META_PREFIX,
   CHART_NUMBER_STYLES,
+  CHART_OOXML_CONTENT_TYPE,
+  CHART_OOXML_NS,
+  CHART_OOXML_RELATIONSHIP,
   CHART_ORIENTATIONS,
+  CHART_PALETTE_SHADES,
+  CHART_PRESENCE_COLORS,
   CHART_SERIES_TYPES,
   CHART_STACKINGS,
+  CHART_TRENDLINE_TYPES,
   CHART_TYPES,
   CHART_TYPE_LABELS,
   CSS_VARIABLE_CHART_THEME,
   ChartController,
+  ChartDirector,
+  ChartPresence,
+  ChartStream,
   DEFAULT_CHART_PALETTE,
   DEFAULT_CHART_THEME,
+  MAX_CHART_DATA_LABELS,
+  MAX_CHART_LINE_POINTS,
+  MAX_CHART_MARKERS,
+  analyzeChartTable,
+  blendChartScenes,
   canDragChartPoint,
+  chartBoxStats,
   chartClientToScene,
+  chartColorDistance,
   chartColorInputValue,
+  chartColorsByCategory,
+  chartContrastRatio,
   chartDataFromTable,
   chartDataToTable,
+  chartDateLabels,
+  chartDateToSerial,
+  chartFamily,
+  chartFormatToCode,
+  chartFromMermaid,
+  chartFromOoxml,
+  chartFromTable,
+  chartHistogram,
+  chartHitTest,
+  chartLuminance,
+  chartMermaidFamily,
+  chartMovingAverage,
+  chartPointAnchor,
+  chartPointColor,
+  chartPresetPatch,
+  chartQuantile,
+  chartRgbToHex,
+  chartRgbToOklab,
+  chartSceneToDomSpec,
   chartSceneToSvg,
+  chartSerialToDate,
   chartSeriesColor,
   chartSeriesType,
   chartSliceColor,
+  chartSquarify,
+  chartSupportsTrendlines,
   chartTextBaseline,
+  chartTextOn,
   chartTextTransform,
+  chartToMermaid,
+  chartToOoxml,
   chartToSvg,
+  chartTrendlineName,
   chartValueAtPoint,
+  chartXAtPoint,
+  checkChartColors,
   cloneChartSeries,
   cloneChartSpec,
+  compileChartFormatCode,
   contrastingTextColor,
   createChartCommands,
   createChartController,
   createChartSpec,
+  createChartToolProvider,
+  createInstantChartClock,
+  cyclePaletteColor,
+  decimateChartPoints,
   defaultChartAxis,
+  describeChart,
   describeChartSelection,
+  easeChartTween,
   estimateChartTextWidth,
+  findMermaidCharts,
+  fitChartTrendline,
+  formatChartDate,
   formatChartNumber,
+  formatChartValueWithCode,
   handleChartKey,
   isCartesianChart,
+  isXyChart,
   layoutChart,
+  layoutSparkline,
   linearMap,
+  monochromeChartPalette,
   niceScale,
   niceStep,
   normalizeChartAxis,
   normalizeChartSpec,
+  normalizeChartTrendline,
   normalizeChartValues,
+  parseChartColor,
+  parseChartDate,
   parseChartValue,
+  parsePartialChartJson,
+  planChartCommand,
+  realChartClock,
+  recommendChartTypes,
+  recommendForShape,
   sameChartSelection,
+  shadeChartColor,
+  simulateChartVision,
+  snapChartDragValue,
   snapChartValue,
+  sparklineToSvg,
   startChartPointDrag,
   stepDecimals,
+  summarizeChart,
+  summarizeChartSeries,
+  trendNumberText,
   uniqueChartSeriesId
 };
 //# sourceMappingURL=index.js.map