@openpresentation/opf-pptx 0.12.3 → 0.13.0

package/DEPENDENCY-NOTES.md

@@ -4,15 +4,17 @@
 
 PPTX 0.11.4 depends on published [`@openpresentation/opf@^0.11.3`](https://www.npmjs.com/package/@openpresentation/opf) (reference layer: ColorRef, document `variables`, exported `resolveColorRef()`). The optional renderer peer is [`@openpresentation/opf-render@^0.11.0`](https://www.npmjs.com/package/@openpresentation/opf-render) so editor 0.10.0 + render 0.11.0 + pptx 0.11.0 install together. CI checks out OPF [`b8a1faf`](https://github.com/OpenPresentation/opf/commit/b8a1faf24203635bd36b09ea19f44bcd53781f16) (`opf-v0.11.0`) for coordinated source linking. Named content colors resolve through core `resolveColorRef()`; eight-digit hex alpha stays a local export concern because core `normalizeHexColor` drops the alpha byte. The deck color scheme is written as the theme `clrScheme`, and named slot and role colors (text, table cells and borders, hyperlinks, backgrounds) are written as `schemeClr` where the deck theme holds exactly that color; card, timeline and media colors, literal hex, variables, translucent colors and slide-override colors stay literal `srgbClr`.
 
-OPF PPTX 0.5.1 ships the exact, unmodified PptxGenJS 4.0.1 ESM distribution in `vendor/pptxgenjs`, with its MIT license, upstream archive integrity and per-file SHA-256 hashes. Its actual JSZip dependency is declared directly. Ordinary npm installations therefore omit the unused image-size parser without requiring consumer overrides. This removes the affected dependency; it does not patch the parser. Published OPF PPTX 0.5.0 retains the older graph.
+Since RR-17 (opf-pptx#162) the vendored engine is [pptxgenjs-plus](https://github.com/lofcz/pptxgenjs-plus) 4.3.4, the maintained MIT fork of PptxGenJS (same public API and default export): `vendor/pptxgenjs/pptxgen.es.js` is the exact, unmodified `package/dist/pptxgen.es.js` of the npm archive, with its MIT license, the archive's SHA-512 integrity, per-file SHA-256 hashes and the source commit of its npm SLSA provenance (`lofcz/pptxgenjs-plus@ecfa5086`) in `UPSTREAM.json`. Its imports are declared directly and pinned: `@node-projects/jszip` 4.3.0 (replacing `jszip` 3.10.2), `@rgrove/parse-xml` 4.2.3 and `pako` 3.0.2. `@node-projects/jszip` declares `@types/node` as a runtime dependency (type declarations, no code), so it is installed too. opf-pptx's own package reading and writing stays on `fflate`. Every output change and how it was measured is in [docs/pptxgenjs-plus-migration.md](docs/pptxgenjs-plus-migration.md); `src/vendor-compat.js` keeps the PptxGenJS 4.0.1 output where opf-pptx's contracts need it.
 
-The inspected PptxGenJS 4.0.1 ESM/CommonJS distributions do not import `image-size`. The only sizing-module reference is in a commented, unused helper. OPF supplies image geometry itself. The image-fit follow-up reads bounded PNG/JPEG/GIF/WebP dimension headers and inline JPEG EXIF orientation; it does not load image-size or decode pixels.
+Before RR-17: OPF PPTX 0.5.1 to 0.12.x ship the exact, unmodified PptxGenJS 4.0.1 ESM distribution in `vendor/pptxgenjs`, with its MIT license, upstream archive integrity and per-file SHA-256 hashes. Its actual JSZip dependency is declared directly. Ordinary npm installations therefore omit the unused image-size parser without requiring consumer overrides. This removes the affected dependency; it does not patch the parser. Published OPF PPTX 0.5.0 retains the older graph.
 
-`npm test` requires image-size to be absent, then blocks both ESM and CommonJS loading before running the full model suite and checking image-byte preservation for data URIs, local paths and host-resolved bytes. Browser bundling retains upstream's Node built-in exclusions through the vendor directory's package metadata. This is not a guarantee about every upstream PptxGenJS API or future version.
+The inspected PptxGenJS 4.0.1 ESM/CommonJS distributions do not import `image-size`, and neither does pptxgenjs-plus 4.3.4 (no `image-size` dependency). The only sizing-module reference is in a commented, unused helper. OPF supplies image geometry itself. The image-fit follow-up reads bounded PNG/JPEG/GIF/WebP dimension headers and inline JPEG EXIF orientation; it does not load image-size or decode pixels.
+
+`npm test` requires image-size to be absent, then blocks both ESM and CommonJS loading before running the full model suite and checking image-byte preservation for data URIs, local paths and host-resolved bytes. Browser bundling retains upstream's Node built-in exclusions through the vendor directory's package metadata (pptxgenjs-plus has no static `node:` import; it loads `fs`, `http` and `https` with a runtime `import()` only in Node, for media given by `path`). This is not a guarantee about every upstream PptxGenJS API or future version.
 
 Every build checks the vendored code and license against `UPSTREAM.json`. `node scripts/vendor-pptxgenjs.mjs` is an explicit maintainer command that fetches the pinned official npm archive, verifies its SHA-512 integrity and reads only the named distribution/license entries. It is never run by builds or installations. Review the upstream source, actual imports, license and audit before changing versions; retain tests and reassess [GHSA-w3rx-r6r6-pgpr](https://github.com/advisories/GHSA-w3rx-r6r6-pgpr) and [GHSA-5p2g-fcmc-qvqq](https://github.com/advisories/GHSA-5p2g-fcmc-qvqq). Do not accept npm's incompatible PptxGenJS downgrade suggestion.
 
-Package normalization removes PptxGenJS 4.0.1 content-type declarations for generated slide-master parts that do not exist, without changing the vendor bytes or existing package parts. The smoke regression requires every override to target an actual part. This ports the independently audited correction from [commit 1363a65](https://github.com/OpenPresentation/opf-pptx/commit/1363a653c8b0e80c50d970bc30db3587bcf6f14e). Its notes-master SDK/native-order disagreement remains separate; the native ordering is unchanged.
+Package normalization removes PptxGenJS 4.0.1 content-type declarations for generated slide-master parts that do not exist (pptxgenjs-plus no longer writes them; the filter stays as a guard), without changing the vendor bytes or existing package parts. The smoke regression requires every override to target an actual part. This ports the independently audited correction from [commit 1363a65](https://github.com/OpenPresentation/opf-pptx/commit/1363a653c8b0e80c50d970bc30db3587bcf6f14e). Its notes-master SDK/native-order disagreement remains separate; the native ordering is unchanged.
 
 ## Compatible raster decoding
 

package/README.md

@@ -4,11 +4,13 @@ Version 0.12.0 requires `@openpresentation/opf` ^0.12.0 (composed font sizes on
 
 Chart options (RR-35, unreleased): `axisTitles`, `legend` and `dataLabels` on a chart export as native `c:title`, `c:legendPos` and `c:dLbls` (and `cx:title`, `cx:legend`, `cx:dataLabels` on the Office 2016 constructs) and import back; the preview draws the same options. See core `docs/chart-options.md` for the per-type support table and the `chart-option-adapted` diagnostic.
 
+Chart and table data (RR-54, unreleased; core `docs/chart-table-data.md`): chart values pass core `chartNumber` (a string that is not a plain decimal, such as `"12%"`, `"$5"` or `"(5)"`, is a gap and one `chart-value-not-numeric` diagnostic per chart, where the exporter used to strip it to a number). A column number format (`{"name": "Revenue", "format": "$#,##0.0"}`) is written as the series format code, the data-label and value-axis number formats (the axis takes the first plotted series' format, as the preview does) and the embedded workbook cell formats (Edit Data shows it), on classic and chartex charts. Top-level `datasets` referenced by `{"dataset": "<id>", "fields"?}` and `chart.mapping` export exactly like their inline equivalent; dataset tables and formatted table cells export their display text. With `full` provenance, `OPF_DATASETS_V1` (beside the document tag) and `OPF_DATA_V1` (on each chart or table frame that uses these fields) restore the datasets, references, mapping, formats and `data.source` on import while the native caches (a plain PowerPoint save keeps them), the referenced datasets and the cell texts are unchanged (tags are limited to 16 MiB and shape-checked; a bad one is reported as `invalid-data-provenance`); a deck without them maps every series format code that core `numberFormatFromExcel` maps back to the column format and reports any other code (`chart-number-format-adapted`). A deck that uses none of these fields exports byte for byte as before.
+
 Version 0.9.1 kept core `^0.11.0` and raised the optional `@openpresentation/opf-render` peer to `^0.9.0` so it coexists with editor 0.8.0. ColorRef / `variables` on content colors still hex-resolve through core `resolveColorRef()` before PptxGenJS `srgbClr` export. Unrecognized run colors such as `color:'invalid'` still validate and fall back to the theme text color. Native DrawingML `schemeClr` and theme `clrScheme` writes, and native `p:hf` headers/footers, are not in this release. Import still flattens theme colors to hex. Metric, quote and timeline layout placeholders and the corrected text-bullet contract from 0.8.1 are retained.
 
 Unfinished prepared shaping work is preserved in the [September 15 roadmap](docs/roadmap-shaping-20260915.md); it is not part of the published runtime.
 
-Version 0.8.0 and this checkout require Node 24 (`24.x`). Use `.nvmrc` for local development. Earlier published versions retain their original engine declarations. Browser entrypoints remain browser-safe; native application compatibility is verified separately.
+This checkout supports Node 22 or later (`engines.node` `>=22`; CI tests Node 22, 24 and 26). Versions 0.8.0 to 0.12.3 declared `24.x`, so npm on Node 22 or 26 silently installed an older release instead (RR-20); upgrade past 0.12.3. Use `.nvmrc` (Node 24) for local development. Earlier published versions retain their original engine declarations. Browser entrypoints remain browser-safe; native application compatibility is verified separately.
 
 Version 0.8.0 consumes shared heading/scalar/rich line placement, including `textRasterPadding`, through editable native line boxes without autofit. Complete heading tags retain title/subtitle/tag roles, line ordering and current edited text during import. Source boundary metadata also records hard-line separators, so complete scalar/heading groups recover current native text with spaces, tabs and exact authored line endings. Incomplete, duplicate, ambiguous or bulleted groups fall back to ordinary import with diagnostics. Legacy heading tags retain their prior native-line behavior; arbitrary formatting, nesting and geometry are not reconstructed. See the [source contract and limits](https://github.com/OpenPresentation/opf/blob/f94125a1ff95bf0974a055fe1c081d348dad54f2/docs/plans/text-placement.md). Native raster certification remains separate.
 
@@ -93,12 +95,12 @@ 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.
-- 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 ("12%", "$5" and "1,234" count) 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.
+- 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.
 - A chart cell that holds no number (`null`, an empty or non-numeric string, a boolean) is a gap in the native chart: its cache has no point at that row (`c:ptCount` keeps the row count), its workbook cell is blank, and it re-imports as `null`. An actual zero stays zero.
 - ZIP entries, generated chart/workbook part names, core-property timestamps, and nested chart workbook timestamps are normalized for reproducible bytes. [Export determinism](docs/export-determinism.md) lists the tested time zone, locale, clock and host-font controls and each known variance (WebP conversion, font registries, ICU segmentation, timestamps).
 - The package names only the document's chosen fonts. Chart text (data labels, axes, legend, titles) uses the chart slide's body font in `latin`/`ea`/`cs`; each embedded chart workbook uses the same fonts in its styles and theme; run `pitchFamily` follows the font scheme type (monospace is fixed pitch, serif is roman); and `docProps/app.xml` "Fonts Used" lists the fonts the package actually uses. The theme keeps PptxGenJS's per-script supplements (`THEME_SCRIPT_SUPPLEMENTS`) and empty `ea`/`cs` slots unless a script font was selected for that slot (see [Languages, right-to-left text and script fonts](#languages-right-to-left-text-and-script-fonts)).
-- `checkPptxTypefaces(bytes, {fonts, monospace, themeScripts})` (optional `themeScripts: {major: {ea, cs}, minor: {ea, cs}}` names the East Asian / complex-script families the author selected; a selected theme slot that is empty or different is reported as `theme-script-slot`, an unselected one may stay empty) inventories every `typeface`, workbook font name and "Fonts Used" entry in every XML part, including nested packages, and reports each font outside that policy. `inventoryPptxTypefaces()` returns the raw inventory.
+- `checkPptxTypefaces(bytes, {fonts, monospace, themeScripts, themeScriptsByPart})` (optional `themeScripts: {major: {ea, cs}, minor: {ea, cs}}` names the East Asian / complex-script families the author selected; a selected theme slot that is empty or different is reported as `theme-script-slot`, an unselected one may stay empty; `themeScriptsByPart` overrides it per theme part, for the theme of a per-slide script master; theme references resolve against the theme of the part's own slide or notes master) inventories every `typeface`, workbook font name and "Fonts Used" entry in every XML part, including nested packages, and reports each font outside that policy. `inventoryPptxTypefaces()` returns the raw inventory.
 
 This pass did not require an OPF schema change. The deferred full OOXML placeholder mapping from `docs/plans/layout-placeholders.md` remains a later hand-written OOXML emitter concern.
 
@@ -203,7 +205,8 @@ The exporter reads the presentation `language` through core `resolveScriptFonts(
 - Every run, end-of-paragraph and default run property carries `lang` set to the resolved OOXML tag instead of a fixed `en-US`. That tag is the catalog's curated `ooxmlLang` (for example `ja-JP` or `ar-SA`) or an authored region tag such as `en-NZ`. `altLang` is not written: it names the editing-UI language, which OPF does not model.
 - Theme major/minor `a:ea`/`a:cs` are written only for a slot where a script font is actually selected (FF-49): an explicit `eastAsian`/`complexScript` on the design font scheme, the scheme's own script family, or the language's script font (a language that uses the East Asian slot, such as Japanese, writes `ea`; one that uses the complex-script slot, such as Arabic, Hebrew, Indic or Thai, writes `cs`). Every other slot keeps the vendored empty typeface, exactly as Office's own themes leave it, so PowerPoint picks its per-language default for script text typed later and the package names nothing the author did not select (owner font policy). Latin, Cyrillic, Greek, Armenian, Georgian and Ethiopic decks write neither; the other slot of a CJK or complex-script deck is empty too. The language never changes the theme's latin fonts (Model C): `design.fontScheme` alone sets them. The preview resolves the same slots (opf-render's script profile: the theme's family where it names one, the latin family where it is empty), and `test/theme-script-slots.mjs` checks preview against export for every catalog font scheme.
 - The theme's per-script entry for the language's own script (for example `Jpan`, `Hang`, `Arab` or `Deva`) names the resolver's supplement. The rest of the vendored Office per-script list is unchanged; that list is FF-08's call.
-- Run `a:ea`/`a:cs` name the resolved slot when the language or the font scheme supplies a script-specific font, for example Meiryo in `a:ea` for Japanese or Arabic Typesetting in `a:cs` for Arabic. Headings take the heading font and other text the body font. Otherwise the slots keep repeating the run's latin face, so Latin, Cyrillic and Greek decks keep their run bytes.
+- Slide and notes runs name no `a:ea`/`a:cs` (FF-05: PowerPoint lists an explicit run East Asian or complex-script typeface as an empty-name font in `Presentation.Fonts`); their script text takes the theme slots through `+mn-ea`/`+mn-cs`. The theme `ea` always names a font (the selected script font, an East Asian font for East Asian text in the deck, else the latin family), so no paragraph end mark reads an empty font. Chart text keeps its own latin/ea/cs in the chart's body font.
+- Per-slide script fonts (opf-pptx#168): the presentation theme is built from the first slide. A slide whose own font scheme, slide theme or inline `eastAsian`/`complexScript` selects script fonts that theme does not carry gets its own slide master: a copy of slide master 1 and its layout, with a theme that is the presentation theme plus that slide's East Asian / complex-script slots and per-script entry (named `1_<theme>`, `2_<theme>`, ... as PowerPoint names a second master's theme). Slides with the same script fonts share a master, a slide that selects none stays on master 1, and masters are numbered in slide order. A deck with one script profile keeps one master and is byte-identical to the export before this change. A presentation has one notes master, whose theme is a copy of the presentation theme, so the notes of a slide on another master draw in the presentation theme's script fonts: `script-font-notes-not-exported` (path `slides.N.notes`) reports each such slide with notes.
 - In a right-to-left deck, each slide and notes paragraph takes its direction from core `paragraphDirection(text, direction)`, the same rule the renderer uses: `rtl="1"` when its first strong character is right-to-left or it has none (digits, punctuation, empty), else an explicit `rtl="0"` (an English quote, a code line). The master, layout and presentation default paragraph levels start right-to-left only in a right-to-left deck. Left-to-right decks write no paragraph direction. Alignment is logical (RR-05, needs the core release that composes right-to-left decks): `left` is the start edge, so a right-to-left paragraph writes `rtl="1"` with `algn="r"` (PowerPoint's `algn` is physical, and `marL`/`indent` are the start-side margin and hanging indent, so a bullet hangs at the right), and every wrapped line shares its paragraph's direction and alignment (core computes the direction once per paragraph, not per line). The composition is mirrored through core: the `left` region and the first column are drawn at the right, a right-to-left table writes `a:tblPr rtl="1"` with its columns in logical order, column, line and area charts write `c:catAx` orientation `maxMin` (first category and value axis at the right), cover logos and header/footer zones swap sides, the master, layout and notes default levels start right-aligned, and notes paragraphs start at the right. Each Latin phrase inside an Arabic or Hebrew run (letters, joining spaces and word punctuation, digits) is written as its own `en-US` run, so PowerPoint orders `v2.0` and `PowerPoint 365` left to right instead of splitting them into items; digits that touch Arabic words stay in the Arabic run. Re-import reads right alignment of a right-to-left table cell as the logical start. Left-to-right decks are written exactly as before.
 - The PPTX names the chosen fonts only and never embeds font programs. Licensed fonts are never embedded; only open fonts could be, through the explicit FF-13 embed path. Catalog names such as Meiryo must be installed where the deck is opened.
 
@@ -215,7 +218,7 @@ When the package carries an FF-32 stored `language` ([document round trip](docs/
 - `language-ambiguous`: records share one curated tag and none has it as its own tag (`bn-BD` is Bengali and Chittagonian, `fil-PH` Filipino and Tagalog); the record of the same primary language is imported.
 - `language-uncatalogued`: no catalog record matches; the tag is imported.
 - `rtl-language-mismatch`: right-to-left paragraphs under a left-to-right language.
-- `script-font-not-imported`: theme `ea`/`cs` name a font that neither repeats latin nor matches the language default. Imported OPF does not yet carry explicit font-scheme script slots.
+- `script-font-not-imported`: theme `ea`/`cs` name a font that neither repeats latin nor matches what the imported document resolves for the first slide (path `design.fontScheme`), or a slide on another slide master has a master theme whose `ea`/`cs` the imported slide does not resolve to (path `slides.N.design.fontScheme`; with FF-32 provenance the slide's font scheme is restored and nothing is reported). Without provenance, imported OPF does not carry the script slots.
 
 Exports report `language-unresolved` when the document's language cannot be resolved locally (a URL, `pkg:` reference or unknown id) and `en-US` is used.
 
@@ -280,7 +283,7 @@ Pass the same `textMeasurement` provider used by preview and pagination to `toPp
 
 The PPTX always names the font family the document chose (for example `typeface="Aptos"`), so PowerPoint opens the file and shows the actual font, installed or as a Microsoft 365 cloud font. This is the [OPF font policy](https://github.com/OpenPresentation/opf/blob/main/docs/font-fidelity.md#font-policy-ff-31): the user's selection is the source of truth, licensed fonts are never bundled or embedded, and previews draw an open look-alike instead. A provider may preview that family with another face: a metric-compatible substitute (Carlito for Calibri, the goal), a visual-only one (Roboto or Carlito for Aptos, a documented fallback and known layout-fidelity gap until a metric-compatible replacement exists), a caller alias or a generic fallback. That face changes measurement and drawing only. It never reaches the theme, runs, bullets or chart parts. Faces of the chosen family itself, such as Roboto Medium for Roboto at weight 500, keep their native style-link names. `test/export-chosen-fonts.mjs` checks this for every renderer Office-pack substitute. The exporter does not embed font binaries. Viewers resolve the named family themselves. When the preview used a non-metric substitute, PowerPoint can break lines differently from the preview.
 
-Since 0.5.1, the exact PptxGenJS 4.0.1 ESM distribution is shipped with its MIT license and verified upstream hashes. Its unused `image-size` dependency is not installed; JSZip is declared directly. See [dependency provenance and regression coverage](DEPENDENCY-NOTES.md). The published 0.5.0 package retains the older dependency graph.
+The exact [pptxgenjs-plus](https://github.com/lofcz/pptxgenjs-plus) 4.3.4 ESM distribution (the maintained PptxGenJS fork; PptxGenJS 4.0.1 from 0.5.1 to 0.12.x) is shipped with its MIT license and verified upstream hashes. Its imports (`@node-projects/jszip`, `@rgrove/parse-xml`, `pako`) are declared directly; `image-size` is not installed. Output changes of the move: [docs/pptxgenjs-plus-migration.md](docs/pptxgenjs-plus-migration.md). See [dependency provenance and regression coverage](DEPENDENCY-NOTES.md). The published 0.5.0 package retains the older dependency graph.
 
 ### Native table fitting
 
@@ -334,7 +337,7 @@ Native viewer check: Keynote 14.4 displays the PNG/JPEG/GIF media-type specimens
 
 Set `imageFormat: "preserve"` to embed WebP unchanged when the receiving application supports it. Other image formats keep their existing export behavior. Conversion errors include the OPF image path; images above 40 megapixels are rejected before compatible conversion. Decoder differences can affect color/alpha rounding, so byte identity across platforms is not promised.
 
-Node conversion lazily loads the pinned open-source Sharp dependency and requires Node 24. Normal package installation must include platform optional dependencies for its native binaries. Browser bundles select a separate browser decoder using local Blob/image/canvas APIs; Sharp and Node code are excluded. Neither path uploads images or fetches asset URLs. Source-preserving export and ordinary PNG/JPEG/GIF operations do not load Sharp.
+Node conversion lazily loads the pinned open-source Sharp dependency and requires Node 22 or later. Normal package installation must include platform optional dependencies for its native binaries. Browser bundles select a separate browser decoder using local Blob/image/canvas APIs; Sharp and Node code are excluded. Neither path uploads images or fetches asset URLs. Source-preserving export and ordinary PNG/JPEG/GIF operations do not load Sharp.
 
 `npm test` includes the Node pixel-reference cases and verifies browser bundling. To run the browser pixel checks, run `npm run build:browser-check`, serve this repository locally, and open `/artifacts/webp-fallback/browser/index.html`. The page reports 13 checks covering embedded PNG pixels, alpha, EXIF, the first animation frame, fit/crop, resolver calls and DOM canvas fallback. These are browser export checks, separate from the recorded Keynote viewing evidence.
 

package/dist/chart-data.js

@@ -0,0 +1,156 @@
+// RR-54: chart and table data in the PPTX export and import (core docs/chart-table-data.md).
+//
+// Core resolves chart and table data for every engine: one strict number rule (`chartNumber`), the NumberFormat to
+// Excel code conversion, top-level datasets and series mapping by column name. This module reads those functions from
+// core and writes their result into the native chart: the series c:numCache/c:formatCode, the data-label and value-axis
+// c:numFmt and the embedded workbook cell formats (src/chart-workbook.js). A chart without number formats is written
+// exactly as before.
+//
+// Optional core exports are read from the namespace, so a published core before RR-54 still loads: its schema rejects
+// the new fields, so the fallbacks only need the inline positional form, with the same strict number rule.
+import * as opfCore from '@openpresentation/opf';
+
+const object = value => value !== null && typeof value === 'object' && !Array.isArray(value);
+const STRICT_DECIMAL = /^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?$/;
+
+/** Core `chartNumber` (strict decimal syntax; everything else is a gap). */
+export const chartNumber = typeof opfCore.chartNumber === 'function' ? opfCore.chartNumber : value => {
+  if (typeof value === 'number') return Number.isFinite(value) ? value : null;
+  if (typeof value !== 'string') return null;
+  const text = value.trim();
+  if (!STRICT_DECIMAL.test(text)) return null;
+  const number = Number(text);
+  return Number.isFinite(number) && (!Number.isInteger(number) || Number.isSafeInteger(number)) ? number : null;
+};
+/** NumberFormat -> Excel format code ("General" when absent). */
+export const excelNumberFormat = typeof opfCore.excelNumberFormat === 'function' ? opfCore.excelNumberFormat : () => 'General';
+/** Excel format code -> NumberFormat, or undefined when it has no exact equivalent. */
+export const numberFormatFromExcel = typeof opfCore.numberFormatFromExcel === 'function' ? opfCore.numberFormatFromExcel : () => undefined;
+export const isDatasetRef = typeof opfCore.isDatasetRef === 'function' ? opfCore.isDatasetRef : value => object(value) && typeof value.dataset === 'string';
+export const inlineChartData = typeof opfCore.inlineChartData === 'function' ? opfCore.inlineChartData : chart => chart;
+export const inlineTableData = typeof opfCore.inlineTableData === 'function' ? opfCore.inlineTableData : table => table;
+export const tableCellDisplayValue = typeof opfCore.tableCellDisplayValue === 'function' ? opfCore.tableCellDisplayValue : cell => cell;
+export const resolveTableData = typeof opfCore.resolveTableData === 'function' ? opfCore.resolveTableData
+  : table => ({...(Array.isArray(table?.columns) ? {columns: table.columns} : {}), rows: Array.isArray(table?.rows) ? table.rows : [], formats: [], diagnostics: []});
+
+const columnName = column => typeof column === 'string' ? column : object(column) && typeof column.name === 'string' ? column.name : '';
+
+// Before RR-54 core: inline positional data only (the schema of that core has no datasets or mapping).
+function positionalChartData(chart) {
+  const data = chart?.data;
+  if (!object(data) || !Array.isArray(data.columns)) return {ok: false, reason: 'no-columns', message: 'The chart data has no columns.', diagnostics: []};
+  if (!data.columns.length) return {ok: false, reason: 'no-columns', message: 'The chart data has no columns.', diagnostics: []};
+  if (!Array.isArray(data.rows) || !data.rows.length) return {ok: false, reason: 'no-rows', message: 'The chart data has no rows.', diagnostics: []};
+  const diagnostics = [];
+  const rows = data.rows.map((row, rowIndex) => data.columns.map((_, index) => {
+    const cell = Array.isArray(row) && index < row.length ? row[index] : null;
+    if (index === 0) return cell === undefined ? null : cell;
+    const number = chartNumber(cell);
+    if (number === null && cell !== null && cell !== undefined && cell !== '') diagnostics.push({code: 'chart-value-not-numeric', severity: 'warning', path: `/data/rows/${rowIndex}/${index}`, message: `chart value ${JSON.stringify(cell)} is not a number; it is plotted as a gap.`});
+    return number;
+  }));
+  return {ok: true, columns: data.columns.map(columnName), formats: data.columns.map(() => undefined), rows, diagnostics};
+}
+
+/** Core `resolveChartData`: the canonical positional table [category, (x,) ...series], or {ok: false, reason}. */
+export const resolveChartData = typeof opfCore.resolveChartData === 'function' ? opfCore.resolveChartData : positionalChartData;
+
+/** True when a chart uses an RR-54 data field that the native cache alone cannot carry back. */
+export function chartUsesDataFields(chart) {
+  const data = chart?.data;
+  return object(chart) && (chart.mapping !== undefined || isDatasetRef(data) || (object(data) && (data.source !== undefined || (Array.isArray(data.columns) && data.columns.some(object)))));
+}
+
+/** True when a table is dataset-backed or carries a DataColumn header or a number format. */
+export function tableUsesDataFields(table) {
+  if (!object(table)) return false;
+  if (isDatasetRef(table)) return true;
+  const formatted = cell => object(cell) && (typeof cell.format === 'string' || (typeof cell.name === 'string' && !Object.hasOwn(cell, 'value')));
+  return (Array.isArray(table.columns) && table.columns.some(formatted)) || (Array.isArray(table.rows) && table.rows.some(row => Array.isArray(row) && row.some(formatted)));
+}
+
+// ---------------------------------------------------------------------------
+// Export: number formats in the classic chart part
+
+const escapeXml = value => String(value).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
+/** The Excel code of a NumberFormat, or undefined when it is absent or General (the exporter's default). */
+export function excelCode(format) {
+  if (format === undefined) return undefined;
+  const code = excelNumberFormat(format);
+  return code && code !== 'General' ? code : undefined;
+}
+
+/**
+ * Write the number formats of a generated classic chart part (after its data labels are written). `formats`:
+ *   series  the Excel code of each c:ser, in document order (undefined keeps General);
+ *   x       the X column's code (scatter c:xVal and the horizontal value axis);
+ *   axis    the value axis code (the first plotted series' format, as Excel does), or undefined to keep the axis;
+ *   labels  false when the labels show percentages (the percent label keeps PowerPoint's own percent form);
+ *   scatter true for an XY chart (two value axes: axPos b/t is X).
+ * Every c:numCache of a series takes its code, every c:numFmt of a series' data labels too; the chart group's labels
+ * take the first series' code.
+ */
+export function applyChartNumberFormats(xml, {series = [], x, axis, labels = true, scatter = false}) {
+  // CT_NumData: formatCode is the cache's first child (PptxGenJS writes none on pie and doughnut series).
+  const formatCode = (text, code) => code === undefined ? text : /<c:formatCode>/.test(text)
+    ? text.replace(/<c:formatCode>[^<]*<\/c:formatCode>/g, `<c:formatCode>${escapeXml(code)}</c:formatCode>`)
+    : text.replace(/<c:numCache>/g, `<c:numCache><c:formatCode>${escapeXml(code)}</c:formatCode>`);
+  const labelFormats = (text, code) => code === undefined || !labels ? text : text.replace(/<c:dLbls>[\s\S]*?<\/c:dLbls>/g, block => block.replace(/<c:numFmt\b[^>]*\/>/g, `<c:numFmt formatCode="${escapeXml(code)}" sourceLinked="0"/>`));
+  // Radar and scatter series carry no labels of their own (PptxGenJS writes the chart group's only), so every series would
+  // show the first series' format. When shown labels differ by series, each series gets a copy of the group's labels,
+  // in the CT_RadarSer / CT_ScatterSer position (before trendline, errBars, cat, val, xVal and yVal).
+  const group = xml.split(/<c:ser>[\s\S]*?<\/c:ser>/).join('').match(/<c:dLbls>[\s\S]*?<\/c:dLbls>/)?.[0];
+  const ownLabels = labels && group && /<c:showVal val="1"\/>/.test(group) && series.some(code => code !== series[0]);
+  let index = 0;
+  const out = (ownLabels ? xml.replace(/<c:ser>[\s\S]*?<\/c:ser>/g, ser => /<c:dLbls>/.test(ser) ? ser : ser.replace(/<c:(?:trendline|errBars|cat|val|xVal|yVal)>/, at => `${group}${at}`)) : xml).replace(/<c:ser>[\s\S]*?<\/c:ser>/g, ser => {
+    const code = series[index++];
+    const result = ser.replace(/<c:(val|yVal|xVal)>[\s\S]*?<\/c:\1>/g, (role, name) => formatCode(role, name === 'xVal' ? x : code));
+    return labelFormats(result, code);
+  });
+  // The chart group's own label block (outside every c:ser) follows the first series.
+  const grouped = out.split(/(<c:ser>[\s\S]*?<\/c:ser>)/).map((part, position) => position % 2 ? part : labelFormats(part, series[0])).join('');
+  return grouped.replace(/<c:valAx>[\s\S]*?<\/c:valAx>/g, valAx => {
+    const code = scatter && /<c:axPos val="[bt]"\/>/.test(valAx) ? x : axis;
+    return code === undefined ? valAx : valAx.replace(/<c:numFmt\b[^>]*\/>/, `<c:numFmt formatCode="${escapeXml(code)}" sourceLinked="0"/>`);
+  });
+}
+
+/** The workbook ranges and codes of a classic chart part's numeric series: [{formula, code}]. */
+export function numericRanges(xml, {series = [], x}) {
+  const ranges = [];
+  let index = 0;
+  for (const [ser] of xml.matchAll(/<c:ser>[\s\S]*?<\/c:ser>/g)) {
+    const code = series[index++];
+    for (const [, role, body] of ser.matchAll(/<c:(val|yVal|xVal)>([\s\S]*?)<\/c:\1>/g)) {
+      const formula = /<c:numRef>\s*<c:f>([^<]*)<\/c:f>/.exec(body)?.[1];
+      const value = role === 'xVal' ? x : code;
+      if (formula && value !== undefined && !ranges.some(range => range.formula === formula)) ranges.push({formula, code: value});
+    }
+  }
+  return ranges;
+}
+
+// ---------------------------------------------------------------------------
+// Import: series number formats
+
+/**
+ * The NumberFormat of a native cache's format code: {format} when core maps it back exactly, {unmapped: code} when it
+ * is a code with no NumberFormat equivalent, {} for General or no code.
+ */
+export function formatFromCode(code) {
+  if (typeof code !== 'string' || code.trim() === '' || /^general$/i.test(code.trim())) return {};
+  const format = numberFormatFromExcel(code);
+  return format === undefined ? {unmapped: code} : {format};
+}
+
+/** Columns with their number formats: a column whose code maps back becomes {name, format}; the others stay names. */
+export function formattedColumns(names, codes, report) {
+  const unmapped = [];
+  const columns = names.map((name, index) => {
+    const {format, unmapped: code} = formatFromCode(codes[index]);
+    if (code !== undefined) unmapped.push(`'${name}' (${code})`);
+    return format === undefined ? name : {name, format};
+  });
+  if (unmapped.length) report?.({code: 'chart-number-format-adapted', option: 'data', message: `The number ${unmapped.length === 1 ? 'format' : 'formats'} of ${unmapped.join(', ')} ${unmapped.length === 1 ? 'has' : 'have'} no OPF number format equivalent; ${unmapped.length === 1 ? 'that column imports' : 'those columns import'} without a format (the General form), so the values keep their numbers but not their native display.`});
+  return columns;
+}

package/dist/chart-options.js

@@ -133,7 +133,7 @@ function titleString(title) {
  * plus `notes` naming what the three fields cannot express. `defaults` is what an export writes without the field:
  * `{legend: 'right' | undefined}` (a legend at the right of multi-series, pie and doughnut charts) and the chart kind.
  */
-export function chartOptionsFromClassic(chartSpace, {chartNode, target, seriesCount, circular, scatter}) {
+export function chartOptionsFromClassic(chartSpace, {chartNode, target, seriesCount, circular, scatter, seriesFormats = []}) {
   // An older core's schema has no such fields (additionalProperties is false), so nothing is added to the imported chart.
   if (!coreKnowsChartOptions()) return {options: {}, notes: []};
   const chart = chartSpace?.['c:chart'];
@@ -164,12 +164,12 @@ export function chartOptionsFromClassic(chartSpace, {chartNode, target, seriesCo
     if (!(defaultLegend && position === 'right')) out.legend = position;
   } else if (defaultLegend) out.legend = 'none';
 
-  const dataLabels = classicDataLabels(chartNode, target, notes);
+  const dataLabels = classicDataLabels(chartNode, target, notes, seriesFormats);
   if (dataLabels !== undefined) out.dataLabels = dataLabels;
   return {options: out, notes};
 }
 
-function classicDataLabels(chartNode, target, notes) {
+function classicDataLabels(chartNode, target, notes, seriesFormats = []) {
   const series = asArray(chartNode?.['c:ser']);
   // The labels the chart shows: the first series' block when it has one (PptxGenJS writes pie and doughnut visibility as per
   // point overrides), else the chart group's block.
@@ -188,7 +188,8 @@ function classicDataLabels(chartNode, target, notes) {
   }
   const support = target && typeof opfCore.chartOptionSupport === 'function' ? opfCore.chartOptionSupport(target) : undefined;
   const numberFormat = source['c:numFmt']?.formatCode ?? block['c:numFmt']?.formatCode;
-  if (numberFormat && numberFormat !== 'General' && numberFormat !== '#,##0' && numberFormat !== '0%') notes.push({option: 'dataLabels', message: `The label number format '${numberFormat}' cannot be expressed; labels import in the General format.`});
+  // RR-54: a label format that is a series' own number format imports with that column's format (or its own note).
+  if (numberFormat && numberFormat !== 'General' && numberFormat !== '#,##0' && numberFormat !== '0%' && !seriesFormats.includes(numberFormat)) notes.push({option: 'dataLabels', message: `The label number format '${numberFormat}' cannot be expressed; labels import in the General format.`});
   const out = {};
   const position = DLBL_POS_BACK[source['c:dLblPos']?.val ?? block['c:dLblPos']?.val];
   const supported = support?.dataLabels.positions ?? [];

package/dist/chart-workbook.js

@@ -82,7 +82,44 @@ export function writeChartCategoryHeading(entries,chartPart,heading){
  entries[context.workbookPart]=zipSync(workbook);
 }
 
-// PptxGenJS 4.0.1 writes broken range metadata into chart workbooks (upstream gitbrent/PptxGenJS#1531): the
+// RR-54: the number formats of a generated chart's value cells, so Edit Data in PowerPoint shows them as the chart does.
+// `ranges` are the chart's numeric series ranges with their Excel codes ([{formula: "Sheet1!$B$2:$B$5", code}]). Each
+// distinct code becomes a custom numFmt (ids from 164) and a cellXfs entry; every cell of its range (blank gap cells too)
+// takes that style. PptxGenJS writes no cellXfs, so the default style 0 is written with them. A chart without formats is
+// never passed here, and its workbook keeps its bytes.
+export function writeChartWorkbookFormats(entries,chartPart,ranges){
+ if(!ranges.length)return;
+ const chart=xml(entries,chartPart)?.chartSpace;
+ const ref=relationship(entries,chartPart,chart?.externalData?.id);
+ if(!ref?.type?.endsWith('/package')||!entries[ref.path])throw Error('Generated chart has no embedded workbook.');
+ const workbook=unzipSync(entries[ref.path]);
+ const stylesPart='xl/styles.xml';
+ let styles=workbook[stylesPart]&&decoder.decode(workbook[stylesPart]);
+ if(!styles||/<cellXfs\b/.test(styles)||!/<numFmts count="\d+">/.test(styles)||!/<dxfs\b/.test(styles))throw Error('Generated chart workbook styles are not in the expected form.');
+ const codes=[...new Set(ranges.map(range=>range.code))];
+ const numFmts=codes.map((code,index)=>`<numFmt numFmtId="${164+index}" formatCode="${escape(code)}"/>`).join('');
+ styles=styles.replace(/<numFmts count="(\d+)">([\s\S]*?)<\/numFmts>/,(_match,count,body)=>`<numFmts count="${Number(count)+codes.length}">${body}${numFmts}</numFmts>`);
+ const xfs=codes.map((_code,index)=>`<xf numFmtId="${164+index}" fontId="0" fillId="0" borderId="0" xfId="0" applyNumberFormat="1"/>`).join('');
+ // CT_Stylesheet order: numFmts, fonts, fills, borders, cellStyleXfs, cellXfs, cellStyles, dxfs.
+ styles=styles.replace(/<dxfs\b/,`<cellStyleXfs count="1"><xf numFmtId="0" fontId="0" fillId="0" borderId="0"/></cellStyleXfs><cellXfs count="${codes.length+1}"><xf numFmtId="0" fontId="0" fillId="0" borderId="0" xfId="0"/>${xfs}</cellXfs><cellStyles count="1"><cellStyle name="Normal" xfId="0" builtinId="0"/></cellStyles><dxfs`);
+ workbook[stylesPart]=encoder.encode(styles);
+ const sheets=array(xml(workbook,'xl/workbook.xml')?.workbook?.sheets?.sheet);
+ for(const {formula,code}of ranges){
+  const range=/^(?:'((?:[^']|'')+)'|([^'!]+))!\$?([A-Z]+)\$?(\d+):\$?([A-Z]+)\$?(\d+)$/i.exec(formula);
+  if(!range||range[3].toUpperCase()!==range[5].toUpperCase())throw Error('Generated chart series range is not one column.');
+  const name=range[1]?.replaceAll("''","'")??range[2];
+  const sheetRef=relationship(workbook,'xl/workbook.xml',sheets.find(sheet=>sheet.name===name)?.id);
+  if(!sheetRef?.type?.endsWith('/worksheet')||!workbook[sheetRef.path])throw Error('Generated chart series sheet is missing.');
+  const column=range[3].toUpperCase(),first=Number(range[4]),last=Number(range[6]),style=codes.indexOf(code)+1;
+  const sheet=decoder.decode(workbook[sheetRef.path]).replace(/<c r="([A-Z]+)(\d+)"(?![^>]*\bs=)/g,(cell,letters,row)=>letters===column&&Number(row)>=first&&Number(row)<=last?`<c r="${letters}${row}" s="${style}"`:cell);
+  workbook[sheetRef.path]=encoder.encode(sheet);
+ }
+ entries[ref.path]=zipSync(workbook);
+}
+
+// PptxGenJS 4.0.1 wrote broken range metadata into chart workbooks (upstream gitbrent/PptxGenJS#1531). pptxgenjs-plus
+// 4.3.4 (vendored) fixed the category and scatter tables; its bubble table still takes its last row from the column
+// count (lofcz/pptxgenjs-plus#15). The 4.0.1 shapes: the
 // category-chart branch (bar, line, area, pie, doughnut, radar, and the classic fallback of chartex charts) ends the
 // table ref with a stray apostrophe (ref="A1:C7'"), the bubble branch takes the table's last row from its column
 // count, and the category sheet dimension counts one label column (too narrow for multi-level categories). Keynote

package/dist/chartex.js

@@ -17,6 +17,7 @@
 // cached dimensions restore the category-major data.
 import {CHARTEX_NAMESPACES, chartTypeFromChartex} from './chart-types.js';
 import {chartOptionsFromChartex} from './chart-options.js';
+import {formattedColumns} from './chart-data.js';
 
 const NS = Object.freeze({
   a: 'http://schemas.openxmlformats.org/drawingml/2006/main',
@@ -131,16 +132,20 @@ const CX_POSITION = Object.freeze({center: 'ctr', 'inside-end': 'inEnd', 'inside
 
 // RR-35: an explicit dataLabels option writes the selected content, position and separator for every construct that takes it;
 // `dataLabels: false` removes the labels a treemap or funnel carries by default. Without the option the defaults are unchanged.
-function dataLabels(spec, text, options) {
+// RR-54: a value label of a series with a number format (not a binned construct, whose labels are counts) shows it.
+const labelFormat = (spec, code) => code === undefined || spec.binning ? '' : `<cx:numFmt formatCode="${escapeXml(code)}" sourceLinked="0"/>`;
+
+function dataLabels(spec, text, options, code) {
   if (options?.dataLabelsOff) return '';
   const labels = options?.dataLabels;
   if (labels) {
     const has = part => labels.content.includes(part) ? 1 : 0;
     const position = labels.position === null ? (spec.layoutId === 'treemap' || spec.layoutId === 'funnel' ? 'ctr' : undefined) : CX_POSITION[labels.position];
-    return `<cx:dataLabels${position ? ` pos="${position}"` : ''}>${text}<cx:visibility seriesName="0" categoryName="${has('category')}" value="${has('value')}"/><cx:separator>${escapeXml(labels.separator)}</cx:separator></cx:dataLabels>`;
+    // CT_DataLabels: numFmt precedes spPr and txPr.
+    return `<cx:dataLabels${position ? ` pos="${position}"` : ''}>${has('value') ? labelFormat(spec, code) : ''}${text}<cx:visibility seriesName="0" categoryName="${has('category')}" value="${has('value')}"/><cx:separator>${escapeXml(labels.separator)}</cx:separator></cx:dataLabels>`;
   }
   if (spec.layoutId === 'treemap') return `<cx:dataLabels pos="ctr">${text}<cx:visibility seriesName="0" categoryName="1" value="0"/></cx:dataLabels>`;
-  if (spec.layoutId === 'funnel') return `<cx:dataLabels pos="ctr">${text}<cx:visibility seriesName="0" categoryName="0" value="1"/></cx:dataLabels>`;
+  if (spec.layoutId === 'funnel') return `<cx:dataLabels pos="ctr">${labelFormat(spec, code)}${text}<cx:visibility seriesName="0" categoryName="0" value="1"/></cx:dataLabels>`;
   return '';
 }
 
@@ -164,14 +169,16 @@ const axisTitle = (value, text, run) => {
     `<a:p><a:pPr algn="ctr"><a:defRPr ${props}>${fill}</a:defRPr></a:pPr><a:r><a:rPr lang="en-US" ${props}>${fill}</a:rPr><a:t>${escapeXml(value)}</a:t></a:r></a:p></cx:rich></cx:tx></cx:title>`;
 };
 
-function axes(spec, gridColor, text, titles = {}, run = {}) {
+function axes(spec, gridColor, text, titles = {}, run = {}, code) {
   if (!spec.axes) return '';
   const gridlines = `<cx:majorGridlines><cx:spPr><a:ln w="9525"><a:solidFill><a:srgbClr val="${gridColor}"><a:alpha val="70000"/></a:srgbClr></a:solidFill></a:ln></cx:spPr></cx:majorGridlines>`;
   const gapWidth = {clusteredColumn: '0.06', paretoLine: '0.06', boxWhisker: '1', waterfall: '0.5', funnel: '0.06'}[spec.layoutId] ?? '1';
   // CT_Axis order: scaling, units, majorGridlines, tickLabels, spPr, txPr.
   const category = `<cx:axis id="0"><cx:catScaling gapWidth="${gapWidth}"/>${axisTitle(titles.category, text, run)}<cx:tickLabels/>${text}</cx:axis>`;
   if (spec.layoutId === 'funnel') return `${category}<cx:axis id="1" hidden="1"><cx:valScaling/><cx:tickLabels/>${text}</cx:axis>`;
-  const value = `<cx:axis id="1"><cx:valScaling/>${axisTitle(titles.value, text, run)}${gridlines}<cx:tickLabels/>${text}</cx:axis>`;
+  // RR-54: the value axis shows the first series' number format (none when that series has none) (CT_Axis: numFmt follows tickLabels); a binned axis counts.
+  const numberFormat = code === undefined || spec.binning ? '' : `<cx:numFmt formatCode="${escapeXml(code)}" sourceLinked="0"/>`;
+  const value = `<cx:axis id="1"><cx:valScaling/>${axisTitle(titles.value, text, run)}${gridlines}<cx:tickLabels/>${numberFormat}${text}</cx:axis>`;
   const percentage = spec.layoutId === 'paretoLine' ? `<cx:axis id="2"><cx:valScaling max="1" min="0"/><cx:units unit="percentage"/><cx:tickLabels/>${text}</cx:axis>` : '';
   return `${category}${value}${percentage}`;
 }
@@ -183,7 +190,7 @@ function axes(spec, gridColor, text, titles = {}, run = {}) {
  * layout is PptxGenJS's: Sheet1, headings in row 1, categories in column A and
  * one series per following column.
  */
-export function chartexPartXml({spec, series, hasCategories, number, workbookRelId, fill, labelColor, gridColor, font, palette, textSize, options}) {
+export function chartexPartXml({spec, series, hasCategories, number, workbookRelId, fill, labelColor, gridColor, font, palette, textSize, options, formats = []}) {
   const rows = series[0].labels.length;
   const range = (letter) => `Sheet1!$${letter}$2:$${letter}$${rows + 1}`;
   const categories = hasCategories
@@ -191,7 +198,7 @@ export function chartexPartXml({spec, series, hasCategories, number, workbookRel
     : '';
   const data = series.map((entry, index) => {
     const points = entry.values.map((value, row) => value === null || !Number.isFinite(value) ? '' : `<cx:pt idx="${row}">${numberText(value)}</cx:pt>`).join('');
-    return `<cx:data id="${index}">${categories}<cx:numDim type="${spec.dimension}"><cx:f>${range(columnLetters(index + 2))}</cx:f><cx:lvl ptCount="${rows}" formatCode="General">${points}</cx:lvl></cx:numDim></cx:data>`;
+    return `<cx:data id="${index}">${categories}<cx:numDim type="${spec.dimension}"><cx:f>${range(columnLetters(index + 2))}</cx:f><cx:lvl ptCount="${rows}" formatCode="${escapeXml(formats[index] ?? 'General')}">${points}</cx:lvl></cx:numDim></cx:data>`;
   }).join('');
   const text = textProperties(labelColor, font, textSize);
   const plotted = series.map((entry, index) => {
@@ -203,7 +210,7 @@ export function chartexPartXml({spec, series, hasCategories, number, workbookRel
     const line = spec.layoutId === 'boxWhisker' ? `<a:ln w="9525">${solidFill(labelColor)}</a:ln>` : '';
     return `<cx:series layoutId="${spec.owner ?? spec.layoutId}" uniqueId="${seriesUniqueId(number, index)}">` +
       `<cx:tx><cx:txData><cx:f>Sheet1!$${letter}$1</cx:f><cx:v>${escapeXml(entry.name)}</cx:v></cx:txData></cx:tx>` +
-      `<cx:spPr>${solidFill(color)}${line}</cx:spPr>${pointFills}${dataLabels(spec, text, options)}<cx:dataId val="${index}"/>${layoutProperties(spec, entry, hasCategories)}` +
+      `<cx:spPr>${solidFill(color)}${line}</cx:spPr>${pointFills}${dataLabels(spec, text, options, formats[index])}<cx:dataId val="${index}"/>${layoutProperties(spec, entry, hasCategories)}` +
       (spec.axes ? '<cx:axisId val="0"/><cx:axisId val="1"/>' : '') + '</cx:series>';
   });
   if (spec.owner) {
@@ -219,7 +226,7 @@ export function chartexPartXml({spec, series, hasCategories, number, workbookRel
   return '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>' +
     `<cx:chartSpace xmlns:a="${NS.a}" xmlns:r="${NS.r}" xmlns:cx="${NS.cx}">` +
     `<cx:chartData><cx:externalData r:id="${workbookRelId}" cx:autoUpdate="0"/>${data}</cx:chartData>` +
-    `<cx:chart><cx:plotArea><cx:plotAreaRegion>${plotted.join('')}</cx:plotAreaRegion>${axes(spec, gridColor, text, options?.axisTitles, {labelColor, font, textSize})}</cx:plotArea>${legend}</cx:chart>` +
+    `<cx:chart><cx:plotArea><cx:plotAreaRegion>${plotted.join('')}</cx:plotAreaRegion>${axes(spec, gridColor, text, options?.axisTitles, {labelColor, font, textSize}, formats[0])}</cx:plotArea>${legend}</cx:chart>` +
     `<cx:spPr>${solidFill(fill.color, alpha)}<a:ln><a:noFill/></a:ln></cx:spPr>${text}` +
     '</cx:chartSpace>';
 }
@@ -396,7 +403,7 @@ export function chartFromChartex(doc, {heading, limits, invalid, path, report})
     return result;
   };
   let labels = null;
-  const names = [], values = [];
+  const names = [], values = [], codes = [];
   plotted.forEach((series, index) => {
     const data = dataById.get(String(series['cx:dataId'].val));
     if (!data) invalid('series data is missing', `${path}#cx:series[${index}]/cx:dataId`);
@@ -405,6 +412,9 @@ export function chartFromChartex(doc, {heading, limits, invalid, path, report})
     if (categories && !labels) labels = level(categories, `${location}/cx:strDim`, false);
     const numeric = asArray(data['cx:numDim'])[0];
     values.push(numeric ? level(numeric, `${location}/cx:numDim`, true) : []);
+    // RR-54: the series' number format code (cx:lvl formatCode); core maps the codes it can back to column formats.
+    const code = asArray(numeric?.['cx:lvl'])[0]?.formatCode;
+    codes.push(typeof code === 'string' ? code : undefined);
     const name = series['cx:tx']?.['cx:txData']?.['cx:v'];
     names.push(name === undefined ? `Series ${index + 1}` : scalar(name));
   });
@@ -415,8 +425,8 @@ export function chartFromChartex(doc, {heading, limits, invalid, path, report})
   // RR-35: axis titles, legend position and data labels read back into the chart's option fields.
   const {options, notes} = chartOptionsFromChartex(space, {type, seriesCount: plotted.length});
   for (const note of notes) report?.(note);
-  if (!labels) return {type, data: {columns: [names[0]], rows: values[0].slice(0, rowCount).map((value, index) => [values[0][index] ?? null])}, ...options};
+  if (!labels) return {type, data: {columns: formattedColumns([names[0]], [codes[0]], report), rows: values[0].slice(0, rowCount).map((value, index) => [values[0][index] ?? null])}, ...options};
   const rows = [];
   for (let index = 0; index < rowCount; index += 1) rows.push([labels[index] ?? null, ...values.map(row => row[index] ?? null)]);
-  return {type, data: {columns: [heading ?? 'Category', ...names], rows}, ...options};
+  return {type, data: {columns: formattedColumns([heading ?? 'Category', ...names], [undefined, ...codes], report), rows}, ...options};
 }

package/dist/code-provenance.js

@@ -53,7 +53,7 @@ export function attachTextTags(entries, records, tagName, prefix, kind, {picture
       rels = rels.replace('</Relationships>',`<Relationship Id="${id}" Type="${REL}" Target="../tags/${prefix}${count}.xml"/></Relationships>`);
       // Optional alternative text (a:cNvPr descr) for generated decoration such as the metric trend arrow.
       const descr = descriptions?.get(name);
-      if (descr !== undefined) shape = shape.replace(/<p:cNvPr\b([^>]*?)>/, (_match, attributes) => `<p:cNvPr${attributes} descr="${descr.replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/"/g,'&quot;')}">`);
+      if (descr !== undefined) shape = shape.replace(/<p:cNvPr\b([^>]*?)(\/?)>/, (_match, attributes, close) => `<p:cNvPr${attributes} descr="${descr.replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/"/g,'&quot;')}"${close}>`);
       shape = shape.replace(/<p:nvPr\s*\/>/,'<p:nvPr></p:nvPr>');
       if (!shape.includes('</p:nvPr>')) throw new Error(`Generated ${kind} shape has no native application properties.`);
       return shape.replace('</p:nvPr>',`<p:custDataLst><p:tags r:id="${id}"/></p:custDataLst></p:nvPr>`);