@pixerate/editor 0.163.0 → 0.165.0

package/dist/chart/index.d.cts

@@ -1,6 +1,7 @@
 export * from './types.cjs';
 export * from './spec.cjs';
 export * from './tree.cjs';
+export * from './links.cjs';
 export * from './scale.cjs';
 export * from './numfmt.cjs';
 export * from './color.cjs';
@@ -28,3 +29,4 @@ export * from './office-files.cjs';
 export * from './file-tools.cjs';
 export * from './playback.cjs';
 export * from './editorDocument.cjs';
+export * from './style.cjs';

package/dist/chart/index.d.ts

@@ -1,6 +1,7 @@
 export * from './types.js';
 export * from './spec.js';
 export * from './tree.js';
+export * from './links.js';
 export * from './scale.js';
 export * from './numfmt.js';
 export * from './color.js';
@@ -28,3 +29,4 @@ export * from './office-files.js';
 export * from './file-tools.js';
 export * from './playback.js';
 export * from './editorDocument.js';
+export * from './style.js';

package/dist/chart/index.js

@@ -2,6 +2,8 @@ import {
   CATEGORY_REF,
   CHART_UPDATE_PROPERTIES,
   HEIGHT,
+  LINK_INDEX,
+  LINK_PROPS,
   REFERENCE_BAND_PATCH,
   REFERENCE_BAND_PROPS,
   REFERENCE_INDEX,
@@ -14,7 +16,7 @@ import {
   TRENDLINE_PROPS,
   VALUE,
   WIDTH
-} from "../chunk-5FNGLV2D.js";
+} from "../chunk-FEU2XVQH.js";
 import {
   CHART_OOXML_CONTENT_TYPE,
   CHART_OOXML_NS,
@@ -22,7 +24,7 @@ import {
   chartFormatToCode,
   chartFromOoxml,
   chartToOoxml
-} from "../chunk-POR54B55.js";
+} from "../chunk-CRFSQWKQ.js";
 import {
   CHART_COLOR_SCHEMES,
   CHART_LAYOUT_PRESETS,
@@ -44,7 +46,8 @@ import {
   monochromeChartPalette,
   sparklineToSvg,
   summarizeChart
-} from "../chunk-SZA42R4N.js";
+} from "../chunk-FRBRLKNQ.js";
+import "../chunk-KGRZMHZB.js";
 import {
   CHART_DATE_STEPS,
   MAX_CHART_DATA_LABELS,
@@ -84,7 +87,7 @@ import {
   suggestChartReferences,
   summarizeChartSeries,
   trendNumberText
-} from "../chunk-Z4P2RBMJ.js";
+} from "../chunk-V5GSY3NC.js";
 import {
   CHART_AXIS_KINDS,
   CHART_AXIS_SCALES,
@@ -102,6 +105,7 @@ import {
   CHART_PALETTE_SHADES,
   CHART_RADAR_GRATICULES,
   CHART_REFERENCE_AXES,
+  CHART_SANKEY_LINK_COLORS,
   CHART_SERIES_TYPES,
   CHART_STACKINGS,
   CHART_TRENDLINE_TYPES,
@@ -110,8 +114,10 @@ import {
   CSS_VARIABLE_CHART_THEME,
   DEFAULT_CHART_PALETTE,
   DEFAULT_CHART_THEME,
+  MAX_CHART_LINKS,
   MAX_CHART_TREE_DEPTH,
   MAX_CHART_TREE_NODES,
+  addChartLink,
   addChartTreeRow,
   chartColorDistance,
   chartColorInputValue,
@@ -123,10 +129,13 @@ import {
   chartErrorBarsOfType,
   chartFamily,
   chartLikertColor,
+  chartLinksFromTable,
   chartLuminance,
   chartPointColor,
   chartRgbToHex,
   chartRgbToOklab,
+  chartSankeyNodeValues,
+  chartSankeyNodes,
   chartSeriesColor,
   chartSeriesType,
   chartSliceColor,
@@ -155,6 +164,7 @@ import {
   isXyChart,
   normalizeChartAxis,
   normalizeChartErrorBars,
+  normalizeChartLinks,
   normalizeChartReferenceBand,
   normalizeChartReferenceLine,
   normalizeChartSpec,
@@ -165,12 +175,14 @@ import {
   parseChartColor,
   parseChartValue,
   removeChartTreeRow,
+  setChartLinkField,
   setChartTreeRowName,
   setChartTreeRowValue,
   shadeChartColor,
   simulateChartVision,
   uniqueChartSeriesId
-} from "../chunk-3NEZJCBY.js";
+} from "../chunk-2ZRN43IN.js";
+import "../chunk-O6OGNDND.js";
 import "../chunk-II2WIF5Z.js";
 import {
   parseCsv
@@ -188,11 +200,12 @@ import {
 } from "../chunk-CIQIM2IP.js";
 import {
   defineEditorDocument
-} from "../chunk-NHLYK3AX.js";
+} from "../chunk-XBQX76CT.js";
 import "../chunk-HF5QZS7Z.js";
 import "../chunk-RNSANXPT.js";
-import "../chunk-QYZGBVNC.js";
-import "../chunk-4VU4CP7R.js";
+import "../chunk-7272D3K2.js";
+import "../chunk-YBAPT7NL.js";
+import "../chunk-MHLU6GRJ.js";
 import "../chunk-6ONMQ6WF.js";
 
 // src/chart/raster.ts
@@ -800,6 +813,80 @@ function createChartCommands(controller, options = {}) {
         return { groups: controller.getSpec().tree.map((n) => ({ name: n.name, total: chartTreeTotal(n) })) };
       }
     },
+    {
+      ...base,
+      id: `${prefix}setLinks`,
+      label: "Replace Flows\u2026",
+      keywords: ["chart", "sankey", "flow", "links", "funnel", "budget"],
+      description: "Replaces the data with flows between named nodes for a Sankey diagram; [] goes back to plain data.",
+      params: object(
+        {
+          links: { type: "array", items: { type: "object", properties: LINK_PROPS, required: ["source", "target", "value"], additionalProperties: false }, description: "All the flows; [] removes them." },
+          nodes: { type: "array", items: { type: "string" }, description: "Node names in stacking order." }
+        },
+        ["links"]
+      ),
+      run: (_ctx, params) => {
+        check(controller.setLinks(params.links, { nodes: params.nodes }));
+        return { links: controller.getSpec().links, nodes: controller.getSpec().sankeyNodes };
+      }
+    },
+    {
+      ...base,
+      id: `${prefix}importLinksCsv`,
+      label: "Import Flows from CSV\u2026",
+      keywords: ["chart", "sankey", "flow", "csv", "import"],
+      description: "Replaces the data with flows from CSV / TSV rows of source, target and value.",
+      params: object(
+        {
+          csv: { type: "string", description: "CSV or TSV text." },
+          header: { type: ["boolean", "string"], enum: [true, false, "auto"], description: "The first row holds column names (default auto)." }
+        },
+        ["csv"]
+      ),
+      run: (_ctx, params) => {
+        check(controller.importLinksTable(parseCsv(params.csv, { delimiter: params.csv.includes("	") ? "	" : "," }), { header: params.header }));
+        return { links: controller.getSpec().links };
+      }
+    },
+    {
+      ...base,
+      id: `${prefix}addLink`,
+      label: "Add Flow\u2026",
+      keywords: ["chart", "sankey", "flow", "link", "add"],
+      description: "Adds a flow between two nodes. Returns its index.",
+      params: object(LINK_PROPS, ["source", "target", "value"]),
+      run: (_ctx, params) => {
+        const result = controller.addLink(params);
+        check(result);
+        return { index: result.index };
+      }
+    },
+    {
+      ...base,
+      id: `${prefix}updateLink`,
+      label: "Change Flow\u2026",
+      keywords: ["chart", "sankey", "flow", "link", "value"],
+      description: "Changes a flow by index (color null for the default).",
+      params: object({ index: LINK_INDEX, ...LINK_PROPS, color: { type: ["string", "null"], description: "CSS colour, or null for the default." } }, ["index"]),
+      run: (_ctx, params) => {
+        const { index, ...patch } = params;
+        check(controller.updateLink(index, patch));
+        return { link: controller.getSpec().links[index] };
+      }
+    },
+    {
+      ...base,
+      id: `${prefix}removeLink`,
+      label: "Delete Flow",
+      keywords: ["chart", "sankey", "flow", "link", "remove"],
+      description: "Deletes a flow by index.",
+      params: object({ index: LINK_INDEX }, ["index"]),
+      run: (_ctx, params) => {
+        check(controller.removeLink(params.index));
+        return { links: controller.getSpec().links };
+      }
+    },
     {
       ...base,
       id: `${prefix}applyPreset`,
@@ -851,11 +938,11 @@ function createChartCommands(controller, options = {}) {
       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.",
+      description: "Replaces the chart with Mermaid xychart-beta, pie, radar-beta, sankey-beta or treemap-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.");
+        if (!read.family) fail(read.issues.map((i) => i.message).join(" ") || "Expected Mermaid starting with xychart-beta, pie, radar-beta, sankey-beta or treemap-beta.");
         check(controller.update({ ...read.spec }, { label: "Import Mermaid chart" }));
         return { spec: controller.toJSON(), issues: read.issues };
       }
@@ -1366,6 +1453,11 @@ function planChartToolPlayback(tool, args) {
     case "add_chart_tree_node":
     case "update_chart_tree_node":
     case "remove_chart_tree_node":
+    case "set_chart_links":
+    case "import_chart_links_csv":
+    case "add_chart_link":
+    case "update_chart_link":
+    case "remove_chart_link":
     case "import_chart_csv":
     case "import_chart_mermaid":
     case "import_chart_ooxml":
@@ -1456,6 +1548,7 @@ function createChartToolProvider(controller, options = {}) {
     const depth = chartTreeDepth(spec().tree);
     return [[...Array.from({ length: depth }, (_, k) => k === 0 ? "Group" : k === depth - 1 ? "Item" : `Level ${k + 1}`), "Value"], ...rows.map((r) => [...r.path, ...Array(depth - r.path.length).fill(""), r.value])];
   };
+  const linksSummary = () => ({ links: spec().links, nodes: spec().sankeyNodes.map((name, i) => ({ name, value: chartSankeyNodeValues(spec().links, spec().sankeyNodes)[i] })) });
   const treeSummary = () => ({ tree: spec().tree, groups: spec().tree.map((n) => ({ name: n.name, total: chartTreeTotal(n) })), depth: chartTreeDepth(spec().tree) });
   const Parser = () => options.DOMParser ?? globalThis.DOMParser;
   const getChart = {
@@ -1580,7 +1673,7 @@ function createChartToolProvider(controller, options = {}) {
   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.',
+    description: 'Returns the chart as Mermaid text for Markdown or chat: xychart-beta, pie or radar-beta, sankey-beta for Sankey diagrams with flows, treemap-beta for treemaps and sunbursts (with their levels). 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 }) })
@@ -1767,13 +1860,13 @@ function createChartToolProvider(controller, options = {}) {
   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.',
+    description: 'Replaces the chart with Mermaid xychart-beta, pie, radar-beta, sankey-beta or treemap-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.");
+      if (!read.family) fail2(read.issues.map((i) => i.message).join(" ") || "Expected Mermaid starting with xychart-beta, pie, radar-beta, sankey-beta or treemap-beta.");
       resolve(controller.update({ ...read.spec }, { label: "Import Mermaid chart" }));
       return { spec: controller.toJSON(), issues: read.issues };
     }
@@ -1982,6 +2075,81 @@ function createChartToolProvider(controller, options = {}) {
       return { groups: treeSummary().groups };
     }
   };
+  const setLinks = {
+    name: "set_chart_links",
+    title: "Replace the flows",
+    description: `Replaces the chart's data with flows between named nodes for a Sankey diagram, as one undo step: each {"source", "target", "value"} with a value above 0. Flows only go forwards (no loops) and a source-target pair appears once. The nodes become the categories and how much passes through each the first series. nodes (optional) sets the stacking order. [] goes back to plain data. Returns the flows and each node's throughput.`,
+    inputSchema: {
+      type: "object",
+      properties: {
+        links: { type: "array", items: { type: "object", properties: LINK_PROPS, required: ["source", "target", "value"], additionalProperties: false }, description: "All the flows; [] removes them." },
+        nodes: { type: "array", items: { type: "string" }, description: "Node names in stacking order (default: as the flows first name them)." }
+      },
+      required: ["links"],
+      additionalProperties: false
+    },
+    annotations: { title: "Replace the flows", ...WRITE_IDEMPOTENT },
+    handler: ({ links, nodes }) => {
+      resolve(controller.setLinks(links, { nodes }));
+      return linksSummary();
+    }
+  };
+  const importLinksCsv = {
+    name: "import_chart_links_csv",
+    title: "Import flows from CSV",
+    description: "Replaces the data with flows from CSV or TSV rows of source, target and value (as Mermaid sankey-beta and spreadsheets write them). One undo step. Returns the flows and each node's throughput.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        csv: { type: "string", description: 'CSV or TSV text, e.g. "Website,Signup,120\\nSignup,Paid,30".' },
+        header: { type: ["boolean", "string"], enum: [true, false, "auto"], description: "The first row holds column names (default auto: when its third cell is not a number)." }
+      },
+      required: ["csv"],
+      additionalProperties: false
+    },
+    annotations: { title: "Import flows from CSV", ...WRITE },
+    handler: ({ csv, header }) => {
+      resolve(controller.importLinksTable(parseCsv(csv, { delimiter: csv.includes("	") ? "	" : "," }), { header }));
+      return linksSummary();
+    }
+  };
+  const addLink = {
+    name: "add_chart_link",
+    title: "Add a flow",
+    description: "Adds a flow from one node to another (new names add nodes). Refused when the pair exists already or it would close a loop. Returns its index and the throughput of its two nodes.",
+    inputSchema: { type: "object", properties: LINK_PROPS, required: ["source", "target", "value"], additionalProperties: false },
+    annotations: { title: "Add a flow", ...WRITE },
+    handler: (args) => {
+      const result = resolve(controller.addLink(args));
+      const s = spec();
+      const through = (n) => s.series[0]?.values[s.sankeyNodes.indexOf(n)] ?? 0;
+      const link = s.links[result.index];
+      return { index: result.index, link, nodes: [link.source, link.target].map((name) => ({ name, value: through(name) })) };
+    }
+  };
+  const updateLink = {
+    name: "update_chart_link",
+    title: "Change a flow",
+    description: "Changes a flow by index: its source, target, value or colour (null goes back to the default). Checked like a new flow. Returns the flow as stored.",
+    inputSchema: { type: "object", properties: { index: LINK_INDEX, ...LINK_PROPS, color: { type: ["string", "null"], description: "CSS colour, or null for the default." } }, required: ["index"], additionalProperties: false },
+    annotations: { title: "Change a flow", ...WRITE_IDEMPOTENT },
+    handler: ({ index, ...patch }) => {
+      if (!Object.keys(patch).length) fail2(`Nothing to change: pass source, target, value or color with the index, e.g. {"index": ${index}, "value": 40}.`);
+      resolve(controller.updateLink(index, patch));
+      return { index, link: spec().links[index] };
+    }
+  };
+  const removeLink = {
+    name: "remove_chart_link",
+    title: "Delete a flow",
+    description: "Deletes a flow by index; the ones after it move up one, and nodes no flow uses any more go. Returns the flows left.",
+    inputSchema: { type: "object", properties: { index: LINK_INDEX }, required: ["index"], additionalProperties: false },
+    annotations: { title: "Delete a flow", ...DESTRUCTIVE },
+    handler: ({ index }) => {
+      resolve(controller.removeLink(index));
+      return { links: spec().links };
+    }
+  };
   const applyPreset = {
     name: "apply_chart_preset",
     title: "Apply a chart style",
@@ -2174,6 +2342,11 @@ function createChartToolProvider(controller, options = {}) {
     addTreeNode,
     updateTreeNode,
     removeTreeNode,
+    setLinks,
+    importLinksCsv,
+    addLink,
+    updateLink,
+    removeLink,
     applyPreset,
     transpose,
     select,
@@ -2186,7 +2359,7 @@ function createChartToolProvider(controller, options = {}) {
     id: options.id ?? "chart",
     namespace: options.namespace,
     title: "Chart editor",
-    description: "One chart: its spec, data and values, series and categories, trendlines, reference lines and bands, callouts, highlight, grouped data and presets, CSV, Mermaid and OOXML import, rendering and colour checks.",
+    description: "One chart: its spec, data and values, series and categories, trendlines, reference lines and bands, callouts, highlight, grouped data, flows and presets, CSV, Mermaid and OOXML import, rendering and colour checks.",
     skill: "pixerate-chart",
     tools: () => {
       if (readOnlyReason()) return reads;
@@ -2669,6 +2842,194 @@ function createChartEditorDocument(controller) {
     }
   });
 }
+
+// src/chart/style.ts
+var CHART_TYPES3 = ["bar", "line", "area", "scatter", "bubble", "pie", "donut", "radar", "waterfall", "histogram", "box", "funnel", "treemap"];
+var COLOR = { type: "string", minLength: 1, description: 'A CSS colour (hex or rgb()), or a { "$token": ... } reference.' };
+function chartColors(spec) {
+  const out = [];
+  const visible = spec.series.map((s, i) => ({ s, i })).filter(({ s }) => !s.hidden);
+  if (chartColorsByCategory(spec.type)) {
+    const first = visible[0];
+    spec.categories.forEach((name, index) => {
+      const color = first?.s.pointColors?.[index] || chartSliceColor(spec, index);
+      out.push({ color, label: `Slice "${name}"`, target: first ? { kind: "point", seriesId: first.s.id, index } : { kind: "category", index } });
+    });
+    return out;
+  }
+  for (const { s, i } of visible) {
+    out.push({ color: chartSeriesColor(spec, i), label: `Series "${s.name}"`, target: { kind: "series", seriesId: s.id } });
+    s.pointColors?.forEach((c, index) => {
+      if (c) out.push({ color: c, label: `Point ${index + 1} of "${s.name}"`, target: { kind: "point", seriesId: s.id, index } });
+    });
+  }
+  return out;
+}
+var paletteOf = (profile) => {
+  const palette = profile.palette;
+  if (!palette?.length) throw new Error("the profile has no palette.");
+  return palette;
+};
+var paletteOnly = {
+  id: "palette-only",
+  description: "Every series, slice and point colour comes from the house palette (or a lighter or darker shade the chart cycles to once the palette runs out).",
+  optionsSchema: {
+    type: "object",
+    properties: { tolerance: { type: "number", minimum: 0, maximum: 1, description: "Largest OKLab distance still counted as the same colour (default 0.02)." } },
+    additionalProperties: false
+  },
+  run(spec, profile, { tolerance = 0.02 }) {
+    const palette = paletteOf(profile);
+    const allowed = palette.flatMap((c) => CHART_PALETTE_SHADES.map((t) => shadeChartColor(c, t))).map((c) => ({ c, rgb: parseChartColor(c) }));
+    return chartColors(spec).flatMap(({ color, label, target }) => {
+      const rgb = parseChartColor(color);
+      if (!rgb) return [];
+      let best = { c: palette[0], d: Infinity };
+      for (const a of allowed) {
+        if (!a.rgb) continue;
+        const d = chartColorDistance(rgb, a.rgb);
+        if (d < best.d) best = { c: a.c, d };
+      }
+      if (best.d <= tolerance) return [];
+      const nearest = palette.map((c) => ({ c, d: parseChartColor(c) ? chartColorDistance(rgb, parseChartColor(c)) : Infinity })).sort((a, b) => a.d - b.d)[0].c;
+      return [{ severity: "error", message: `${label} uses ${color}, which is not in the house palette; use ${nearest} or another palette colour (${palette.join(", ")}).`, target }];
+    });
+  }
+};
+var distinguishable = {
+  id: "distinguishable",
+  description: "Series (or slice) colours can be told apart with normal vision and with protanopia, deuteranopia and tritanopia.",
+  optionsSchema: {
+    type: "object",
+    properties: { minDistance: { type: "number", minimum: 0, maximum: 1, description: "Smallest OKLab distance between two colours after simulation (default 0.08)." } },
+    additionalProperties: false
+  },
+  run(spec, _profile, { minDistance = 0.08 }) {
+    const colors = chartColors(spec).filter((c) => c.target.kind !== "point" || chartColorsByCategory(spec.type));
+    const result = checkChartColors(colors.map((c) => c.color), { minDistance, minContrast: 0 });
+    const findings = [];
+    for (const [vision, pair] of Object.entries(result.closest)) {
+      if (!pair || pair.distance >= minDistance) continue;
+      const who = vision === "normal" ? "" : ` with ${vision}`;
+      findings.push({
+        severity: "warning",
+        message: `${colors[pair.a].label} (${pair.colors[0]}) and ${colors[pair.b].label} (${pair.colors[1]}) are hard to tell apart${who} (distance ${pair.distance}, want ${minDistance}); give the second another palette colour.`,
+        target: colors[pair.b].target
+      });
+    }
+    return findings;
+  }
+};
+var minContrast = {
+  id: "min-contrast",
+  description: "Marks stand out from the background: each series or slice colour against the profile theme's background (or surface, default white).",
+  optionsSchema: {
+    type: "object",
+    properties: { ratio: { type: "number", minimum: 1, maximum: 21, description: "Smallest contrast ratio (default 3, the WCAG ratio for graphics)." } },
+    additionalProperties: false
+  },
+  run(spec, profile, { ratio = 3 }) {
+    const theme = profile.theme ?? {};
+    const background = theme.background && theme.background !== "transparent" ? theme.background : theme.surface ?? "#ffffff";
+    return chartColors(spec).flatMap(({ color, label, target }) => {
+      const r = chartContrastRatio(color, background);
+      if (r === null || r >= ratio) return [];
+      return [{ severity: "warning", message: `${label} (${color}) has contrast ${Math.round(r * 100) / 100}:1 against the background ${background}; want at least ${ratio}:1, so use a darker or lighter palette colour.`, target }];
+    });
+  }
+};
+var allowedType = {
+  id: "allowed-type",
+  description: "The chart is one of the chart types the house style allows.",
+  optionsSchema: {
+    type: "object",
+    properties: { types: { type: "array", items: { type: "string", enum: [...CHART_TYPES3] }, minItems: 1, description: "Allowed chart types." } },
+    required: ["types"],
+    additionalProperties: false
+  },
+  run(spec, _profile, { types }) {
+    const allowed = types;
+    if (allowed.includes(spec.type)) return [];
+    return [{ severity: "error", message: `This is a ${spec.type} chart; the house style allows ${allowed.join(", ")}. Change the type with update_chart.`, target: { kind: "chart" } }];
+  }
+};
+var chartStyleDomain = {
+  id: "chart",
+  title: "Charts",
+  description: "The house palette and theme for charts, which colour schemes and layouts are allowed, defaults for new charts, and the checks to run.",
+  profileSchema: {
+    type: "object",
+    properties: {
+      palette: { type: "array", items: COLOR, minItems: 1, description: "Series colours in order." },
+      colorSchemes: { type: "array", items: { type: "string", enum: CHART_COLOR_SCHEMES.map((s) => s.id) }, description: "Colour scheme ids allowed besides the palette (empty: none)." },
+      layouts: { type: "array", items: { type: "string", enum: CHART_LAYOUT_PRESETS.map((p) => p.id) }, description: "Layout preset ids allowed." },
+      theme: {
+        type: "object",
+        properties: {
+          background: COLOR,
+          surface: COLOR,
+          text: COLOR,
+          mutedText: COLOR,
+          grid: COLOR,
+          axis: COLOR,
+          positive: COLOR,
+          negative: COLOR,
+          fontFamily: { type: "string", minLength: 1, description: "CSS font family." },
+          fontSize: { type: "number", minimum: 6, maximum: 48, description: "Body text size in px." },
+          titleSize: { type: "number", minimum: 6, maximum: 72, description: "Title size in px." }
+        },
+        additionalProperties: false,
+        description: "Colours and type to draw charts with."
+      },
+      defaults: {
+        type: "object",
+        properties: {
+          dataLabels: { type: "boolean", description: "Value labels on." },
+          points: { type: "boolean", description: "Dots on lines." },
+          curve: { type: "string", enum: ["linear", "smooth", "step"], description: "Line interpolation." },
+          stacking: { type: "string", enum: ["none", "stacked", "percent"], description: "Stacking." },
+          orientation: { type: "string", enum: ["vertical", "horizontal"], description: "Bar direction." },
+          labelPosition: { type: "string", enum: ["auto", "inside", "outside", "center"], description: "Bar label position." }
+        },
+        additionalProperties: false,
+        description: "Spec values new charts start from."
+      }
+    },
+    additionalProperties: false
+  },
+  checks: [paletteOnly, distinguishable, minContrast, allowedType]
+};
+function chartStylePatch(profile) {
+  const p = profile;
+  return { ...p.defaults ?? {}, ...p.palette?.length ? { palette: [...p.palette] } : {} };
+}
+function createChartStyleToolProvider(controller, styles, options = {}) {
+  if (!styles.domains.some((d) => d.id === "chart")) throw new Error('The style resolver has no "chart" domain; add chartStyleDomain to its domains.');
+  const check2 = {
+    name: "check_chart_style",
+    title: "Check chart house style",
+    description: 'Checks the chart against the house style (see get_style with domain "chart"): runs the checks its profile turns on (palette-only, distinguishable, min-contrast, allowed-type). Returns findings with a severity, a sentence saying how to fix it, a target selection (series id or point) for update_chart_series or update_chart, and the layer that asked for it; plus the checks that ran and the ones skipped with the reason. Check after a batch of edits and again after fixing.',
+    inputSchema: { type: "object", properties: {}, additionalProperties: false },
+    annotations: { title: "Check chart house style", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    handler: async () => {
+      const { style, ...report } = await styles.check("chart", controller.getSpec());
+      return {
+        ...report,
+        ok: report.findings.length === 0,
+        ...style.skills.length ? {} : { note: "No house style applies to charts." },
+        ...style.issues.length ? { issues: style.issues } : {}
+      };
+    }
+  };
+  return {
+    id: options.id ?? "chart-style",
+    namespace: options.namespace ?? "chart",
+    title: "Chart house style",
+    description: "Check a chart against the house style.",
+    skill: "pixerate-chart",
+    tools: [check2]
+  };
+}
 export {
   CHART_AXIS_KINDS,
   CHART_AXIS_SCALES,
@@ -2695,6 +3056,7 @@ export {
   CHART_RADAR_GRATICULES,
   CHART_RASTER_MAX_SIZE,
   CHART_REFERENCE_AXES,
+  CHART_SANKEY_LINK_COLORS,
   CHART_SERIES_TYPES,
   CHART_STACKINGS,
   CHART_TRENDLINE_TYPES,
@@ -2709,11 +3071,13 @@ export {
   DEFAULT_CHART_THEME,
   MAX_CHART_DATA_LABELS,
   MAX_CHART_LINE_POINTS,
+  MAX_CHART_LINKS,
   MAX_CHART_MARKERS,
   MAX_CHART_TREE_DEPTH,
   MAX_CHART_TREE_NODES,
   OfficeChartsError,
   RENDER_CHART_INSTRUCTIONS,
+  addChartLink,
   addChartTreeRow,
   analyzeChartTable,
   blendChartScenes,
@@ -2739,6 +3103,7 @@ export {
   chartHistogram,
   chartHitTest,
   chartLikertColor,
+  chartLinksFromTable,
   chartLuminance,
   chartMermaidFamily,
   chartMovingAverage,
@@ -2750,6 +3115,8 @@ export {
   chartRasterSize,
   chartRgbToHex,
   chartRgbToOklab,
+  chartSankeyNodeValues,
+  chartSankeyNodes,
   chartScaleFromPixel,
   chartScaleToPixel,
   chartSceneToDomSpec,
@@ -2760,6 +3127,8 @@ export {
   chartSliceColor,
   chartSpecColorsByCategory,
   chartSquarify,
+  chartStyleDomain,
+  chartStylePatch,
   chartSupportsTrendlines,
   chartTextBaseline,
   chartTextOn,
@@ -2789,6 +3158,7 @@ export {
   createChartEditorDocument,
   createChartRasterizer,
   createChartSpec,
+  createChartStyleToolProvider,
   createChartToolProvider,
   createInstantChartClock,
   createOfficeChartToolProvider,
@@ -2827,6 +3197,7 @@ export {
   niceStep,
   normalizeChartAxis,
   normalizeChartErrorBars,
+  normalizeChartLinks,
   normalizeChartReferenceBand,
   normalizeChartReferenceLine,
   normalizeChartSpec,
@@ -2847,6 +3218,7 @@ export {
   removeChartTreeRow,
   resolveChartSvgPaints,
   sameChartSelection,
+  setChartLinkField,
   setChartTreeRowName,
   setChartTreeRowValue,
   shadeChartColor,

package/dist/chart/layout-families.d.cts

@@ -38,3 +38,10 @@ export declare function layoutTreemapTree(ctx: LayoutCtx, area: ChartRect, serie
  * wide enough for them; the total and `sunburstLabel` sit in the centre.
  */
 export declare function layoutSunburst(ctx: LayoutCtx, area: ChartRect, series: ChartSeries | undefined): FamilyResult;
+/**
+ * Sankey: `spec.links` as flows between columns of nodes. A node's column is the longest chain
+ * of flows into it, and nodes nothing flows out of line up in the last column. Node heights and
+ * flow widths share one scale (the tightest column fills the height); flows leave and arrive
+ * in the order of the nodes at their other end, so they cross as little as the order allows.
+ */
+export declare function layoutSankey(ctx: LayoutCtx, area: ChartRect, series: ChartSeries | undefined): FamilyResult;

package/dist/chart/layout-families.d.ts

@@ -38,3 +38,10 @@ export declare function layoutTreemapTree(ctx: LayoutCtx, area: ChartRect, serie
  * wide enough for them; the total and `sunburstLabel` sit in the centre.
  */
 export declare function layoutSunburst(ctx: LayoutCtx, area: ChartRect, series: ChartSeries | undefined): FamilyResult;
+/**
+ * Sankey: `spec.links` as flows between columns of nodes. A node's column is the longest chain
+ * of flows into it, and nodes nothing flows out of line up in the last column. Node heights and
+ * flow widths share one scale (the tightest column fills the height); flows leave and arrive
+ * in the order of the nodes at their other end, so they cross as little as the order allows.
+ */
+export declare function layoutSankey(ctx: LayoutCtx, area: ChartRect, series: ChartSeries | undefined): FamilyResult;