@openpresentation/opf-pptx 0.13.2 → 0.15.0

package/dist/chart-types.js

@@ -1,34 +1,35 @@
 // OPF chart type ids -> native PowerPoint chart constructs (FF-22).
 //
 // The core catalog keeps one chart type per Aspose.Slides ChartType
-// (spec/catalogs/chart-types, OpenPresentation/opf#121) and deprecates the
-// rest with a replacement id. The published core package this exporter
-// depends on predates that metadata, so the mapping is carried here. Kept ids
-// map to the exact Office construct; deprecated ids resolve to their
-// replacement; any other id keeps the legacy substring heuristic.
+// (spec/catalogs/chart-types, OpenPresentation/opf#121). The mapping is carried
+// here so the exporter stays self-contained. Every id maps to the exact Office construct (OPF 0.15: chart.type is a
+// schema enum, so there is no other id).
 
 const category = (pptx, extra = {}) => ({ family: 'category', pptx, ...extra });
 
 export const CHART_TYPES = Object.freeze({
   column: category('bar', { aspose: 'ClusteredColumn', barDir: 'col', grouping: 'clustered' }),
-  'stacked-column-3x': category('bar', { aspose: 'StackedColumn', barDir: 'col', grouping: 'stacked' }),
-  '100pct-stacked-column-3x': category('bar', { aspose: 'PercentsStackedColumn', barDir: 'col', grouping: 'percentStacked' }),
+  'stacked-column': category('bar', { aspose: 'StackedColumn', barDir: 'col', grouping: 'stacked' }),
+  '100pct-stacked-column': category('bar', { aspose: 'PercentsStackedColumn', barDir: 'col', grouping: 'percentStacked' }),
   bar: category('bar', { aspose: 'ClusteredBar', barDir: 'bar', grouping: 'clustered' }),
-  'stacked-bar-3x': category('bar', { aspose: 'StackedBar', barDir: 'bar', grouping: 'stacked' }),
-  '100pct-stacked-bar-3x': category('bar', { aspose: 'PercentsStackedBar', barDir: 'bar', grouping: 'percentStacked' }),
+  'stacked-bar': category('bar', { aspose: 'StackedBar', barDir: 'bar', grouping: 'stacked' }),
+  '100pct-stacked-bar': category('bar', { aspose: 'PercentsStackedBar', barDir: 'bar', grouping: 'percentStacked' }),
   line: category('line', { aspose: 'Line', grouping: 'standard', markers: false }),
   'line-with-markers': category('line', { aspose: 'LineWithMarkers', grouping: 'standard', markers: true }),
-  'stacked-line-3x': category('line', { aspose: 'StackedLine', grouping: 'stacked', markers: false }),
-  'stacked-line-with-markers-3x': category('line', { aspose: 'StackedLineWithMarkers', grouping: 'stacked', markers: true }),
+  'stacked-line': category('line', { aspose: 'StackedLine', grouping: 'stacked', markers: false }),
+  'stacked-line-with-markers': category('line', { aspose: 'StackedLineWithMarkers', grouping: 'stacked', markers: true }),
   area: category('area', { aspose: 'Area', grouping: 'standard' }),
-  'stacked-area-3x': category('area', { aspose: 'StackedArea', grouping: 'stacked' }),
-  '100pct-stacked-area-3x': category('area', { aspose: 'PercentsStackedArea', grouping: 'percentStacked' }),
+  'stacked-area': category('area', { aspose: 'StackedArea', grouping: 'stacked' }),
+  '100pct-stacked-area': category('area', { aspose: 'PercentsStackedArea', grouping: 'percentStacked' }),
   pie: { family: 'circular', pptx: 'pie', aspose: 'Pie' },
   doughnut: { family: 'circular', pptx: 'doughnut', aspose: 'Doughnut' },
   scatter: { family: 'xy', pptx: 'scatter', aspose: 'ScatterWithMarkers' },
   radar: category('radar', { aspose: 'Radar', radarStyle: 'standard', markers: false }),
   'radar-with-markers': category('radar', { aspose: 'RadarWithMarkers', radarStyle: 'marker', markers: true }),
   'filled-radar': category('radar', { aspose: 'FilledRadar', radarStyle: 'filled', markers: false }),
+  // FA-15: clustered columns (a c:barChart on the primary axes) with line series with markers (a c:lineChart per value axis;
+  // the secondary one crosses at the right on a deleted second c:catAx). Core's resolveChartData says which series is which.
+  combo: { family: 'combo', pptx: 'bar', aspose: 'ClusteredColumn', barDir: 'col', grouping: 'clustered', markers: true },
   // Office 2016 chartex constructs (cx:chartSpace, one cx:series per plot,
   // named by layoutId). `requires` is the markup-compatibility namespace the
   // slide's mc:Choice names, so older readers take the classic fallback.
@@ -75,65 +76,12 @@ export function chartTypeFromChartex(layoutIds) {
   return null;
 }
 
-const variants = (base, target) => Object.fromEntries([base, `${base}-2x`, `${base}-3x`].map((id) => [id, target]));
-
-// Deprecated core ids (opf 0.12.0 removes them) -> replacement id.
-export const DEPRECATED_CHART_TYPES = Object.freeze({
-  ...variants('100pct-bullet-bar', '100pct-stacked-bar-3x'),
-  '100pct-progress-bar': '100pct-stacked-bar-3x',
-  '100pct-stacked-bar-2x': '100pct-stacked-bar-3x',
-  ...variants('100pct-bullet-column', '100pct-stacked-column-3x'),
-  '100pct-stacked-column-2x': '100pct-stacked-column-3x',
-  '100pct-stacked-area-2x': '100pct-stacked-area-3x',
-  australia: 'world',
-  canada: 'world',
-  'united-kingdom': 'world',
-  'united-states': 'world',
-  'box-and-whisker-2x': 'box-and-whisker',
-  'box-and-whisker-3x': 'box-and-whisker',
-  ...variants('bullet-bar', 'bar'),
-  'clustered-bar-2x': 'bar',
-  ...variants('bullet-column', 'column'),
-  'clustered-column': 'column',
-  ...Object.fromEntries(['', '-2x', '-3x', '-4x', '-5x', '-6x'].map((suffix) => [`dot-plot${suffix}`, 'scatter'])),
-  dumbbell: 'scatter',
-  'line-2x': 'line',
-  'line-3x': 'line',
-  'line-with-high-low': 'line',
-  ...Object.fromEntries(['', '-2x', '-3x', '-4x', '-5x', '-6x'].map((suffix) => [`sparkline${suffix}`, 'line'])),
-  'line-with-high-low-and-markers': 'line-with-markers',
-  'line-with-markers-2x': 'line-with-markers',
-  'line-with-markers-3x': 'line-with-markers',
-  'stacked-area-2x': 'stacked-area-3x',
-  'stacked-bar-2x': 'stacked-bar-3x',
-  'stacked-column-2x': 'stacked-column-3x',
-  'stacked-line-2x': 'stacked-line-3x',
-  'stacked-line-with-markers-2x': 'stacked-line-with-markers-3x',
-  'treemap-2x': 'treemap',
-  'treemap-3x': 'treemap',
-});
-
-const ALIASES = Object.freeze({ donut: 'doughnut' });
-
-// Resolve an OPF chart type id to {id, spec}. Kept and deprecated ids resolve
-// to a kept id; anything else returns the legacy heuristic with id: null.
+// Resolve an OPF chart type id to {id, spec}. `chart.type` is a schema enum in OPF 0.15 (core CHART_TYPES), so every
+// validated document names one of these; an id outside the table (a caller that skipped validation) resolves to
+// {id: null, spec: undefined}.
 export function resolveChartType(type) {
-  const raw = String(type ?? '').trim().toLowerCase();
-  const id = ALIASES[raw] ?? DEPRECATED_CHART_TYPES[raw] ?? raw;
-  if (Object.hasOwn(CHART_TYPES, id)) return { id, spec: CHART_TYPES[id] };
-  return { id: null, spec: legacyChartType(raw) };
-}
-
-// The pre-FF-22 heuristic for ids outside the core catalog.
-function legacyChartType(normalized) {
-  if (normalized.includes('pie')) return CHART_TYPES.pie;
-  if (normalized.includes('doughnut') || normalized.includes('donut')) return CHART_TYPES.doughnut;
-  if (normalized.includes('area')) return { ...CHART_TYPES.area, legacy: true };
-  if (normalized.includes('line')) return { ...CHART_TYPES['line-with-markers'], legacy: true };
-  if (normalized.includes('scatter')) return CHART_TYPES.scatter;
-  if (normalized.includes('radar')) return { ...CHART_TYPES.radar, legacy: true };
-  const grouping = normalized.includes('stacked') ? 'stacked' : 'clustered';
-  return category('bar', { barDir: normalized.includes('bar') ? 'bar' : 'col', grouping, legacy: true });
+  const id = String(type ?? '').trim();
+  return Object.hasOwn(CHART_TYPES, id) ? { id, spec: CHART_TYPES[id] } : { id: null, spec: undefined };
 }
 
 // Native construct -> kept OPF id, for import. `node` is the parsed chart-type
@@ -149,17 +97,17 @@ export function chartTypeFromNative(element, node) {
     case 'barChart':
     case 'bar3DChart': {
       const direction = attr('barDir') === 'bar' ? 'bar' : 'column';
-      if (percent) return `100pct-stacked-${direction}-3x`;
-      if (stacked) return `stacked-${direction}-3x`;
+      if (percent) return `100pct-stacked-${direction}`;
+      if (stacked) return `stacked-${direction}`;
       return direction;
     }
     case 'lineChart':
     case 'line3DChart':
-      if (stacked) return markers ? 'stacked-line-with-markers-3x' : 'stacked-line-3x';
+      if (stacked) return markers ? 'stacked-line-with-markers' : 'stacked-line';
       return markers ? 'line-with-markers' : 'line';
     case 'areaChart':
     case 'area3DChart':
-      return percent ? '100pct-stacked-area-3x' : stacked ? 'stacked-area-3x' : 'area';
+      return percent ? '100pct-stacked-area' : stacked ? 'stacked-area' : 'area';
     case 'pieChart':
     case 'pie3DChart':
     case 'ofPieChart':
@@ -179,6 +127,25 @@ export function chartTypeFromNative(element, node) {
   }
 }
 
+/**
+ * A combo chart in a parsed c:plotArea: exactly one clustered (or standard) column c:barChart and one or two standard
+ * c:lineChart groups, and no other chart group. Returns {bar, lines: [{node, secondary}]} (a line group is secondary when it
+ * plots against an axis the column group does not use) or null for any other plot area.
+ */
+export function comboFromNative(plotArea) {
+  if (!plotArea) return null;
+  const bars = asArray(plotArea['c:barChart']);
+  const lines = asArray(plotArea['c:lineChart']);
+  if (bars.length !== 1 || lines.length < 1 || lines.length > 2) return null;
+  if (NATIVE_CHART_ELEMENTS.some((element) => element !== 'barChart' && element !== 'lineChart' && plotArea[`c:${element}`] !== undefined)) return null;
+  const [bar] = bars;
+  if ((bar['c:barDir']?.val ?? 'col') !== 'col' || !['clustered', 'standard'].includes(bar['c:grouping']?.val ?? 'clustered')) return null;
+  if (lines.some((line) => !['standard', undefined].includes(line['c:grouping']?.val))) return null;
+  const axes = (node) => asArray(node['c:axId']).map((axis) => String(axis?.val));
+  const primary = axes(bar);
+  return { bar, lines: lines.map((node) => ({ node, secondary: axes(node).some((id) => !primary.includes(id)) })) };
+}
+
 export const NATIVE_CHART_ELEMENTS = Object.freeze([
   'barChart', 'bar3DChart', 'lineChart', 'line3DChart', 'pieChart', 'pie3DChart', 'ofPieChart',
   'doughnutChart', 'areaChart', 'area3DChart', 'scatterChart', 'radarChart',
@@ -191,6 +158,7 @@ function asArray(value) {
 // PptxGenJS omits or cannot express parts of these constructs. Rewrite only
 // the generated chart-type element so the part states the exact grouping.
 export function applyChartConstruct(xml, spec) {
+  if (spec?.family === 'combo') return applyComboConstruct(xml);
   // ScatterWithMarkers: the core catalog records scatterStyle "marker" (markers, no connecting line). PptxGenJS writes lineMarker and relies on the series line being noFill.
   if (spec?.family === 'xy') return xml.replace(/<c:scatterStyle val="[^"]*"\/>/, '<c:scatterStyle val="marker"/>');
   if (!spec || spec.family !== 'category') return xml;
@@ -214,3 +182,21 @@ export function applyChartConstruct(xml, spec) {
   }
   return xml.slice(0, start) + open + body + xml.slice(end);
 }
+
+// FA-15: PptxGenJS writes each c:lineChart of a multi-type chart without the c:grouping CT_LineChart requires, gives its series
+// the bar-only c:invertIfNegative, and writes c:dLbls before c:marker (CT_LineSer orders marker, dPt, dLbls). Rewrite every line
+// group of a combo chart into schema order; the c:barChart already states barDir and grouping.
+export function applyComboConstruct(xml) {
+  return xml.replace(/<c:lineChart>([\s\S]*?)<\/c:lineChart>/g, (_, body) => {
+    let next = `<c:grouping val="standard"/>${body.replace(/<c:grouping val="[^"]*"\/>/g, '')}`;
+    next = next.replace(/<c:invertIfNegative val="[^"]*"\/>/g, '');
+    next = next.replace(/<c:ser>[\s\S]*?<\/c:ser>/g, (ser) => {
+      const marker = /<c:marker>[\s\S]*?<\/c:marker>/.exec(ser)?.[0];
+      const labels = /<c:dLbls>[\s\S]*?<\/c:dLbls>/.exec(ser);
+      if (!marker || !labels || ser.indexOf(marker) < labels.index) return ser;
+      const without = ser.replace(marker, '');
+      return without.replace(/<c:dLbls>/, `${marker}<c:dLbls>`);
+    });
+    return `<c:lineChart>${next}</c:lineChart>`;
+  });
+}

package/dist/code-provenance.js

@@ -19,8 +19,8 @@ function unhex(value) {
   return JSON.parse(dec.decode(Uint8Array.from(value.match(/../g),byte=>parseInt(byte,16))));
 }
 
-export function codeManifest(value, layout, group) {
-  return {v:1, group, role:'panel', value, parts:layout.parts.map(part=>({role:part.role, generated:part.generated === true,
+export function codeManifest(value, layout, group, bands) {
+  return {v:1, group, role:'panel', value, ...(bands ? {bands} : {}), parts:layout.parts.map(part=>({role:part.role, generated:part.generated === true,
     lines:part.fit.sourceLines.map(({start,end,nextStart,boundary})=>({start,end,nextStart,boundary}))}))};
 }
 
@@ -126,11 +126,16 @@ function sourceFor(value, role, generated) {
 function validateManifest(manifest) {
   const {value,parts} = manifest;
   const object = value && typeof value === 'object' && !Array.isArray(value);
-  if (typeof value !== 'string' && (!object || typeof value.source !== 'string' || Object.keys(value).some(key=>!['source','filename','language'].includes(key)) || ['filename','language'].some(key=>value[key] !== undefined && typeof value[key] !== 'string'))) throw new Error('Invalid source value.');
+  if (typeof value !== 'string' && (!object || typeof value.source !== 'string' || Object.keys(value).some(key=>!['source','filename','language','highlight'].includes(key)) || ['filename','language'].some(key=>value[key] !== undefined && typeof value[key] !== 'string'))) throw new Error('Invalid source value.');
+  // FA-13: code.highlight is a list of line numbers and [start, end] pairs from 1.
+  const line = entry => Number.isSafeInteger(entry) && entry >= 1;
+  if (object && value.highlight !== undefined && (!Array.isArray(value.highlight) || !value.highlight.length || !value.highlight.every(entry => line(entry) || (Array.isArray(entry) && entry.length === 2 && entry.every(line))))) throw new Error('Invalid highlight value.');
   // Empty metadata is preserved in the manifest but does not produce a label.
   const roles = [...(object && value.filename ? ['filename'] : []), ...(object && value.language ? ['language'] : []), 'body'];
   if (roles.length === 1) roles.unshift('language');
   if (!Array.isArray(parts) || parts.length !== roles.length) throw new Error('Invalid code parts.');
+  // FA-13: the number of native highlight bands the export drew behind the lines.
+  if (manifest.bands !== undefined && (!Number.isSafeInteger(manifest.bands) || manifest.bands < 1 || manifest.bands > 100000 || !object || value.highlight === undefined)) throw new Error('Invalid highlight bands.');
   parts.forEach((part,i)=>{
     const generated = roles.length === 2 && roles[0] === 'language' && !(object && (value.filename || value.language)) && i === 0;
     if (part.role !== roles[i] || part.generated !== generated || !Array.isArray(part.lines) || !part.lines.length) throw new Error('Invalid source part.');
@@ -180,10 +185,21 @@ export function importCodeGroups(shapes, paragraphs, relationships, entries, rep
       if (panels.length !== 1 || panels[0].text !== '') throw new Error('Missing, duplicated or edited panel.');
       const panel = panels[0], manifest = panel.data;
       validateManifest(manifest);
+      // FA-13: highlight bands are decoration. The panel and every line are required; a band may be missing (someone removed it in
+      // PowerPoint) without losing the source, and code.highlight itself comes from the manifest value.
       const expectedCount = 1 + manifest.parts.reduce((sum,part)=>sum+part.lines.length,0);
-      if (group.length !== expectedCount || new Set(group.map(item=>item.shape)).size !== group.length) throw new Error('Incomplete or duplicated code shapes.');
+      const bandCount = group.filter(item=>item.data.role === 'highlight').length;
+      if (group.length !== expectedCount + bandCount || new Set(group.map(item=>item.shape)).size !== group.length) throw new Error('Incomplete or duplicated code shapes.');
       const nativeLines = new Map();
+      const seenBands = new Set();
       for (const item of group) if (item !== panel) {
+        // FA-13: a highlight band holds no text; it only has to be one of the manifest's bands.
+        if (item.data.role === 'highlight') {
+          const {index} = item.data;
+          if (!Number.isSafeInteger(index) || index < 0 || index >= (manifest.bands ?? 0) || seenBands.has(index) || item.text !== '') throw new Error('Ambiguous highlight band.');
+          seenBands.add(index);
+          continue;
+        }
         const {role,part,line} = item.data, key = `${part}:${line}`;
         if (role !== 'line' || !Number.isSafeInteger(part) || !Number.isSafeInteger(line) || !manifest.parts[part]?.lines[line] || nativeLines.has(key)) throw new Error('Ambiguous source line.');
         nativeLines.set(key,item.text);

package/dist/color-ref.js

@@ -1,7 +1,7 @@
 // Export ColorRef through published core resolveColorRef(). Keep 8-digit hex
 // alpha locally: normalizeHexColor() strips the AA byte, which PptxGenJS needs.
 
-import { resolveColorRef as resolveCoreColorRef } from "@openpresentation/opf";
+import { resolveColorRef as resolveCoreColorRef } from "@openpresentation/opf/composition";
 
 const UNRESOLVED = "";
 
@@ -38,14 +38,19 @@ export function resolveVariableColors(variables) {
   return isPlainObject(variables) ? variables : {};
 }
 
+// The color roles a ColorRef names. An export context carries them resolved (core resolveColorRoles); a bare
+// context with only `colors` maps those fields (the exporter's colors.accent is the primary color).
 function coreRoles(ctx) {
   const colors = ctx.colors ?? {};
+  const roles = ctx.roles;
   return {
-    background: withHash(colors.background),
-    surface: withHash(colors.surface),
-    text: withHash(colors.text),
-    textSecondary: withHash(colors.mutedText),
-    accent: withHash(colors.accent),
+    primary: withHash(roles?.primary),
+    secondary: withHash(roles?.secondary),
+    accent: withHash(roles ? roles.accent : colors.accent),
+    background: withHash(roles?.background ?? colors.background),
+    surface: withHash(roles?.surface ?? colors.surface),
+    text: withHash(roles?.text ?? colors.text),
+    textSecondary: withHash(roles?.textSecondary ?? colors.mutedText),
   };
 }
 
@@ -76,6 +81,7 @@ export function colorContext(context, fallback) {
   return {
     colorScheme: context.colorScheme,
     colors: context.colors,
+    roles: context.roles,
     variables: context.variables ?? {},
     fallback: fallback ?? context.colors?.text ?? "000000",
   };

package/dist/data-provenance.js

@@ -1,7 +1,7 @@
 import {XMLParser} from 'fast-xml-parser';
-import {validatePresentation} from '@openpresentation/opf';
+import {checkFormat, isValidFormat} from './format-check.js';
 import {decodeTextTag, encodeTextTag} from './code-provenance.js';
-import {chartUsesDataFields, isDatasetRef, numberFormatFromExcel, resolveTableData, tableCellDisplayValue, tableUsesDataFields} from './chart-data.js';
+import {chartUsesDataFields, isDatasetRef, fromExcelNumberFormat, resolveTableData, tableCellDisplayValue, tableUsesDataFields} from './chart-data.js';
 
 // RR-54: chart and table data survive a PPTX round trip (core docs/chart-table-data.md).
 //
@@ -13,11 +13,13 @@ import {chartUsesDataFields, isDatasetRef, numberFormatFromExcel, resolveTableDa
 //
 //   OPF_DATASETS_V1  on p:presentation (beside OPF_DOCUMENT_V1): the whole `datasets` map, unused datasets included.
 //   OPF_DATA_V1      on each chart or table graphic frame that uses one of the fields above:
-//     chart  {v: 1, kind: 'chart', data, mapping?, dataset?: hash, evidence: [hash]}   `data` is the authored
+//     chart  {v: 1, kind: 'chart', data, mapping?, highlight?, dataset?: hash, evidence: [hash]}   `data` is the authored
 //            chart.data (a dataset reference, or inline columns with DataColumn objects and `source`); `evidence`
 //            hashes the native caches (series names, categories, values and format codes) of the chart part(s) the frame
 //            shows (the chartex part and its classic fallback); `dataset` hashes the referenced dataset, so a slide
-//            pasted into a deck whose dataset of the same id holds other data keeps its values inline.
+//            pasted into a deck whose dataset of the same id holds other data keeps its values inline. `highlight` (FA-14) is
+//            the authored chart.highlight: the native chart carries only the accent and muted colours it produced, which no
+//            exact inference turns back into series and category names, and a chart with only a highlight records its inline `data`.
 //     table  {v: 1, kind: 'table', table}                                a dataset-backed table, as authored
 //            {v: 1, kind: 'table', headers: [[column, header, text]], cells: [[row, column, value, format, text]]}
 //                                                                         an inline table: the DataColumn or formatted
@@ -79,13 +81,13 @@ const canonicalValue = text => NUMBER.test(text.trim()) && Number.isFinite(Numbe
 // A General format code is left out: on a plain save PowerPoint writes <c:formatCode>General</c:formatCode> into every
 // cache that has none (PptxGenJS writes none on pie and doughnut series), so General and no code are the same evidence.
 const generalCode = code => /^\s*general\s*$/i.test(code);
-// A format code is hashed in core's canonical form (numberFormatFromExcel), because a plain PowerPoint save re-spells codes
+// A format code is hashed in core's canonical form (fromExcelNumberFormat), because a plain PowerPoint save re-spells codes
 // without changing what they show: `$#,##0.0` becomes `\$#,##0.0` and `#,##0 "units"` becomes `#,##0\ "units"` (native
 // check opf#385). Core reads quoted and backslash-escaped literals and literal-safe characters to the same NumberFormat, so
 // both spellings hash equal, while a real change (another number of decimals, another unit) still changes the hash. A code
 // core cannot map is hashed as written; the `opf:` prefix keeps a mapped form apart from a verbatim code of the same text.
 const formatEvidence = code => {
-  const format = numberFormatFromExcel(code);
+  const format = fromExcelNumberFormat(code);
   return typeof format === 'string' ? `format:opf:${format}` : `format:${code}`;
 };
 function hash(text) {
@@ -119,9 +121,9 @@ const datasetHash = (datasets, id) => own(datasets, id) ? hash(canonical(dataset
 
 /** The record of a chart that uses an RR-54 data field, or undefined (the frame then carries no tag). */
 export function chartDataRecord(chart, datasets) {
-  if (!chartUsesDataFields(chart)) return undefined;
+  if (!chartUsesDataFields(chart) && !object(chart?.highlight)) return undefined;
   const dataset = isDatasetRef(chart.data) ? datasetHash(datasets, chart.data.dataset) : undefined;
-  return {v: 1, kind: 'chart', data: clone(chart.data), ...(chart.mapping !== undefined ? {mapping: clone(chart.mapping)} : {}), ...(dataset ? {dataset} : {})};
+  return {v: 1, kind: 'chart', data: clone(chart.data), ...(chart.mapping !== undefined ? {mapping: clone(chart.mapping)} : {}), ...(object(chart.highlight) ? {highlight: clone(chart.highlight)} : {}), ...(dataset ? {dataset} : {})};
 }
 
 /** The record of a table that is dataset-backed or formats numbers, or undefined. `layout` is the exported table layout. */
@@ -281,8 +283,9 @@ export function readDatasetsTag(entries, presentationRoot, relationships, report
     const datasets = readTags(entries, presentationRoot?.['p:custDataLst'], relationships, DATASETS_TAG);
     if (datasets === undefined) return undefined;
     if (!object(datasets) || !Object.keys(datasets).length) throw Error('Invalid datasets record.');
-    const result = validatePresentation({slides: [{title: 'Datasets'}], datasets});
-    if (!result.valid) throw Error(`The stored datasets do not validate (${result.errors[0]?.path ?? ''} ${result.errors[0]?.message ?? ''}).`);
+    const report = checkFormat({slides: [{title: 'Datasets'}], datasets});
+    const [first] = report.findings.filter(finding => finding.severity === 'error');
+    if (!report.valid) throw Error(`The stored datasets do not validate (${first?.path ?? ''} ${first?.message ?? ''}).`);
     return datasets;
   } catch (error) {
     report?.({code: 'invalid-data-provenance', path: 'datasets', message: `${error instanceof Error ? error.message : String(error)} The datasets recorded at export were not restored.`});
@@ -297,6 +300,7 @@ export function readDataTag(entries, frame, relationships) {
   if (!object(record) || record.v !== 1 || !['chart', 'table'].includes(record.kind)) throw Error('Unsupported data provenance version.');
   if (record.kind === 'chart' && (!object(record.data) || !Array.isArray(record.evidence) || !record.evidence.every(item => typeof item === 'string'))) throw Error('Invalid chart data record.');
   if (record.kind === 'chart' && record.dataset !== undefined && typeof record.dataset !== 'string') throw Error('Invalid chart data record.');
+  if (record.kind === 'chart' && record.highlight !== undefined && !object(record.highlight)) throw Error('Invalid chart data record.');
   if (record.kind === 'table' && !(object(record.table) || (Array.isArray(record.headers) && Array.isArray(record.cells)))) throw Error('Invalid table data record.');
   // Inline table entries are [column, header, text] and [row, column, value, format, text]; their indices are array
   // indices (non-negative integers), never a key such as "__proto__" or "length".
@@ -309,7 +313,7 @@ export function readDataTag(entries, frame, relationships) {
   return record;
 }
 
-const validWith = (payload, datasets) => validatePresentation({slides: [{title: 'Data', ...payload}], ...(datasets ? {datasets} : {})}).valid;
+const validWith = (payload, datasets) => isValidFormat({slides: [{title: 'Data', ...payload}], ...(datasets ? {datasets} : {})});
 
 /**
  * The authored chart data while the native caches are unchanged: the imported chart (type and options) with the recorded
@@ -317,7 +321,7 @@ const validWith = (payload, datasets) => validatePresentation({slides: [{title:
  */
 export function restoreChartData(chart, record, evidence, {datasets, report}) {
   if (!record.evidence.includes(evidence)) {
-    report({code: 'chart-data-provenance-changed', message: 'The chart\'s cached data or number formats changed after export (for example in Edit Data), so the dataset reference, column mapping, column formats and data source recorded at export were not restored; the chart imports the values and formats it now shows.'});
+    report({code: 'chart-data-provenance-changed', message: 'The chart\'s cached data or number formats changed after export (for example in Edit Data), so the dataset reference, column mapping, column formats and data source recorded at export were not restored; the chart imports the values and formats it now shows.' + (record.highlight ? ' The chart highlight (series and categories named at export) was not restored either: its names refer to the data as exported.' : '')});
     return chart;
   }
   if (isDatasetRef(record.data) && !own(datasets, record.data.dataset)) {
@@ -328,8 +332,8 @@ export function restoreChartData(chart, record, evidence, {datasets, report}) {
     report({code: 'chart-dataset-unavailable', message: `The chart referenced dataset '${record.data.dataset}', but this package's dataset of that id holds other data than at export (a slide pasted from another deck); the chart imports its values inline.`});
     return chart;
   }
-  const {mapping: _mapping, ...rest} = chart;
-  const restored = {...rest, data: clone(record.data), ...(record.mapping !== undefined ? {mapping: clone(record.mapping)} : {})};
+  const {mapping: _mapping, highlight: _highlight, ...rest} = chart;
+  const restored = {...rest, data: clone(record.data), ...(record.mapping !== undefined ? {mapping: clone(record.mapping)} : {}), ...(record.highlight !== undefined ? {highlight: clone(record.highlight)} : {})};
   if (!validWith({chart: restored}, isDatasetRef(record.data) ? datasets : undefined)) {
     report({code: 'invalid-data-provenance', message: 'The chart data recorded at export does not form a valid chart; the chart imports the values it shows.'});
     return chart;