@openpresentation/opf-pptx 0.11.1 → 0.11.2

package/DEPENDENCY-NOTES.md

@@ -2,7 +2,7 @@
 
 ## Coordinated `@openpresentation/opf` pin
 
-PPTX 0.11.1 depends on published [`@openpresentation/opf@^0.11.2`](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. Native `schemeClr` / theme `clrScheme` writes remain follow-up work.
+PPTX 0.11.2 depends on published [`@openpresentation/opf@^0.11.2`](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. Native `schemeClr` / theme `clrScheme` writes remain follow-up work.
 
 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.
 

package/README.md

@@ -1,6 +1,6 @@
 # OPF PPTX
 
-Version 0.11.1 exports `design.watermark` as a native picture (it re-imports) and embeds byte-identical media parts once, with no API or dependency change. Version 0.11.0 requires core `^0.11.2` (cover slides are centered between header and footer furniture) and the optional `@openpresentation/opf-render` peer `^0.11.0`; install them together so export and preview resolve the same core. Version 0.10.0 required core `^0.11.1` and the peer `^0.10.0`. It adds native slide-number and date fields, socials, slide-image treatments, theme color schemes, script-slot fonts and RTL, re-import of design and metadata references, native underline and current-body formatting on import, and UTC-canonical `zipDate` (see the changelog for the intentional contract changes).
+Version 0.11.2 exports the classic chart types as native chart constructs and writes named and default table colours, text pairs and hyperlink colours as theme references (no API or dependency change; resolved colours are unchanged). Version 0.11.1 exports `design.watermark` as a native picture (it re-imports) and embeds byte-identical media parts once, with no API or dependency change. Version 0.11.0 requires core `^0.11.2` (cover slides are centered between header and footer furniture) and the optional `@openpresentation/opf-render` peer `^0.11.0`; install them together so export and preview resolve the same core. Version 0.10.0 required core `^0.11.1` and the peer `^0.10.0`. It adds native slide-number and date fields, socials, slide-image treatments, theme color schemes, script-slot fonts and RTL, re-import of design and metadata references, native underline and current-body formatting on import, and UTC-canonical `zipDate` (see the changelog for the intentional contract changes).
 
 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.
 
@@ -80,7 +80,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)).
+- 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. Chartex types (treemap, histogram, pareto, box & whisker, waterfall, funnel, map) still export as clustered columns and report `chart-data-adapted` (`chartex-fallback`); a pie or doughnut chart 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. It exports as a native chart and reports `chart-data-adapted`: a histogram is binned into equal-width bins (Sturges' count, at most 50) and written as a column chart of the counts, and any other chart type plots the values against their row numbers. PowerPoint's own histogram chart is not exported (histogram is a column chart at this engine). Cells parse as in every chart ("12%", "$5" and "1,234" count) and cells that hold no number are skipped, not plotted as 0. Binned counts do not round-trip: re-importing the file gives a `Bin`/`Frequency` column chart, not the raw values. 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.
 - 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).
@@ -113,7 +113,7 @@ The first importer is mechanical and schema-compatible:
 - The first slide master's theme `clrScheme` maps to `design.colorScheme`: a catalog id on an exact twelve-slot match, otherwise inline slots. A theme named like a catalog theme maps to `design.theme` when its colors or heading/body fonts corroborate it (see [Theme color scheme](#theme-color-scheme)).
 - 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.
-- PowerPoint tables map to OPF table blocks, embedded images map to data URI image blocks, and cached chart series map to basic OPF chart blocks.
+- 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-3x`, 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.
 - Native table text preserves run/field/break order, significant whitespace, and blank paragraphs. Cells return canonical `{value, style}` objects; `value` retains scalar text or supported rich runs. Covered merge positions are `null`. Explicit normal headers override OPF’s bold header default. Numeric/boolean/null source types cannot be reconstructed from native display text.
@@ -268,15 +268,22 @@ Import reads `a:pattFill` with a DrawingML preset and resolvable foreground/back
 
 Export writes the deck's resolved color scheme into `ppt/theme/theme1.xml` `a:clrScheme`, named after the scheme. The OPF slots map one to one: `dark1`/`light1`/`dark2`/`light2` to `dk1`/`lt1`/`dk2`/`lt2`, `accent1`-`accent6` to themselves, and `hyperlink`/`followedHyperlink` to `hlink`/`folHlink`. An abstract role fills a slot only when the scheme leaves that slot unset. Previously every export carried the vendored Office palette (`accent1` `4472C4`). When the deck names a catalog `design.theme`, `a:theme` and its `thm15:themeFamily` take that theme's name. The rewrite happens during package normalization; the vendored PptxGenJS bytes are unchanged.
 
-Document colors that name a slot or role (`accent2`, `textSecondary`, `surface`, ...) become `a:schemeClr` in runs, table cell fills and text, and table borders. Theme-slot backgrounds (`{type:'theme', slot}` or a slot name) do the same. Slide content reaches the theme through the master color map, so `dark1`, `light1`, `dark2` and `light2` are written as `tx1`, `bg1`, `tx2` and `bg2`. A reference becomes `schemeClr` only when the deck theme slot holds exactly the color the slide resolved. PowerPoint has one theme per master, so a slide-level `design.colorScheme` that changes a slot keeps that color literal. These stay `a:srgbClr`:
+Document colors that name a slot or role (`accent2`, `textSecondary`, `surface`, ...) become `a:schemeClr` in runs, table cell fills and text, and table borders. Theme-slot backgrounds (`{type:'theme', slot}` or a slot name) do the same. Slide content reaches the theme through the master color map, so `dark1`, `light1`, `dark2` and `light2` are written as `tx1`, `bg1`, `tx2` and `bg2`. A reference becomes `schemeClr` only when the deck theme slot holds exactly the color the slide resolved. PowerPoint has one theme per master, so a slide with its own `design.colorScheme` (or a slide theme that changes any slot) keeps **every** color literal, including values that happen to equal the deck theme, so a theme edit never partially recolors it.
+
+Default text follows the theme only where the background does. When a slide's background is an opaque theme reference (`light1`/`light2` or `dark1`/`dark2`, the only slots a theme background accepts), the exporter's default and muted text are written as the paired slot: `tx1`/`tx2` on `bg1`/`bg2`, and `bg1`/`bg2` on `tx1`/`tx2`. This applies only when the resolved color is exactly that deck slot, so a PowerPoint theme switch moves text and background together. It covers headings, body and list text, list markers, metric labels, quote text and footers, header/footer text and placeholders. Text on a literal background, text on a card fill and override slides stay literal.
+
+Table chrome follows the theme too (FF-24c). With no theme override on the slide, the default header fill is `accent1`, the body fill is the `surface` slot (`bg2`, or `tx2` on a dark deck), and every cell border is `accent5`. Each is written as `a:schemeClr` when the deck theme slot holds exactly that color. Default cell text pairs with its fill: `tx1` on a `bg2` fill, `bg1` on a `tx2` fill, and light1 or dark1 (`bg1`/`tx1`) on an accent fill, again only when the contrast-selected color is exactly that slot. A named `fill`, `color` or border color on a cell (`accent2`, `surface`, `light2`, `textSecondary`, ...) is a scheme reference, `hyperlink` and `followedHyperlink` included, and a literal on the cell stays literal (default text on a literal fill included). PptxGenJS 4.0.1 cannot write `hlink`/`folHlink`, so those two are written as a reserved literal (`FE01A0`/`FE01A1`, or the next free pair) and rewritten to `a:schemeClr` in the finished slide part; a document that itself uses every reserved value keeps its link colors literal.
+
+When the deck background is a theme slot other than `light1`, the slide master gets that background and its title/body/other text styles use the paired text slot. The layout drops its own `bg1` background and inherits the master, so slides added in PowerPoint match the theme. `light1` decks keep the vendored master.
+
+These stay `a:srgbClr`:
 
 - literal hex colors, even when they equal a scheme slot;
 - `var:<id>` variables;
 - translucent colors;
-- engine-derived chrome: default text, headings, list markers, muted text, card and chart panels, chart series, and default table header fill. These colors are contrast-selected per slide, not named by the document.
-- `hyperlink` and `followedHyperlink` run and cell colors, because PptxGenJS 4.0.1 cannot emit `hlink`/`folHlink`. Borders and backgrounds can.
+- other engine-derived chrome: card fills and borders, chart panels, series and labels, timeline connectors and markers, and image and media placeholders, plus default text on a card or a literal background. These colors are contrast-selected or derived from roles, not named by the document, and are not yet theme references.
 
-Import reads the first slide master's theme. An exact twelve-slot match with a bundled catalog scheme returns its id; the `clrScheme` name breaks ties. Otherwise the importer returns inline slots, relative to the catalog scheme the `clrScheme` is named after when there is one (`{id:'boost', accent1:'#123456'}`). A theme whose name equals a catalog theme's name maps to `design.theme` only if the package's color scheme or heading/body fonts match that theme; otherwise `theme-unverified` is reported. A missing theme, or slots that are not opaque sRGB/system colors, report `unsupported-theme-colors` on `design.colorScheme`. Slide colors are still imported as resolved hex. Role overrides such as `primary` have no theme slot and are not recovered. `test/theme-colors.mjs` covers all 14 catalog schemes and 4 catalog themes, override, foreign and damaged themes, and the literal-color boundaries. This establishes package structure and round-trip, not PowerPoint rendering.
+Import reads the first slide master's theme. An exact twelve-slot match with a bundled catalog scheme returns its id; the `clrScheme` name breaks ties. Otherwise the importer returns inline slots, relative to the catalog scheme the `clrScheme` is named after when there is one (`{id:'boost', accent1:'#123456'}`). A theme whose name equals a catalog theme's name maps to `design.theme` only if the package's color scheme or heading/body fonts match that theme; otherwise `theme-unverified` is reported. A missing theme, or slots that are not opaque sRGB/system colors, report `unsupported-theme-colors` on `design.colorScheme`. Slide colors are still imported as resolved hex. Role overrides such as `primary` have no theme slot and are not recovered. `test/theme-colors.mjs` covers all 14 catalog schemes and 4 catalog themes, override, foreign and damaged themes, and the literal-color boundaries. `test/table-theme-colors.mjs` covers named and default table chrome on all 14 schemes and four backgrounds, literals, override slides, the link colors, re-import and a theme switch in the package. This establishes package structure and round-trip, not PowerPoint rendering.
 
 ## JPEG orientation on import
 

package/dist/chart-types.js

@@ -0,0 +1,183 @@
+// OPF chart type ids -> native PowerPoint chart constructs (FF-22).
+//
+// The core catalog keeps one chart type per Aspose.Slides ChartType
+// (spec/catalogs/chart-types, OpenPresentation/opf#121) and deprecates the
+// rest with a replacement id. The published core package this exporter
+// depends on predates that metadata, so the mapping is carried here. Kept ids
+// map to the exact Office construct; deprecated ids resolve to their
+// replacement; any other id keeps the legacy substring heuristic.
+
+const category = (pptx, extra = {}) => ({ family: 'category', pptx, ...extra });
+
+export const CHART_TYPES = Object.freeze({
+  column: category('bar', { aspose: 'ClusteredColumn', barDir: 'col', grouping: 'clustered' }),
+  'stacked-column-3x': category('bar', { aspose: 'StackedColumn', barDir: 'col', grouping: 'stacked' }),
+  '100pct-stacked-column-3x': category('bar', { aspose: 'PercentsStackedColumn', barDir: 'col', grouping: 'percentStacked' }),
+  bar: category('bar', { aspose: 'ClusteredBar', barDir: 'bar', grouping: 'clustered' }),
+  'stacked-bar-3x': category('bar', { aspose: 'StackedBar', barDir: 'bar', grouping: 'stacked' }),
+  '100pct-stacked-bar-3x': category('bar', { aspose: 'PercentsStackedBar', barDir: 'bar', grouping: 'percentStacked' }),
+  line: category('line', { aspose: 'Line', grouping: 'standard', markers: false }),
+  'line-with-markers': category('line', { aspose: 'LineWithMarkers', grouping: 'standard', markers: true }),
+  'stacked-line-3x': category('line', { aspose: 'StackedLine', grouping: 'stacked', markers: false }),
+  'stacked-line-with-markers-3x': category('line', { aspose: 'StackedLineWithMarkers', grouping: 'stacked', markers: true }),
+  area: category('area', { aspose: 'Area', grouping: 'standard' }),
+  'stacked-area-3x': category('area', { aspose: 'StackedArea', grouping: 'stacked' }),
+  '100pct-stacked-area-3x': category('area', { aspose: 'PercentsStackedArea', grouping: 'percentStacked' }),
+  pie: { family: 'circular', pptx: 'pie', aspose: 'Pie' },
+  doughnut: { family: 'circular', pptx: 'doughnut', aspose: 'Doughnut' },
+  scatter: { family: 'xy', pptx: 'scatter', aspose: 'ScatterWithMarkers' },
+  radar: category('radar', { aspose: 'Radar', radarStyle: 'standard', markers: false }),
+  'radar-with-markers': category('radar', { aspose: 'RadarWithMarkers', radarStyle: 'marker', markers: true }),
+  'filled-radar': category('radar', { aspose: 'FilledRadar', radarStyle: 'filled', markers: false }),
+  treemap: { family: 'chartex', layoutId: 'treemap', aspose: 'Treemap' },
+  histogram: { family: 'chartex', layoutId: 'clusteredColumn', aspose: 'Histogram' },
+  pareto: { family: 'chartex', layoutId: 'clusteredColumn', aspose: 'ParetoLine' },
+  'box-and-whisker': { family: 'chartex', layoutId: 'boxWhisker', aspose: 'BoxAndWhisker' },
+  waterfall: { family: 'chartex', layoutId: 'waterfall', aspose: 'Waterfall' },
+  funnel: { family: 'chartex', layoutId: 'funnel', aspose: 'Funnel' },
+  world: { family: 'chartex', layoutId: 'regionMap', aspose: 'Map' },
+});
+
+// A chartex id (treemap, histogram, ...) has no classic construct; the exporter
+// writes it as a clustered column chart and reports chart-data-adapted.
+export const CHARTEX_FALLBACK = CHART_TYPES.column;
+
+const variants = (base, target) => Object.fromEntries([base, `${base}-2x`, `${base}-3x`].map((id) => [id, target]));
+
+// Deprecated core ids (opf 0.12.0 removes them) -> replacement id.
+export const DEPRECATED_CHART_TYPES = Object.freeze({
+  ...variants('100pct-bullet-bar', '100pct-stacked-bar-3x'),
+  '100pct-progress-bar': '100pct-stacked-bar-3x',
+  '100pct-stacked-bar-2x': '100pct-stacked-bar-3x',
+  ...variants('100pct-bullet-column', '100pct-stacked-column-3x'),
+  '100pct-stacked-column-2x': '100pct-stacked-column-3x',
+  '100pct-stacked-area-2x': '100pct-stacked-area-3x',
+  australia: 'world',
+  canada: 'world',
+  'united-kingdom': 'world',
+  'united-states': 'world',
+  'box-and-whisker-2x': 'box-and-whisker',
+  'box-and-whisker-3x': 'box-and-whisker',
+  ...variants('bullet-bar', 'bar'),
+  'clustered-bar-2x': 'bar',
+  ...variants('bullet-column', 'column'),
+  'clustered-column': 'column',
+  ...Object.fromEntries(['', '-2x', '-3x', '-4x', '-5x', '-6x'].map((suffix) => [`dot-plot${suffix}`, 'scatter'])),
+  dumbbell: 'scatter',
+  'line-2x': 'line',
+  'line-3x': 'line',
+  'line-with-high-low': 'line',
+  ...Object.fromEntries(['', '-2x', '-3x', '-4x', '-5x', '-6x'].map((suffix) => [`sparkline${suffix}`, 'line'])),
+  'line-with-high-low-and-markers': 'line-with-markers',
+  'line-with-markers-2x': 'line-with-markers',
+  'line-with-markers-3x': 'line-with-markers',
+  'stacked-area-2x': 'stacked-area-3x',
+  'stacked-bar-2x': 'stacked-bar-3x',
+  'stacked-column-2x': 'stacked-column-3x',
+  'stacked-line-2x': 'stacked-line-3x',
+  'stacked-line-with-markers-2x': 'stacked-line-with-markers-3x',
+  'treemap-2x': 'treemap',
+  'treemap-3x': 'treemap',
+});
+
+const ALIASES = Object.freeze({ donut: 'doughnut' });
+
+// Resolve an OPF chart type id to {id, spec}. Kept and deprecated ids resolve
+// to a kept id; anything else returns the legacy heuristic with id: null.
+export function resolveChartType(type) {
+  const raw = String(type ?? '').trim().toLowerCase();
+  const id = ALIASES[raw] ?? DEPRECATED_CHART_TYPES[raw] ?? raw;
+  if (Object.hasOwn(CHART_TYPES, id)) return { id, spec: CHART_TYPES[id] };
+  return { id: null, spec: legacyChartType(raw) };
+}
+
+// The pre-FF-22 heuristic for ids outside the core catalog.
+function legacyChartType(normalized) {
+  if (normalized.includes('pie')) return CHART_TYPES.pie;
+  if (normalized.includes('doughnut') || normalized.includes('donut')) return CHART_TYPES.doughnut;
+  if (normalized.includes('area')) return { ...CHART_TYPES.area, legacy: true };
+  if (normalized.includes('line')) return { ...CHART_TYPES['line-with-markers'], legacy: true };
+  if (normalized.includes('scatter')) return CHART_TYPES.scatter;
+  if (normalized.includes('radar')) return { ...CHART_TYPES.radar, legacy: true };
+  const grouping = normalized.includes('stacked') ? 'stacked' : 'clustered';
+  return category('bar', { barDir: normalized.includes('bar') ? 'bar' : 'col', grouping, legacy: true });
+}
+
+// Native construct -> kept OPF id, for import. `node` is the parsed chart-type
+// element (fast-xml-parser, attributes as plain keys).
+export function chartTypeFromNative(element, node) {
+  const attr = (name) => node?.[`c:${name}`]?.val;
+  const series = asArray(node?.['c:ser']);
+  const markers = !series.length || series.some((ser) => ser?.['c:marker']?.['c:symbol']?.val !== 'none');
+  const grouping = attr('grouping') ?? 'standard';
+  const stacked = grouping === 'stacked' || grouping === 'percentStacked';
+  const percent = grouping === 'percentStacked';
+  switch (element) {
+    case 'barChart':
+    case 'bar3DChart': {
+      const direction = attr('barDir') === 'bar' ? 'bar' : 'column';
+      if (percent) return `100pct-stacked-${direction}-3x`;
+      if (stacked) return `stacked-${direction}-3x`;
+      return direction;
+    }
+    case 'lineChart':
+    case 'line3DChart':
+      if (stacked) return markers ? 'stacked-line-with-markers-3x' : 'stacked-line-3x';
+      return markers ? 'line-with-markers' : 'line';
+    case 'areaChart':
+    case 'area3DChart':
+      return percent ? '100pct-stacked-area-3x' : stacked ? 'stacked-area-3x' : 'area';
+    case 'pieChart':
+    case 'pie3DChart':
+    case 'ofPieChart':
+      return 'pie';
+    case 'doughnutChart':
+      return 'doughnut';
+    case 'scatterChart':
+      return 'scatter';
+    case 'radarChart': {
+      const style = attr('radarStyle');
+      if (style === 'filled') return 'filled-radar';
+      if (style === 'marker' && markers) return 'radar-with-markers';
+      return 'radar';
+    }
+    default:
+      return null;
+  }
+}
+
+export const NATIVE_CHART_ELEMENTS = Object.freeze([
+  'barChart', 'bar3DChart', 'lineChart', 'line3DChart', 'pieChart', 'pie3DChart', 'ofPieChart',
+  'doughnutChart', 'areaChart', 'area3DChart', 'scatterChart', 'radarChart',
+]);
+
+function asArray(value) {
+  return value === undefined ? [] : Array.isArray(value) ? value : [value];
+}
+
+// PptxGenJS omits or cannot express parts of these constructs. Rewrite only
+// the generated chart-type element so the part states the exact grouping.
+export function applyChartConstruct(xml, spec) {
+  // ScatterWithMarkers: the core catalog records scatterStyle "marker" (markers, no connecting line). PptxGenJS writes lineMarker and relies on the series line being noFill.
+  if (spec?.family === 'xy') return xml.replace(/<c:scatterStyle val="[^"]*"\/>/, '<c:scatterStyle val="marker"/>');
+  if (!spec || spec.family !== 'category') return xml;
+  const element = { bar: 'barChart', line: 'lineChart', area: 'areaChart', radar: 'radarChart' }[spec.pptx];
+  if (!element || element === 'radarChart') return xml;
+  const open = `<c:${element}>`;
+  const start = xml.indexOf(open);
+  if (start < 0) return xml;
+  const end = xml.indexOf(`</c:${element}>`, start);
+  let body = xml.slice(start + open.length, end);
+  const grouping = `<c:grouping val="${spec.grouping}"/>`;
+  if (element === 'barChart') {
+    body = body.replace(/<c:grouping val="[^"]*"\/>/, grouping);
+  } else {
+    body = grouping + body.replace(/<c:grouping val="[^"]*"\/>/g, '');
+    // CT_LineSer/CT_AreaSer have no invertIfNegative (bar series only).
+    body = body.replace(/<c:invertIfNegative val="[^"]*"\/>/g, '');
+  }
+  if (spec.grouping === 'stacked' || spec.grouping === 'percentStacked') {
+    body = body.replace(/<c:overlap val="[^"]*"\/>/, '<c:overlap val="100"/>');
+  }
+  return xml.slice(0, start) + open + body + xml.slice(end);
+}

package/dist/chart-workbook.js

@@ -29,7 +29,7 @@ function workbookContext(entries,chartPart){
   if(!/^xl\/(workbook\.xml|_rels\/workbook\.xml\.rels|sharedStrings\.xml|worksheets\/[^/]+\.xml)$/.test(file.name))return false;
   size+=file.originalSize;if(size>16*1024*1024)throw Error('Chart workbook metadata exceeds the limit.');return true;
  }});
- const category=find(chart,'cat')[0],formula=category?.strRef?.f??category?.multiLvlStrRef?.f??category?.numRef?.f;
+ const category=find(chart,'cat')[0]??find(chart,'xVal')[0],formula=category?.strRef?.f??category?.multiLvlStrRef?.f??category?.numRef?.f;
  // Infer a heading only for one contiguous vertical category range with a row
  // above it. Other chart/workbook arrangements remain explicitly unrecovered.
  const range=/^(?:'((?:[^']|'')+)'|([^'!]+))!\$?([A-Z]+)\$?(\d+):\$?([A-Z]+)\$?(\d+)$/i.exec(text(formula));

package/dist/index.js

@@ -3,6 +3,7 @@ import {isFaceStyleSuffix} from './font-weights.js';
 import {importTableFrames} from './table-import.js';
 import {applyChartFonts, applyPitchFamilies, finalizeFontsUsed, fontPitchFamilies} from './package-fonts.js';
 import {readChartCategoryHeading,writeChartCategoryHeading} from './chart-workbook.js';
+import {CHARTEX_FALLBACK,resolveChartType,chartTypeFromNative,applyChartConstruct,NATIVE_CHART_ELEMENTS} from './chart-types.js';
 import {attachCodeTags, codeManifest, importCodeGroups, nativeShapeParagraphs, nativeTextShapes} from './code-provenance.js';
 import {attachMetricTags,metricManifest,importMetricGroups} from './metric-provenance.js';
 import {attachCardTags,importCardFrames} from './card-provenance.js';
@@ -19,7 +20,7 @@ import {dedupeMedia} from './media-dedupe.js';
 import {placeWatermarks, importWatermark, watermarkName, watermarkBox, watermarkOpacity} from './watermark-provenance.js';
 import {nativeBackgroundFill, nativeImageBackgroundFill, nativePatternPreset} from './background.js';
 import {importBackground} from './background-import.js';
-import {themeSlotColors, writeThemeColors, schemeColorValue, schemeBackgroundFill, readThemeSlotColors, recoverColorScheme, recoverTheme, presentationThemePath} from './theme-colors.js';
+import {themeSlotColors, writeThemeColors, schemeColorValue, schemeBackgroundFill, schemeBackgroundValue, defaultTextSchemeValues, tableTextSchemeValue, solidColorXml, writeMasterBackground, inheritLayoutBackground, readThemeSlotColors, recoverColorScheme, recoverTheme, presentationThemePath} from './theme-colors.js';
 import {languageDiagnostics, observeLanguage, partScriptFonts, planScriptFonts, reconcileLanguage} from './script-fonts.js';
 import { webpToPng } from '#image-fallback';
 import { rasterMetadata, pictureTransform, normalizeImageOrientation } from './image-geometry.js';
@@ -233,6 +234,8 @@ export async function toPptx(input, options = {}) {
     report: diagnostic => options.onDiagnostic?.(diagnostic)
   });
   context.scriptFonts = planScriptFonts(presentation, options.onDiagnostic);
+  context.masterBackground = masterBackground(context);
+  context.linkSentinels = linkSentinels(presentation);
   const pptx = new PptxGenJS();
   configurePresentation(pptx, presentation, {...context,fonts:resolveSlideContext(presentation,presentation.slides[0],context,options).fonts});
 
@@ -851,6 +854,7 @@ function chartFromRelationship(entries, slidePath, relationships, relId) {
 
   const budget = { cells: 0 };
   const cachePath = (index, role) => `${relationship.path}#c:ser[${index}]/${role}`;
+  if (chartNode.type === 'scatter') return scatterFromSeries(entries, relationship.path, series, budget, cachePath);
   const labels = cachedValues(series[0]?.["c:cat"], cachePath(0, 'c:cat'), budget);
   const names = series.map((entry, index) => firstCachedValue(entry?.["c:tx"], cachePath(index, 'c:tx'), budget) ?? `Series ${index + 1}`);
   const values = series.map((entry, index) => {
@@ -880,19 +884,31 @@ function chartFromRelationship(entries, slidePath, relationships, relId) {
   };
 }
 
+// Scatter charts share X values (c:xVal) across Y series (c:yVal). OPF keeps
+// them category-major: [point label, X, Y1, Y2, ...]; native charts carry no
+// point labels, so points are numbered.
+function scatterFromSeries(entries, chartPart, series, budget, cachePath) {
+  // The same cache helpers as every other chart: bounded, indexed by c:pt@idx, with gaps kept as null (never plotted as 0).
+  const xRole = series[0]?.["c:xVal"];
+  const xs = cachedValues(xRole, cachePath(0, "c:xVal"), budget, numericCacheValue);
+  const names = series.map((entry, index) => firstCachedValue(entry?.["c:tx"], cachePath(index, "c:tx"), budget) ?? `Series ${index + 1}`);
+  const values = series.map((entry, index) => cachedValues(entry?.["c:yVal"], cachePath(index, "c:yVal"), budget, numericCacheValue));
+  const rowCount = values.reduce((count, row) => Math.max(count, row.length), xs.length);
+  if (rowCount === 0) return null;
+  if (rowCount * (series.length + 2) > MAX_CHART_CACHE_CELLS) {
+    throw new OPFPptxError('invalid-chart-cache', 'Chart cache exceeds the 1,000,000-cell import limit; reduce its rows or series before importing.', {path: chartPart});
+  }
+  const rows = [];
+  // A chart without c:xVal plots against 1..n natively; a c:xVal gap stays a gap.
+  for (let index = 0; index < rowCount; index += 1) rows.push([String(index + 1), xRole === undefined ? index + 1 : xs[index] ?? null, ...values.map((row) => row[index] ?? null)]);
+  return { type: "scatter", data: { columns: ["Point", readChartCategoryHeading(entries, chartPart) ?? "X", ...names], rows } };
+}
+
 function firstChartNode(plotArea) {
-  const candidates = [
-    ["c:barChart", (node) => node?.["c:barDir"]?.val === "bar" ? "bar" : "column"],
-    ["c:lineChart", () => "line"],
-    ["c:pieChart", () => "pie"],
-    ["c:doughnutChart", () => "doughnut"],
-    ["c:areaChart", () => "area"],
-    ["c:scatterChart", () => "scatter"],
-    ["c:radarChart", () => "radar"]
-  ];
-  for (const [key, type] of candidates) {
-    const node = asArray(plotArea[key])[0];
-    if (node) return { node, type: type(node) };
+  // Map the native construct back to the kept OPF chart type id (FF-22).
+  for (const element of NATIVE_CHART_ELEMENTS) {
+    const node = asArray(plotArea[`c:${element}`])[0];
+    if (node) return { node, type: chartTypeFromNative(element, node) };
   }
   return null;
 }
@@ -1133,8 +1149,48 @@ function exportColor(entry, context, fallback) {
 // PptxGenJS color for a document color reference: a theme scheme value when the
 // reference names a scheme slot or role that the deck theme holds exactly,
 // otherwise the resolved literal RRGGBB. Alpha stays in the caller's transparency.
-function nativeColor(reference, hex, context) {
-  return schemeColorValue(reference, hex, context, {vendor: true}) ?? normalizeHex(hex);
+function nativeColor(reference, hex, context, fallback) {
+  if (fallback !== undefined && (reference === undefined || reference === null || reference === '')) return pptxColor(fallback);
+  const value = schemeColorValue(reference, hex, context, {vendor: true});
+  if (value) return value;
+  // PptxGenJS cannot write hlink or folHlink: a reserved literal stands in and
+  // is rewritten to the scheme color in the finished slide part.
+  const link = schemeColorValue(reference, hex, context);
+  return (link && context.linkSentinels?.[link]) ?? normalizeHex(hex);
+}
+
+// FF-24c: two literals no document color uses stand in for hlink and folHlink
+// (see nativeColor). When the document uses every candidate, those colors stay literal.
+const LINK_SENTINELS = [['FE01A0', 'FE01A1'], ['FE02B0', 'FE02B1'], ['FE03C0', 'FE03C1']];
+function linkSentinels(presentation) {
+  const text = JSON.stringify(presentation).toUpperCase();
+  const pair = LINK_SENTINELS.find(hexes => hexes.every(hex => !text.includes(hex)));
+  return pair ? {hlink: pair[0], folHlink: pair[1]} : {};
+}
+
+function writeLinkSentinels(xml, sentinels) {
+  const values = Object.entries(sentinels ?? {});
+  if (!values.length) return xml;
+  return xml.replace(/<a:srgbClr val="([0-9A-F]{6})"(\/>|>[\s\S]*?<\/a:srgbClr>)/g, (node, hex, rest) => {
+    const link = values.find(([, value]) => value === hex)?.[0];
+    return link ? `<a:schemeClr val="${link}"${rest.replace(/<\/a:srgbClr>$/, '</a:schemeClr>')}` : node;
+  });
+}
+
+// PptxGenJS color option: a scheme value it can emit (tx1, bg2, ...) or RRGGBB.
+function pptxColor(value) {
+  return /^(?:tx[12]|bg[12])$/.test(value) ? value : normalizeHex(value);
+}
+
+// Deck-level theme background for the slide master, so slides added in
+// PowerPoint match. The vendored layout already uses bg1, so only a theme
+// background on another slot (dark themes, light2, accents) changes the master.
+function masterBackground(context) {
+  const deck = {...context, schemeOverride: false};
+  const value = schemeBackgroundValue(deck.backgroundDefinition, deck);
+  const fill = schemeBackgroundFill(deck.backgroundDefinition, deck);
+  if (!value || value === 'bg1' || !fill || fill.includes('<a:alpha')) return null;
+  return {fill, text: defaultTextSchemeValues(deck).text ?? normalizeHex(context.colors.text)};
 }
 
 // The theme part carries the deck-level scheme (slide overrides stay literal)
@@ -1225,7 +1281,7 @@ async function addSlide(pptx, presentation, opfSlide, slideIndex, context, optio
       options.onDiagnostic?.({code: 'unresolved-asset', path: imagePath, message: 'The background image needs an embedded raster, a declared asset or a host imageResolver; the slide background color was exported instead.'});
     }
   }
-  slide.color = slideContext.colors.text;
+  slide.color = slideContext.textColor;
   if (opfSlide.hidden === true) slide.hidden = true;
 
   const { widthInches, heightInches } = slideContext.dimensions;
@@ -1247,49 +1303,51 @@ async function addSlide(pptx, presentation, opfSlide, slideIndex, context, optio
   if (geometry.slideImage) await addSlideImage(slide, presentation, geometry.slideImage, slideIndex, slideContext, options);
   await addWatermark(slide, presentation, opfSlide, slideIndex, slideContext, context, options);
   for (const item of geometry.items) {
+    // Card text sits on a literal card fill, not the slide background: keep it literal.
+    const itemContext = item.frameBox ? {...slideContext, textColor: slideContext.colors.text, mutedColor: slideContext.colors.mutedText} : slideContext;
     const region = { x: item.box.x / 96, y: item.box.y / 96, w: item.box.width / 96, h: item.box.height / 96 };
     if (item.frameBox) {
       const frame=item.frameBox;
       context.cardTags.set(`OPF card ${item.path}`,item.path);
       const paint=value=>({color:normalizeHex(value),transparency:/^#[0-9a-f]{8}$/i.test(value)?(1-parseInt(value.slice(7),16)/255)*100:0});
-      const surface=slideContext.colorScheme[isDarkHex(slideContext.colors.background)?'dark2':'light2']??`#${slideContext.colors.surface}`;
+      const surface=itemContext.colorScheme[isDarkHex(itemContext.colors.background)?'dark2':'light2']??`#${itemContext.colors.surface}`;
       slide.addShape('roundRect',{x:frame.x/96,y:frame.y/96,w:frame.width/96,h:frame.height/96,
         rectRadius:8*Math.min(widthInches,heightInches)/720,
-        fill:paint(surface),line:{...paint(slideContext.colorScheme.accent5??`#${slideContext.colors.border}`),width:.75},objectName:`OPF card ${item.path}`});
+        fill:paint(surface),line:{...paint(itemContext.colorScheme.accent5??`#${itemContext.colors.border}`),width:.75},objectName:`OPF card ${item.path}`});
     }
     if(['text','title','subtitle','tag'].includes(item.field)&&(item.text?.placement||item.text?.sourceLines)&&!item.text.richLines) {
-      addMeasuredPayloadText(slide,item.value,item.box,slideContext,options,{path:item.path,fit:item.text,textStyle:item.textStyle,sourceText:item.field==='text'&&!!item.text.sourceLines,align:alignmentFor(item),diagnosticsHandled:true,heading:['title','subtitle','tag'].includes(item.field)?item.field:undefined,color:item.field==='tag'?slideContext.colors.accent:slideContext.colors.text});
+      addMeasuredPayloadText(slide,item.value,item.box,itemContext,options,{path:item.path,fit:item.text,textStyle:item.textStyle,sourceText:item.field==='text'&&!!item.text.sourceLines,align:alignmentFor(item),diagnosticsHandled:true,heading:['title','subtitle','tag'].includes(item.field)?item.field:undefined,color:item.field==='tag'?itemContext.colors.accent:itemContext.textColor});
     } else if (["title", "subtitle", "tag"].includes(item.field)) {
       // Estimated-font headings use one native text box, which still needs a
       // role tag. Role recovery must not depend on outline measurement support.
       const objectName = `OPF heading ${item.path} line 0`;
       context.headingTags.set(objectName,{v:1,group:item.path,field:item.field,line:0,count:1});
       slide.addText(item.text.lines.join("\n"), {
-        ...textBoxOptions(region, slideContext, item.text.fontSize * 0.75),
+        ...textBoxOptions(region, itemContext, item.text.fontSize * 0.75),
         ...nativeFontOptions(item.textStyle),
-        color: item.field === "tag" ? slideContext.colors.accent : slideContext.colors.text,
+        color: item.field === "tag" ? itemContext.colors.accent : itemContext.textColor,
         align: alignmentFor(item),
         objectName,
         breakLine: false
       });
     } else if ((item.field === "items" || item.field === "bullets") && item.text?.listEntries) {
-      addMeasuredList(slide,item.text,slideContext,item.path);
+      addMeasuredList(slide,item.text,itemContext,item.path);
     } else if (item.field === "text" && item.text?.richLines) {
       const alignment=item.text.placement?.alignment??alignmentFor(item)??'left';
       for(const [index,line] of item.text.richLines.entries()){
         const runs=line.fragments.map(fragment=>{
-          const runColor=exportColor(fragment.run.color,slideContext,slideContext.colors.text);
-          const color=nativeColor(fragment.run.color,runColor,slideContext);
+          const runColor=exportColor(fragment.run.color,itemContext,itemContext.colors.text);
+          const color=nativeColor(fragment.run.color,runColor,itemContext,itemContext.textColor);
           return {text:fragment.text,options:{...nativeFontOptions(fragment.style),fontSize:fragment.fontSize*.75,color,underline:fragment.run.underline?{style:'sng',color}:undefined,strike:fragment.run.strikethrough?'sngStrike':undefined,baseline:fragment.baselineShift?-fragment.baselineShift/fragment.fontSize*2000:undefined,hyperlink:fragment.run.link&&/^(https?:|mailto:)/i.test(fragment.run.link)?{url:fragment.run.link}:undefined}};
         });
         const placed=item.text.placement?.lines[index],factor=alignment==='right'?1:alignment==='center'?.5:0;
         const area=placed?{...region,x:(placed.x+line.width*factor-item.box.width*factor)/96,y:placed.y/96,h:placed.height/96}:{...region,y:region.y+line.y/96,h:line.height/96};
-        if(runs.length)slide.addText(runs,{...textBoxOptions(area,slideContext,item.text.fontSize*.75),align:alignment,fit:'none',wrap:false,lineSpacingMultiple:1});
+        if(runs.length)slide.addText(runs,{...textBoxOptions(area,itemContext,item.text.fontSize*.75),align:alignment,fit:'none',wrap:false,lineSpacingMultiple:1});
       }
     } else if (item.field === "text" && typeof item.value === "string") {
-      slide.addText(item.text.lines.join("\n"), {...textBoxOptions(region, slideContext, item.text.fontSize * 0.75),...nativeFontOptions(item.textStyle),align:alignmentFor(item)});
+      slide.addText(item.text.lines.join("\n"), {...textBoxOptions(region, itemContext, item.text.fontSize * 0.75),...nativeFontOptions(item.textStyle),align:alignmentFor(item)});
     } else {
-      await addPayload(slide, presentation, item.payload, region, item.path, { ...slideContext, composition: item.composition, contentAlignment: alignmentFor(item) ?? "left" }, options, item.quoteLayout, item.codeLayout,item.metricLayout,item.timelineLayout);
+      await addPayload(slide, presentation, item.payload, region, item.path, { ...itemContext, composition: item.composition, contentAlignment: alignmentFor(item) ?? "left" }, options, item.quoteLayout, item.codeLayout,item.metricLayout,item.timelineLayout);
     }
   }
   // Core composes furniture above all content and opf-render paints it last, so
@@ -1321,7 +1379,17 @@ function resolveSlideContext(presentation, slide, baseContext, options, slideInd
     || Math.abs(resolved.dimensions.heightInches - baseContext.dimensions.heightInches) > 1e-6) {
     throw new OPFPptxError("mixed-slide-dimensions", "PowerPoint requires one canvas size per presentation. Set dimensions on the deck or export this slide separately.");
   }
-  return { ...baseContext, backgroundDefinition: resolved.backgroundDefinition, colorScheme: resolved.colorScheme, fonts: resolved.fonts, colors: resolved.colors, variables: resolved.variables, imageFill: effective.design.imageFill ?? "fit" };
+  const slideContext = { ...baseContext, backgroundDefinition: resolved.backgroundDefinition, colorScheme: resolved.colorScheme, fonts: resolved.fonts, colors: resolved.colors, variables: resolved.variables, imageFill: effective.design.imageFill ?? "fit" };
+  // A slide-level color scheme (directly or through a slide theme) pins every
+  // named color on that slide to literal sRGB; see schemeColorValue().
+  const slideScheme = themeSlotColors(resolved.colorScheme), deckScheme = baseContext.themeColors ?? {};
+  slideContext.schemeOverride = slide.design?.colorScheme !== undefined
+    || Object.keys({...slideScheme, ...deckScheme}).some(slot => slideScheme[slot] !== deckScheme[slot]);
+  // Default and muted text follow the theme only where the background does.
+  const text = defaultTextSchemeValues(slideContext);
+  slideContext.textColor = text.text ?? resolved.colors.text;
+  slideContext.mutedColor = text.muted ?? resolved.colors.mutedText;
+  return slideContext;
 }
 
 function fieldToType(field) {
@@ -1389,10 +1457,10 @@ function addTextPayload(slide, value, region, context) {
   slide.addText(stringifyText(value), textBoxOptions(region, context, 18));
 }
 
-function richLineRuns(line,color,context) {
+function richLineRuns(line,color,native,context) {
   const fallback=color.replace(/^#/,'');
   return line.fragments.map(fragment=>{
-    const runColor=exportColor(fragment.run.color,context,fallback),color=nativeColor(fragment.run.color,runColor,context);
+    const runColor=exportColor(fragment.run.color,context,fallback),color=nativeColor(fragment.run.color,runColor,context,native);
     return {text:fragment.text,options:{...nativeFontOptions(fragment.style),fontSize:fragment.fontSize*.75,color,underline:fragment.run.underline?{style:'sng',color}:undefined,strike:fragment.run.strikethrough?'sngStrike':undefined,baseline:fragment.baselineShift?-fragment.baselineShift/fragment.fontSize*2000:undefined,hyperlink:fragment.run.link&&/^(https?:|mailto:)/i.test(fragment.run.link)?{url:fragment.run.link}:undefined}};
   });
 }
@@ -1404,14 +1472,14 @@ function richLineRuns(line,color,context) {
 function addMeasuredList(slide,fit,context,path) {
   let lineNumber=0;
   for(const entry of fit.listEntries){
-    const addLines=(text,box,color,withBullet)=>{
+    const addLines=(text,box,color,native,withBullet)=>{
       text.richLines.forEach((line,index)=>{
         const first=withBullet&&index===0,level=Math.min(8,entry.level),inset=first?entry.marker.indent*(level+1):0;
         const region={x:(box.x-inset)/96,y:(box.y+line.y)/96,w:(box.width+inset)/96,h:line.height/96};
         const objectName=`OPF list ${path} line ${lineNumber++}`;
-        if(first)context.listMarkers.set(objectName,{fontFamily:entry.marker.style.fontFamily,fontSize:entry.marker.fontSize*.75,color:normalizeHex(context.colors.text)});
+        if(first)context.listMarkers.set(objectName,{fontFamily:entry.marker.style.fontFamily,fontSize:entry.marker.fontSize*.75,color:pptxColor(context.textColor)});
         const paragraph=first?{bullet:{characterCode:entry.marker.text.codePointAt(0).toString(16).padStart(4,'0'),indent:entry.marker.indent*.75},indentLevel:level}:{bullet:false};
-        const runs=richLineRuns(line,color,context);
+        const runs=richLineRuns(line,color,native,context);
         if(!runs.length)runs.push({text:'',options:{}});
         // Keep paragraph intent identical across runs. ZIP normalization below
         // removes the duplicate paragraph-property nodes emitted by PptxGenJS.
@@ -1419,8 +1487,8 @@ function addMeasuredList(slide,fit,context,path) {
         slide.addText(runs,{...textBoxOptions(region,context,text.fontSize*.75),fontFace:nativeFontOptions(entry.marker.style).fontFace,objectName,align:'left',fit:'none',wrap:false,lineSpacingMultiple:1,...paragraph});
       });
     };
-    addLines(entry.text,entry.textBox,context.colors.text,true);
-    if(entry.description)addLines(entry.description,entry.descriptionBox,context.colors.mutedText,false);
+    addLines(entry.text,entry.textBox,context.colors.text,context.textColor,true);
+    if(entry.description)addLines(entry.description,entry.descriptionBox,context.colors.mutedText,context.mutedColor,false);
   }
 }
 
@@ -1440,7 +1508,7 @@ function addListPayload(slide, items, region, context) {
       options: {
         bullet: { type: "bullet", indent: 14 + level * 14 },
         breakLine: index < list.length - 1 || Boolean(isPlainObject(item) && item.description),
-        color: context.colors.text,
+        color: context.textColor,
         fontFace: context.fonts.body,
         fontSize: 15,
         hanging: 4 + level * 10
@@ -1451,7 +1519,7 @@ function addListPayload(slide, items, region, context) {
         text: stringifyText(item.description),
         options: {
           breakLine: index < list.length - 1,
-          color: context.colors.mutedText,
+          color: context.mutedColor,
           fontFace: context.fonts.body,
           fontSize: 11,
           margin: [0, 0, 0, 18 + level * 14]
@@ -1553,7 +1621,7 @@ function addChartPayload(slide, chart, region, context, options = {}, path = "ch
     addPlaceholderPayload(slide, "Chart", chartData.summary, region, context);
     return;
   }
-  if (chartData.adapted) options.onDiagnostic?.({code: "chart-data-adapted", path, message: chartData.message, adaptation: chartData.adapted});
+  for (const {adaptation, message} of chartData.adaptations ?? []) options.onDiagnostic?.({code: "chart-data-adapted", path, message, adaptation});
 
   // Keep the resolved palette surface (including alpha) explicit in native
   // chart/plot areas, so inherited labels are assessed against their own panel.
@@ -1563,15 +1631,16 @@ function addChartPayload(slide, chart, region, context, options = {}, path = "ch
   const fill = {color:normalizeHex(panelFill),transparency};
   const objectName = `OPF chart ${context.chartHeadings.size + 1}`;
   const circular = chartData.type === 'pie' || chartData.type === 'doughnut';
-  context.chartHeadings.set(objectName,{heading:chartData.type === 'scatter' ? undefined : chartData.heading ?? chart.data.columns[0],labelColor});
+  context.chartHeadings.set(objectName,{heading:chartData.type === 'scatter' ? undefined : chartData.heading ?? chart.data.columns[0],labelColor,spec:chartData.spec});
   context.chartFonts.set(objectName,{heading:context.fonts.heading,body:context.fonts.body});
+  const percent = chartData.spec.grouping === 'percentStacked';
   slide.addChart(chartData.type, chartData.series, {
     objectName,
     x: region.x,
     y: region.y,
     w: region.w,
     h: region.h,
-    showLegend: circular || chartData.series.length > 1,
+    showLegend: circular || chartData.series.length > (chartData.type === 'scatter' ? 2 : 1),
     showTitle: false,
     chartColors: CHART_COLORS.map(color=>normalizeHex(chartColorForFill(panelFill,`#${color}`))),
     chartArea: {fill:{...fill},roundedCorners:false},
@@ -1589,7 +1658,12 @@ function addChartPayload(slide, chart, region, context, options = {}, path = "ch
     showValue: false,
     valGridLine: { color: context.colors.border, transparency: 30, size: 1 },
     barDir: chartData.barDir,
-    barGrouping: chartData.barGrouping
+    barGrouping: chartData.barGrouping,
+    ...(percent ? { valAxisLabelFormatCode: '0%' } : {}),
+    ...(chartData.spec.markers === undefined ? {} : { lineDataSymbol: chartData.spec.markers ? 'circle' : 'none' }),
+    ...(chartData.spec.radarStyle ? { radarStyle: chartData.spec.radarStyle } : {}),
+    // ScatterWithMarkers: markers only, no connecting line.
+    ...(chartData.type === 'scatter' ? { lineSize: 0, lineDataSymbol: 'circle' } : {})
   });
 }
 
@@ -1612,8 +1686,13 @@ function addTablePayload(slide, table, region, context, options, path) {
     const cellStyle = cell.style ?? {};
     const defaultFillHex = header ? context.colors.accent : context.colors.surface;
     const baseFill = exportColor(cellStyle.fill ?? defaultFillHex, context, defaultFillHex);
+    // FF-24c: engine chrome resolves from scheme roles (header accent1, body surface), so it follows the deck theme like a named fill.
+    const fillReference = cellStyle.fill ?? (header ? 'accent1' : 'surface');
+    const fillValue = schemeColorValue(fillReference, baseFill, context);
     const inheritedText = textColorForFill(`#${baseFill}`, header ? "#FFFFFF" : `#${context.colors.text}`);
     const baseColor = exportColor(cellStyle.color ?? inheritedText.replace(/^#/, ""), context, inheritedText.replace(/^#/, ""));
+    // Default cell text follows the theme only with a theme-referenced fill: paired slot on a light or dark fill, light1/dark1 on an accent fill.
+    const defaultText = cellStyle.color === undefined ? tableTextSchemeValue(fillValue, baseColor, context) : undefined;
     const alpha = value => value.length === 8 ? (1 - parseInt(value.slice(6), 16) / 255) * 100 : 0;
     const text = stringifyText(cell.value), style = cell.textStyle;
     const fragments = rich ? fit.richLines.flatMap(line => line.fragments) : [];
@@ -1622,7 +1701,7 @@ function addTablePayload(slide, table, region, context, options, path) {
       const fragment = fragments.find(item => item.runIndex === index);
       const runStyle = fragment?.style ?? resolveTextStyle({...style,fontFamily:run.fontFamily ?? style.fontFamily,fontWeight:run.bold === undefined ? style.fontWeight : run.bold ? 700 : 400,italic:run.italic ?? style.italic}, options.textMeasurement);
       const rawColor = run.color !== undefined && run.color !== '' ? exportColor(run.color, context, baseColor) : baseColor;
-      const color = nativeColor(run.color !== undefined && run.color !== '' ? run.color : cellStyle.color, rawColor, context), transparency = rawColor.length === 8 ? (1 - parseInt(rawColor.slice(6), 16) / 255) * 100 : 0;
+      const color = nativeColor(run.color !== undefined && run.color !== '' ? run.color : cellStyle.color, rawColor, context, defaultText), transparency = rawColor.length === 8 ? (1 - parseInt(rawColor.slice(6), 16) / 255) * 100 : 0;
       const runOptions = {
         ...nativeFontOptions(runStyle),fontSize:fragment ? fragment.fontSize * .75 : fit.fontSize * .75,
         underline:run.underline ? {style:'sng',color} : undefined,strike:run.strikethrough ? 'sngStrike' : undefined,
@@ -1652,17 +1731,17 @@ function addTablePayload(slide, table, region, context, options, path) {
         valign: cellStyle.verticalAlign ?? 'top',
         ...(cell.colSpan > 1 ? {colspan:cell.colSpan} : {}),
         ...(cell.rowSpan > 1 ? {rowspan:cell.rowSpan} : {}),
-        color: nativeColor(cellStyle.color, baseColor, context),
+        color: nativeColor(cellStyle.color, baseColor, context, defaultText),
         // Rich runs carry resolved alpha. A translucent cell default would
         // overwrite an explicit opaque run because PptxGenJS inherits falsy 0.
         ...(cellStyle.color && !rich ? {transparency:alpha(baseColor)} : {}),
-        fill: { color: nativeColor(cellStyle.fill, baseFill, context), ...(cellStyle.fill ? {transparency:alpha(baseFill)} : {}) },
+        fill: { color: nativeColor(fillReference, baseFill, context), ...(cellStyle.fill ? {transparency:alpha(baseFill)} : {}) },
       },
     };
   }));
   const objectName = `OPF table ${context.tableHeaders.size + 1}`;
   context.tableHeaders.set(objectName, hasHeaders);
-  if (layout.rows.some(row => row.cells.some(cell => Object.keys(cell.style ?? {}).length))) context.tableCells.set(objectName, {layout, scale, defaultBorder:{color:"#"+context.colors.border,width:1/scale}});
+  if (layout.rows.some(row => row.cells.some(cell => Object.keys(cell.style ?? {}).length))) context.tableCells.set(objectName, {layout, scale, context, defaultBorder:{color:"accent5",width:1/scale}});
   slide.addTable(rows, {
     objectName,
     x: region.x,
@@ -1678,7 +1757,7 @@ function addTablePayload(slide, table, region, context, options, path) {
     fontFace: context.fonts.body,
     fontSize: 15 * scale * 0.75,
     color: context.colors.text,
-    border: { type: "solid", color: context.colors.border, pt: 0.75 },
+    border: { type: "solid", color: nativeColor("accent5", context.colors.border, context), pt: 0.75 },
     margin: [6 * scale, 7.5 * scale, 3 * scale, 7.5 * scale],
     valign: "top"
   });
@@ -1720,7 +1799,7 @@ function addMeasuredPayloadText(slide, text, box, context, options, config) {
     else if(config.sourceText)context.plainTextTags.set(objectName,{v:1,group:config.path,line:index,count:fit.lines.length,...boundary});
     const area=placed?{x:(placed.x+placed.width*factor-box.width*factor)/96,y:(placed.baseline-fit.fontSize)/96,w:box.width/96,h:placed.height/96}:{x:box.x/96,y:(box.y+index*fit.lineHeight)/96,w:box.width/96,h:fit.lineHeight/96};
     // A run-level link keeps the muted, non-underlined furniture look of the preview (hlinkClr=tx, u=none).
-    const lineColor = normalizeHex(config.color ?? context.colors.text);
+    const lineColor = pptxColor(config.color ?? context.textColor);
     slide.addText(link?.href && line ? [{text: line, options: {hyperlink: {url: link.href}, color: lineColor, underline: {style: 'none'}}}] : line, {
       ...textBoxOptions(area, context, fit.fontSize * .75),
       ...nativeFontOptions(style),
@@ -1768,7 +1847,7 @@ async function addFurniture(slide,presentation,source,layout,context,options,sli
           if(marker) staticDates.set(index,marker);
         }
       }
-      addMeasuredPayloadText(slide,part.text,part.box,context,options,{path:part.path,fit:part.fit,textStyle:part.style,align:part.alignment,diagnosticsHandled:true,color:context.colors.mutedText,keepEmpty:true,objectName:`OPF furniture ${slideIndex} part ${index}`,furniture:{group:String(slideIndex),part:index},liveFields,links:part.links});
+      addMeasuredPayloadText(slide,part.text,part.box,context,options,{path:part.path,fit:part.fit,textStyle:part.style,align:part.alignment,diagnosticsHandled:true,color:context.mutedColor,keepEmpty:true,objectName:`OPF furniture ${slideIndex} part ${index}`,furniture:{group:String(slideIndex),part:index},liveFields,links:part.links});
     }
   }
   const manifest = furnitureManifest(presentation, source, layout, slideIndex, staticDates);
@@ -1823,7 +1902,7 @@ function addMetricPayload(slide,value,layout,context,path) {
       slide.addText(part.text.slice(line.start,line.end),{
         ...textBoxOptions({x:(anchor-part.box.width*factor)/96,y:(origin.baseline-part.fit.fontSize)/96,w:part.box.width/96,h:part.fit.lineHeight/96},context,part.fit.fontSize*.75),
         ...nativeFontOptions(part.style),
-        color:part.role==='value'?context.colors.accent:context.colors.text,align:layout.alignment,fit:'none',wrap:false,lineSpacingMultiple:1,
+        color:part.role==='value'?context.colors.accent:context.textColor,align:layout.alignment,fit:'none',wrap:false,lineSpacingMultiple:1,
         tabStops:tabStops.length?tabStops:undefined,objectName,
       });
     }
@@ -1836,7 +1915,7 @@ function addQuotePayload(slide, layout, context, options, path) {
     if (!part.fit) throw new OPFPptxError('layout-overflow', 'Quote content has no usable internal space; increase its cell size before exporting.', {path:part.path,issues:layout.diagnostics});
     addMeasuredPayloadText(slide,part.text,part.box,context,options,{
       path:part.path,fit:part.fit,textStyle:part.style,diagnosticsHandled:true,
-      color:part.role==='footer'?context.colors.mutedText:context.colors.text,
+      color:part.role==='footer'?context.mutedColor:context.textColor,
     });
   }
 }
@@ -1972,7 +2051,7 @@ function addPlaceholderPayload(slide, label, description, region, context) {
     margin: 0,
     fontFace: context.fonts.body,
     fontSize: 11,
-    color: context.colors.mutedText,
+    color: context.mutedColor,
     fit: "shrink",
     valign: "mid",
     align: "center"
@@ -2040,7 +2119,7 @@ function textBoxOptions(region, context, fontSize) {
     lineSpacingMultiple: 1.22,
     fontFace: context.fonts.body,
     fontSize,
-    color: context.colors.text,
+    color: context.textColor,
     breakLine: false,
     fit: "shrink",
     valign: "top"
@@ -2054,7 +2133,7 @@ function textRuns(value, context, fallbackFontSize) {
       return {
         text: run,
         options: {
-          color: context.colors.text,
+          color: context.textColor,
           fontFace: context.fonts.body,
           fontSize: fallbackFontSize
         }
@@ -2065,9 +2144,9 @@ function textRuns(value, context, fallbackFontSize) {
       options: {
         bold: run?.bold,
         italic: run?.italic,
-        underline: run?.underline ? { style: "sng", color: nativeColor(run?.color, exportColor(run?.color, context, context.colors.text), context) } : undefined,
+        underline: run?.underline ? { style: "sng", color: nativeColor(run?.color, exportColor(run?.color, context, context.colors.text), context, context.textColor) } : undefined,
         strike: run?.strikethrough ? "sngStrike" : undefined,
-        color: nativeColor(run?.color, exportColor(run?.color, context, context.colors.text), context),
+        color: nativeColor(run?.color, exportColor(run?.color, context, context.colors.text), context, context.textColor),
         fontFace: run?.fontFamily ?? context.fonts.body,
         fontSize: run?.fontSize ?? fallbackFontSize,
         superscript: run?.superscript,
@@ -2093,7 +2172,16 @@ function toPptxChartData(chart) {
   }
   if (data.rows.length === 0) return unplottable("no-rows", "The chart has no data rows.", "The chart data has no rows.");
   if (data.columns.length === 0) return unplottable("no-columns", "The chart has no data columns.", "The chart data has no columns.");
-  const mapped = mapChartType(chart.type);
+  const resolved = resolveChartType(chart.type).spec;
+  // Chartex types (treemap, box & whisker, waterfall, ...) have no classic construct here: they export as a clustered column chart, never silently.
+  const chartex = resolved.family === 'chartex';
+  const spec = chartex ? CHARTEX_FALLBACK : resolved;
+  const typeName = stringifyText(chart.type);
+  const adaptations = [];
+  if (chartex) {
+    adaptations.push({adaptation: "chartex-fallback", message: `The '${typeName}' chart is a PowerPoint extension (chartex) chart that this exporter does not write; its data is exported as a native clustered column chart instead.`});
+  }
+  const mapped = {type: spec.pptx, spec, barDir: spec.barDir, barGrouping: spec.pptx === 'bar' || spec.pptx === 'area' ? spec.grouping : undefined};
   if (data.columns.length === 1) {
     const heading = stringifyText(data.columns[0]);
     const cell = (row) => Array.isArray(row) ? row[0] : row;
@@ -2107,10 +2195,12 @@ function toPptxChartData(chart) {
     if (String(chart.type ?? "").toLowerCase() === "histogram") {
       const bins = histogramBins(points.map((point) => point.value));
       return {
-        type: "bar", barDir: "col", barGrouping: "clustered", heading: "Bin",
+        type: "bar", spec: CHARTEX_FALLBACK, barDir: "col", barGrouping: "clustered", heading: "Bin",
         series: [{name: "Frequency", labels: bins.map((bin) => bin.label), values: bins.map((bin) => bin.count)}],
-        adapted: "histogram-binned",
-        message: `The histogram's single data column '${heading}' (${points.length} values${skippedNote}) was binned into ${bins.length} equal-width bins and exported as a column chart of the counts; PowerPoint's own histogram chart is not exported, and the binned counts do not restore the raw values on re-import.`
+        adaptations: [{
+          adaptation: "histogram-binned",
+          message: `The histogram's single data column '${heading}' (${points.length} values${skippedNote}) was binned into ${bins.length} equal-width bins and exported as a column chart of the counts; PowerPoint's own histogram chart is not exported, and the binned counts do not restore the raw values on re-import.`
+        }]
       };
     }
     // Rows keep their own row numbers, so a skipped cell leaves a gap in the numbering.
@@ -2119,22 +2209,31 @@ function toPptxChartData(chart) {
     const series = mapped.type === "scatter"
       ? [{name: "Row", labels, values: points.map((point) => point.row)}, {name: heading, labels, values: numbers}]
       : [{name: heading, labels, values: numbers}];
-    return {
-      ...mapped, series, heading: "Row", adapted: "row-numbers",
-      message: `The chart's single data column '${heading}' has no category column, so its ${points.length} values${skippedNote} are plotted against their row numbers.`
-    };
+    adaptations.push({adaptation: "row-numbers", message: `The chart's single data column '${heading}' has no category column, so its ${points.length} values${skippedNote} are plotted against their row numbers.`});
+    return {...mapped, series, heading: "Row", adaptations};
   }
 
   const labels = data.rows.map((row) => stringifyText(row?.[0]));
-  const series = data.columns.slice(1).map((name, seriesIndex) => ({
+  let series = data.columns.slice(1).map((name, seriesIndex) => ({
     name: stringifyText(name),
     labels,
     values: data.rows.map((row) => numericValue(row?.[seriesIndex + 1]))
   }));
-
-  return { ...mapped, series };
+  if (spec.family === 'circular' && series.length > 1) {
+    // A pie or doughnut plots one series; name the ones left out instead of dropping them silently.
+    const dropped = series.slice(1).map((entry) => `'${entry.name}'`);
+    adaptations.push({adaptation: "series-dropped", message: `The ${typeName} chart plots one series, so its first series '${series[0].name}' is exported and the other ${dropped.length} (${dropped.join(", ")}) ${dropped.length === 1 ? "is" : "are"} not.`});
+    series = series.slice(0, 1);
+  }
+  if (spec.family === 'xy' && series.length === 1) {
+    // [Point, X, Y...] carries its own X column; a lone value column is plotted against the row numbers.
+    series = [{name: 'X', labels, values: data.rows.map((_, index) => index + 1)}, ...series];
+    adaptations.push({adaptation: "row-numbers", message: `The scatter chart has no X column (a point label column and one value column), so its ${data.rows.length} values are plotted against their row numbers.`});
+  }
+  return {type: spec.pptx, spec, series, barDir: spec.barDir, barGrouping: spec.pptx === 'bar' || spec.pptx === 'area' ? spec.grouping : undefined, adaptations};
 }
 
+
 /**
  * Equal-width bins (Sturges' count, at most 50) from the minimum to the maximum; every bin but the last is [low, high).
  * Arithmetic stays finite for any finite input (values of +-1e308 and denormals included): the bin edges are
@@ -2160,28 +2259,6 @@ function histogramBins(values) {
   }
 }
 
-function mapChartType(type) {
-  const normalized = String(type ?? "").toLowerCase();
-  if (normalized.includes("pie")) return { type: "pie" };
-  if (normalized.includes("doughnut") || normalized.includes("donut")) return { type: "doughnut" };
-  if (normalized.includes("area")) return { type: "area" };
-  if (normalized.includes("line") || normalized.includes("sparkline")) return { type: "line" };
-  if (normalized.includes("scatter")) return { type: "scatter" };
-  if (normalized.includes("radar")) return { type: "radar" };
-  if (normalized.includes("bar")) {
-    return {
-      type: "bar",
-      barDir: "bar",
-      barGrouping: normalized.includes("stacked") ? "stacked" : "clustered"
-    };
-  }
-  return {
-    type: "bar",
-    barDir: "col",
-    barGrouping: normalized.includes("stacked") ? "stacked" : "clustered"
-  };
-}
-
 async function resolveImage(asset, presentation, options, path) {
   const assetObject = dereferenceAsset(asset, presentation, path);
   const src = typeof assetObject === "string" ? assetObject : assetObject?.src;
@@ -2400,8 +2477,9 @@ async function normalizePptxZip(raw, context) {
       if(!context.chartHeadings.has(name))continue;
       const id=frame.match(/<c:chart\b[^>]*\br:id="([^"]+)"/)?.[1],chartPart=relationships.get(id)?.path;
       if(!chartPart)throw new OPFPptxError('packaging-failed','Generated chart relationship is missing.');
-      const {heading,labelColor}=context.chartHeadings.get(name);
+      const {heading,labelColor,spec}=context.chartHeadings.get(name);
       if(heading!==undefined)writeChartCategoryHeading(entries,chartPart,heading);
+      entries[chartPart]=encodeText(applyChartConstruct(decodeText(entries[chartPart]),spec));
       // PptxGenJS hardcodes a black fallback in pie/doughnut label properties.
       // Normalize only our generated chart text styles; point/series fills stay intact.
       entries[chartPart]=encodeText(decodeText(entries[chartPart]).replace(/<c:txPr>[\s\S]*?<\/c:txPr>/g,properties=>properties.replace(/<a:solidFill>[\s\S]*?<\/a:solidFill>/g,()=>`<a:solidFill><a:srgbClr val="${labelColor}"/></a:solidFill>`)));
@@ -2559,8 +2637,11 @@ function normalizePartBytes(path, bytes, context, renameMaps, entries, imageMeta
       xml = xml.replace('</Types>', `${overrides}</Types>`);
     }
     if (/^ppt\/slideMasters\/slideMaster\d+\.xml$/.test(path)) xml = themeMasterBulletFonts(xml);
+    if (context.masterBackground && path === 'ppt/slideMasters/slideMaster1.xml') xml = writeMasterBackground(xml, context.masterBackground);
+    if (context.masterBackground && /^ppt\/slideLayouts\/slideLayout\d+\.xml$/.test(path)) xml = inheritLayoutBackground(xml);
     if (path === 'ppt/theme/theme1.xml') xml = writeThemeColors(xml, {colors: context.themeColors, schemeName: context.schemeName, themeName: context.themeName});
     if (/^ppt\/slides\/slide\d+\.xml$/.test(path)) {
+      xml = writeLinkSentinels(xml, context.linkSentinels);
       const fill = context.backgroundFills.get(path);
       if (typeof fill === 'string') xml = xml.replace(/<p:bg>[\s\S]*?<\/p:bg>/, `<p:bg><p:bgPr>${fill}<a:effectLst/></p:bgPr></p:bg>`);
       else if (fill?.image) {
@@ -2631,10 +2712,10 @@ function normalizePartBytes(path, bytes, context, renameMaps, entries, imageMeta
               for (const [edge, native] of [['left','lnL'],['right','lnR'],['top','lnT'],['bottom','lnB']]) {
                 const border = style.borders?.[edge];
                 if (!border) continue;
-                const borderHex = exportColor(border.color, context, context.colors.border);
+                const slideContext = table.context, borderHex = exportColor(border.color, slideContext, slideContext.colors.border);
                 const borderOpacity = borderHex.length === 8 ? parseInt(borderHex.slice(6), 16) / 255 : 1;
-                const borderScheme = borderOpacity === 1 ? schemeColorValue(border.color, borderHex, context) : undefined;
-                const fill = border.width === 0 ? '<a:noFill/>' : borderScheme ? `<a:solidFill><a:schemeClr val="${borderScheme}"/></a:solidFill>` : nativeBackgroundFill({type:'solid',color:'#' + borderHex.slice(0, 6), opacity: borderOpacity},{width:1,height:1}, context.colors.border);
+                const borderScheme = borderOpacity === 1 ? schemeColorValue(border.color, borderHex, slideContext) : undefined;
+                const fill = border.width === 0 ? '<a:noFill/>' : borderScheme ? `<a:solidFill><a:schemeClr val="${borderScheme}"/></a:solidFill>` : nativeBackgroundFill({type:'solid',color:'#' + borderHex.slice(0, 6), opacity: borderOpacity},{width:1,height:1}, slideContext.colors.border);
                 const dash = {solid:'solid',dash:'dash',dot:'sysDot'}[border.dash ?? 'solid'];
                 const line = `<a:${native} w="${Math.round(border.width * table.scale * 9525)}" cap="flat" cmpd="sng" algn="ctr">${fill}<a:prstDash val="${dash}"/></a:${native}>`;
                 const existing = new RegExp(`<a:${native}\\b[^>]*>[\\s\\S]*?<\\/a:${native}>`);
@@ -2670,7 +2751,7 @@ function normalizePartBytes(path, bytes, context, renameMaps, entries, imageMeta
         const marker=context.listMarkers.get(shape.match(/name="(OPF list [^"]* line \d+)"/)?.[1]);
         if(!marker)return shape;
         const family=marker.fontFamily.replace(/[&<>"']/g,char=>({'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;',"'":'&apos;'}[char]));
-        return shape.replace(/<a:buSzPct val="100000"\/>/g,`<a:buClr><a:srgbClr val="${marker.color}"/></a:buClr><a:buSzPts val="${Math.round(marker.fontSize*100)}"/><a:buFont typeface="${family}"/>`);
+        return shape.replace(/<a:buSzPct val="100000"\/>/g,`<a:buClr>${solidColorXml(marker.color)}</a:buClr><a:buSzPts val="${Math.round(marker.fontSize*100)}"/><a:buFont typeface="${family}"/>`);
       });
       // PptxGenJS gives shapes no alternative text. An unavailable image's panel
       // carries the accessible name the preview gives its group.

package/dist/theme-colors.js

@@ -102,7 +102,9 @@ function backgroundSlot(definition) {
  * `vendor` limits the result to scheme values PptxGenJS 4.0.1 can emit.
  */
 export function schemeColorValue(reference, hex, context, {vendor = false} = {}) {
-  if (typeof reference !== 'string') return undefined;
+  // A slide with its own color scheme is pinned to literal colors: a theme edit
+  // in PowerPoint must not partially recolor it, even where a value coincides.
+  if (typeof reference !== 'string' || context.schemeOverride) return undefined;
   const name = reference.trim();
   const resolved = sixDigitHex(hex);
   const deck = context.themeColors;
@@ -120,17 +122,73 @@ export function schemeColorValue(reference, hex, context, {vendor = false} = {})
   return undefined;
 }
 
+function backgroundOpacity(definition) {
+  const opacity = typeof definition === 'object' && Number.isFinite(definition?.opacity) ? definition.opacity : 1;
+  return Math.max(0, Math.min(1, opacity));
+}
+
+/** Scheme value of a theme-slot slide background, or undefined when the background stays literal. */
+export function schemeBackgroundValue(definition, context) {
+  const slot = backgroundSlot(definition);
+  return slot ? schemeColorValue(slot, context.colors?.background, context) : undefined;
+}
+
 /** Native slide background fill for a theme-slot background, or null when it must stay literal. */
 export function schemeBackgroundFill(definition, context) {
-  const slot = backgroundSlot(definition);
-  if (!slot) return null;
-  const value = schemeColorValue(slot, context.colors?.background, context);
+  const value = schemeBackgroundValue(definition, context);
   if (!value) return null;
-  const opacity = typeof definition === 'object' && Number.isFinite(definition.opacity) ? definition.opacity : 1;
-  const alpha = Math.round(Math.max(0, Math.min(1, opacity)) * 100000);
+  const alpha = Math.round(backgroundOpacity(definition) * 100000);
   return `<a:solidFill>${alpha === 100000 ? `<a:schemeClr val="${value}"/>` : `<a:schemeClr val="${value}"><a:alpha val="${alpha}"/></a:schemeClr>`}</a:solidFill>`;
 }
 
+// The exporter picks default text for contrast with the slide background:
+// light1 on a dark background, else the scheme text (dark1); muted text is
+// dark2/light2. When the background itself is a theme reference, the matching
+// text slot is the semantic pair, so a PowerPoint theme switch moves both.
+const TEXT_PAIRS = Object.freeze({
+  light1: {text: 'dark1', muted: 'dark2'}, light2: {text: 'dark1', muted: 'dark2'},
+  dark1: {text: 'light1', muted: 'light2'}, dark2: {text: 'light1', muted: 'light2'},
+});
+
+/**
+ * Scheme values for the exporter's default text and muted text on this slide.
+ * A role gets a scheme value only when the slide background is an opaque theme
+ * reference to a light or dark slot, the slide has no scheme override, and the
+ * resolved default color is exactly the paired slot in the deck theme.
+ */
+export function defaultTextSchemeValues(context) {
+  const background = schemeBackgroundValue(context.backgroundDefinition, context);
+  if (!background || backgroundOpacity(context.backgroundDefinition) !== 1) return {};
+  const pair = TEXT_PAIRS[backgroundSlot(context.backgroundDefinition)];
+  if (!pair) return {};
+  const values = {};
+  for (const role of ['text', 'muted']) {
+    const hex = role === 'text' ? context.colors?.text : context.colors?.mutedText;
+    const value = schemeColorValue(pair[role], hex, context);
+    if (value) values[role] = value;
+  }
+  return values;
+}
+
+/**
+ * Scheme value for the exporter's default text in a table cell whose fill is a
+ * theme reference (`fillValue`, from schemeColorValue). A light or dark fill (bg1,
+ * bg2, tx1, tx2) pairs with the opposite text slot (dark1 on bg, light1 on tx).
+ * An accent fill has contrast-selected text, which stays a theme reference only
+ * when the selection is exactly the deck light1 or dark1. Anything else, and any
+ * fill that is not a theme reference, keeps literal text.
+ */
+export function tableTextSchemeValue(fillValue, hex, context) {
+  if (!fillValue) return undefined;
+  const light = /^bg[12]$/.test(fillValue), dark = /^tx[12]$/.test(fillValue);
+  const candidates = light ? ['dark1'] : dark ? ['light1'] : /^accent[1-6]$/.test(fillValue) ? ['light1', 'dark1'] : [];
+  for (const slot of candidates) {
+    const value = schemeColorValue(slot, hex, context, {vendor: true});
+    if (value) return value;
+  }
+  return undefined;
+}
+
 // ---------------------------------------------------------------------------
 // Import
 
@@ -202,3 +260,31 @@ export function recoverTheme({themeName, colors, majorFont, minorFont}, {themes,
   const fontMatch = !!fonts && fonts.heading === majorFont && fonts.body === minorFont;
   return colorMatch || fontMatch ? {id: theme.id} : {unverified: theme.id};
 }
+
+// ---------------------------------------------------------------------------
+// Slide master
+
+/** a:solidFill child for a pptx color value: a scheme value or RRGGBB. */
+export function solidColorXml(value) {
+  return /^(?:tx[12]|bg[12]|accent[1-6]|hlink|folHlink)$/.test(value) ? `<a:schemeClr val="${value}"/>` : `<a:srgbClr val="${value}"/>`;
+}
+
+/**
+ * Give the slide master the deck's theme background and matching default text
+ * so slides added in PowerPoint follow the chosen theme. The vendored master
+ * has no background (its layout uses the bg1 background style) and tx1 text.
+ */
+export function writeMasterBackground(xml, {fill, text}) {
+  let result = xml.replace(/<p:bg>[\s\S]*?<\/p:bg>/, '');
+  result = result.replace(/<p:cSld\b([^>]*)>/, `<p:cSld$1><p:bg><p:bgPr>${fill}<a:effectLst/></p:bgPr></p:bg>`);
+  if (text && text !== 'tx1') {
+    result = result.replace(/<p:txStyles>[\s\S]*?<\/p:txStyles>/, styles =>
+      styles.split('<a:solidFill><a:schemeClr val="tx1"/></a:solidFill>').join(`<a:solidFill>${solidColorXml(text)}</a:solidFill>`));
+  }
+  return result;
+}
+
+/** The vendored layout's own bg1 background would hide the master background. */
+export function inheritLayoutBackground(xml) {
+  return xml.replace(/<p:bg>[\s\S]*?<\/p:bg>/, '');
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openpresentation/opf-pptx",
-  "version": "0.11.1",
+  "version": "0.11.2",
   "description": "Pure local OPF to PPTX export and PPTX to OPF import tooling.",
   "license": "MIT",
   "type": "module",
@@ -37,8 +37,8 @@
   "sideEffects": false,
   "scripts": {
     "build": "node scripts/build.mjs",
-    "typecheck": "node --check src/index.js && node --check test/design-alignment.mjs && node --check src/color-ref.js && node --check src/theme-colors.js && node --check test/theme-colors.mjs && node --check scripts/build.mjs && node --check scripts/validate-package.mjs && node --check test/smoke.mjs && node --check src/image-geometry.js && node --check src/slide-image-provenance.js && node --check test/slide-image.mjs && node --check test/slide-image-treatments.mjs && node --check src/watermark-provenance.js && node --check src/media-dedupe.js && node --check test/media-dedupe.mjs && node --check test/watermark.mjs && node --check test/image-fit.mjs && node --check test/image-orientation.mjs && node --check test/table-layout.mjs && node --check test/table-import.mjs && node --check test/object-ids.mjs && node --check test/export-corpus.mjs && node --check test/image-media-type.mjs && node --check src/image-fallback-node.js && node --check src/image-fallback-browser.js && node --check test/webp-fallback.mjs && node --check scripts/build-browser-check.mjs && node --check test/webp-fallback-browser.js && node --check test/image-fallback-boundary.mjs && node --check src/background.js && node --check test/background.mjs && node --check src/image-import.js && node --check test/image-import.mjs && node --check test/native-background.mjs && node --check src/background-import.js && node --check test/background-inheritance.mjs && node --check test/rich-table.mjs && node --check src/table-import.js && node --check test/rich-table-import.mjs && node --check test/rich-table-import-browser.js && node --check test/table-row-sizing.mjs && node --check test/table-styles.mjs && node --check test/table-styles-browser.js && node --check test/styled-table.mjs && node --check src/table-cell-import.js && node --check test/styled-table-import.mjs && node --check test/styled-table-import-browser.js && node --check src/table-border-import.js && node --check test/table-border-styles.mjs && node --check src/card-provenance.js && node --check test/content-cards.mjs && node --check src/chart-workbook.js && node --check test/chart-colors.mjs && node --check test/chart-workbook.mjs && node --check test/single-column-chart.mjs && node --check test/native-chart-colors.mjs && node --check src/heading-provenance.js && node --check test/accepted-text.mjs && node --check test/heading-provenance.mjs && node --check src/text-provenance.js && node --check test/plain-whitespace.mjs && node --check src/timeline-provenance.js && node --check test/shared-timeline.mjs && node --check test/shared-furniture.mjs && node --check src/furniture-provenance.js && node --check src/document-provenance.js && node --check test/document-provenance.mjs && node --check test/furniture-provenance.mjs && node --check src/furniture-fields.js && node --check test/furniture-fields.mjs && node --check test/furniture-wrapped-date.mjs && node --check test/native-picture.mjs && node --check test/compare-native-picture.mjs && node --check test/compare-native-picture-edit.mjs && node --check test/compare-native-picture-edit-controls.mjs && node --check test/native-font-embed-audit.mjs && node --check test/native-font-embed-controls.mjs && node --check test/native-font-embed-fixture-source.mjs && node --check test/native-font-edit-fixture.mjs && node --check test/native-mixed-edit-audit.mjs && node --check test/native-mixed-edit-controls.mjs && node --check test/master-bullet-font.mjs && node --check test/native-font-inventory-audit.mjs && node --check test/native-font-inventory-controls.mjs && node --check test/default-font-scheme.mjs && node --check test/export-chosen-fonts.mjs && node --check test/background-fills.mjs && node --check src/typeface-inventory.js && node --check src/package-fonts.js && node --check test/typeface-inventory.mjs && node --check src/script-fonts.js && node --check test/script-fonts.mjs && node --check test/powershell-scan.mjs && node --check test/powershell-scan-probes.mjs && node --check test/socials-furniture.mjs && node --check src/media-provenance.js && node --check test/layout-parity.mjs && node --check test/cover-centering.mjs && node --check test/media-placeholder.mjs && node --check test/image-placeholder.mjs && node --check test/list-shape-names.mjs && node --check test/layout-intent.mjs && node --check test/chart-cache-import.mjs && node --check test/zip-date.mjs && node --check test/native-text-whitespace.mjs && node --check test/native-underline.mjs && node --check src/native-text-style.js && node --check src/font-weights.js && node --check test/font-weight-import.mjs && node --check src/body-text-import.js && node --check test/native-body-rich-text.mjs && node --check test/native-body-rich-text-browser.js && node --check test/native-quote-import-contract.mjs && node --check test/native-quote-import-controls.mjs && node --check test/native-quote.mjs && node --check test/determinism.mjs && node --check test/determinism-fixtures.mjs && node --check test/table-frame-furniture-order.mjs && node --check test/shape-border-widths.mjs",
-    "test": "npm run build && node test/zip-date.mjs && node test/background-fills.mjs && npm run test:furniture && node test/slide-image.mjs && node test/slide-image-treatments.mjs && node test/watermark.mjs && node test/media-dedupe.mjs && node test/document-provenance.mjs && node test/layout-intent.mjs && node test/master-bullet-font.mjs && node test/default-font-scheme.mjs && node test/script-fonts.mjs && node test/export-chosen-fonts.mjs && node test/typeface-inventory.mjs && node test/color-ref-export.mjs && node test/theme-colors.mjs && node test/plain-whitespace.mjs && node test/native-text-whitespace.mjs && node test/native-body-rich-text.mjs && node test/native-underline.mjs && node test/font-weight-import.mjs && node test/design-alignment.mjs && node test/accepted-text.mjs && node test/heading-provenance.mjs && node test/native-quote-import-controls.mjs && node test/chart-colors.mjs && node test/content-cards.mjs && node test/chart-workbook.mjs && node test/single-column-chart.mjs && node --test test/chart-cache-import.mjs && node test/dependency-boundary.mjs && npm run build:browser-check && npm run test:styled-table && node test/content-layout.mjs && node test/layout-parity.mjs && node test/cover-centering.mjs && node test/table-frame-furniture-order.mjs && node test/media-placeholder.mjs && node test/shape-border-widths.mjs && node test/image-placeholder.mjs && node test/list-shape-names.mjs && node test/shared-quote.mjs && npm run test:timeline && npm run test:determinism",
+    "typecheck": "node --check src/index.js && node --check src/chart-types.js && node --check test/chart-types.mjs && node --check test/design-alignment.mjs && node --check src/color-ref.js && node --check src/theme-colors.js && node --check test/theme-colors.mjs && node --check test/table-theme-colors.mjs && node --check scripts/build.mjs && node --check scripts/validate-package.mjs && node --check test/smoke.mjs && node --check src/image-geometry.js && node --check src/slide-image-provenance.js && node --check test/slide-image.mjs && node --check test/slide-image-treatments.mjs && node --check src/watermark-provenance.js && node --check src/media-dedupe.js && node --check test/media-dedupe.mjs && node --check test/watermark.mjs && node --check test/image-fit.mjs && node --check test/image-orientation.mjs && node --check test/table-layout.mjs && node --check test/table-import.mjs && node --check test/object-ids.mjs && node --check test/export-corpus.mjs && node --check test/image-media-type.mjs && node --check src/image-fallback-node.js && node --check src/image-fallback-browser.js && node --check test/webp-fallback.mjs && node --check scripts/build-browser-check.mjs && node --check test/webp-fallback-browser.js && node --check test/image-fallback-boundary.mjs && node --check src/background.js && node --check test/background.mjs && node --check src/image-import.js && node --check test/image-import.mjs && node --check test/native-background.mjs && node --check src/background-import.js && node --check test/background-inheritance.mjs && node --check test/rich-table.mjs && node --check src/table-import.js && node --check test/rich-table-import.mjs && node --check test/rich-table-import-browser.js && node --check test/table-row-sizing.mjs && node --check test/table-styles.mjs && node --check test/table-styles-browser.js && node --check test/styled-table.mjs && node --check src/table-cell-import.js && node --check test/styled-table-import.mjs && node --check test/styled-table-import-browser.js && node --check src/table-border-import.js && node --check test/table-border-styles.mjs && node --check src/card-provenance.js && node --check test/content-cards.mjs && node --check src/chart-workbook.js && node --check test/chart-colors.mjs && node --check test/chart-workbook.mjs && node --check test/single-column-chart.mjs && node --check test/native-chart-colors.mjs && node --check src/heading-provenance.js && node --check test/accepted-text.mjs && node --check test/heading-provenance.mjs && node --check src/text-provenance.js && node --check test/plain-whitespace.mjs && node --check src/timeline-provenance.js && node --check test/shared-timeline.mjs && node --check test/shared-furniture.mjs && node --check src/furniture-provenance.js && node --check src/document-provenance.js && node --check test/document-provenance.mjs && node --check test/furniture-provenance.mjs && node --check src/furniture-fields.js && node --check test/furniture-fields.mjs && node --check test/furniture-wrapped-date.mjs && node --check test/native-picture.mjs && node --check test/compare-native-picture.mjs && node --check test/compare-native-picture-edit.mjs && node --check test/compare-native-picture-edit-controls.mjs && node --check test/native-font-embed-audit.mjs && node --check test/native-font-embed-controls.mjs && node --check test/native-font-embed-fixture-source.mjs && node --check test/native-font-edit-fixture.mjs && node --check test/native-mixed-edit-audit.mjs && node --check test/native-mixed-edit-controls.mjs && node --check test/master-bullet-font.mjs && node --check test/native-font-inventory-audit.mjs && node --check test/native-font-inventory-controls.mjs && node --check test/default-font-scheme.mjs && node --check test/export-chosen-fonts.mjs && node --check test/background-fills.mjs && node --check src/typeface-inventory.js && node --check src/package-fonts.js && node --check test/typeface-inventory.mjs && node --check src/script-fonts.js && node --check test/script-fonts.mjs && node --check test/powershell-scan.mjs && node --check test/powershell-scan-probes.mjs && node --check test/socials-furniture.mjs && node --check src/media-provenance.js && node --check test/layout-parity.mjs && node --check test/cover-centering.mjs && node --check test/media-placeholder.mjs && node --check test/image-placeholder.mjs && node --check test/list-shape-names.mjs && node --check test/layout-intent.mjs && node --check test/chart-cache-import.mjs && node --check test/zip-date.mjs && node --check test/native-text-whitespace.mjs && node --check test/native-underline.mjs && node --check src/native-text-style.js && node --check src/font-weights.js && node --check test/font-weight-import.mjs && node --check src/body-text-import.js && node --check test/native-body-rich-text.mjs && node --check test/native-body-rich-text-browser.js && node --check test/native-quote-import-contract.mjs && node --check test/native-quote-import-controls.mjs && node --check test/native-quote.mjs && node --check test/determinism.mjs && node --check test/determinism-fixtures.mjs && node --check test/table-frame-furniture-order.mjs && node --check test/shape-border-widths.mjs",
+    "test": "npm run build && node test/chart-types.mjs && node test/zip-date.mjs && node test/background-fills.mjs && npm run test:furniture && node test/slide-image.mjs && node test/slide-image-treatments.mjs && node test/watermark.mjs && node test/media-dedupe.mjs && node test/document-provenance.mjs && node test/layout-intent.mjs && node test/master-bullet-font.mjs && node test/default-font-scheme.mjs && node test/script-fonts.mjs && node test/export-chosen-fonts.mjs && node test/typeface-inventory.mjs && node test/color-ref-export.mjs && node test/theme-colors.mjs && node test/table-theme-colors.mjs && node test/plain-whitespace.mjs && node test/native-text-whitespace.mjs && node test/native-body-rich-text.mjs && node test/native-underline.mjs && node test/font-weight-import.mjs && node test/design-alignment.mjs && node test/accepted-text.mjs && node test/heading-provenance.mjs && node test/native-quote-import-controls.mjs && node test/chart-colors.mjs && node test/content-cards.mjs && node test/chart-workbook.mjs && node test/single-column-chart.mjs && node --test test/chart-cache-import.mjs && node test/dependency-boundary.mjs && npm run build:browser-check && npm run test:styled-table && node test/content-layout.mjs && node test/layout-parity.mjs && node test/cover-centering.mjs && node test/table-frame-furniture-order.mjs && node test/media-placeholder.mjs && node test/shape-border-widths.mjs && node test/image-placeholder.mjs && node test/list-shape-names.mjs && node test/shared-quote.mjs && npm run test:timeline && npm run test:determinism",
     "validate": "node scripts/validate-package.mjs",
     "test:packed": "node test/packed-install.mjs",
     "test:compare-published": "node test/compare-published.mjs",