@pixerate/editor 0.272.0 → 0.272.1

package/dist/chart/index.d.cts

@@ -34,3 +34,4 @@ export * from './file-tools.cjs';
 export * from './playback.cjs';
 export * from './editorDocument.cjs';
 export * from './style.cjs';
+export * from './contract.cjs';

package/dist/chart/index.d.ts

@@ -34,3 +34,4 @@ export * from './file-tools.js';
 export * from './playback.js';
 export * from './editorDocument.js';
 export * from './style.js';
+export * from './contract.js';

package/dist/chart/index.js

@@ -1,3 +1,12 @@
+import {
+  EUROPE_CHART_MAP
+} from "../chunk-EI5GFTKG.js";
+import "../chunk-CHZYVNXZ.js";
+import {
+  CommandRegistry,
+  createCommandToolProvider
+} from "../chunk-HAEB3MZD.js";
+import "../chunk-JV7DKLMX.js";
 import {
   CATEGORY_REF,
   CHART_UPDATE_PROPERTIES,
@@ -18,6 +27,18 @@ import {
   VALUE,
   WIDTH
 } from "../chunk-6NQPKNUZ.js";
+import "../chunk-ZA7L5YJB.js";
+import "../chunk-55ALHYJY.js";
+import "../chunk-PXXXRCME.js";
+import {
+  createStyleResolver,
+  memoryStyleStore
+} from "../chunk-5UGRMVNE.js";
+import {
+  ToolRegistry
+} from "../chunk-K4BGRCSH.js";
+import "../chunk-EHTX34RE.js";
+import "../chunk-NZ3CTY7K.js";
 import {
   CHART_OOXML_CONTENT_TYPE,
   CHART_OOXML_NS,
@@ -47,7 +68,7 @@ import {
   monochromeChartPalette,
   sparklineToSvg,
   summarizeChart
-} from "../chunk-NMZQMPFZ.js";
+} from "../chunk-4LZQO5Y7.js";
 import "../chunk-KGRZMHZB.js";
 import {
   CHART_DATE_STEPS,
@@ -208,14 +229,19 @@ import {
   realPresenceClock,
   tweenPresenceCursor
 } from "../chunk-IVSWRVB4.js";
+import "../chunk-V2ZCJRDM.js";
 import {
   readZip
 } from "../chunk-CIQIM2IP.js";
 import {
-  defineEditorDocument
+  EDITOR_DOCUMENT_FORMAT,
+  defineEditorDocument,
+  toEditorDocumentFile
 } from "../chunk-XBQX76CT.js";
 import "../chunk-HF5QZS7Z.js";
-import "../chunk-GAZPHCTV.js";
+import {
+  HistoryManager
+} from "../chunk-GAZPHCTV.js";
 import "../chunk-2EUW2XZX.js";
 import "../chunk-E2V5DA3W.js";
 import "../chunk-VR6OGHU5.js";
@@ -513,7 +539,7 @@ function createChartCommands(controller, options = {}) {
       params: object({ width: WIDTH, height: HEIGHT }),
       run: (_ctx, params = {}) => {
         const spec = controller.getSpec();
-        return { spec: controller.toJSON(), table: chartDataToTable(spec), summary: summarizeChart(controller.toJSON(), { width: params?.width ?? 640, height: params?.height ?? 400 }), issues: controller.getState().issues };
+        return { spec: controller.toJSON(), table: chartDataToTable(spec), summary: summarizeChart(controller.toJSON(), { width: params?.width ?? 640, height: params?.height ?? 400, measureText: controller.measureText }), issues: controller.getState().issues };
       }
     },
     {
@@ -1068,7 +1094,7 @@ function createChartCommands(controller, options = {}) {
       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 })
+        svg: chartToSvg(controller.toJSON(), { width: params?.width ?? 640, height: params?.height ?? 400, measureText: controller.measureText })
       })
     },
     {
@@ -1686,6 +1712,7 @@ function resolve(result) {
 }
 function createChartToolProvider(controller, options = {}) {
   const size = options.size ?? { width: 640, height: 400 };
+  const measureText = options.measureText ?? controller.measureText;
   const readOnlyReason = () => {
     const r = typeof options.readOnly === "function" ? options.readOnly() : options.readOnly;
     if (!r) return null;
@@ -1741,7 +1768,7 @@ function createChartToolProvider(controller, options = {}) {
         spec: controller.toJSON(),
         table: table(),
         selection: controller.getState().selection,
-        summary: summarizeChart(controller.toJSON(), { width, height }),
+        summary: summarizeChart(controller.toJSON(), { width, height, measureText }),
         ...spec().tree.length ? { treeTable: treeTable() } : {},
         issues: controller.getState().issues,
         ...reason ? { readOnly: reason } : {}
@@ -1766,7 +1793,7 @@ function createChartToolProvider(controller, options = {}) {
     handler: async ({ width = size.width, height = size.height, format = "svg", time }) => {
       const json = controller.toJSON();
       const raceFrame = time !== void 0 ? raceFrameOf(time) : controller.getState().raceFrame;
-      const scene = layoutChart(json, { width, height, selection: null, raceFrame });
+      const scene = layoutChart(json, { width, height, selection: null, raceFrame, measureText });
       const svg = chartSceneToSvg(scene, { ariaLabel: json.title || void 0, description: describeChart(json) });
       const warnings = scene.warnings;
       if (format === "png") {
@@ -2505,9 +2532,9 @@ function createChartToolProvider(controller, options = {}) {
     },
     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 scene = layoutChart(controller.toJSON(), { width, height, measureText });
       const start = { x: from.x * width, y: from.y * height };
-      const target = chartHitTest(scene, start);
+      const target = chartHitTest(scene, start, measureText);
       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;
@@ -2535,7 +2562,7 @@ function createChartToolProvider(controller, options = {}) {
     },
     annotations: { title: "Press a key on the chart", ...DESTRUCTIVE },
     handler: ({ key: k, shift, alt }) => {
-      const scene = layoutChart(controller.toJSON(), size);
+      const scene = layoutChart(controller.toJSON(), { ...size, measureText });
       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;
@@ -3283,12 +3310,448 @@ function createChartStyleToolProvider(controller, styles, options = {}) {
     tools: [check2]
   };
 }
+
+// src/chart/contract.ts
+var CHART_CONTRACT_FORMAT_VERSION = 1;
+var conformanceChartTextMeasure = estimateChartTextWidth;
+var NULLABLE_NUMBER_ARRAY = {
+  type: "array",
+  items: { type: ["number", "null"] }
+};
+var CHART_TRENDLINE_JSON_SCHEMA = {
+  type: "object",
+  properties: TRENDLINE_PROPS,
+  required: ["type"],
+  additionalProperties: false
+};
+var CHART_LINK_JSON_SCHEMA = {
+  type: "object",
+  properties: LINK_PROPS,
+  required: ["source", "target", "value"],
+  additionalProperties: false
+};
+var CHART_SERIES_JSON_SCHEMA = {
+  type: "object",
+  required: ["id", "name", "values"],
+  additionalProperties: false,
+  properties: {
+    id: { type: "string", minLength: 1, description: "Unique series id (`series-1`, `series-2`, \u2026)." },
+    ...SERIES_PROPS,
+    values: { ...NULLABLE_NUMBER_ARRAY, description: SERIES_PROPS.values.description },
+    x: { ...NULLABLE_NUMBER_ARRAY, description: SERIES_PROPS.x.description },
+    sizes: { ...NULLABLE_NUMBER_ARRAY, description: SERIES_PROPS.sizes.description },
+    trendlines: {
+      type: "array",
+      items: CHART_TRENDLINE_JSON_SCHEMA,
+      description: "Fitted trendlines drawn over the series."
+    }
+  }
+};
+var CHART_SPEC_PROPERTIES = {
+  version: { type: "integer", const: 1, description: "Always 1." },
+  ...CHART_UPDATE_PROPERTIES,
+  categories: {
+    type: "array",
+    items: { type: "string" },
+    description: "Category labels along the x axis (or slice / time-point labels)."
+  },
+  series: {
+    type: "array",
+    items: CHART_SERIES_JSON_SCHEMA,
+    description: "Data series."
+  },
+  tree: {
+    type: "array",
+    items: { $ref: "#/$defs/chartTreeNode" },
+    description: "Hierarchical nodes for treemap and sunburst charts."
+  },
+  links: {
+    type: "array",
+    items: CHART_LINK_JSON_SCHEMA,
+    description: "Directed weighted links for sankey charts."
+  }
+};
+var CHART_DOCUMENT_JSON_SCHEMA = {
+  type: "object",
+  description: "A saved chart document, as the chart editor's save tools and autosave write it.",
+  $defs: TREE_DEFS,
+  properties: {
+    format: { type: "string", const: EDITOR_DOCUMENT_FORMAT, description: `Always "${EDITOR_DOCUMENT_FORMAT}".` },
+    kind: { type: "string", const: "chart", description: 'Always "chart".' },
+    formatVersion: { type: "integer", minimum: 1, description: "Version of the envelope for this kind; readers migrate older ones." },
+    name: { type: "string", description: "Display name, when it has one." },
+    document: {
+      type: "object",
+      description: "The chart (`ChartSpec`, as get_chart returns it in `spec`).",
+      properties: CHART_SPEC_PROPERTIES,
+      required: Object.keys(CHART_SPEC_PROPERTIES),
+      additionalProperties: false
+    }
+  },
+  required: ["format", "kind", "formatVersion", "document"],
+  additionalProperties: false
+};
+var XML_ENTITIES = {
+  lt: "<",
+  gt: ">",
+  amp: "&",
+  quot: '"',
+  apos: "'"
+};
+function decodeXmlEntities(raw) {
+  return raw.replace(/&(#x[0-9a-fA-F]+|#[0-9]+|[a-zA-Z]+);/g, (match, code) => {
+    if (code.startsWith("#x") || code.startsWith("#X")) return String.fromCodePoint(parseInt(code.slice(2), 16));
+    if (code.startsWith("#")) return String.fromCodePoint(parseInt(code.slice(1), 10));
+    return XML_ENTITIES[code] ?? match;
+  });
+}
+var MiniXmlElement = class {
+  nodeType = 1;
+  tagName;
+  localName;
+  prefix;
+  namespaceURI;
+  parentElement = null;
+  childNodes = [];
+  attributes = [];
+  constructor(tagName, localName, prefix, namespaceURI) {
+    this.tagName = tagName;
+    this.localName = localName;
+    this.prefix = prefix;
+    this.namespaceURI = namespaceURI;
+  }
+  get children() {
+    return this.childNodes.filter((n) => n.nodeType === 1);
+  }
+  get textContent() {
+    return this.childNodes.map((n) => n.textContent).join("");
+  }
+  getAttribute(name) {
+    const found = this.attributes.find((a) => a.name === name);
+    return found ? found.value : null;
+  }
+  getElementsByTagName(name) {
+    const out = [];
+    const visit = (el) => {
+      for (const child of el.children) {
+        if (name === "*" || child.tagName === name || child.localName === name) out.push(child);
+        visit(child);
+      }
+    };
+    visit(this);
+    return out;
+  }
+  getElementsByTagNameNS(ns, localName) {
+    const out = [];
+    const visit = (el) => {
+      for (const child of el.children) {
+        const nsMatch = ns === "*" || child.namespaceURI === ns;
+        const nameMatch = localName === "*" || child.localName === localName;
+        if (nsMatch && nameMatch) out.push(child);
+        visit(child);
+      }
+    };
+    visit(this);
+    return out;
+  }
+};
+var FallbackXmlDomParser = class {
+  parseFromString(xml, _type) {
+    const stripped = xml.replace(/^\uFEFF/, "").replace(/<\?[\s\S]*?\?>/g, "").replace(/<!--[\s\S]*?-->/g, "").replace(/<!DOCTYPE[^>]*>/gi, "").trim();
+    const tokenRe = /<!\[CDATA\[([\s\S]*?)\]\]>|<\/([A-Za-z_][\w:.-]*)\s*>|<([A-Za-z_][\w:.-]*)((?:\s+[A-Za-z_][\w:.-]*\s*=\s*(?:"[^"]*"|'[^']*'))*)\s*(\/?)>|([^<]+)/g;
+    const stack = [];
+    let root = null;
+    let hasError = false;
+    let lastIndex = 0;
+    for (let m = tokenRe.exec(stripped); m !== null; m = tokenRe.exec(stripped)) {
+      if (m.index !== lastIndex) {
+        hasError = true;
+        break;
+      }
+      lastIndex = tokenRe.lastIndex;
+      const [, cdata, closeName, openName, attrText, selfClose, text] = m;
+      if (cdata !== void 0) {
+        const top = stack[stack.length - 1];
+        if (top) top.el.childNodes.push({ nodeType: 3, textContent: cdata });
+      } else if (closeName !== void 0) {
+        const popped = stack.pop();
+        if (!popped || popped.el.tagName !== closeName) {
+          hasError = true;
+          break;
+        }
+      } else if (openName !== void 0) {
+        const parent = stack[stack.length - 1];
+        const ns = new Map(parent ? parent.ns : [["xml", "http://www.w3.org/XML/1998/namespace"]]);
+        const rawAttrs = [];
+        const attrRe = /([A-Za-z_][\w:.-]*)\s*=\s*(?:"([^"]*)"|'([^']*)')/g;
+        for (let am = attrRe.exec(attrText ?? ""); am !== null; am = attrRe.exec(attrText ?? "")) {
+          const name = am[1];
+          const val = decodeXmlEntities(am[2] ?? am[3] ?? "");
+          rawAttrs.push([name, val]);
+          if (name === "xmlns") ns.set("", val);
+          else if (name.startsWith("xmlns:")) ns.set(name.slice(6), val);
+        }
+        const colon = openName.indexOf(":");
+        const prefix = colon >= 0 ? openName.slice(0, colon) : null;
+        const localName = colon >= 0 ? openName.slice(colon + 1) : openName;
+        const namespaceURI = prefix ? ns.get(prefix) ?? null : ns.get("") ?? null;
+        const el = new MiniXmlElement(openName, localName, prefix, namespaceURI);
+        for (const [name, value] of rawAttrs) {
+          const ac = name.indexOf(":");
+          const ap = ac >= 0 ? name.slice(0, ac) : null;
+          const al = ac >= 0 ? name.slice(ac + 1) : name;
+          const ans = name === "xmlns" || ap === "xmlns" ? "http://www.w3.org/2000/xmlns/" : ap ? ns.get(ap) ?? null : null;
+          el.attributes.push({ name, localName: al, prefix: ap, namespaceURI: ans, value });
+        }
+        if (parent) {
+          el.parentElement = parent.el;
+          parent.el.childNodes.push(el);
+        } else if (!root) {
+          root = el;
+        } else {
+          hasError = true;
+          break;
+        }
+        if (!selfClose) stack.push({ el, ns });
+      } else if (text !== void 0) {
+        const top = stack[stack.length - 1];
+        if (top) top.el.childNodes.push({ nodeType: 3, textContent: decodeXmlEntities(text) });
+        else if (text.trim() !== "") {
+          hasError = true;
+          break;
+        }
+      }
+    }
+    if (lastIndex !== stripped.length || !root || stack.length > 0) hasError = true;
+    const errorEl = new MiniXmlElement("parsererror", "parsererror", null, null);
+    const doc = {
+      documentElement: root,
+      getElementsByTagName(name) {
+        if (name === "parsererror") return hasError ? [errorEl] : [];
+        if (!root) return [];
+        const own = name === "*" || root.tagName === name || root.localName === name ? [root] : [];
+        return [...own, ...root.getElementsByTagName(name)];
+      },
+      getElementsByTagNameNS(ns, localName) {
+        if (!root) return [];
+        const nsMatch = ns === "*" || root.namespaceURI === ns;
+        const nameMatch = localName === "*" || root.localName === localName;
+        const own = nsMatch && nameMatch ? [root] : [];
+        return [...own, ...root.getElementsByTagNameNS(ns, localName)];
+      }
+    };
+    return doc;
+  }
+};
+function defaultDomParser() {
+  return globalThis.DOMParser ?? FallbackXmlDomParser;
+}
+function toolList(provider) {
+  const tools = typeof provider.tools === "function" ? provider.tools() : provider.tools;
+  return {
+    id: provider.id,
+    title: provider.title,
+    ...provider.skill ? { skill: provider.skill } : {},
+    tools: tools.map((t) => ({ name: t.name, title: t.title, description: t.description, inputSchema: t.inputSchema, annotations: t.annotations }))
+  };
+}
+function uiTables() {
+  return {
+    layoutPresets: CHART_LAYOUT_PRESETS,
+    colorSchemes: CHART_COLOR_SCHEMES,
+    errorBars: {
+      types: CHART_ERROR_BAR_TYPES,
+      directions: CHART_ERROR_BAR_DIRECTIONS,
+      labels: CHART_ERROR_BAR_LABELS
+    },
+    paletteShades: CHART_PALETTE_SHADES,
+    dateSteps: CHART_DATE_STEPS,
+    types: CHART_TYPES,
+    typeLabels: CHART_TYPE_LABELS,
+    seriesTypes: CHART_SERIES_TYPES,
+    stackings: CHART_STACKINGS,
+    orientations: CHART_ORIENTATIONS,
+    curves: CHART_CURVES,
+    markers: CHART_MARKERS,
+    labelPositions: CHART_LABEL_POSITIONS,
+    legendPositions: CHART_LEGEND_POSITIONS,
+    numberStyles: CHART_NUMBER_STYLES,
+    trendlineTypes: CHART_TRENDLINE_TYPES,
+    axisKinds: CHART_AXIS_KINDS,
+    axisScales: CHART_AXIS_SCALES,
+    radarGraticules: CHART_RADAR_GRATICULES,
+    likertNeutrals: CHART_LIKERT_NEUTRALS,
+    likertSorts: CHART_LIKERT_SORTS,
+    sankeyLinkColors: CHART_SANKEY_LINK_COLORS,
+    referenceAxes: CHART_REFERENCE_AXES,
+    defaultPalette: DEFAULT_CHART_PALETTE,
+    defaultTheme: DEFAULT_CHART_THEME,
+    textMeasure: {
+      normalEm: 0.56,
+      boldEm: 0.6,
+      boldWeight: 600,
+      formula: "text.length * size * (weight >= 600 ? 0.6 : 0.56)"
+    }
+  };
+}
+function chartContracts() {
+  const controller = new ChartController({ measureText: conformanceChartTextMeasure });
+  const specs = createChartCommands(controller);
+  const styles = createStyleResolver({
+    layers: [{ id: "org", store: memoryStyleStore() }],
+    domains: [chartStyleDomain]
+  });
+  const DOMParser = defaultDomParser();
+  const providers = [
+    createChartToolProvider(controller, { namespace: "", DOMParser, measureText: conformanceChartTextMeasure }),
+    createChartStyleToolProvider(controller, styles, { namespace: "" }),
+    createOfficeChartToolProvider({ namespace: "", files: () => [], controller, DOMParser })
+  ].map(toolList);
+  const document = createChartEditorDocument(controller);
+  const files = {
+    "document.schema.json": { $schema: "https://json-schema.org/draft/2020-12/schema", $id: "document.schema.json", ...CHART_DOCUMENT_JSON_SCHEMA },
+    "tools.json": { providers },
+    "commands.json": specs.map((s) => ({
+      id: s.id,
+      label: s.label,
+      ...s.group ? { group: s.group } : {},
+      ...s.keywords?.length ? { keywords: s.keywords } : {},
+      ...s.description ? { description: s.description } : {},
+      ...s.params ? { params: s.params } : {},
+      ...s.shortcut !== void 0 ? { shortcut: s.shortcut } : {},
+      ...s.scope ? { scope: s.scope } : {},
+      undoable: !!s.undoable,
+      readOnly: !!s.readOnly,
+      ...s.hidden ? { hidden: true } : {}
+    })),
+    "ui.json": uiTables()
+  };
+  files["manifest.json"] = {
+    domain: "chart",
+    formatVersion: CHART_CONTRACT_FORMAT_VERSION,
+    document: { kind: document.kind, formatVersion: document.formatVersion },
+    counts: { providers: providers.length, tools: providers.reduce((n, p) => n + p.tools.length, 0), commands: specs.length },
+    files: Object.keys(files).sort()
+  };
+  document.destroy?.();
+  controller.destroy();
+  return files;
+}
+function decodeBase64Bytes(data) {
+  if (data instanceof Uint8Array) return data;
+  const clean = String(data).replace(/^data:[^,]*,/, "").replace(/\s+/g, "");
+  const binary = atob(clean);
+  const out = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) out[i] = binary.charCodeAt(i);
+  return out;
+}
+function parseSetupFiles(raw) {
+  if (!raw) return [];
+  if (Array.isArray(raw)) {
+    return raw.map((entry) => ({ name: entry.name, data: decodeBase64Bytes(entry.data) }));
+  }
+  return Object.entries(raw).map(([name, data]) => ({
+    name,
+    data: decodeBase64Bytes(data)
+  }));
+}
+function createChartConformanceHost(setup = {}) {
+  registerChartMap(EUROPE_CHART_MAP);
+  if (Array.isArray(setup.maps)) {
+    for (const map of setup.maps) registerChartMap(map);
+  }
+  let raceClock = 0;
+  let raceQueue = [];
+  const raceTicker = {
+    now: () => raceClock,
+    next: (step) => {
+      raceQueue.push(step);
+      return () => {
+        raceQueue = raceQueue.filter((q) => q !== step);
+      };
+    }
+  };
+  const advanceRace = (ms = 16) => {
+    raceClock += ms;
+    const pending = raceQueue;
+    raceQueue = [];
+    for (const step of pending) step();
+  };
+  const width = typeof setup.width === "number" ? setup.width : 640;
+  const height = typeof setup.height === "number" ? setup.height : 400;
+  const history = new HistoryManager();
+  const controller = new ChartController({
+    spec: setup.spec,
+    history,
+    raceTicker,
+    measureText: conformanceChartTextMeasure
+  });
+  const openFiles = parseSetupFiles(setup.files);
+  const styleFiles = setup.style ? {
+    "house/SKILL.md": "---\nname: house\ndescription: House chart style.\n---\nFollow the house chart style.",
+    "house/chart.json": JSON.stringify(setup.style)
+  } : {};
+  const styles = createStyleResolver({
+    layers: [{ id: "org", store: memoryStyleStore(styleFiles) }],
+    domains: [chartStyleDomain]
+  });
+  const commands = new CommandRegistry({ context: controller, history });
+  commands.register(createChartCommands(controller));
+  const DOMParser = defaultDomParser();
+  const registry = new ToolRegistry({ validateArguments: true });
+  registry.register(
+    createChartToolProvider(controller, {
+      namespace: "",
+      size: { width, height },
+      readOnly: setup.readOnly,
+      DOMParser,
+      measureText: conformanceChartTextMeasure
+    })
+  );
+  registry.register(createChartStyleToolProvider(controller, styles, { namespace: "" }));
+  registry.register(
+    createOfficeChartToolProvider({
+      namespace: "",
+      files: () => openFiles,
+      controller,
+      readOnly: setup.readOnly,
+      DOMParser
+    })
+  );
+  registry.register(createCommandToolProvider(commands, { id: "chart-commands", namespace: "" }));
+  const document = createChartEditorDocument(controller);
+  return {
+    controller,
+    advanceRace,
+    callTool: (name, args) => registry.callTool(name, args),
+    document: () => toEditorDocumentFile(document),
+    pixels: () => {
+      throw new Error("The chart conformance host has no pixels; compare its document, results, render data and SVG export.");
+    },
+    render: () => {
+      const state = controller.getState();
+      return layoutChart(controller.toJSON(), {
+        width,
+        height,
+        selection: state.selection,
+        raceFrame: state.raceFrame,
+        measureText: conformanceChartTextMeasure
+      });
+    },
+    dispose: () => {
+      document.destroy?.();
+      controller.destroy();
+    }
+  };
+}
 export {
   CHART_AXIS_KINDS,
   CHART_AXIS_SCALES,
   CHART_COLOR_SCHEMES,
+  CHART_CONTRACT_FORMAT_VERSION,
   CHART_CURVES,
   CHART_DATE_STEPS,
+  CHART_DOCUMENT_JSON_SCHEMA,
   CHART_ERROR_BAR_DIRECTIONS,
   CHART_ERROR_BAR_LABELS,
   CHART_ERROR_BAR_TYPES,
@@ -3341,6 +3804,7 @@ export {
   chartColorDistance,
   chartColorInputValue,
   chartColorsByCategory,
+  chartContracts,
   chartContrastRatio,
   chartDataFromTable,
   chartDataToTable,
@@ -3414,8 +3878,10 @@ export {
   cloneChartSpec,
   cloneChartTree,
   compileChartFormatCode,
+  conformanceChartTextMeasure,
   contrastingTextColor,
   createChartCommands,
+  createChartConformanceHost,
   createChartController,
   createChartEditorDocument,
   createChartRasterizer,

package/dist/chart/tools.d.cts

@@ -1,5 +1,6 @@
 import type { AgentToolProvider } from '../tools/registry.cjs';
 import type { ChartController } from './controller.cjs';
+import { type ChartTextMeasure } from './layout.cjs';
 import type { ChartDirector, ChartDirectorActor } from './presence.cjs';
 type ParserCtor = {
     new (): DOMParser;
@@ -19,6 +20,8 @@ export interface ChartToolProviderOptions {
         width: number;
         height: number;
     };
+    /** Text width in pixels for layout, summaries and hit testing (default: the controller's `measureText`, else `estimateChartTextWidth`). */
+    measureText?: ChartTextMeasure;
     /** Enables `import_chart_ooxml` (reading Office chart XML needs a DOMParser). Default: the global one, if any. */
     DOMParser?: ParserCtor;
     /**

package/dist/chart/tools.d.ts

@@ -1,5 +1,6 @@
 import type { AgentToolProvider } from '../tools/registry.js';
 import type { ChartController } from './controller.js';
+import { type ChartTextMeasure } from './layout.js';
 import type { ChartDirector, ChartDirectorActor } from './presence.js';
 type ParserCtor = {
     new (): DOMParser;
@@ -19,6 +20,8 @@ export interface ChartToolProviderOptions {
         width: number;
         height: number;
     };
+    /** Text width in pixels for layout, summaries and hit testing (default: the controller's `measureText`, else `estimateChartTextWidth`). */
+    measureText?: ChartTextMeasure;
     /** Enables `import_chart_ooxml` (reading Office chart XML needs a DOMParser). Default: the global one, if any. */
     DOMParser?: ParserCtor;
     /**