@openpresentation/opf-pptx 0.18.0 → 0.18.1

package/README.md

@@ -63,7 +63,7 @@ const bytes = await toPptx({
 await fs.promises.writeFile("quarterly-review.pptx", bytes);
 ```
 
-`toPptx` returns a `Uint8Array` containing a PowerPoint-openable `.pptx`. It does not fetch remote assets. Data URI images and local paths can be embedded directly; hosts that need private asset loading should pass `imageResolver(src, context)`. Every picture path (image blocks and region images, quote photos, slide and deck background pictures, watermarks, cover logos, header and footer images and logos, picture bullets) reports an unresolved source with exactly one `unresolved-asset` diagnostic at its OPF path and draws the preview's fallback (the placeholder, the background colour, no watermark, or the character bullets), so strict CLI export (`--fail-on warning`) gates it. A local file path that cannot be read is unresolved like any other source (`reason: 'file-unreadable'`), instead of failing the export. Set `strictAssets: true` to turn unresolved or remote image assets into structured `OPFPptxError` failures instead of editable placeholder boxes.
+`toPptx` returns a `Uint8Array` containing a PowerPoint-openable `.pptx`. It does not fetch remote assets. Data URI images and local paths can be embedded directly; hosts that need private asset loading should pass `imageResolver(src, context)`. Every picture path (image blocks and region images, quote photos, slide and deck background pictures, watermarks, cover logos, header and footer images and logos, picture bullets) reports an unresolved source with exactly one `unresolved-asset` diagnostic at its OPF path and draws the preview's fallback (the placeholder, the background colour, no watermark, or the character bullets), so strict CLI export (`--fail-on warning`) gates it. A local file path that cannot be read is unresolved like any other source (`reason: 'file-unreadable'`), instead of failing the export. Set `strictAssets: true` to turn unresolved or remote image assets into structured `OPFPptxError` failures instead of editable placeholder boxes. The "Image unavailable" placeholder (a dashed panel `OPF image placeholder N` with its label lines, or a cross when no label fits) is one native group `OPF image placeholder N group` (opf-pptx#221) that carries the accessible name (`Image unavailable: <alt>`) as its alt text, so PowerPoint moves or deletes it as one object while each member stays an editable shape; a logo and a header or footer image keep their ungrouped panel (generated furniture is never grouped). In `full` provenance the panel of an image block carries an `OPF_IMAGE_PLACEHOLDER_V1` tag (the slide, the block path, the authored image value and the block's own fields), and `fromPptx` turns it back into that image block; without the tag (`references-only`, `provenance: false`) or with a damaged one (`invalid-image-provenance`) the shapes import as ordinary content.
 
 Embedded picture bytes are a PNG, JPEG, GIF, WebP or SVG. Bytes that are no readable image (or an SVG that cannot be exported: malformed XML, no `xmlns`, no width and height and no viewBox, or no rasterizer, see below) export what the preview shows, like an unresolved asset: the "Image unavailable" placeholder (nothing for a watermark, the background colour for a background image) and one `unresolved-asset` diagnostic with a `reason` (`unsupported-format`, `svg-malformed`, `svg-no-size`, `svg-too-large`, `svg-unsafe`, `svg-unreadable`, `svg-rasterizer-unavailable`, `svg-render-failed`); `strictAssets` throws `unsupported-image-dimensions` for an unreadable raster, `invalid-svg-image` for an unusable SVG, `svg-rasterizer-unavailable` or `svg-render-failed`.
 
@@ -100,7 +100,7 @@ The first exporter keeps the public API stable while using `pptxgenjs` internall
 
 - `Slide.title`, `Slide.subtitle`, and `Slide.tag` become editable text boxes, not PowerPoint master placeholders.
 - Root payloads, `blocks[]`, and promoted region keys become editable slide objects in deterministic regions. Promoted keys use the OPF 3x3 region vocabulary (`top`, `middle`, `bottom`, `left`, `center`, `right`).
-- Text, lists, metrics, quotes, timelines, code, tables, and inline-data charts are emitted as editable PowerPoint text, table, and chart objects. Content ColorRef values (hex, scheme slots/roles, and `var:<id>`) resolve through core `resolveColorRef()`. Slot and role names become native `a:schemeClr` references when the exported theme holds that exact color; hex, `var:<id>` and slide-override colors stay `a:srgbClr` (see [Theme color scheme](#theme-color-scheme)). Each classic chart type the core catalog keeps (one per Aspose.Slides `ChartType`: clustered/stacked/100% stacked column and bar, line and stacked line with or without markers, area/stacked/100% area, pie, doughnut, scatter with markers, radar/radar with markers/filled radar) is written as its exact native construct; deprecated core ids export as their replacement; other ids keep the previous best-effort mapping. The chartex types treemap, histogram, pareto, box & whisker, waterfall and funnel are written as native Office 2016 chartex parts (confirmed in desktop PowerPoint on 2026-09-30; see [Chartex charts](#chartex-charts-ff-22b)); the map (`world`) stays a clustered column chart by default and reports `chart-data-adapted` (`chartex-fallback`) until PowerPoint accepts its regionMap part (`chartex: "native"` writes it anyway, `chartex: "fallback"` writes clustered columns for every chartex id). A pie or doughnut chart, or a one-series chartex construct, plots only its first series and reports `chart-data-adapted` (`series-dropped`) when it has more.
+- Text, lists, metrics, quotes, timelines, code, tables, and inline-data charts are emitted as editable PowerPoint text, table, and chart objects. Content ColorRef values (hex, scheme slots/roles, and `var:<id>`) resolve through core `resolveColorRef()`. Slot and role names become native `a:schemeClr` references when the exported theme holds that exact color; hex, `var:<id>` and slide-override colors stay `a:srgbClr` (see [Theme color scheme](#theme-color-scheme)). Each classic chart type the core catalog keeps (one per Aspose.Slides `ChartType`: clustered/stacked/100% stacked column and bar, line and stacked line with or without markers, area/stacked/100% area, pie, doughnut, scatter with markers, radar/radar with markers/filled radar) is written as its exact native construct; deprecated core ids export as their replacement; other ids keep the previous best-effort mapping. The chartex types treemap, histogram, pareto, box & whisker, waterfall and funnel are written as native Office 2016 chartex parts (confirmed in desktop PowerPoint on 2026-09-30; see [Chartex charts](#chartex-charts-ff-22b)); the map (`world`) stays a clustered column chart by default and reports `chart-data-adapted` (`chartex-fallback`) until PowerPoint accepts its regionMap part (`chartex: "native"` writes it anyway, `chartex: "fallback"` writes clustered columns for every chartex id). A pie or doughnut chart, or a one-series chartex construct, plots only its first series and reports `chart-data-adapted` (`series-dropped`) when it has more. Every classic chart part follows the `dml-chart.xsd` child sequences (opf-pptx#175): each series is written in its `CT_*Ser` order (a line series has `c:marker` before `c:dLbls`), a radar series carries no `c:invertIfNegative`, and the scatter X `c:valAx` carries no category-axis elements.
 - A timeline event's `status` (`done`, `current`, `planned`) is drawn from the deck's colors with core's shared shapes (the same as the preview): a filled `ellipse` marker for `done` and for no status, a `current` marker inside a ring (a second `ellipse`, tagged with its marker) with a bold label, and a `planned` marker that is an `ellipse` with the background fill and an accent outline, with muted text kept at 4.5:1 or more. Import restores `status` from the marker tags, not from the shapes' look, and drops the timeline provenance (keeping plain text) when a current event's ring is missing or duplicated.
 - A chart whose data is one column of values (a histogram or dot plot) has no category column. A histogram or Pareto chart bins the values itself (PowerPoint's histogram with an explicit automatic bin count, no diagnostic) and re-imports as authored; any other chart type plots the values against their row numbers and reports `chart-data-adapted` (`row-numbers`). With `chartex: "fallback"` a histogram is binned into equal-width bins (Sturges' count, at most 50) and written as a column chart of the counts (`histogram-binned`; the binned counts do not round-trip). Cells parse as in every chart (core `chartNumber`: numbers and plain decimal strings; "12%", "$5" and "1,234" are not numbers) and cells that hold no number are skipped, not plotted as 0. Chart data that cannot be plotted (no numbers, no rows, or an external data source), an empty table and unsupported content keep a placeholder frame with a plain-language description (never a dump of the source data or URLs) and report `chart-data-unplottable` or `content-placeholder` with a `reason`; content is never dropped without a diagnostic.
 - Image assets are embedded only when supplied as data URIs, local paths, or host-resolved bytes/paths. Remote asset URLs are never fetched by the runtime path. A picture's native description is the authored `alt` (never a stand-in such as `preencoded.png` or the file path), and a distinct asset `title` is the picture's native `title`; `fromPptx` reads both back.
@@ -143,7 +143,7 @@ The first importer is mechanical and schema-compatible:
 - The first slide master's theme `clrScheme` maps to `design.colorScheme`: the bare id of a colour scheme in the host default catalog (the first of `fromPptx`'s `catalogs`) on an exact twelve-slot match, otherwise inline slots. A theme named like a theme of that catalog maps to `design.theme` when its colors or heading/body fonts corroborate it. With no catalog registered the colour scheme is inline and no theme id is recovered (see [Theme color scheme](#theme-color-scheme)).
 - Rich headline text (FA-10): a `TextRun[]` `title`, `subtitle` or `tag` exports as one tagged native text box per laid-out line with its runs (color, weight, italic, links, super/subscript, citation markers), and a `TextRun[]` `quote.text` the same way under the quote tags. Import returns `TextRun[]` where a heading's native runs are formatted differently from one another and a plain string where they are uniform: a tagged export records the heading's own weight, color, size and family (`base`), so only authored run formatting comes back, and a native title placeholder is read like body text, dropping what every run shares. A weight that the export writes as bold on every run of a title (and on a quote body) is the default, so only a `bold: false` word in a title is kept; `bold: true` in a quote body is indistinguishable from the body weight and is not restored. Marker runs become `cite`/`footnote` again, and heading and quote runs take part in the run-color reference slots.
 - Native title/subtitle placeholders retain their roles. On slides without complete OPF heading tags, recognizable text-box positions and sizes provide a fallback. If any complete OPF heading role is recovered, untagged body text stays in `blocks[]` instead of being promoted into an absent heading role. Damaged tags retain visible text through ordinary import and diagnostics.
-- Remaining text boxes map to `blocks[]` as text or list payloads, sorted by OOXML position.
+- Remaining text boxes map to `blocks[]` as text or list payloads, sorted by OOXML position. A measured list writes its size, family, weight and colour on every native run; in `full` provenance the slide record (`OPF_SLIDE_V1.listRuns`, opf-pptx#212) keeps that look per list (entry and description lines, never text), and import removes a run value still equal to it, so an untouched list round trip returns its items as authored instead of baking those values into `TextRun`s. A value edited in PowerPoint differs and comes back as observed; a run colour reference that resolves to the list colour (the `text` role) still returns through the run colour record, but an authored literal colour, size or family equal to the list's own cannot be told from it and returns absent. Without the record (`references-only`, `provenance: false`, a plain PPTX) runs are read as observed.
 - PowerPoint tables map to OPF table blocks, embedded images map to data URI image blocks, and cached chart series map to OPF chart blocks whose `type` is the core chart type id for the native construct (for example a `percentStacked` column chart imports as `100pct-stacked-column`, a filled radar as `filled-radar`; a scatter chart imports as `[Point, X, ...series]`).
 - Chart cache points are placed by their native `c:pt@idx`, with `c:ptCount` retaining trailing gaps. Missing labels and values become `null`; explicitly empty labels and series names stay empty strings, and an actual numeric zero stays zero. Empty numeric cache values remain missing. Malformed or duplicate indices, contradictory counts, competing caches and allocation limits reject with `invalid-chart-cache` and the chart-part/cache path; hierarchical category caches reject with `unsupported-chart-cache` instead of flattening labels. Each cache is limited to 100,000 positions, and combined caches and the emitted table each to 1,000,000 cells. Complete decimal scientific notation in numeric caches is read as a number; exponent overflow or nonzero underflow to zero rejects with `unsupported-chart-cache` and the chart part, series, cache and logical point path. Zero coefficients remain zero. This finite-number boundary does not classify rejected text as invalid OOXML. Malformed exponent strings and other nonblank numeric text retain the existing legacy conversion policy. This cache-only import does not repair embedded worksheets, restore unsupported scatter X/point labels, change exporter/workbook parsing or export/re-export missing-data handling, or establish native chart fidelity.
 - Table imports retain empty rows. A native `firstRow` flag of `1` or `true` maps the first row to column labels; absent/false flags retain every row as data. New exports set this flag from OPF columns. Older exports without the flag retain their labels as the first data row rather than inferring headers.
@@ -212,6 +212,29 @@ The seven kept chart types with no ECMA-376 construct are written as Office 2016
 
 The chart area, label colour, label font (`latin`/`ea`/`cs` in the chart's body font) and series colours follow the classic charts. Re-import (`fromPptx`) reads the chartex part first: the layoutIds name the OPF id (an owned `paretoLine` is `pareto`), `cx:strDim type="cat"` restores the categories and each `cx:numDim` a series, under the same 100,000-point and 1,000,000-cell bounds as classic chart caches; a lone value column comes back as authored. A chartex part with no OPF construct (sunburst) falls back to the `mc:Fallback` chart, or to a text placeholder when PowerPoint's own text fallback is all there is. Native PowerPoint rendering of each construct is confirmed through the program's bounded native sample, not by this package's tests.
 
+## Pass `fonts`, otherwise the estimate
+
+Text measurement comes from one place: the `fonts` handle that opf-render's `loadFonts()` returns (`@openpresentation/opf-render/fonts-node`, or `/fonts-browser`). Pass the same handle to preview, validation, pagination and `toPptx`, so that the exported text boxes break lines where the preview does:
+
+```js
+import { loadFonts } from '@openpresentation/opf-render/fonts-node';
+import { toSvg } from '@openpresentation/opf-render';
+import { validate } from '@openpresentation/opf';
+import { paginate } from '@openpresentation/opf/pagination';
+import { toPptx } from '@openpresentation/opf-pptx';
+
+const fonts = await loadFonts({ pack: 'office' });
+const report = validate(deck, { fonts });
+const { presentation } = paginate(deck, { fonts });
+const svgs = toSvg(presentation, { fonts });            // preview
+const pptx = await toPptx(presentation, { fonts });     // export: the same lines, as editable text
+```
+
+One handle carries the measurement for core's `validate`, `paginate` and slide context, for opf-render's `toSvg`, `toPng` and `toPdf`, and for `toPptx`. The same handle gives identical text geometry across engines: every engine reads core's one composition, so it is the measurement that decides the lines. This package's `test/layout-parity.mjs` checks that the exported PowerPoint paragraphs agree with the SVG preview and with core's composed items, with and without `fonts`.
+
+Without `fonts`, `toPptx` uses core's built-in estimate: 0.54 em per character, 0.62 em for capitals and digits, 0.32 em for a space, 1 em for CJK characters and zero for combining marks. That is deterministic and needs no font files and no renderer, but it is too narrow for some scripts (opf#566 tracks improving it), and the line breaks it chooses can differ from the faces PowerPoint draws. The PPTX still names the font family the document chose (`fonts` changes where lines break, not which font is named). Core's Node `convert` and the `opf` CLI prepare an office-pack handle for you; a library call to `toPptx` never loads fonts on its own, so pass the handle you want. See also [opf#364](https://github.com/OpenPresentation/opf/issues/364) and core's [measured fonts](https://github.com/OpenPresentation/opf/blob/main/docs/font-fidelity.md#pass-fonts-otherwise-the-estimate).
+
+
 ## Languages, right-to-left text and script fonts
 
 The exporter reads the presentation `language` through core `resolveScriptFonts()` (FF-07; the model is core `docs/programs/font-fidelity-everywhere/script-font-model.md`):

package/dist/chart-order.js

@@ -0,0 +1,76 @@
+// opf-pptx#175: the classic chart series in ECMA-376 schema order (Part 1, dml-chart.xsd).
+//
+// pptxgenjs-plus 4.3.4 writes a line series' c:dLbls before its c:marker, and gives radar series the bar-only
+// c:invertIfNegative; the scatter X axis (a c:valAx) carries the category-axis-only c:auto, c:lblAlgn and c:noMultiLvlLbl.
+// PowerPoint opens these parts, but stricter consumers (the Open XML SDK validator, LibreOffice, Keynote) may not. This runs
+// last on each generated chart part, after every other chart rewrite: a series whose children are already in sequence keeps
+// its bytes, and only a series that needs it is rebuilt (stable, so repeated c:dPt keep their order).
+
+const SHARED = ['idx', 'order', 'tx', 'spPr'];
+const BAR = [...SHARED, 'invertIfNegative', 'pictureOptions', 'dPt', 'dLbls', 'trendline', 'errBars', 'cat', 'val', 'shape', 'extLst'];
+const LINE = [...SHARED, 'marker', 'dPt', 'dLbls', 'trendline', 'errBars', 'cat', 'val', 'smooth', 'extLst'];
+const AREA = [...SHARED, 'pictureOptions', 'dPt', 'dLbls', 'trendline', 'errBars', 'cat', 'val', 'extLst'];
+const RADAR = [...SHARED, 'marker', 'dPt', 'dLbls', 'cat', 'val', 'extLst'];
+const SCATTER = [...SHARED, 'marker', 'dPt', 'dLbls', 'trendline', 'errBars', 'xVal', 'yVal', 'smooth', 'extLst'];
+const PIE = [...SHARED, 'explosion', 'dPt', 'dLbls', 'cat', 'val', 'extLst'];
+
+/** The CT_*Ser child sequence of each classic chart group. */
+export const SERIES_SEQUENCES = Object.freeze({
+  barChart: BAR, bar3DChart: BAR,
+  lineChart: LINE, line3DChart: LINE,
+  areaChart: AREA, area3DChart: AREA,
+  radarChart: RADAR,
+  scatterChart: SCATTER,
+  pieChart: PIE, pie3DChart: PIE, doughnutChart: PIE, ofPieChart: PIE,
+});
+
+// The top-level children of an element body, each with the whitespace before it: [{name, text}], or null when the body is
+// not a plain run of elements (text content, comments or an unbalanced tag), which is then left alone.
+function children(body) {
+  const out = [];
+  const tag = /<(\/?)([A-Za-z_][\w.:-]*)\b[^>]*?(\/?)>/g;
+  let depth = 0, start = 0, name = null, match;
+  while ((match = tag.exec(body))) {
+    const [, close, tagName, selfClose] = match;
+    if (depth === 0) {
+      if (close || body.slice(start, match.index).trim()) return null;
+      name = tagName;
+    }
+    if (close) depth--;
+    else if (!selfClose) depth++;
+    if (depth < 0) return null;
+    if (depth === 0) {
+      out.push({name, text: body.slice(start, tag.lastIndex)});
+      start = tag.lastIndex;
+    }
+  }
+  if (depth !== 0 || body.slice(start).trim()) return null;
+  return {items: out, tail: body.slice(start)};
+}
+
+function orderSeries(ser, sequence) {
+  const body = ser.slice('<c:ser>'.length, -'</c:ser>'.length);
+  const parsed = children(body);
+  if (!parsed || parsed.items.some(item => !item.name.startsWith('c:'))) return ser;
+  const rank = item => sequence.indexOf(item.name.slice(2));
+  // A child the series type does not define (c:invertIfNegative in a radar series) is dropped; the rest sort stably by rank.
+  const kept = parsed.items.filter(item => rank(item) >= 0);
+  const ordered = kept.map((item, position) => ({item, position, rank: rank(item)}))
+    .sort((a, b) => a.rank - b.rank || a.position - b.position)
+    .map(entry => entry.item);
+  if (kept.length === parsed.items.length && ordered.every((item, index) => item === parsed.items[index])) return ser;
+  return `<c:ser>${ordered.map(item => item.text).join('')}${parsed.tail}</c:ser>`;
+}
+
+// CT_ValAx has no c:auto, c:lblAlgn or c:noMultiLvlLbl (they belong to CT_CatAx); the generator writes them on the scatter X axis.
+const CATEGORY_AXIS_ONLY = /\s*<c:(?:auto|lblAlgn|noMultiLvlLbl)\b[^>]*\/>/g;
+
+/** Every classic chart series of a chart part in its CT_*Ser sequence, and every c:valAx without category-axis children. */
+export function orderChartSeries(xml) {
+  let out = xml;
+  for (const [group, sequence] of Object.entries(SERIES_SEQUENCES)) {
+    if (!out.includes(`<c:${group}>`)) continue;
+    out = out.replace(new RegExp(`<c:${group}>[\\s\\S]*?</c:${group}>`, 'g'), block => block.replace(/<c:ser>[\s\S]*?<\/c:ser>/g, ser => orderSeries(ser, sequence)));
+  }
+  return out.replace(/<c:valAx>[\s\S]*?<\/c:valAx>/g, axis => axis.replace(CATEGORY_AXIS_ONLY, ''));
+}

package/dist/content-topology.js

@@ -373,6 +373,31 @@ export function validateListBreaks(value) {
   return value;
 }
 
+// opf-pptx#212: `listRuns` = [[list path, {text: Look, description?: Look}]], the look the exporter writes on every run of a
+// list's entry lines (`text`) and description lines (`description`) where the source states none: Look = {bold, color,
+// fontSize, fontFamily} (color '#RRGGBB', fontSize in points). Import removes a run value still equal to it, so inherited
+// formatting returns absent; a value edited in PowerPoint differs and is imported as observed. Never text.
+const LOOK_KEYS = Object.freeze({
+  bold: value => typeof value === 'boolean',
+  color: value => typeof value === 'string' && /^#[0-9A-Fa-f]{6}$/.test(value),
+  fontSize: value => Number.isFinite(value) && value > 0 && value < 10000,
+  fontFamily: value => typeof value === 'string' && value.length > 0 && value.length <= 200,
+});
+const validLook = value => object(value) && Object.keys(value).length > 0 && Object.entries(value).every(([key, item]) => LOOK_KEYS[key]?.(item) === true);
+
+/** Throws when `value` is not a well-formed `listRuns` record (untrusted input). Returns it otherwise. */
+export function validateListRuns(value) {
+  if (!Array.isArray(value) || !value.length || value.length > MAX_LIST_PATHS) throw Error('Invalid list runs record.');
+  const paths = new Set();
+  for (const entry of value) {
+    if (!Array.isArray(entry) || entry.length !== 2 || typeof entry[0] !== 'string' || !LIST_PATH.test(entry[0]) || paths.has(entry[0]) || !object(entry[1])
+      || Object.keys(entry[1]).some(key => key !== 'text' && key !== 'description') || !validLook(entry[1].text)
+      || (entry[1].description !== undefined && !validLook(entry[1].description))) throw Error('Invalid list runs entry.');
+    paths.add(entry[0]);
+  }
+  return value;
+}
+
 // ---------------------------------------------------------------------------
 // Import: validation
 

package/dist/data-provenance.js

@@ -116,7 +116,7 @@ export function chartEvidence(xml) {
 }
 
 /** Native cell text, formatting and table geometry, canonicalized independently of XML attribute order. */
-export function tableCellEvidence(table, relationships = new Map()) {
+export function tableCellEvidence(table, relationships = new Map(), {form = 'current'} = {}) {
   const related = value => {
     const ids = new Set(), stack = [value];
     while (stack.length) {
@@ -132,8 +132,72 @@ export function tableCellEvidence(table, relationships = new Map()) {
       return [id, link ? {type: link.type, target: link.target, targetMode: link.targetMode} : null];
     }))} : {};
   };
-  const properties = {properties: table?.['a:tblPr'], grid: table?.['a:tblGrid']};
-  return array(table?.['a:tr']).map(row => array(row?.['a:tc']).map(cell => hash(canonical({properties, row: Object.fromEntries(Object.entries(row).filter(([key]) => key !== 'a:tc')), cell, ...related({properties, cell})}))));
+  // 'raw' hashes the XML as written (records before opf-pptx#241); 'saved' rebuilds the form this exporter wrote from a
+  // PowerPoint-saved copy of it, so such a record still matches a cell the save left alone.
+  const read = form === 'raw' ? value => value : form === 'saved' ? exporterForm : nativeDefaults;
+  const properties = {properties: table?.['a:tblPr'], grid: read(table?.['a:tblGrid'])};
+  return array(table?.['a:tr']).map(row => array(row?.['a:tc']).map(cell => hash(canonical({properties, row: read(Object.fromEntries(Object.entries(row).filter(([key]) => key !== 'a:tc'))), cell: read(cell), ...related({properties, cell})}))));
+}
+
+// opf-pptx#241: a PowerPoint save drops attributes that hold their schema default and adds identity extensions, so the same
+// table would hash differently. The evidence reads the native table with those defaults applied: an absent value and its
+// default are one value (on a:tcPr: anchor t, margins 0.1 / 0.05 inch, anchorCtr 0, horzOverflow clip, vert horz; on a:pPr:
+// marL 0, indent 0, algn l), whitespace between child elements, and the a16:colId / a16:rowId extensions PowerPoint adds to a:gridCol and a:tr are not content.
+// Attribute order never mattered (canonical sorts keys). Records written before this fix hash the raw XML (legacy), and the
+// importer still accepts that form for a file nobody changed.
+// What this exporter wrote on every cell before the evidence read defaults: anchor on a:tcPr, and the whitespace PptxGenJS leaves
+// after a:tcPr's children and after a:tcPr. A PowerPoint save removes all three; putting them back reproduces the recorded hash.
+function exporterForm(value) {
+  const cleaned = nativeDefaults(value, false);
+  const rebuild = item => {
+    if (Array.isArray(item)) return item.map(rebuild);
+    if (!object(item)) return item;
+    const out = {};
+    for (const [key, child] of Object.entries(item)) out[key] = rebuild(child);
+    if (Object.hasOwn(out, 'a:txBody') && Object.hasOwn(out, 'a:tcPr') && !Object.hasOwn(out, '#text')) {
+      const properties = object(out['a:tcPr']) ? {...out['a:tcPr']} : {};
+      if (!Object.hasOwn(properties, 'anchor')) properties.anchor = 't';
+      if (!Object.hasOwn(properties, '#text') && Object.keys(properties).some(name => name.startsWith('a:'))) properties['#text'] = '  ';
+      out['a:tcPr'] = properties;
+      out['#text'] = ' ';
+    }
+    return out;
+  };
+  return rebuild(cleaned);
+}
+const PROPERTY_DEFAULTS = {
+  'a:tcPr': {marL: '91440', marR: '91440', marT: '45720', marB: '45720', anchor: 't', anchorCtr: '0', horzOverflow: 'clip', vert: 'horz'},
+  'a:pPr': {marL: '0', indent: '0', algn: 'l'}
+};
+const IDENTITY_EXTENSIONS = new Set(['a16:colId', 'a16:rowId']);
+const attributeValue = (name, value) => {
+  const text = String(value).trim();
+  return name === 'anchorCtr' ? ({false: '0', off: '0', true: '1', on: '1'}[text.toLowerCase()] ?? text) : text;
+};
+function nativeDefaults(value, normalize = true) {
+  if (Array.isArray(value)) return value.map(item => nativeDefaults(item, normalize));
+  if (!object(value)) return value;
+  const out = {};
+  // Whitespace between child elements is not content (the exporter leaves some inside a:tcPr and a:tc; a save removes it).
+  const hasChildren = Object.keys(value).some(name => /^[a-z][w-]*:/i.test(name) && !/^xml(ns)?:/i.test(name));
+  for (const [key, item] of Object.entries(value)) {
+    if (key === '#text' && normalize && hasChildren && typeof item === 'string' && !item.trim()) continue;
+    if (key === 'a:extLst') {
+      const kept = array(item?.['a:ext']).filter(ext => !(object(ext) && Object.keys(ext).filter(name => name !== 'uri').every(name => IDENTITY_EXTENSIONS.has(name))));
+      if (kept.length) out[key] = {...item, 'a:ext': nativeDefaults(kept.length === 1 ? kept[0] : kept, normalize)};
+      continue;
+    }
+    out[key] = nativeDefaults(item, normalize);
+  }
+  if (!normalize) return out;
+  for (const [tag, defaults] of Object.entries(PROPERTY_DEFAULTS)) {
+    if (!Object.hasOwn(out, tag)) continue;
+    const properties = object(out[tag]) ? {...out[tag]} : {};
+    for (const [name, fallback] of Object.entries(defaults)) if (Object.hasOwn(properties, name) && attributeValue(name, properties[name]) === fallback) delete properties[name];
+    // No attributes and no children is the same as an empty element (the parser reads `<a:tcPr/>` as '').
+    out[tag] = Object.keys(properties).length ? properties : '';
+  }
+  return out;
 }
 
 /** Theme and table-style edits can change effective cell formatting without changing the cell XML. */
@@ -372,8 +436,11 @@ export function restoreChartData(chart, record, evidence, {datasets, report}) {
 }
 
 /** The authored table data where the native evidence is unchanged; edited native cells otherwise. */
-export function restoreTableData(table, record, {datasets, report, evidence, environment}) {
+export function restoreTableData(table, record, {datasets, report, evidence: currentEvidence, olderEvidence = [], environment}) {
   if (!object(table)) return table;
+  // opf-pptx#241: a record written before the evidence read schema defaults hashes the raw XML (or, for a PowerPoint-saved copy, the
+  // form rebuilt from it); a cell still matching one of those is unchanged.
+  const evidence = currentEvidence?.map((row, r) => row.map((hash, c) => olderEvidence.map(older => older?.[r]?.[c]).find(older => older !== undefined && older === record.evidence?.[r]?.[c]) ?? hash));
   const columns = Array.isArray(table.columns) ? table.columns : undefined;
   const rows = Array.isArray(table.rows) ? table.rows : [];
   const sameCell = (row, column) => record.environment === environment && record.evidence?.[row]?.[column] === evidence?.[row]?.[column];

package/dist/document-provenance.js

@@ -1,6 +1,6 @@
 import {XMLParser} from 'fast-xml-parser';
 import {decodeTextTag, encodeTextTag} from './code-provenance.js';
-import {contentTopology, rebuildContent, validateTopology, listLineBreaks, validateListBreaks} from './content-topology.js';
+import {contentTopology, rebuildContent, validateTopology, listLineBreaks, validateListBreaks, validateListRuns, MAX_LIST_PATHS} from './content-topology.js';
 import {runColorRecord, validateRunColors} from './run-colors.js';
 import {validateCatalogRecord} from '@openpresentation/opf';
 import {parseReference, resolveReference, resolveSocialProfile} from '@openpresentation/opf/composition';
@@ -548,6 +548,17 @@ export function recordContentTopology(provenance, slide, index, items) {
   if (omittedLists.length) provenance.slides[index].omittedLists = omittedLists;
 }
 
+/**
+ * opf-pptx#212: record the look the exporter writes on every run of list `path` on slide `index` where the source states none
+ * ({text, description?}, see validateListRuns), `full` mode only. Import removes a run value still equal to it.
+ */
+export function recordListRuns(provenance, index, path, look) {
+  if (!look || !provenance || provenance.mode !== 'full' || !provenance.slides[index]) return;
+  const record = provenance.slides[index];
+  record.listRuns ??= [];
+  if (record.listRuns.length < MAX_LIST_PATHS && !record.listRuns.some(([list]) => list === path)) record.listRuns.push([path, look]);
+}
+
 function base64ToBytes(value) {
   const binary = atob(value.replace(/\s+/g, ''));
   const bytes = new Uint8Array(binary.length);
@@ -698,7 +709,7 @@ function storable(entries, provenance) {
     const result = {v: 1, slide: index};
     if (record.omittedContent) omit(`slides.${index}.content`, record.omittedContent);
     for (const [path, reason] of record.omittedLists ?? []) omit(path, reason);
-    for (const key of ['id', 'beat', ...SLIDE_STRUCTURE, ...SLIDE_METADATA, 'content', 'colors', 'lists']) {
+    for (const key of ['id', 'beat', ...SLIDE_STRUCTURE, ...SLIDE_METADATA, 'content', 'colors', 'lists', 'listRuns']) {
       if (record[key] === undefined) continue;
       const value = prepare(`slides.${index}.${key}`, record[key]);
       if (value !== undefined) result[key] = value;
@@ -735,7 +746,7 @@ function storable(entries, provenance) {
   }
   for (const [index, record] of slides.entries()) {
     while (tagChars(record) > budget) {
-      const candidates = [...['id', 'beat', ...SLIDE_STRUCTURE, ...SLIDE_METADATA, 'content', 'colors', 'lists', 'layoutRecord'].filter(key => record[key] !== undefined).map(key => ({key, size: sizeOf(record[key])})),
+      const candidates = [...['id', 'beat', ...SLIDE_STRUCTURE, ...SLIDE_METADATA, 'content', 'colors', 'lists', 'listRuns', 'layoutRecord'].filter(key => record[key] !== undefined).map(key => ({key, size: sizeOf(record[key])})),
         ...Object.keys(record.design ?? {}).map(key => ({key, design: true, size: sizeOf(record.design[key])}))];
       if (!candidates.length) break;
       const largest = candidates.sort((a, b) => b.size - a.size)[0];
@@ -874,6 +885,7 @@ function validateSlide(stored) {
   if (value.content !== undefined) validateTopology(value.content);
   if (value.colors !== undefined) validateRunColors(value.colors);
   if (value.lists !== undefined) validateListBreaks(value.lists);
+  if (value.listRuns !== undefined) validateListRuns(value.listRuns);
   validateOmitted(value.omitted);
   return value;
 }
@@ -914,19 +926,23 @@ function pruneDangling(value, dangling, path, removed) {
 }
 
 /**
- * The hard line breaks stored for the lists of one slide: Map(list path -> Map(line number -> gap)), or null when the slide
- * carries none, its record is unreadable, or its arrangement changed since export (the lines are then no longer the exported
- * ones). Read before the slide's shapes are merged into list blocks; any damage is reported later by restoreDocumentProvenance.
+ * The list records of one slide, read before its shapes are merged into list blocks:
+ * - `breaks`: the hard line breaks, Map(list path -> Map(line number -> gap)), or null when the slide carries none, its record is
+ *   unreadable, or its arrangement changed since export (the lines are then no longer the exported ones);
+ * - `runs` (opf-pptx#212): the look export wrote on every run of each list, Map(list path -> {text, description?}), or null. It
+ *   does not depend on the arrangement: import compares each run value with it, so an edited value is still observed.
+ * Any damage is reported later by restoreDocumentProvenance.
  */
-export function slideListBreaks(entries, path, root, rels) {
+export function slideListRecord(entries, path, root, rels) {
   try {
     const found = readTag(entries, root?.['p:cSld']?.['p:custDataLst'], rels, SLIDE_TAG);
-    if (found.missing) return null;
+    if (found.missing) return {breaks: null, runs: null};
     const record = validateSlide(found.value);
-    if (record.lists === undefined || record.native.structure !== nativeSlide(entries, path).structure) return null;
-    return new Map(record.lists.map(([list, lines]) => [list, new Map(lines)]));
+    const runs = record.listRuns === undefined ? null : new Map(record.listRuns);
+    const breaks = record.lists === undefined || record.native.structure !== nativeSlide(entries, path).structure ? null : new Map(record.lists.map(([list, lines]) => [list, new Map(lines)]));
+    return {breaks, runs};
   } catch {
-    return null;
+    return {breaks: null, runs: null};
   }
 }
 

package/dist/image-provenance.js

@@ -271,3 +271,57 @@ export function importImages({pictures, shapes, relationships, entries, slideInd
   }
   return {blocks, background, backgroundOverlay, backgroundOverlayShape, consumed, consumedShapes};
 }
+
+// opf-pptx#221: the "Image unavailable" placeholder of an image block whose source could not be embedded (a remote URL is never
+// fetched) is one native group, `OPF image placeholder N group`, that carries the panel's accessible name (descr) and holds the
+// dashed panel `OPF image placeholder N` and its label lines (`... text line i`) or cross strokes (`... icon i`), each an
+// editable shape. In `full` mode the panel carries OPF_IMAGE_PLACEHOLDER_V1: the slide, the block path, the authored image value
+// and the block's own fields. Import turns an intact tagged panel back into that image block and consumes its label shapes;
+// without a valid tag (provenance false or references-only, a damaged tag) the shapes stay ordinary content, as before.
+export const IMAGE_PLACEHOLDER_TAG = 'OPF_IMAGE_PLACEHOLDER_V1';
+export const imagePlaceholderGroupName = panel => `${panel} group`;
+const PLACEHOLDER_PANEL = /^OPF image placeholder \d+$/;
+const PLACEHOLDER_GROUP = /^OPF image placeholder \d+ group$/;
+const BLOCK_PATH = /^slides\.\d+(?:\.[A-Za-z0-9_:+-]{1,64}){1,32}$/;
+const placeholderPart = (panel, name) => typeof name === 'string' && name.startsWith(`${panel} `) && /^(?:text line|icon) \d+$/.test(name.slice(panel.length + 1));
+
+/** Whether a native group is an exported image placeholder group with an identity transform (its children keep their boxes). */
+export function isImagePlaceholderGroup(group) {
+  if (!PLACEHOLDER_GROUP.test(String(group?.['p:nvGrpSpPr']?.['p:cNvPr']?.name ?? ''))) return false;
+  const xfrm = group?.['p:grpSpPr']?.['a:xfrm'];
+  return ['x', 'y'].every(key => String(xfrm?.['a:off']?.[key]) === String(xfrm?.['a:chOff']?.[key]))
+    && ['cx', 'cy'].every(key => String(xfrm?.['a:ext']?.[key]) === String(xfrm?.['a:chExt']?.[key]));
+}
+
+/**
+ * Recover the image blocks of tagged unavailable-image placeholders on one slide. `shapes` are the slide's native text shapes
+ * (nativeTextShapes order, group members included); `valid(payload)` checks a recovered image block against the OPF format.
+ * Returns `items`: [{panel (shape index), members (shape indexes, the panel first), payload}] and `consumed`, every member index.
+ */
+export function importImagePlaceholders({shapes, relationships, entries, slideIndex, valid, report}) {
+  const slide = `slides.${slideIndex}`;
+  const items = [], consumed = new Set();
+  const names = shapes.map(shape => shape?.['p:nvSpPr']?.['p:cNvPr']?.name);
+  const invalid = message => report({code: 'invalid-image-provenance', path: slide, message});
+  for (const [index, shape] of shapes.entries()) {
+    let manifest;
+    try { manifest = ownTag(shape?.['p:nvSpPr']?.['p:nvPr']?.['p:custDataLst'], relationships, entries, IMAGE_PLACEHOLDER_TAG); }
+    catch { invalid('A tagged OPF image placeholder is ambiguous; its shapes were imported as ordinary content.'); continue; }
+    if (manifest === null) continue;
+    const name = names[index];
+    const image = manifest?.image;
+    const treatment = manifest?.treatment ?? {};
+    if (manifest?.v !== 1 || manifest.slide !== slide || typeof manifest.path !== 'string' || !BLOCK_PATH.test(manifest.path) || !manifest.path.startsWith(`${slide}.`)
+      || !PLACEHOLDER_PANEL.test(name ?? '') || !(typeof image === 'string' || object(image)) || !object(treatment)
+      || Object.keys(treatment).some(key => !IMAGE_TREATMENT_KEYS.includes(key))) {
+      invalid('An edited or invalid tagged OPF image placeholder was imported as ordinary content; its image block is not reconstructed.');
+      continue;
+    }
+    const payload = {type: 'image', image: structuredClone(image), ...structuredClone(treatment)};
+    if (!valid(payload)) { invalid('A tagged OPF image placeholder does not form a valid image block; its shapes were imported as ordinary content.'); continue; }
+    const members = [index, ...names.flatMap((other, position) => position !== index && placeholderPart(name, other) ? [position] : [])];
+    for (const member of members) consumed.add(member);
+    items.push({panel: index, members, payload});
+  }
+  return {items, consumed};
+}

package/dist/index.js

@@ -10,7 +10,7 @@ import {applyChartNumberFormats,chartNumber,excelCode,formattedColumns,inlineCha
 import {attachDataProvenance,chartDataRecord,chartEvidence,readDataTag,readDatasetsTag,restoreChartData,restoreTableData,tableDataRecord,tableCellEvidence,tableEnvironmentEvidence} from './data-provenance.js';
 import {CHARTEX_FALLBACK,resolveChartType,chartTypeFromNative,applyChartConstruct,comboFromNative,NATIVE_CHART_ELEMENTS} from './chart-types.js';
 import {attachChartexParts,chartFromChartex,CHARTEX_GRAPHIC_DATA_URI} from './chartex.js';
-import {applyFrameAlt,readFrameAlt} from './frame-alt.js';
+import {applyFrameAlt,readFrameAlt,writeFrameAlt} from './frame-alt.js';
 import {applyDataLabels,chartOptionsFromClassic,chartTargetFor,classicChartOptions,reportChartOptionDiagnostics,resolveChartOptionsFor} from './chart-options.js';
 import {attachCodeTags, attachTextTags, codeManifest, importCodeGroups, nativeShapeParagraphs, nativeTextShapes} from './code-provenance.js';
 import {attachMetricTags,metricManifest,importMetricGroups} from './metric-provenance.js';
@@ -20,27 +20,28 @@ import {attachMediaTags,importMediaGroups,mediaCaption,mediaFrameRecord,mediaTex
 import {addCaption, addFootnotes} from './annotation-export.js';
 import {attachAnnotationTags, captionValue, importAnnotations, restoreCitations} from './annotation-provenance.js';
 import {attachHeadingTags,importHeadingGroups} from './heading-provenance.js';
-import {headingValue,joinRichLines} from './rich-heading.js';
+import {cleanBase,headingValue,joinRichLines} from './rich-heading.js';
 import {attachPlainTextTags,importPlainTextGroups} from './text-provenance.js';
 import {attachTimelineTags,timelineManifest,importTimelineGroups} from './timeline-provenance.js';
 import {attachQuoteTags,quoteManifest,importQuoteGroups,quotePhotoName} from './quote-provenance.js';
 import {attachFurnitureTags, furnitureManifest, importFurniture, logoShape, staticDateFallback, stampFurnitureImageKeys} from './furniture-provenance.js';
 import {restoreRunColors} from './run-colors.js';
 import {joinWrappedText} from './content-topology.js';
-import {applyDocumentProvenance, attachDocumentProvenance, documentProvenance, recordContentTopology, restoreDocumentProvenance, joinAuthors, splitAuthors, slideListBreaks, storedMetadata, DEFAULT_AUTHOR, DEFAULT_TITLE} from './document-provenance.js';
+import {applyDocumentProvenance, attachDocumentProvenance, documentProvenance, recordContentTopology, recordListRuns, restoreDocumentProvenance, joinAuthors, splitAuthors, slideListRecord, storedMetadata, DEFAULT_AUTHOR, DEFAULT_TITLE} from './document-provenance.js';
 import {INVALID_XML_CHARACTER, nativeSections, writeSectionList} from './sections.js';
 import {attachFurnitureFields, furniturePartFields, lineFields, nativeFieldType} from './furniture-fields.js';
 import {attachNativePlaceholders, defaultPlaceholderGeometry, nativeDateText, nativeFurnitureParts, nativePlaceholderForPart, writeNativeMasters} from './native-furniture.js';
 import {liftMasterFurniture} from './master-furniture.js';
 import {importImageOrientation} from './image-import.js';
 import {extractSignals, normalizeSignalOptions, themeFactsFor} from './import-signals.js';
-import {placeImages, importImages, imageName, imageOverlayName, backgroundImageName, backgroundOverlayName, IMAGE_TREATMENT_KEYS, BACKGROUND_IMAGE_KEYS} from './image-provenance.js';
+import {placeImages, importImages, importImagePlaceholders, isImagePlaceholderGroup, imageName, imageOverlayName, imagePlaceholderGroupName, backgroundImageName, backgroundOverlayName, IMAGE_TREATMENT_KEYS, BACKGROUND_IMAGE_KEYS, IMAGE_PLACEHOLDER_TAG} from './image-provenance.js';
 import {dedupeMedia} from './media-dedupe.js';
 import {placeWatermarks, importWatermark, importTextWatermark, tagTextWatermarks, watermarkName, watermarkTextName, watermarkBox, watermarkOpacity} from './watermark-provenance.js';
 import {placeLogos, importLogo, importLogoPlaceholders, logoName, LOGO_TAG} from './logo-provenance.js';
 import {nativeBackgroundFill, nativeImageBackgroundFill, nativePatternPreset} from './background.js';
 import {importBackground} from './background-import.js';
 import {chartHighlightPlan, applyChartHighlight} from './chart-highlight.js';
+import {orderChartSeries} from './chart-order.js';
 import {themeSlotColors, writeThemeColors, schemeColorValue, schemeBackgroundFill, schemeBackgroundValue, defaultTextSchemeValues, tableTextSchemeValue, solidColorXml, writeMasterBackground, inheritLayoutBackground, readThemeSlotColors, recoverColorScheme, recoverTheme, presentationThemePath} from './theme-colors.js';
 import {languageDiagnostics, observeLanguage, observedRtl, partScriptFonts, physicalAlignment, planScriptFonts, planSlideThemes, reconcileLanguage, reportPerSlideNotesScriptFonts, runLanguageFonts, runLanguageTag, stripRunScriptFonts, themeEastAsianFromLatin} from './script-fonts.js';
 import { webpToPng, svgToPng, readLocalFile, localFileReadable } from '#image-fallback';
@@ -255,6 +256,9 @@ export async function toPptx(input, options = {}) {
   const context = resolvePresentationContext(presentation, {...options,textMeasurement:undefined});
   context.listMarkers = new Map();
   context.imagePlaceholders = new Map();
+  // opf-pptx#221: the placeholder panels written as one native group, and the OPF_IMAGE_PLACEHOLDER_V1 records of image blocks.
+  context.imagePlaceholderGroups = new Set();
+  context.imagePlaceholderTags = new Map();
   context.tableHeaders = new Map();
   context.tableCells = new Map();
   // FA-23: every exported image picture (image blocks, the alt-text form of an image background, timeline pictures) and
@@ -815,8 +819,8 @@ function importSlide(entries, slidePath, slideIndex, presentationDimensions, opt
       item.text = current.map(paragraph => paragraph.text).join('\n');
     }
   }
-  const listBreaks = slideListBreaks(entries, slidePath, slideRoot, relationships);
-  const content = mergeAdjacentBulletShapes(mergeOpfListShapes(items, listBreaks, diagnostic => options.onDiagnostic?.({...diagnostic, path: `slides.${slideIndex}`})))
+  const listRecord = slideListRecord(entries, slidePath, slideRoot, relationships);
+  const content = mergeAdjacentBulletShapes(mergeOpfListShapes(items, listRecord.breaks, diagnostic => options.onDiagnostic?.({...diagnostic, path: `slides.${slideIndex}`}), listRecord.runs))
     .map((item) => ({payload: payloadFromSlideItem(item, diagnostic => options.onDiagnostic?.({...diagnostic, path: `slides.${slideIndex}`})), bounds: item.visualBounds ?? item.bounds, sources: item.sources ?? []}))
     .filter((entry) => entry.payload);
   const blocks = content.map((entry) => entry.payload);
@@ -860,7 +864,8 @@ function collectSlideItems(entries, slideRoot, slidePath, relationships, dimensi
   const tree = slideRoot["p:cSld"]?.["p:spTree"];
   const items = [];
   const shapes = nativeContext.shapes;
-  if (tree?.['p:grpSp']) options.onDiagnostic?.({code:'grouped-text-reflow',path:`slides.${slideIndex}`,message:'Grouped native text and pictures are retained, but group transforms and unsupported group members are not reconstructed; review the reflowed OPF.'});
+  // opf-pptx#221: an exported image placeholder group (identity transform) is not a reflow risk.
+  if (asArray(tree?.['p:grpSp']).some(group => !isImagePlaceholderGroup(group))) options.onDiagnostic?.({code:'grouped-text-reflow',path:`slides.${slideIndex}`,message:'Grouped native text and pictures are retained, but group transforms and unsupported group members are not reconstructed; review the reflowed OPF.'});
   const paragraphs = nativeContext.paragraphs;
   // FF-45: OMML equations (a14:m math zones) have no OPF model. Their fallback text is imported as plain text; the equation
   // layout (fractions, radicals, limits, matrices) is lost, and that loss is diagnosed per shape instead of passing silently.
@@ -914,11 +919,17 @@ function collectSlideItems(entries, slideRoot, slidePath, relationships, dimensi
   for (const item of code.items) items.push({kind:'code',bounds:shapeBounds(item.shape['p:spPr']?.['a:xfrm']),payload:item.payload,sources:sourcesOf([item.shape])});
   for (const item of metric.items) items.push({kind:'metric',bounds:shapeBounds(item.shape['p:spPr']?.['a:xfrm']),payload:item.payload,sources:sourcesOf([item.shape])});
   for (const item of media.items) items.push({kind:'media',sourceText:item.payload.type==='text',bounds:shapeBounds(item.shape['p:spPr']?.['a:xfrm']),payload:item.payload,sources:sourcesOf([item.shape])});
+  // opf-pptx#221: a tagged unavailable-image placeholder is its image block again; its panel and label shapes are consumed.
+  const placeholders = importImagePlaceholders({shapes, relationships, entries, slideIndex, valid: payload => isValidFormat({slides: [{blocks: [payload]}]}), report: diagnostic => options.onDiagnostic?.(diagnostic)});
+  for (const item of placeholders.items) {
+    for (const member of item.members) roles.set(`sp:${member}`, 'image');
+    items.push({kind: 'image', bounds: shapeBounds(shapes[item.panel]['p:spPr']?.['a:xfrm']), payload: item.payload, sources: item.members.map(member => `sp:${member}`)});
+  }
   for (const [index,shape] of shapes.entries()) {
     const role = furniture.text.has(index) ? 'furniture' : nativeContext.imageShapes?.has(index) ? 'image-overlay' : nativeContext.watermarkShapes?.has(index) ? 'watermark' : nativeContext.logoPlaceholderShapes?.has(index) ? 'logo' : cards.has(shape) ? 'card-frame'
       : code.consumed.has(shape) ? 'code' : metric.consumed.has(shape) ? 'metric' : media.consumed.has(shape) ? 'media' : timelines.consumed.has(shape) ? 'timeline' : quotes.consumed.has(shape) ? 'quote' : undefined;
     if (role) roles.set(shapeKeys.get(shape), role);
-    if (furniture.text.has(index) || nativeContext.imageShapes?.has(index) || nativeContext.watermarkShapes?.has(index) || nativeContext.logoPlaceholderShapes?.has(index)) continue;
+    if (furniture.text.has(index) || nativeContext.imageShapes?.has(index) || nativeContext.watermarkShapes?.has(index) || nativeContext.logoPlaceholderShapes?.has(index) || placeholders.consumed.has(index)) continue;
     if (annotations.consumed.has(shape)) { roles.set(shapeKeys.get(shape), 'annotation'); continue; }
     if (code.consumed.has(shape)||metric.consumed.has(shape)||cards.has(shape)||media.consumed.has(shape)||headings.consumed.has(shape)||plainText.consumed.has(shape)||timelines.consumed.has(shape)||quotes.consumed.has(shape)) continue;
     const ordinaryBody = Object.hasOwn(shape, 'p:txBody') && !shape['p:nvSpPr']?.['p:nvPr']?.['p:custDataLst']?.['p:tags'];
@@ -1020,7 +1031,7 @@ function importGraphicFrame(entries, frame, slidePath, relationships, importedTa
   };
   if (table) {
     const stored = importedTable && record('table');
-    const restoredTable = stored ? restore('table', importedTable, () => restoreTableData(importedTable, stored, {evidence: tableCellEvidence(table, relationships), environment: tableEnvironmentEvidence(entries), datasets: data.datasets, report: diagnostic => data.report?.('table', diagnostic)})) : importedTable;
+    const restoredTable = stored ? restore('table', importedTable, () => restoreTableData(importedTable, stored, {evidence: tableCellEvidence(table, relationships), olderEvidence: [tableCellEvidence(table, relationships, {form: 'raw'}), tableCellEvidence(table, relationships, {form: 'saved'})], environment: tableEnvironmentEvidence(entries), datasets: data.datasets, report: diagnostic => data.report?.('table', diagnostic)})) : importedTable;
     // FA-27: the frame's descr (or PowerPoint's decorative marker) is the table's text alternative.
     const alt = restoredTable && typeof restoredTable === 'object' ? readFrameAlt(frame["p:nvGraphicFramePr"]?.["p:cNvPr"]) : undefined;
     return {
@@ -1240,10 +1251,13 @@ function joinRich(a, b) {
   }
   return joined;
 }
-// `breaks` (slideListBreaks) holds the whitespace of the hard breaks the export recorded, by list path and line number: the
+// `breaks` (slideListRecord) holds the whitespace of the hard breaks the export recorded, by list path and line number: the
 // continuation line after a break joins with it, so a newline inside an item (or a description) returns. A blank line is a
 // native shape with no text: it is never a description. Without a record the lines join without a separator, as before.
-function mergeOpfListShapes(items, breaks = null, report = () => {}) {
+// `runs` (opf-pptx#212) holds the look export wrote on every run of a list ({text, description?}): a run value still equal to
+// it is inherited formatting, not authored run style, and is removed (as for a tagged heading), so an untouched round trip
+// adds no explicit sizes, families or colours; a value edited in PowerPoint differs and is kept. Without it runs are as read.
+function mergeOpfListShapes(items, breaks = null, report = () => {}, runs = null) {
   const lists = new Map();
   for (const item of items) {
     const match = /^OPF list (.+) line (\d+)$/.exec(item.name ?? '');
@@ -1256,6 +1270,26 @@ function mergeOpfListShapes(items, breaks = null, report = () => {}) {
   for (const [path, entries] of lists) {
     entries.sort((a, b) => a.line - b.line);
     if (!entries[0].item.paragraphs[0].bullet) continue;
+    const look = runs?.get(path), textLook = cleanBase(look?.text), descriptionLook = cleanBase(look?.description);
+    // The line's runs without the inherited look, or the paragraph's own richText when there is no record for this kind of line.
+    // Each run is cleaned on its own and none merge, so the runs stay the slots the run colour record counts (src/run-colors.js);
+    // they stay run objects until the lines are joined (as before), then `plain` gives the authored form back.
+    const own = (paragraph, base) => {
+      if (!base) return paragraph.richText;
+      return richRuns(paragraph.richText ?? paragraph.text).flatMap(run => {
+        const value = headingValue([run], base);
+        const parts = value === '' ? [] : typeof value === 'string' ? [{text: value}] : value.map(part => typeof part === 'string' ? {text: part} : part);
+        // A removed colour stays known until the run colour references are restored (restoreRunColors): an authored `text`
+        // role equals the inherited colour natively.
+        if (typeof run === 'object' && typeof run.color === 'string' && parts.length === 1 && parts[0].color === undefined) parts[0]._opfInherited = run.color;
+        return parts;
+      });
+    };
+    const plain = value => {
+      if (!Array.isArray(value)) return value;
+      const runs = value.map(run => typeof run === 'object' && Object.keys(run).length === 1 ? run.text : run);
+      return runs.length === 0 ? '' : runs.length === 1 && typeof runs[0] === 'string' ? runs[0] : runs;
+    };
     const paragraphs = [];
     const recorded = breaks?.get(path), applied = new Set();
     let bounds, size = 0;
@@ -1263,16 +1297,16 @@ function mergeOpfListShapes(items, breaks = null, report = () => {}) {
       const [paragraph] = item.paragraphs, current = paragraphs.at(-1);
       const gap = recorded?.get(line);
       const join = (a, b) => gap === undefined ? joinRich(a, b) : joinWrappedText([a, b], [gap]);
-      if (paragraph.bullet) { paragraphs.push({...paragraph}); size = paragraph.maxFontSize; }
+      if (paragraph.bullet) { paragraphs.push({...paragraph, richText: own(paragraph, textLook)}); size = paragraph.maxFontSize; }
       else if (paragraph.text === '') { /* a blank line of the entry: no text, no description */ }
       else if (paragraph.maxFontSize < size - 0.01) {
-        const text = paragraph.richText ?? paragraph.text;
+        const text = own(paragraph, descriptionLook) ?? paragraph.text;
         if (current.description === undefined) current.description = text;
         else { current.description = join(current.description, text); applied.add(line); }
       } else {
-        const before = current.text;
+        const before = current.text, rich = own(paragraph, textLook);
         current.text += (gap === undefined ? '' : Array.isArray(gap) ? gap[0] : gap) + paragraph.text;
-        if (current.richText !== undefined || paragraph.richText !== undefined) current.richText = join(current.richText ?? before, paragraph.richText ?? paragraph.text);
+        if (current.richText !== undefined || rich !== undefined) current.richText = join(current.richText ?? before, rich ?? paragraph.text);
         applied.add(line);
       }
       const b = item.visualBounds ?? item.bounds;
@@ -1283,6 +1317,8 @@ function mergeOpfListShapes(items, breaks = null, report = () => {}) {
       consumed.add(item);
     }
     if (recorded && [...recorded.keys()].some(line => !applied.has(line))) report({code: 'list-line-break-changed', message: `A hard line break recorded at export inside the list ${path} no longer has the continuation line it belonged to (a line was edited away, or became an entry), so that break was not restored; the list keeps the lines it has.`});
+    if (textLook) for (const paragraph of paragraphs) paragraph.richText = plain(paragraph.richText);
+    if (descriptionLook) for (const paragraph of paragraphs) if (paragraph.description !== undefined) paragraph.description = plain(paragraph.description);
     const first = entries[0].item;
     merged.set(first, {...first, paragraphs, text: paragraphs.map(paragraph => paragraph.text).join('\n'), bounds, visualBounds: undefined, sources: entries.flatMap(({item}) => item.sources ?? [])});
   }
@@ -2029,6 +2065,8 @@ async function addSlide(pptx, presentation, authoredSlide, slideIndex, context,
       });
     } else if ((item.field === "items" || item.field === "bullets") && item.text?.listEntries) {
       await addMeasuredList(slide,item.text,itemContext,item.path,item.bulletImage,presentation,slideIndex,options,item.payload?.numbering!==undefined);
+      // opf-pptx#212: the look every run of the list is written with where its source states none (full provenance only).
+      if(item.textStyle)recordListRuns(context.documentProvenance,slideIndex,item.path,listRunLook(item.text,item.textStyle,itemContext));
     } else if (["text", "title", "subtitle", "tag"].includes(item.field) && item.text?.richLines) {
       // FA-10: a TextRun[] heading draws and exports like rich body text; its lines are named and tagged as a heading (the body's are not).
       const heading = item.field !== 'text';
@@ -2163,6 +2201,14 @@ function addTextPayload(slide, value, region, context) {
   slide.addText(stringifyText(value), textBoxOptions(region, context, 18));
 }
 
+// opf-pptx#212: the look (richBase) the runs of a measured list are written with where the source states none: {text,
+// description?}, or undefined when its entries do not share one (import then reads every run value as observed).
+function listRunLook(fit,style,context){
+  const looks=kind=>new Set(fit.listEntries.filter(entry=>entry[kind]).map(entry=>JSON.stringify(richBase(entry[kind],style,kind==='text'?context.colors.text:context.colors.mutedText))));
+  const text=looks('text'),description=looks('description');
+  if(text.size!==1||description.size>1)return undefined;
+  return {text:JSON.parse([...text][0]),...(description.size?{description:JSON.parse([...description][0])}:{})};
+}
 function richLineRuns(line,color,native,context) {
   const fallback=color.replace(/^#/,'');
   return line.fragments.map(fragment=>{
@@ -2266,9 +2312,10 @@ function addListPayload(slide, items, region, context) {
 }
 
 // A content picture outside an image block (a timeline event image): one native picture contained in its region.
-async function addImagePayload(slide, presentation, asset, region, path, context, options) {
+// Generated furniture is never grouped (src/master-furniture.js), so a furniture part passes {group: false}.
+async function addImagePayload(slide, presentation, asset, region, path, context, options, {group = true} = {}) {
   const name = await addImagePicture(slide, presentation, asset, region, path, context, options, {fit: 'contain'});
-  if (!name) addImagePlaceholder(slide, presentation, asset, region, path, context, options);
+  if (!name) addImagePlaceholder(slide, presentation, asset, region, path, context, options, {group});
   return name;
 }
 
@@ -2348,8 +2395,13 @@ async function addImageItem(slide, presentation, item, slideIndex, context, opti
     fit: image.fit, focus: image.focus, effects: treated ? effects : null, shrink: !treated && !image.placement, treatment: tagged ? treatment : undefined
   });
   if (!name) {
-    addImagePlaceholder(slide, presentation, item.value, box, item.path, context, options);
-    return `OPF image placeholder ${context.imagePlaceholders.size}`;
+    const panel = addImagePlaceholder(slide, presentation, item.value, box, item.path, context, options);
+    // opf-pptx#221: in full mode the panel records the authored image and the block's own fields, so import restores the block.
+    if (context.provenanceMode === 'full') {
+      const fields = Object.fromEntries(IMAGE_TREATMENT_KEYS.filter(key => block[key] !== undefined).map(key => [key, structuredClone(block[key])]));
+      context.imagePlaceholderTags.set(panel, {v: 1, slide: `slides.${slideIndex}`, path: item.path, image: structuredClone(item.value), ...(Object.keys(fields).length ? {treatment: fields} : {})});
+    }
+    return panel;
   }
   if (image.overlay) addImageOverlay(slide, image.overlay, structuredClone(block.overlay), imageOverlayName(name), name, { ...context, slidePath: `slides.${slideIndex}` }, effects);
   return name;
@@ -2858,7 +2910,7 @@ async function addFurniture(slide,presentation,source,layout,context,options,sli
     if(part.type==='image'){
       const region={x:part.box.x/96,y:part.box.y/96,w:part.box.width/96,h:part.box.height/96};
       // A logo reference draws the organization's asset: a source that cannot be drawn is reported where the asset is written.
-      const objectName = await addImagePayload(slide,presentation,part.image,region,part.reference!==undefined?part.sourcePath:part.path,context,options);
+      const objectName = await addImagePayload(slide,presentation,part.image,region,part.reference!==undefined?part.sourcePath:part.path,context,options,{group:false});
       if (objectName) {
         entry.names.push(objectName);
         context.furnitureTags.set(objectName, {v:1, role:'image', group:String(slideIndex), part:index});
@@ -3130,9 +3182,10 @@ function placeholderAsset(asset, presentation) {
 // minimum) in the readable text colour for the panel, or a cross when the label
 // cannot fit even at that minimum. The panel carries the accessible name the
 // preview gives its group, "Image unavailable: <description>".
-// {logo: true} names the panel's other shapes after its panel (OPF image placeholder N text line i / icon i) and returns the
-// panel's name, so a logo placeholder can be tagged and consumed on import.
-function addImagePlaceholder(slide, presentation, asset, region, path, context, options, {logo = false} = {}) {
+// The panel's other shapes are named after it (OPF image placeholder N text line i / icon i) and the panel's name is returned,
+// so a logo placeholder can be tagged and consumed on import. opf-pptx#221: unless it is a logo's ({logo: true}) or furniture's
+// ({group: false}) placeholder, packaging writes the panel and those shapes as one native group carrying the accessible name.
+function addImagePlaceholder(slide, presentation, asset, region, path, context, options, {logo = false, group = !logo} = {}) {
   const layered = placeholderAsset(asset, presentation);
   const description = String(layered.alt ?? layered.title ?? "Image");
   const label = `Image unavailable\n${description}`;
@@ -3153,6 +3206,8 @@ function addImagePlaceholder(slide, presentation, asset, region, path, context,
   const fit = fitText(label, inner, 20 * scale, minimum, measurer);
   const objectName = `OPF image placeholder ${context.imagePlaceholders.size + 1}`;
   context.imagePlaceholders.set(objectName, `Image unavailable: ${description}`);
+  if (group) context.imagePlaceholderGroups.add(objectName);
+  const named = logo || group;
   slide.addShape("rect", {
     x: region.x, y: region.y, w: region.w, h: region.h,
     fill: { color: surface },
@@ -3166,18 +3221,18 @@ function addImagePlaceholder(slide, presentation, asset, region, path, context,
     const centered = { ...inner, y: inner.y + offset };
     addMeasuredPayloadText(slide, label, centered, context, options, {
       path, fit: fitText(label, centered, 20 * scale, minimum, measurer), textStyle: style,
-      diagnosticsHandled: true, align: "center", color: textColor, ...(logo ? {objectName: `${objectName} text`} : {})
+      diagnosticsHandled: true, align: "center", color: textColor, ...(named ? {objectName: `${objectName} text`} : {})
     });
-    return logo ? objectName : undefined;
+    return objectName;
   }
   // A status indicator, not shortened authored content: the full description stays
   // in the panel's accessible name.
   const size = Math.max(0, Math.min(inner.width, inner.height, 24 * scale));
-  if (!size) return logo ? objectName : undefined;
+  if (!size) return objectName;
   const icon = { x: inner.x + (inner.width - size) / 2, y: inner.y + (inner.height - size) / 2 };
   const line = { color: textColor, width: Math.min(2 * scale, size / 8) * .75 };
-  for (const flipV of [false, true]) slide.addShape("line", { x: icon.x / 96, y: icon.y / 96, w: size / 96, h: size / 96, line, flipV, ...(logo ? {objectName: `${objectName} icon ${flipV ? 2 : 1}`} : {}) });
-  return logo ? objectName : undefined;
+  for (const flipV of [false, true]) slide.addShape("line", { x: icon.x / 96, y: icon.y / 96, w: size / 96, h: size / 96, line, flipV, ...(named ? {objectName: `${objectName} icon ${flipV ? 2 : 1}`} : {}) });
+  return objectName;
 }
 
 // A placeholder names what is missing in plain words. It never dumps the source value, so no data or URL lands in slide text.
@@ -3847,6 +3902,8 @@ async function normalizePptxZip(raw, context) {
   context.nativePlaceholders = attachNativePlaceholders(entries,context.nativeFurniture,context.nativeFurnitureBands);
   // The "Image unavailable" panel of an unresolved logo: identity only, so import does not read it as content.
   attachTextTags(entries,context.logoPlaceholderTags,LOGO_TAG,'opfLogoPlaceholder','logo placeholder');
+  // opf-pptx#221: the image block of an unavailable-image placeholder, on its panel (full provenance).
+  attachTextTags(entries,context.imagePlaceholderTags,IMAGE_PLACEHOLDER_TAG,'opfImagePlaceholder','image placeholder');
   for(const [part,bytes]of Object.entries(entries)){
     if(!/^ppt\/slides\/slide\d+\.xml$/.test(part))continue;
     const relationships=parseRelationships(entries,part);
@@ -3879,6 +3936,12 @@ async function normalizePptxZip(raw, context) {
       }
     }
   }
+  // opf-pptx#175: after every chart rewrite, each classic series in its CT_*Ser sequence (src/chart-order.js).
+  for(const part of Object.keys(entries)){
+    if(!/^ppt\/charts\/chart\d+\.xml$/.test(part))continue;
+    const xml=decodeText(entries[part]),ordered=orderChartSeries(xml);
+    if(ordered!==xml)entries[part]=encodeText(ordered);
+  }
   applyChartFonts(entries,context.chartFonts,parseRelationships);
   if (context.frameAlts.size) for (const [part, bytes] of Object.entries(entries)) if (/^ppt\/slides\/slide\d+\.xml$/.test(part)) { const xml = decodeText(bytes), next = applyFrameAlt(xml, context.frameAlts); if (next !== xml) entries[part] = encodeText(next); }
   // Chartex charts: the native cx:chartSpace part, its style parts and the mc:AlternateContent frame (the classic chart above is the fallback).
@@ -4223,12 +4286,18 @@ function normalizePartBytes(path, bytes, context, renameMaps, entries, imageMeta
       });
       // PptxGenJS gives shapes no alternative text. An unavailable image's panel
       // carries the accessible name the preview gives its group.
+      const escapes={'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;',"'":'&apos;','\r':'&#13;','\n':'&#10;','\t':'&#9;'};
+      const describe=description=>description.replace(/[&<>"'\r\n\t]/g,char=>escapes[char]);
       xml=xml.replace(/<p:cNvPr id="(\d+)" name="(OPF image placeholder \d+)"(\/?)>/g,(node,id,name,close)=>{
         const description=context.imagePlaceholders.get(name);
         if(description===undefined)return node;
-        const escapes={'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;',"'":'&apos;','\r':'&#13;','\n':'&#10;','\t':'&#9;'};
-        return `<p:cNvPr id="${id}" name="${name}" descr="${description.replace(/[&<>"'\r\n\t]/g,char=>escapes[char])}"${close}>`;
+        // opf-pptx#221: a grouped placeholder's accessible name is on its group (below), as the preview names its <g>. The empty panel
+        // then has no alt text of its own, so it is marked decorative (the adec:decorative extension, "Mark as decorative"), or
+        // PowerPoint's Accessibility Checker flags it. The text lines carry text and are not marked. PptxGenJS writes this cNvPr self-closing.
+        if(context.imagePlaceholderGroups.has(name))return close?writeFrameAlt(node,''):node;
+        return `<p:cNvPr id="${id}" name="${name}" descr="${describe(description)}"${close}>`;
       });
+      xml=groupImagePlaceholders(xml,context.imagePlaceholderGroups,name=>describe(context.imagePlaceholders.get(name)));
       // PptxGenJS 4.0.1 emitted pPr before each rich run (pptxgenjs-plus writes
       // one). OOXML allows one pPr, before all runs. Paragraph options belong
       // to the first run.
@@ -4256,6 +4325,34 @@ function normalizePartBytes(path, bytes, context, renameMaps, entries, imageMeta
 // their explicit per-shape buFont; only the master bodyStyle is touched.
 const VENDOR_MASTER_BULLET_FONT = '<a:buFont typeface="Arial" pitchFamily="34" charset="0"/>';
 const THEME_MINOR_BULLET_FONT = '<a:buFont typeface="+mn-lt"/>';
+// opf-pptx#221: each unavailable-image placeholder (panel, then its label lines or cross strokes, written consecutively) becomes
+// one p:grpSp (CT_GroupShape: nvGrpSpPr, grpSpPr, members) named "<panel> group" with the accessible name as its descr. Its
+// transform is the identity (chOff/chExt equal off/ext, the members' union), so every member keeps its box and stays an
+// editable shape; tags and names stay on the members.
+function groupImagePlaceholders(xml,panels,description){
+  if(!panels.size)return xml;
+  let next=Math.max(0,...[...xml.matchAll(/<p:cNvPr\b[^>]*\bid="(\d+)"/g)].map(match=>Number(match[1])))+1;
+  const nameOf=shape=>shape.match(/<p:cNvPr\b[^>]*\bname="([^"]*)"/)?.[1]??'';
+  const memberOf=(panel,name)=>name.startsWith(`${panel} `)&&/^(?:text line|icon) \d+$/.test(name.slice(panel.length+1));
+  return xml.replace(/<p:sp>[\s\S]*?<\/p:sp>(?:<p:sp>[\s\S]*?<\/p:sp>)*/g,run=>{
+    const shapes=run.match(/<p:sp>[\s\S]*?<\/p:sp>/g);
+    let out='';
+    for(let index=0;index<shapes.length;index++){
+      const panel=nameOf(shapes[index]);
+      if(!panels.has(panel)){out+=shapes[index];continue;}
+      const members=[shapes[index]];
+      while(index+1<shapes.length&&memberOf(panel,nameOf(shapes[index+1])))members.push(shapes[++index]);
+      const boxes=members.map(shape=>shape.match(/<a:off x="(-?\d+)" y="(-?\d+)"\/><a:ext cx="(\d+)" cy="(\d+)"\/>/)).filter(Boolean).map(match=>match.slice(1).map(Number));
+      if(!boxes.length){out+=members.join('');continue;}
+      const x=Math.min(...boxes.map(box=>box[0])),y=Math.min(...boxes.map(box=>box[1]));
+      const cx=Math.max(...boxes.map(box=>box[0]+box[2]))-x,cy=Math.max(...boxes.map(box=>box[1]+box[3]))-y;
+      out+=`<p:grpSp><p:nvGrpSpPr><p:cNvPr id="${next++}" name="${imagePlaceholderGroupName(panel)}" descr="${description(panel)}"/><p:cNvGrpSpPr/><p:nvPr/></p:nvGrpSpPr>`+
+        `<p:grpSpPr><a:xfrm><a:off x="${x}" y="${y}"/><a:ext cx="${cx}" cy="${cy}"/><a:chOff x="${x}" y="${y}"/><a:chExt cx="${cx}" cy="${cy}"/></a:xfrm></p:grpSpPr>${members.join('')}</p:grpSp>`;
+    }
+    return out;
+  });
+}
+
 function themeMasterBulletFonts(xml) {
   return xml.replace(/<p:bodyStyle>[\s\S]*?<\/p:bodyStyle>/, bodyStyle =>
     bodyStyle.split(VENDOR_MASTER_BULLET_FONT).join(THEME_MINOR_BULLET_FONT));

package/dist/run-colors.js

@@ -87,7 +87,7 @@ export function validateRunColors(value) {
 function* markedRuns(value) {
   if (Array.isArray(value)) { for (const item of value) yield* markedRuns(item); return; }
   if (!object(value)) return;
-  if (Object.hasOwn(value, '_opfScheme')) yield value;
+  if (Object.hasOwn(value, '_opfScheme') || Object.hasOwn(value, '_opfInherited')) yield value;
   for (const item of Object.values(value)) if (item !== null && typeof item === 'object') yield* markedRuns(item);
 }
 
@@ -96,13 +96,17 @@ function* markedRuns(value) {
  * {record, structure, content}: the stored OPF_SLIDE_V1 value, whether the slide's arrangement matches it and whether its
  * content structure was restored from it, or undefined for an untagged slide. `resolve(slide, name)` returns the '#RRGGBB'
  * the name resolves to in the document (or undefined). Every transient `_opfScheme` marker is removed.
+ * opf-pptx#212: a list run whose colour import removed as the list's own (OPF_SLIDE_V1 listRuns) carries `_opfInherited`, that
+ * colour: a stored reference that resolves to it is restored (an authored `text` role equals the inherited colour), and the
+ * marker is removed; a run left with only its text becomes a plain string again.
  */
 export function restoreRunColors(slides, info, resolve, report) {
   slides.forEach((slide, index) => {
     const tag = info[index];
     const marked = [...markedRuns(slide)];
     const restoreName = (run, name) => {
-      const hex = typeof run.color === 'string' && /^#[0-9a-f]{6}$/i.test(run.color) ? run.color.toUpperCase() : undefined;
+      const current = run.color ?? run._opfInherited;
+      const hex = typeof current === 'string' && /^#[0-9a-f]{6}$/i.test(current) ? current.toUpperCase() : undefined;
       if (hex && resolve(slide, name)?.toUpperCase() === hex) run.color = name;
     };
     if (tag?.record?.colors) {
@@ -117,5 +121,27 @@ export function restoreRunColors(slides, info, resolve, report) {
       for (const run of marked) if (typeof run._opfScheme === 'string') restoreName(run, run._opfScheme);
     }
     for (const run of marked) delete run._opfScheme;
+    const inherited = new Set(marked.filter(run => Object.hasOwn(run, '_opfInherited')));
+    for (const run of inherited) delete run._opfInherited;
+    if (inherited.size) plainInheritedRuns(slide, inherited);
   });
 }
+
+// The list values of a slide in which a run of `runs` is left with only its text: that run becomes a string, and a value that
+// is then one string is that string (the authored form; the run slots are unchanged).
+function plainInheritedRuns(slide, runs) {
+  const plain = value => {
+    if (!Array.isArray(value) || !value.some(run => runs.has(run))) return value;
+    const next = value.map(run => runs.has(run) && Object.keys(run).length === 1 ? run.text : run);
+    return next.length === 1 && typeof next[0] === 'string' ? next[0] : next;
+  };
+  for (const leaf of leaves(slide)) for (const field of ['items', 'bullets']) {
+    if (!Array.isArray(leaf[field])) continue;
+    leaf[field] = leaf[field].map(item => {
+      if (!object(item)) return plain(item);
+      const next = {...item, text: plain(item.text)};
+      if (item.description !== undefined) next.description = plain(item.description);
+      return next;
+    });
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openpresentation/opf-pptx",
-  "version": "0.18.0",
+  "version": "0.18.1",
   "description": "Pure local OPF to PPTX export and PPTX to OPF import tooling.",
   "license": "MIT",
   "type": "module",
@@ -65,7 +65,7 @@
   },
   "dependencies": {
     "@node-projects/jszip": "4.3.0",
-    "@openpresentation/opf": "^0.18.1",
+    "@openpresentation/opf": "^0.18.3",
     "@rgrove/parse-xml": "4.2.3",
     "fast-xml-parser": "^5.8.0",
     "fflate": "^0.8.3",
@@ -73,7 +73,7 @@
     "sharp": "0.35.5"
   },
   "peerDependencies": {
-    "@openpresentation/opf-render": "^0.18.0"
+    "@openpresentation/opf-render": "^0.18.1"
   },
   "peerDependenciesMeta": {
     "@openpresentation/opf-render": {
@@ -86,13 +86,18 @@
     "@expo-google-fonts/carlito": "0.4.1",
     "@expo-google-fonts/cousine": "0.4.3",
     "@expo-google-fonts/gelasio": "0.4.1",
+    "@expo-google-fonts/noto-color-emoji": "0.4.7",
     "@expo-google-fonts/noto-naskh-arabic": "0.4.5",
     "@expo-google-fonts/noto-sans": "0.4.2",
     "@expo-google-fonts/noto-sans-arabic": "0.4.3",
+    "@expo-google-fonts/noto-sans-armenian": "0.4.2",
+    "@expo-google-fonts/noto-sans-ethiopic": "0.4.2",
+    "@expo-google-fonts/noto-sans-georgian": "0.4.3",
+    "@expo-google-fonts/noto-sans-symbols-2": "0.4.1",
     "@expo-google-fonts/roboto": "0.4.3",
     "@expo-google-fonts/roboto-mono": "0.4.2",
     "@expo-google-fonts/tinos": "0.4.2",
-    "@openpresentation/opf-render": "0.18.0",
+    "@openpresentation/opf-render": "0.18.1",
     "@resvg/resvg-js": "2.6.2",
     "esbuild": "0.28.2",
     "playwright": "1.63.0"