@openpresentation/opf-pptx 0.22.0 → 0.23.0

package/README.md

@@ -431,14 +431,25 @@ Table chrome follows the theme too (FF-24c). With no theme override on the slide
 
 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.
 
+### Color variants (RR-96)
+
+A deck's `design.variant` (a background slot string such as `"dark1"`, or `{background, accents?}` with `background` one of `light1`, `light2`, `dark1`, `dark2` and `accents` a permutation of `accent1`-`accent6`) decides what the master color map says. Export writes core's `clrMapAttributes` into the master's `<p:clrMap>`: `bg1`/`tx1`/`bg2`/`tx2` name the slots the variant puts on the background and on text, and the six `accentN` names point at the permuted accent slots. A slide whose variant differs from the deck's writes `<p:clrMapOvr><a:overrideClrMapping .../>` with its own map, so a dark slide in a light deck keeps `bg1`/`tx1` as its background and text. A deck whose theme background is dark gets the dark map without an explicit variant. In PowerPoint, switching a slide's Background Style or the deck's variant therefore recolors text, borders, tables, charts and code panels together.
+
+Every color the exporter derives from the scheme is written as `a:schemeClr`: text, backgrounds, table fills and borders, card fills and edges, chart text, gridlines and axis lines, code panels and syntax colors, metric trend marks, tags and footers. The deck's neutrals are core's `roles.neutrals`: the text color mixed into the background at a fixed share (border 20%, gridline 15%, axis line 25%, chart text 65%). They are written as the text slot with `a:lumMod`/`a:lumOff` (a translucent mix as `a:alpha`), so a variant change keeps them in step. The pass runs over the finished slide, master, layout and chart parts, before provenance is fingerprinted.
+
+A picture background that names its `tone` (`dark` or `light`) and has no overlay of its own is covered by one full-slide rectangle named `OPF background tone <tone> slides.<n>`, directly above the picture: the tone variant's `bg1` as `a:schemeClr` at 40% alpha (the preview's `data-opf-tone-overlay` scrim), so text keeps its contrast in PowerPoint and Keynote. The slide's `clrMapOvr` is the tone's map. Import takes that rectangle back into the background's `tone`.
+
 These stay `a:srgbClr`:
 
-- literal hex colors, even when they equal a scheme slot;
+- literal hex colors the document wrote, even when they equal a scheme slot;
 - `var:<id>` variables;
-- translucent colors;
-- 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.
+- colors on a slide with its own `design.colorScheme` or a slide theme that changes a slot (every color on that slide is literal);
+- a translucent fill the theme cannot hold (`a:schemeClr` plus `a:alpha` is used where the slot color itself is opaque);
+- colors that match no scheme slot or derived neutral, such as contrast-adjusted series colors and `hlink`/`folHlink` fallbacks.
+
+Import reads the master color map into `design.variant` (the string shorthand when there are no accent changes), the slide's `clrMapOvr` into the slide's `design.variant`, and a `schemeClr` background fill into the theme-slot background. A `bg1` background imports as no background (the variant implies it); another light or dark slot imports as `{type:'theme', slot}`. A variant that core already implies from the deck's own design is dropped, so a dark-by-theme deck does not gain one. A color map that is not a permutation core's variants describe reports `unsupported-color-map` and is not applied. On a slide without exporter provenance, a table fill equal to a scheme slot returns as the slot name (`accent1`, `light2`, ...). `test/color-variants.mjs` covers the master map, the override with accents, the scheme neutrals and the import round trip. This establishes package structure and round-trip, not PowerPoint rendering.
 
-Import reads the first slide master's theme and matches it against the host default catalog only (the first of `fromPptx`'s `catalogs`): recovered bare ids resolve in a document that declares no catalogs. Theme and colour-scheme recovery does not use the foreign-layout default: omitted catalogs and explicit `catalogs: []` both leave recovery unregistered. An exact twelve-slot match with one of its colour schemes returns that id; the `clrScheme` name breaks ties. Otherwise the importer returns inline slots, relative to the scheme the `clrScheme` is named after when there is one (`{id:'boost', accent1:'#123456'}`). A theme whose name equals one of its themes' names maps to `design.theme` only if the package's color scheme or heading/body fonts match that theme (its references resolved in its own group first); otherwise `theme-unverified` is reported. With omitted catalogs or explicit `catalogs: []`, or a match only in another registered catalog, the colour scheme imports inline and no theme id is recovered; an FF-32 stored reference still restores. 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 gallery schemes and 4 gallery themes (registered as `defaultCatalog`), import without catalogs, 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.
+Import reads the first slide master's theme and matches it against the host default catalog only (the first of `fromPptx`'s `catalogs`): recovered bare ids resolve in a document that declares no catalogs. Theme and colour-scheme recovery does not use the foreign-layout default: omitted catalogs and explicit `catalogs: []` both leave recovery unregistered. An exact twelve-slot match with one of its colour schemes returns that id; the `clrScheme` name breaks ties. Otherwise the importer returns inline slots, relative to the scheme the `clrScheme` is named after when there is one (`{id:'boost', accent1:'#123456'}`). A theme whose name equals one of its themes' names maps to `design.theme` only if the package's color scheme or heading/body fonts match that theme (its references resolved in its own group first); otherwise `theme-unverified` is reported. With omitted catalogs or explicit `catalogs: []`, or a match only in another registered catalog, the colour scheme imports inline and no theme id is recovered; an FF-32 stored reference still restores. A missing theme, or slots that are not opaque sRGB/system colors, report `unsupported-theme-colors` on `design.colorScheme`. Other 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 gallery schemes and 4 gallery themes (registered as `defaultCatalog`), import without catalogs, 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/background-import.js

@@ -62,7 +62,7 @@ export function readSlideTheme(slidePath, {part, relationships, bytes}) {
       if (elements?.['a:fmtScheme']) {format = elements['a:fmtScheme'];formatPath = themePath;}
     }
   }
-  return {chain, colors, mapping, fonts, format, formatPath, parsedPart};
+  return {chain, colors, mapping, masterMapping, fonts, format, formatPath, parsedPart};
 }
 
 export function importBackground(slidePath, dimensions, archive, report) {
@@ -75,7 +75,7 @@ export function importBackground(slidePath, dimensions, archive, report) {
     return undefined;
   };
   // Picture relationships belong to the part that holds the fill.
-  const context = {colors, mapping, image: fill => readImageBackground(fill, owner.path, archive, dimensions, report)};
+  const context = {colors, mapping, image: fill => readImageBackground(fill, owner.path, archive, dimensions, report, {colors, mapping})};
   if (background['p:bgPr']) return readNativeBackground(background['p:bgPr'], dimensions, report, context);
   const reference = background['p:bgRef'];
   if (!/^\d+$/.test(reference?.idx ?? '')) return unsupported();
@@ -93,7 +93,7 @@ export function importBackground(slidePath, dimensions, archive, report) {
   const style = styles?.[index < 1000 ? index - 1 : index - 1001];
   if (!style) return unsupported();
   context.placeholder = readBackgroundColor(reference, context);
-  context.image = fill => readImageBackground(fill, formatPath, archive, dimensions, report);
+  context.image = fill => readImageBackground(fill, formatPath, archive, dimensions, report, {colors, mapping});
   return readNativeBackground(drawingObject([style]), dimensions, report, context);
 }
 
@@ -108,7 +108,7 @@ const focusValue = value => Math.round(Math.max(0, Math.min(1, value)) * 10000)
 // the focus was, so it reads as the edge-most focus that gives the same crop); centered fill-rectangle insets that keep
 // the picture's aspect are `contain`; an uncropped fill of another aspect is `stretch`. Any other geometry or picture
 // effect is imported as the closest fit and reported.
-function readImageBackground(fill, partPath, {relationships, bytes}, dimensions, report) {
+function readImageBackground(fill, partPath, {relationships, bytes}, dimensions, report, context = {}) {
   const blip = fill['a:blip'] ?? {};
   const relationship = blip['r:embed'] && relationships(partPath).get(blip['r:embed']);
   const data = relationship && relationship.targetMode !== 'External' ? bytes(relationship.path) : undefined;
@@ -125,9 +125,12 @@ function readImageBackground(fill, partPath, {relationships, bytes}, dimensions,
   if (blip['a:grayscl'] !== undefined) recolor = 'grayscale';
   const duotone = blip['a:duotone'], literal = node => /^[\da-f]{6}$/i.test(node?.val ?? '') && Object.keys(node).every(key => key === 'val' || typeof key === 'symbol') ? `#${node.val.toUpperCase()}` : undefined;
   if (duotone) {
-    const colors = Array.isArray(duotone['a:srgbClr']) ? duotone['a:srgbClr'] : [];
-    const [dark, light] = colors.map(literal);
-    if (colors.length === 2 && dark && light && Object.keys(duotone).every(key => key === 'a:srgbClr' || typeof key === 'symbol')) recolor = {dark, light};
+    // RR-96: the two colors are literals or scheme colors (the export writes the scheme-derived ones as schemeClr); a scheme color reads as the color it stands for.
+    const kind = ['a:srgbClr', 'a:schemeClr'].find(name => Array.isArray(duotone[name]) && duotone[name].length === 2);
+    const colors = kind ? duotone[kind] : [];
+    const read = node => { if (kind === 'a:srgbClr') return literal(node); const resolved = readBackgroundColor({[kind]: node}, context); return resolved && resolved.alpha === 1 ? resolved.hex : undefined; };
+    const [dark, light] = colors.map(read);
+    if (colors.length === 2 && dark && light && Object.keys(duotone).every(key => key === kind || typeof key === 'symbol')) recolor = {dark, light};
     else approximate('uses a duotone recolor that is not two literal colours');
   }
   if (recolor && blip['a:grayscl'] !== undefined && duotone) approximate('uses both a grayscale and a duotone recolor');

package/dist/background.js

@@ -184,11 +184,28 @@ function readNativePattern(pattern, report, context) {
     ...(uniform && foreground.alpha !== 1 ? {opacity: foreground.alpha} : {})};
 }
 
+// The OPF slot an `a:schemeClr` with no color transform stands for through the color map (`bg1` stays the role), or undefined.
+// (OPF's theme-slot background is one of the four light and dark slots; an accent keeps its resolved color.)
+const SLOT_NAMES_BY_OOXML = {lt1: 'light1', dk1: 'dark1', lt2: 'light2', dk2: 'dark2'};
+function plainSchemeSlot(fill, context) {
+  const node = fill?.['a:schemeClr'];
+  if (!node || Array.isArray(node) || Object.keys(node).some(key => key.startsWith('a:'))) return undefined;
+  if (node.val === 'bg1') return !context.mapping?.bg1 || SLOT_NAMES_BY_OOXML[context.mapping.bg1] ? 'bg1' : undefined;
+  return SLOT_NAMES_BY_OOXML[context.mapping?.[node.val] ?? node.val];
+}
+
 export function readNativeBackground(properties, {width, height}, report = () => {}, context = {}) {
   if (!properties) return undefined;
   if (Object.hasOwn(properties, 'a:noFill')) return {type: 'solid', color: '#FFFFFF', opacity: 0};
   const solid = readBackgroundColor(properties['a:solidFill'], context);
-  if (solid) return {type: 'solid', color: solid.hex, ...(solid.alpha === 1 ? {} : {opacity: solid.alpha})};
+  if (solid) {
+    // RR-96: a plain scheme color is the theme slot it reaches through the color map (the OPF theme-slot background); bg1 is the variant's own
+    // background, which design.variant already carries, so it imports as no background of its own.
+    const slot = plainSchemeSlot(properties['a:solidFill'], context);
+    if (slot === 'bg1' && solid.alpha === 1) return undefined;
+    if (slot && slot !== 'bg1') return {type: 'theme', slot, ...(solid.alpha === 1 ? {} : {opacity: solid.alpha})};
+    return {type: 'solid', color: solid.hex, ...(solid.alpha === 1 ? {} : {opacity: solid.alpha})};
+  }
   if (properties['a:pattFill']) return readNativePattern(properties['a:pattFill'], report, context);
   if (properties['a:blipFill'] && context.image) return context.image(properties['a:blipFill']);
   const gradient = properties['a:gradFill'];

package/dist/chart-scheme-colors.js

@@ -12,13 +12,14 @@ const hex6 = value => String(value).replace(/^#/, '').toUpperCase();
  * maps a colour reference and its resolved hex to a scheme value when the deck theme holds that colour (theme-colors.js). A colour the
  * panel adjusted, a hex or variable entry and a tint (series 7 to 12) have none.
  */
-export function chartPaletteSchemes(colors, preferred, adjusted, schemeFor) {
+export function chartPaletteSchemes(colors, preferred, adjusted, schemeFor, accents) {
   const authored = Array.isArray(colors) ? colors : [];
   return preferred.map((color, index) => {
     if (hex6(color) !== hex6(adjusted[index])) return undefined;
     const entry = typeof authored[index] === 'string' ? authored[index].trim() : undefined;
     if (entry !== undefined) return /^[A-Za-z]/.test(entry) ? schemeFor(entry, hex6(color)) : undefined;
-    return index < 6 ? schemeFor(`accent${index + 1}`, hex6(color)) : undefined;
+    // RR-96: series i is the slot the variant's accent order puts at position i (accent i + 1 by default), and schemeFor names the role that slot has.
+    return index < 6 ? schemeFor(accents?.[index] ?? `accent${index + 1}`, hex6(color)) : undefined;
   });
 }
 

package/dist/chartex.js

@@ -171,7 +171,7 @@ const axisTitle = (value, text, run) => {
 
 function axes(spec, gridColor, text, titles = {}, run = {}, code) {
   if (!spec.axes) return '';
-  const gridlines = `<cx:majorGridlines><cx:spPr><a:ln w="9525"><a:solidFill><a:srgbClr val="${gridColor}"><a:alpha val="70000"/></a:srgbClr></a:solidFill></a:ln></cx:spPr></cx:majorGridlines>`;
+  const gridlines = `<cx:majorGridlines><cx:spPr><a:ln w="9525"><a:solidFill><a:srgbClr val="${gridColor}"/></a:solidFill></a:ln></cx:spPr></cx:majorGridlines>`;
   const gapWidth = {clusteredColumn: '0.06', paretoLine: '0.06', boxWhisker: '1', waterfall: '0.5', funnel: '0.06'}[spec.layoutId] ?? '1';
   // CT_Axis order: scaling, units, majorGridlines, tickLabels, spPr, txPr.
   const category = `<cx:axis id="0"><cx:catScaling gapWidth="${gapWidth}"/>${axisTitle(titles.category, text, run)}<cx:tickLabels/>${text}</cx:axis>`;
@@ -254,7 +254,7 @@ export function chartStyleXml({labelColor = '000000', gridColor = '000000', font
   // theme's tx1: PowerPoint applies the style part to chartex labels that carry no cx:txPr of their own.
   const textColor = `<a:srgbClr val="${labelColor}"/>`;
   const face = escapeXml(font);
-  const faintLine = `<a:ln w="9525" cap="flat" cmpd="sng" algn="ctr"><a:solidFill><a:srgbClr val="${gridColor}"><a:alpha val="70000"/></a:srgbClr></a:solidFill><a:round/></a:ln>`;
+  const faintLine = `<a:ln w="9525" cap="flat" cmpd="sng" algn="ctr"><a:solidFill><a:srgbClr val="${gridColor}"/></a:solidFill><a:round/></a:ln>`;
   const entry = (name, {fillIdx = '0', fillColor = '', fontColor = textColor, spPr = '', size = '', mods = ''} = {}) =>
     `<cs:${name}${mods ? ` mods="${mods}"` : ''}><cs:lnRef idx="0"/><cs:fillRef idx="${fillIdx}">${fillColor}</cs:fillRef><cs:effectRef idx="0"/><cs:fontRef idx="minor">${fontColor}</cs:fontRef>${spPr ? `<cs:spPr>${spPr}</cs:spPr>` : ''}${size ? `<cs:defRPr sz="${size}" kern="1200">${solidFill(labelColor)}<a:latin typeface="${face}"/><a:ea typeface="${face}"/><a:cs typeface="${face}"/></cs:defRPr>` : ''}</cs:${name}>`;
   const entries = STYLE_ENTRIES.map(name => {

package/dist/image-provenance.js

@@ -151,7 +151,7 @@ export function pictureFrame(metadata, {box, fit, focus = {x: .5, y: .5}, shrink
  * picture's objectName, or 'background' for the overlay of a native slide background fill; `overlay` (the authored value)
  * is stored in OPF_IMAGE_OVERLAY_V1.
  */
-export function placeImages(entries, images, overlays, {metadataFor, fail, fitImage, mediaKeyFor}) {
+export function placeImages(entries, images, overlays, {metadataFor, fail, fitImage, mediaKeyFor, finish = (_part, xml) => xml}) {
   if (!images.size && !overlays.size) return;
   const manifests = new Map(), overlayManifests = new Map(), placed = new Set(), shaped = new Set();
   for (const part of Object.keys(entries).filter(path => /^ppt\/slides\/slide\d+\.xml$/.test(path))) {
@@ -176,6 +176,8 @@ export function placeImages(entries, images, overlays, {metadataFor, fail, fitIm
         const blip = blipEffects(effects);
         if (blip) picture = picture.replace(/<a:blip\b([^>]*?)(?:\/>|>([\s\S]*?)<\/a:blip>)/, (_, attributes, inner = '') => `<a:blip${attributes}>${blip}${inner}</a:blip>`);
       }
+      // RR-96: the colours the treatment wrote become scheme colours before the manifest fingerprints the shape.
+      picture = finish(part, picture);
       placed.add(name);
       if (image.treatment !== undefined) {
         const node = parser.parse(picture)['p:pic'];
@@ -191,6 +193,7 @@ export function placeImages(entries, images, overlays, {metadataFor, fail, fitIm
       if (!overlay) return shape;
       const emu = value => Math.round(value / 96 * EMUS_PER_INCH);
       shape = shape.replace(/<p:spPr>[\s\S]*?<\/p:spPr>/, `<p:spPr><a:xfrm><a:off x="${emu(overlay.box.x)}" y="${emu(overlay.box.y)}"/><a:ext cx="${emu(overlay.box.width)}" cy="${emu(overlay.box.height)}"/></a:xfrm>${presetXml(overlay.shape)}<a:solidFill>${colorXml(overlay, overlay.opacity)}</a:solidFill><a:ln><a:noFill/></a:ln></p:spPr>`);
+      shape = finish(part, shape);
       const node = parser.parse(shape)['p:sp'];
       overlayManifests.set(name, {v: 1, slide: overlay.slide, owner: overlay.owner, overlay: overlay.overlay, properties: node['p:spPr']});
       shaped.add(name);

package/dist/index.js

@@ -42,17 +42,17 @@ import {dedupeMedia, mediaKey} from './media-dedupe.js';
 import {placeWatermarks, importWatermark, importTextWatermark, tagTextWatermarks, watermarkName, watermarkTextName, watermarkBox, watermarkOpacity} from './watermark-provenance.js';
 import {placeLogos, importLogo, importLogoPlaceholders, logoName, LOGO_TAG} from './logo-provenance.js';
 import {nativeBackgroundFill, nativeImageBackgroundFill, nativePatternPreset} from './background.js';
-import {importBackground} from './background-import.js';
+import {importBackground, readSlideTheme} from './background-import.js';
 import {chartHighlightPlan, applyChartHighlight} from './chart-highlight.js';
 import {orderChartSeries} from './chart-order.js';
-import {themeSlotColors, writeThemeColors, schemeColorValue, schemeBackgroundFill, schemeBackgroundValue, defaultTextSchemeValues, tableTextSchemeValue, solidColorXml, writeMasterBackground, inheritLayoutBackground, readThemeSlotColors, recoverColorScheme, recoverTheme, presentationThemePath} from './theme-colors.js';
+import {themeSlotColors, schemeColorTable, writeSchemeColors, authoredLiteralColors, writeThemeColors, schemeColorValue, schemeBackgroundFill, schemeBackgroundValue, defaultTextSchemeValues, tableTextSchemeValue, solidColorXml, writeMasterBackground, inheritLayoutBackground, readThemeSlotColors, recoverColorScheme, recoverTheme, presentationThemePath, variantFromColorMap} from './theme-colors.js';
 import {languageDiagnostics, observeLanguage, observedRtl, partScriptFonts, physicalAlignment, planScriptFonts, planSlideThemes, reconcileLanguage, reportPerSlideNotesScriptFonts, runLanguageFonts, runLanguageTag, stripRunScriptFonts, themeEastAsianFromLatin} from './script-fonts.js';
 import { webpToPng, svgToPng, readLocalFile, localFileReadable } from '#image-fallback';
 import { prepareSvg, svgDataUriBytes, svgRasterScale, svgBlipRelationship, attachSvgPictures } from './svg-image.js';
 import { chartPaletteSchemes, applyChartSchemeColors } from './chart-scheme-colors.js';
 import { rasterMetadata, pictureTransform, normalizeImageOrientation } from './image-geometry.js';
 import {
-  catalogRecords, chartPaletteForFill, chartSeriesPalette, codeHighlightBands, codeHighlightColors, codeHighlightLines, codeLineNumbers, codeLineRuns, codeSyntaxPaletteForScheme, composeSlide,
+  catalogRecords, clrMapAttributes, normalizeColorVariant, chartPaletteForFill, chartSeriesPalette, chartTextSize as coreChartTextSize, codeHighlightBands, codeHighlightColors, codeHighlightLines, codeSyntaxPaletteForRoles, readableSchemeColor, codeLineNumbers, codeLineRuns, codeSyntaxPaletteForScheme, composeSlide,
   ENGINE_DEFAULT_FONT_SCHEME, defaultSlideBackground, fitImage, fitText, layoutTable, layoutWatermark, metricTrendMark, resolveCanvasDimensions, resolveColorRoles, resolveFontFamilies,
   resolveChartColors, resolveReference, resolveScriptFonts, resolveTextStyle, textColorForFill, textWidthMeasurer, timelineMarkerShapes, timelineTextColor, tokenizeCode
 } from "@openpresentation/opf/composition";
@@ -334,6 +334,14 @@ export async function toPptx(input, options = {}) {
     return slide.section;
   });
   context.masterBackground = masterBackground(context);
+  // RR-96: the master's clrMap is the deck variant's map (a dark deck is the dark map, not hand-inverted colors); a slide whose variant
+  // differs writes its own override (exportSlideContext).
+  context.clrMap = context.roles.map ? clrMapAttributes(context.roles.map) : undefined;
+  context.clrMapOverrides = new Map();
+  // RR-96: the scheme-derived colors of the deck (master and layouts) and of each slide (its parts and charts), rewritten to schemeClr in the finished parts.
+  const authoredLiterals = authoredLiteralColors(presentation.variables, {...presentation.design, colorScheme: undefined, theme: undefined});
+  context.deckSchemeColors = {table: schemeColorTable(context), keep: authoredLiterals};
+  context.slideSchemeColors = [];
   context.linkSentinels = linkSentinels(presentation);
   const pptx = new PptxGenJS();
   configurePresentation(pptx, presentation, {...context,fonts:exportSlideContext(presentation,0,context,options).fonts});
@@ -567,6 +575,8 @@ export async function fromPptx(input, options = {}) {
   restoreCitations(imported, furnitureContexts.map(context => context.annotations?.notes ?? []), report);
   restoreLogoFallback(imported, furnitureContexts);
   applyRunColors(imported, slideProvenance, restoredGroups, report, options);
+  restoreSlotFills(imported, slideProvenance, options);
+  dropImpliedVariants(imported, options);
   applyNativeImageFits(imported, furnitureContexts, restoredGroups, options);
   if (imported.design?.theme === undefined) for (const diagnostic of themeDesign.diagnostics) if (diagnostic.code === "theme-unverified") report(diagnostic);
   languageDiagnostics(imported, observedLanguage, options.onDiagnostic && report);
@@ -607,6 +617,66 @@ function applyRunColors(imported, slideProvenance, restoredGroups, report, optio
   restoreRunColors(imported.slides, info, resolve, report);
 }
 
+// RR-96: the variant a color map imports as is dropped where the document's own design already gives that map: core picks light1 or dark1 from the
+// slide background (a dark theme is the dark map), so a deck that is dark by its theme, and a slide that is dark by its own background, need no `variant`.
+function dropImpliedVariants(imported, options) {
+  const rolesVariant = design => {
+    try { return JSON.stringify(coreContext({...imported, design, slides: [{}]}, 0, {...options, textMeasurement: undefined}).resolved.roles?.variant); } catch { return undefined; }
+  };
+  const withoutVariant = design => { const {variant, ...rest} = design ?? {}; return rest; };
+  if (imported.design?.variant !== undefined) {
+    const implied = rolesVariant(withoutVariant(imported.design));
+    if (implied !== undefined && implied === JSON.stringify(normalizeColorVariant(imported.design.variant))) {
+      const {variant, ...rest} = imported.design;
+      if (Object.keys(rest).length) imported.design = rest; else delete imported.design;
+    }
+  }
+  for (const slide of imported.slides) {
+    if (slide.design?.variant === undefined) continue;
+    const rest = withoutVariant(slide.design);
+    const implied = rolesVariant({...imported.design, ...rest});
+    if (implied !== undefined && implied === JSON.stringify(normalizeColorVariant(slide.design.variant))) {
+      if (Object.keys(rest).length) slide.design = rest; else delete slide.design;
+    }
+  }
+}
+
+// RR-96: a fill that is exactly a slot of the slide's color scheme comes back as that slot (`accent1`, `light2`, ...), the way a PowerPoint scheme
+// fill is a theme color. Table cell and column fills only; a literal that is not a slot stays a literal.
+const FILL_SLOT_ORDER = ['accent1', 'accent2', 'accent3', 'accent4', 'accent5', 'accent6', 'dark1', 'light1', 'dark2', 'light2'];
+function restoreSlotFills(imported, slideProvenance, options) {
+  const names = new Map();
+  const slotsOf = slide => {
+    const key = slide.design ?? imported.design ?? null;
+    if (!names.has(key)) {
+      let table = new Map();
+      try {
+        const context = resolvePresentationContext(slide.design ? {...imported, design: {...imported.design, ...slide.design}} : imported, options);
+        const slots = themeSlotColors(context.colorScheme);
+        for (const slot of FILL_SLOT_ORDER) if (slots[slot] && !table.has(slots[slot])) table.set(slots[slot], slot);
+      } catch { table = new Map(); }
+      names.set(key, table);
+    }
+    return names.get(key);
+  };
+  const visit = (value, table) => {
+    if (Array.isArray(value)) { value.forEach(item => visit(item, table)); return; }
+    if (!isPlainObject(value)) return;
+    if (typeof value.fill === 'string') {
+      const hex = value.fill.match(/^#([0-9a-f]{6})$/i)?.[1]?.toUpperCase();
+      const slot = hex && table.get(hex);
+      if (slot) value.fill = slot;
+    }
+    for (const child of Object.values(value)) visit(child, table);
+  };
+  // A slide restored from provenance keeps its authored values (a literal that happens to equal a slot stays the literal).
+  for (const [index, slide] of imported.slides.entries()) {
+    if (slideProvenance[index]?.structure !== 'untagged') continue;
+    const containers = [slide.table, ...asArray(slide.blocks).map(block => block?.table), ...Object.values(slide).flatMap(region => isPlainObject(region) ? [region.table] : [])].filter(Boolean);
+    if (containers.length) { const table = slotsOf(slide); if (table.size) containers.forEach(container => visit(container, table)); }
+  }
+}
+
 // A consumed logo picture (OPF_LOGO_V1) never becomes content. Its own image restores the organization's logo only when the
 // stored document did not (RR-71: logos live on the organization), so a package exported without provenance still keeps its
 // logo: on the primary organization, else on a new one named after the deck. The picture is one drawn asset, so it becomes the
@@ -809,7 +879,31 @@ function importSlide(entries, slidePath, slideIndex, presentationDimensions, opt
     images.consumedShapes.delete(images.backgroundOverlayShape);
     options.onDiagnostic?.({code: 'invalid-image-provenance', path: `slides.${slideIndex}.design.background.overlay`, message: 'The tagged OPF background overlay no longer sits on an image background; it was imported as an ordinary shape.'});
   }
-  if (imageBackground) slide.design = {background: imageBackground};
+  // RR-96: the tone scrim of a picture background is no content; it restores the background's tone.
+  let toned = imageBackground;
+  if (imageBackground?.type === 'image') {
+    for (const tone of ['dark', 'light']) {
+      const index = nativeContext.shapes.findIndex(shape => shape['p:nvSpPr']?.['p:cNvPr']?.name === toneScrimName(`slides.${slideIndex}`, tone));
+      if (index >= 0) { images.consumedShapes.add(index); toned = {...imageBackground, tone}; }
+    }
+  }
+  if (toned) slide.design = {background: toned};
+  // RR-96: a slide's own color map override (accents included) is its variant. An override that is the master's map imports nothing, one that is
+  // the default map on a dark master is the explicit `light1`.
+  {
+    const {mapping, masterMapping} = readSlideTheme(slidePath, {
+      part: (path, parser) => parseRequiredXml(entries, path, parser), relationships: path => parseRelationships(entries, path), bytes: path => entries[path]
+    });
+    const sameMap = [...new Set([...Object.keys(mapping), ...Object.keys(masterMapping)])].every(key => mapping[key] === masterMapping[key]);
+    if (!sameMap) {
+      const mapped = variantFromColorMap(mapping, {explicit: true});
+      // The variant a tone names is the tone's, not a second statement of it.
+      const tone = slide.design?.background?.tone, impliedByTone = tone && mapped.variant === (tone === 'dark' ? 'dark1' : 'light1');
+      if (impliedByTone) { /* the tone names this variant */ }
+      else if (mapped.variant) slide.design = {...slide.design, variant: mapped.variant};
+      else if (mapped.unsupported) options.onDiagnostic?.({code: "unsupported-color-map", path: `slides.${slideIndex}.design.variant`, message: "The slide's color map override is not a variant OPF can name, so slides[n].design.variant was not imported."});
+    }
+  }
   if (Object.keys(furniture.design).length) slide.design = {...slide.design, ...furniture.design};
   nativeContext.imageBlocks = images.blocks;
   nativeContext.imageSources = images.sources;
@@ -1912,10 +2006,20 @@ function resolvePresentationContext(presentation, options, core = coreContext({.
   const {theme, colorScheme} = core.resolved;
   const dimensions = {widthInches: core.options.width / 96, heightInches: core.options.height / 96};
   const variables = resolveVariableColors(presentation.variables);
-  const background = resolveBackground(design.background ?? theme?.background, colorScheme, variables);
+  const definition = design.background ?? theme?.background;
   const fonts = exportFonts(core, options.textMeasurement);
-  // One resolution for every color role (core resolveColorRoles), shared with the SVG preview and the audit.
-  const roles = resolveColorRoles(colorScheme, {background: `#${background}`});
+  // One resolution for every color role, shared with the SVG preview and the audit: core's, which maps the roles through the slide's
+  // variant (RR-96: bg1, tx1, bg2, tx2 and the accent order over the one scheme, the neutrals as slot plus luminance transform).
+  // A core older than the variants has no `resolved.roles`; its roles are resolved from the background as before.
+  let background = resolveBackground(definition, colorScheme, variables);
+  let roles = core.resolved.roles ?? resolveColorRoles(colorScheme, {background: `#${background}`});
+  // A single-color background is the slide's bg1 under its variant, which can differ from the background definition (a deck
+  // variant hides the theme's background); a picture, gradient or pattern keeps its own base color.
+  // A theme-slot background (the theme's own, or a slot name) with no variant keeps the slot's color: the scheme's `background` role does not
+  // restyle it, as the preview draws it.
+  const slotBackground = design.variant === undefined && (typeof definition === 'string' || definition?.type === 'theme');
+  if (core.resolved.roles && isSingleColorBackground(definition) && !slotBackground) background = normalizeHex(roles.background);
+  else if (slotBackground && roles.background !== `#${background}`) roles = {...roles, background: `#${background}`};
   const textColor = normalizeHex(roles.text);
 
   return {
@@ -2022,6 +2126,11 @@ function writeLinkSentinels(xml, sentinels) {
   });
 }
 
+// RR-96: the master's clrMap from the deck variant's map (core clrMapAttributes: bg1, tx1, bg2, tx2, the six accents and the two link slots).
+function writeColorMap(xml, attributes) {
+  return xml.replace(/<p:clrMap\b[^>]*\/>/, `<p:clrMap${Object.entries(attributes).map(([role, slot]) => ` ${role}="${slot}"`).join('')}/>`);
+}
+
 // PptxGenJS color option: a scheme value it can emit (tx1, bg2, ...) or RRGGBB.
 function pptxColor(value) {
   return /^(?:tx[12]|bg[12]|accent[1-6])$/.test(value) ? value : normalizeHex(value);
@@ -2064,6 +2173,16 @@ function hostDefaultRecords(kind, catalogs) {
 function importThemeDesign(entries, presentationRoot, presentationRels, catalogs) {
   const diagnostics = [], design = {};
   const report = (code, path, message) => diagnostics.push({code, path, message});
+  // RR-96: the first slide master's clrMap is the deck's variant (a dark deck is bg1 on dk1 and tx1 on lt1), as design.variant: the background slot
+  // alone, or {background, accents} when the map re-points the accents. The default map imports nothing.
+  const masterId = asArray(presentationRoot?.["p:sldMasterIdLst"]?.["p:sldMasterId"]).map(node => node?.["r:id"]).find(id => presentationRels.get(id)?.type?.endsWith("/slideMaster"));
+  const masterPart = masterId ? presentationRels.get(masterId).path : undefined;
+  const masterMap = masterPart && entries[masterPart] ? parseOptionalXml(entries, masterPart)?.["p:sldMaster"]?.["p:clrMap"] : undefined;
+  if (masterMap) {
+    const mapped = variantFromColorMap(masterMap);
+    if (mapped.variant) design.variant = mapped.variant;
+    else if (mapped.unsupported) report("unsupported-color-map", "design.variant", "The slide master's color map is not a variant OPF can name (a background and text on the light and dark slots, with an accent order that is a permutation of accent1 to accent6), so design.variant was not imported.");
+  }
   const themePath = presentationThemePath(presentationRoot, presentationRels, path => parseRelationships(entries, path), entries);
   const theme = themePath ? parseOptionalXml(entries, themePath)?.["a:theme"] : undefined;
   const elements = theme?.["a:themeElements"];
@@ -2300,6 +2419,11 @@ function exportSlideContext(presentation, slideIndex, baseContext, options) {
     throw new OPFPptxError("mixed-slide-dimensions", "PowerPoint requires one canvas size per presentation. Set dimensions on the deck or export this slide separately.");
   }
   const slideContext = { ...baseContext, core, composeFonts: {...core.options.fontFamilies, heading: resolved.fonts.heading, body: resolved.fonts.body, code: resolved.fonts.code}, backgroundDefinition: resolved.backgroundDefinition, colorScheme: resolved.colorScheme, fonts: resolved.fonts, colors: resolved.colors, roles: resolved.roles, variables: resolved.variables };
+  // RR-96: a slide whose variant differs from the deck's writes its own clrMapOvr (accent order included).
+  if (resolved.roles.map && baseContext.clrMap) {
+    const attributes = clrMapAttributes(resolved.roles.map);
+    if (JSON.stringify(attributes) !== JSON.stringify(baseContext.clrMap)) baseContext.clrMapOverrides.set(`ppt/slides/slide${slideIndex + 1}.xml`, attributes);
+  }
   // 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 ?? {};
@@ -2309,6 +2433,7 @@ function exportSlideContext(presentation, slideIndex, baseContext, options) {
   const text = defaultTextSchemeValues(slideContext);
   slideContext.textColor = text.text ?? resolved.colors.text;
   slideContext.mutedColor = text.muted ?? resolved.colors.mutedText;
+  baseContext.slideSchemeColors[slideIndex] = {table: schemeColorTable(slideContext), keep: authoredLiteralColors(slide, presentation.variables, {...effective.design, colorScheme: undefined, theme: undefined})};
   return slideContext;
 }
 
@@ -2587,6 +2712,9 @@ async function addImageItem(slide, presentation, item, slideIndex, context, opti
   return name;
 }
 
+const TONE_SCRIM_OPACITY = 0.4;
+const toneScrimName = (slidePath, tone) => `OPF background tone ${tone} ${slidePath}`;
+
 // An image background (core SlideComposition.backgroundImage). With alt text it is a full-slide picture at the back of
 // the slide over the canvas colour, carrying the alt text as its descr; without alt it is the native slide background
 // fill (written at packaging). Its overlay is one shape directly above the picture.
@@ -2623,6 +2751,12 @@ async function addBackgroundImage(slide, presentation, background, slideIndex, s
       width: box.w * 96, height: box.h * 96, report: options.onDiagnostic
     } });
   }
+  // RR-96: a picture background that names its tone (and has no overlay of its own) is a picture the text must read on: the slide background
+  // color of the tone's variant (bg1) covers it at 40%, the preview's scrim (opf-render `data-opf-tone-overlay`).
+  const tone = isPlainObject(authored) ? authored.tone : undefined;
+  if (!background.overlay && (tone === 'dark' || tone === 'light')) {
+    slide.addShape('rect', { x: box.x, y: box.y, w: box.w, h: box.h, objectName: toneScrimName(slidePath, tone), fill: { color: normalizeHex(slideContext.roles?.background ?? `#${slideContext.colors.background}`), transparency: 100 - TONE_SCRIM_OPACITY * 100 } });
+  }
   if (background.overlay) addImageOverlay(slide, background.overlay, structuredClone(isPlainObject(authored) ? authored.overlay : undefined) ?? {color: background.overlay.color, opacity: background.overlay.opacity}, overlayName, owner, { ...slideContext, slidePath }, effects);
 }
 
@@ -2695,17 +2829,17 @@ async function addLogo(slide, presentation, logo, slideIndex, slideContext, cont
   slide.addImage({...resolved, objectName: logoName(), ...region, altText: assetAlt(logo.source, presentation) ?? 'Logo'});
 }
 
-// FF-62: chart text is one size. The preview draws every chart label (axis, legend, data label) at
-// max(14, composition.minFontSize ?? 16) px scaled by the slide's shorter side over 720 px (renderer charts.js, `fontPx`),
-// the readability floor: 12 pt on a 13.33 x 7.5 in slide. The export writes that size, in hundredths of a point (DrawingML `sz`).
-// RR-16: core composes every font size on PowerPoint's 0.01 pt grid (1/75 px), so the preview draws the grid size, not the raw
-// product: the floor rounds up (core `snapFontSizeUp`) and an unfloored request of 14 px rounds down (`snapFontSizeDown`).
-// Math.round differed from the preview by 0.01 pt on slide sizes whose scale is not a whole number (A4, Letter, 16:10).
-function chartTextSize(context) {
+// FF-62, RR-90: chart text is one size, core's `chartTextSize` for the chart's box: 20 px at the 1280 x 720 reference (15 pt on a 13.33 x 7.5 in
+// slide), shrunk only when the box is small (at most 1/18 of its height and 1/30 of its width, whole pixels) and never below
+// `composition.minFontSize` (default 16), scaled by the slide's shorter side over 720 px. The preview (opf-render charts.js) and core's value-axis
+// density call the same function with the same inputs, so the axis core composed matches the text drawn. The export writes the size in hundredths
+// of a point (DrawingML `sz`) on core's 0.01 pt grid, as core composes every font size (RR-16): the request rounds down, never below the
+// grid-rounded floor (core `gridFontSize`, `snapFontSizeUp(floor)` against `snapFontSizeDown(request)`).
+function chartTextHundredths(context, region) {
   const scale = Math.min(context.dimensions.widthInches, context.dimensions.heightInches) * 96 / 720;
   const floor = context.composition?.minFontSize ?? 16;
-  const hundredths = Math.max(14, floor) * scale * 75;
-  return floor >= 14 ? Math.ceil(hundredths - 1e-6) : Math.floor(hundredths + 1e-6);
+  const px = coreChartTextSize({width: region.w * 96, height: region.h * 96, scale, minFontSize: floor});
+  return Math.max(Math.ceil(floor * scale * 75 - 1e-6), Math.floor(px * scale * 75 + 1e-6));
 }
 
 // Every c:txPr of a generated classic chart carries the chart text size: PptxGenJS writes no size on the legend (PowerPoint's
@@ -2734,12 +2868,18 @@ function addChartPayload(slide, chart, region, context, options = {}, path = "ch
   // Keep the resolved palette surface (including alpha) explicit in native
   // chart/plot areas, so inherited labels are assessed against their own panel.
   const panelFill = context.colorScheme.surface ?? context.colorScheme[context.roles.dark ? 'dark2' : 'light2'] ?? `#${context.colors.surface}`;
-  const labelColor = normalizeHex(textColorForFill(panelFill, `#${context.colors.text}`));
+  // RR-96: chart text, gridlines and axis lines are core's scheme-derived neutrals (tx1 mixed into bg1 at 65%, 15% and 25%), which the finished
+  // part writes as schemeClr with lumMod/lumOff, so a variant or background style change in PowerPoint recolors them.
+  const neutrals = context.roles.neutrals;
+  const labelColor = normalizeHex(textColorForFill(panelFill, neutrals?.chartText?.hex ?? `#${context.colors.text}`));
+  // Data labels and highlighted marks contrast with their own mark, from the full text colour (the chart-text neutral is for axes and legends).
+  const markLabelColor = normalizeHex(textColorForFill(panelFill, `#${context.colors.text}`));
+  const gridColor = normalizeHex(neutrals?.gridline?.hex ?? `#${context.colors.border}`), axisLineColor = normalizeHex(neutrals?.axisLine?.hex ?? `#${context.colors.border}`);
   const transparency = /^#[0-9a-f]{8}$/i.test(panelFill) ? (1 - parseInt(panelFill.slice(7), 16) / 255) * 100 : 0;
   const fill = {color:normalizeHex(panelFill),transparency};
   const objectName = `OPF chart ${context.chartHeadings.size + 1}`;
   const circular = chartData.type === 'pie' || chartData.type === 'doughnut';
-  const textSize = chartTextSize(context);
+  const textSize = chartTextHundredths(context, region);
   // RR-54: the columns' number formats (Excel codes per exported series) for the caches, labels, value axis and workbook.
   // The value axis shows the first plotted series' format (General when it has none), as the preview does.
   // A combo chart's secondary value axis shows its first series' format (FA-15).
@@ -2747,7 +2887,7 @@ function addChartPayload(slide, chart, region, context, options = {}, path = "ch
   const numberFormats = chartData.formats && {...chartData.formats, axis: chartData.spec.grouping === 'percentStacked' ? undefined : chartData.formats.series[0],
     ...(secondaryIndex >= 0 ? {secondaryAxis: chartData.formats.series[secondaryIndex]} : {}),
     labels: !chartOptions?.dataLabels?.content?.includes('percent'), scatter: chartData.type === 'scatter'};
-  context.chartHeadings.set(objectName,{heading:chartData.type === 'scatter' ? undefined : chartData.heading,labelColor,spec:chartData.spec,textSize,
+  context.chartHeadings.set(objectName,{heading:chartData.type === 'scatter' ? undefined : chartData.heading,labelColor,markLabelColor,spec:chartData.spec,textSize,
     options:chartOptions,kind:chartTargetFor(chart.type)?.kind,pointCount:chartData.pointCount,numberFormats});
   // Synthetic row-number categories are a native adaptation, not an authored
   // data column. Full provenance restores the source form only on unchanged caches.
@@ -2758,15 +2898,15 @@ function addChartPayload(slide, chart, region, context, options = {}, path = "ch
   // RR-89: the series colours are core's chartSeriesPalette (accent1 to accent6 of the deck scheme, then their tints, with the chart's own
   // `colors` over them), adjusted for the chart panel like the preview does. A colour that is still an unadjusted theme accent (or a
   // `chart.colors` scheme slot or role) is written as a schemeClr, so re-theming in PowerPoint recolours the series.
-  const colorContext = {roles: context.roles, variables: context.variables};
+  const colorContext = {roles: context.roles, variables: context.variables, accents: context.roles.map?.accents};
   const preferredPalette = chartSeriesPalette(context.colorScheme, chart.colors, colorContext);
   const adjustedPalette = chartPaletteForFill(panelFill, preferredPalette);
   const palette = adjustedPalette.map(color=>normalizeHex(color));
-  const paletteSchemes = chartPaletteSchemes(chart.colors, preferredPalette, adjustedPalette, (reference, hex) => schemeColorValue(reference, `#${hex}`, context));
+  const paletteSchemes = chartPaletteSchemes(chart.colors, preferredPalette, adjustedPalette, (reference, hex) => schemeColorValue(reference, `#${hex}`, context), context.roles.map?.accents);
   Object.assign(context.chartHeadings.get(objectName), {palette, paletteSchemes, circular});
   // FA-14: chart.highlight. A highlighted chart writes accent and muted colours over the series palette, and its data labels
   // contrast with those colours (src/chart-highlight.js).
-  const highlight = chartData.chartex ? undefined : chartHighlightPlan({options: chartOptions, data: chartData.resolved, kind: chartTargetFor(chart.type)?.kind, panelFill, labelColor, primary: `#${context.colors.accent}`,
+  const highlight = chartData.chartex ? undefined : chartHighlightPlan({options: chartOptions, data: chartData.resolved, kind: chartTargetFor(chart.type)?.kind, panelFill, labelColor: markLabelColor, primary: `#${context.colors.accent}`,
     schemeFor: hex => schemeColorValue('primary', hex, context)});
   context.chartPalettes.set(objectName,highlight ? highlight.seriesFills : palette);
   if (highlight) context.chartHeadings.get(objectName).highlight = highlight;
@@ -2774,7 +2914,7 @@ function addChartPayload(slide, chart, region, context, options = {}, path = "ch
     // The native chartex part is added when the package is normalized (attachChartexParts); the classic chart below becomes its fallback.
     // PptxGenJS rewrites the series it is given (labels become nested levels), so the chartex part keeps its own copy.
     const series = chartData.series.map((entry) => ({name: entry.name, labels: [...entry.labels], values: [...entry.values]}));
-    context.chartex.set(objectName, {spec: chartData.chartex, series, hasCategories: chartData.hasCategories, fill, labelColor, gridColor: context.colors.border, font: context.fonts.body, palette, textSize, options: chartOptions, ...(numberFormats ? {formats: numberFormats.series} : {})});
+    context.chartex.set(objectName, {spec: chartData.chartex, series, hasCategories: chartData.hasCategories, fill, labelColor, gridColor, font: context.fonts.body, palette, textSize, options: chartOptions, ...(numberFormats ? {formats: numberFormats.series} : {})});
     if (chartData.chartex.layoutId === 'regionMap') {
       options.onDiagnostic?.({code: "chart-map-geodata", path, message: `The '${stringifyText(chart.type)}' chart is exported as a native PowerPoint map (chartex regionMap) without cached geography (no cx:geoCache; provider data is never fabricated): PowerPoint must fetch the region shapes from its online map service when the deck is opened, and until it does it shows "There was a problem getting the information for your map chart" and draws nothing. The clustered column fallback shows the same values in readers without chartex support.`});
     }
@@ -2807,10 +2947,13 @@ function addChartPayload(slide, chart, region, context, options = {}, path = "ch
     legendColor: labelColor,
     legendFontFace: context.fonts.body,
     legendFontSize: textSize / 100,
-    dataLabelColor: labelColor,
+    dataLabelColor: markLabelColor,
     dataLabelFontSize: textSize / 100,
     showValue: false,
-    valGridLine: { color: context.colors.border, transparency: 30, size: 1 },
+    ...(circular ? {dataBorder: {color: normalizeHex(neutrals?.outline?.hex ?? `#${context.colors.background}`), pt: 0.75}} : {}),
+    valGridLine: { color: gridColor, size: 1 },
+    catAxisLineColor: axisLineColor,
+    valAxisLineColor: axisLineColor,
     // Magnitude bars/columns/areas must not let Office auto-truncate a near-equal range.
     ...(chartData.spec.family === "category" && ["bar", "area"].includes(chartData.type) && chartData.spec.grouping !== "percentStacked" ? {
       ...(chartData.series.every(entry => entry.values.every(value => value == null || value >= 0)) ? {valAxisMinVal: 0} : {}),
@@ -2903,7 +3046,8 @@ function addTablePayload(slide, authoredTable, region, context, options, path, p
     // 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}`);
+    // RR-96: header text is the role (bg1 or tx1) that reads better on the fill, as the preview chooses it (core readableSchemeColor).
+    const inheritedText = header && context.roles ? readableSchemeColor(`#${baseFill}`, context.roles).hex : 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;
@@ -3199,7 +3343,8 @@ function addCodePayload(slide, value, layout, region, context, path, options) {
   const highlight = codeHighlight(value, layout, context);
   context.codeTags.set(panelName,codeManifest(value,layout,group,highlight?.bands.length));
   const syntax = codeSyntax(value, layout, context, path, options);
-  slide.addShape('rect', {...region, fill: {color: '111827'}, line: {color: '334155', width: .75}, objectName:panelName});
+  const palette = codePalette(context);
+  slide.addShape('rect', {...region, fill: {color: codePanelColor(context).slice(1)}, line: {color: context.roles.neutrals?.codePanel ? context.colors.border : '334155', width: .75}, objectName:panelName});
   if (highlight) {
     const bodyPart = layout.parts.find(part => part.role === 'body');
     highlight.bands.forEach((band, bandIndex) => {
@@ -3223,7 +3368,7 @@ function addCodePayload(slide, value, layout, region, context, path, options) {
       const lineOptions = {
         ...textBoxOptions({x:part.box.x/96,y:(part.box.y+index*part.fit.lineHeight)/96,w:part.box.width/96,h:part.fit.lineHeight/96},context,part.fit.fontSize*.75),
         ...nativeFontOptions(part.style),
-        color:part.role==='body'?(lineColors?.plain.slice(1)??'E5E7EB'):'93C5FD',align:'left',fit:'none',wrap:false,lineSpacingMultiple:1,
+        color:part.role==='body'?(lineColors?.plain.slice(1)??palette.plain.slice(1)):palette.keyword.slice(1),align:'left',fit:'none',wrap:false,lineSpacingMultiple:1,
         tabStops:tabStops.length?tabStops:undefined,objectName,
       };
       // A run's own options replace the line's, so every run repeats the font, size, alignment and tab stops and differs only in colour.
@@ -3240,7 +3385,7 @@ function codeHighlight(value, layout, context) {
   if (!body?.fit) return undefined;
   const lines = codeHighlightLines(value.highlight, body.text).lines;
   if (!lines.length) return undefined;
-  return {marked: new Set(lines), numbers: codeLineNumbers(body.fit.sourceLines), bands: codeHighlightBands(body.fit.sourceLines, lines), colors: codeHighlightColors(context.colorScheme)};
+  return {marked: new Set(lines), numbers: codeLineNumbers(body.fit.sourceLines), bands: codeHighlightBands(body.fit.sourceLines, lines), colors: codeHighlightColors(context.colorScheme, codePalette(context), codePanelColor(context))};
 }
 
 // Token ranges and palette for the code body, from core (the preview calls the same functions); undefined for plain code.
@@ -3249,14 +3394,23 @@ function codeSyntax(value, layout, context, path, options) {
   const language = typeof value?.language === 'string' ? value.language : layout.parts.find(part => part.role === 'language')?.text;
   if (!body || !language) return undefined;
   const tokens = tokenizeCode(body.text, language);
-  return tokens.length ? {tokens, palette: codeSyntaxPaletteForScheme(context.colorScheme)} : undefined;
+  return tokens.length ? {tokens, palette: codePalette(context)} : undefined;
+}
+
+// RR-96: the code panel, plain text, comment and syntax colors are the slide's own roles through its variant (core codeSyntaxPaletteForRoles, the
+// panel `roles.neutrals.codePanel`), written as scheme colors in the finished slide; an older core keeps the fixed palette.
+function codePalette(context) {
+  return context.roles.neutrals?.codePanel ? codeSyntaxPaletteForRoles(context.roles) : codeSyntaxPaletteForScheme(context.colorScheme);
+}
+function codePanelColor(context) {
+  return context.roles.neutrals?.codePanel?.hex ?? '#111827';
 }
 
 function addMetricPayload(slide,value,layout,context,path,options) {
   if (!layout) throw new OPFPptxError('missing-metric-layout','Metric export requires coordinated core metric geometry.',{path});
   const group=String(context.metricTags.size+1),manifest=metricManifest(value,layout,group);
   // RR-07: a trend colours the trend and delta text and adds one native arrow shape, from core's accepted geometry.
-  const trendMark=metricTrendMark(layout,{background:`#${normalizeHex(context.colors.background)}`});
+  const trendMark=metricTrendMark(layout,{background:`#${normalizeHex(context.colors.background)}`,...(context.roles.neutrals?.trendNeutral ? {neutral: context.roles.neutrals.trendNeutral.hex} : {})});
   const partColor=part=>trendMark&&(part.role==='trend'||part.role==='delta')?trendMark.color.slice(1):part.role==='value'?context.colors.accent:context.textColor;
   for (const [partIndex,part] of layout.parts.entries()) {
     const invalid=/[\u0000-\u0008\u000B\u000C\u000E-\u001F\uD800-\uDFFF\uFFFE\uFFFF]/u.exec(part.text);
@@ -3385,7 +3539,7 @@ function addMediaPayload(slide, presentation, value, region, path, context, opti
   }
   slide.addShape("rect", {x: region.x, y: region.y, w: region.w, h: region.h, fill: {color: context.colors.surface}, line: {color: context.colors.border, width: 0.75}, hyperlink, objectName: names.frame});
   slide.addShape("ellipse", {x: icon.x / 96, y: icon.y / 96, w: 72 / 96, h: 72 / 96, fill: {color: context.colors.accent}, line: {transparency: 100}, hyperlink: hyperlink && {url: source}, objectName: names.badge});
-  slide.addShape("triangle", {x: (icon.x + 28) / 96, y: (icon.y + 22) / 96, w: 28 / 96, h: 28 / 96, rotate: 90, fill: {color: "FFFFFF"}, line: {transparency: 100}, hyperlink: hyperlink && {url: source}, objectName: names.play});
+  slide.addShape("triangle", {x: (icon.x + 28) / 96, y: (icon.y + 22) / 96, w: 28 / 96, h: 28 / 96, rotate: 90, fill: {color: context.roles ? normalizeHex(readableSchemeColor(`#${context.colors.accent}`, context.roles).hex) : "FFFFFF"}, line: {transparency: 100}, hyperlink: hyperlink && {url: source}, objectName: names.play});
   addMeasuredPayloadText(slide, mediaCaption(value), {...box, y: icon.y + 72 + 20, height: 50}, context, options,
     {path, fontSize: 18, fontFamily: context.fonts.body, fontWeight: 600, align: "center", color: context.colors.mutedText, objectName: `OPF media ${path} caption`, media: true, keepEmpty: true, hyperlink});
 }
@@ -4058,6 +4212,13 @@ function referenceId(reference) {
 
 // A solid color or pattern background color is a ColorRef (hex, `var:` variable, colour-scheme slot or role), resolved
 // as for table fills and run colours. Roles resolve through the colour scheme alone: the background cannot depend on itself.
+// A background that is one color: a color string, a theme slot, or a solid fill (not a picture, gradient or pattern).
+function isSingleColorBackground(value) {
+  if (value === undefined || value === null) return true;
+  if (typeof value === 'string') return true;
+  return isPlainObject(value) && (value.type === 'solid' || value.type === 'theme');
+}
+
 function resolveBackgroundColorRef(entry, colorScheme, variables = {}) {
   return resolveColorRefValue(entry, {colorScheme, colors: {}, variables});
 }
@@ -4125,6 +4286,12 @@ async function normalizePptxZip(raw, context) {
     });
   }
 
+  // RR-96: slide colors that are scheme colors become schemeClr first, so every fingerprint of a shape's properties (card frames, picture
+  // manifests) records the final XML.
+  for (const path of Object.keys(entries)) {
+    const match = /^ppt\/slides\/slide(\d+)\.xml$/.exec(path), entry = match && context.slideSchemeColors[Number(match[1]) - 1];
+    if (entry) entries[path] = encodeText(writeSchemeColors(decodeText(entries[path]), entry.table, entry.keep));
+  }
   attachCodeTags(entries, context.codeTags);
   attachMetricTags(entries,context.metricTags,context.metricDescriptions);
   attachCardTags(entries,context.cardTags);
@@ -4150,7 +4317,7 @@ 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,spec,textSize}=context.chartHeadings.get(name);
+      const {heading,labelColor,markLabelColor,spec,textSize}=context.chartHeadings.get(name);
       if(heading!==undefined)writeChartCategoryHeading(entries,chartPart,heading);
       entries[chartPart]=encodeText(omitEmptyNumberPoints(applyChartConstruct(decodeText(entries[chartPart]),spec)));
       const highlight=context.chartHeadings.get(name).highlight;
@@ -4168,7 +4335,7 @@ async function normalizePptxZip(raw, context) {
       entries[chartPart]=encodeText(applyChartTextSize(decodeText(entries[chartPart]),textSize));
       // RR-35: data labels last, so their own text colours (contrast inside a mark) are not normalized away.
       const {options:chartOptions,kind:optionKind,pointCount}=context.chartHeadings.get(name);
-      if(chartOptions?.dataLabels)entries[chartPart]=encodeText(applyDataLabels(decodeText(entries[chartPart]),{resolved:chartOptions,kind:optionKind,palette:context.chartPalettes.get(name),labelColor,font:context.chartFonts.get(name)?.body??'Arial',textSize,pointCount,highlight}));
+      if(chartOptions?.dataLabels)entries[chartPart]=encodeText(applyDataLabels(decodeText(entries[chartPart]),{resolved:chartOptions,kind:optionKind,palette:context.chartPalettes.get(name),labelColor:markLabelColor,font:context.chartFonts.get(name)?.body??'Arial',textSize,pointCount,highlight}));
       // RR-54: the columns' number formats, after the labels: caches, label and value-axis formats, then the workbook cells.
       const numberFormats=context.chartHeadings.get(name).numberFormats;
       if(numberFormats){
@@ -4238,6 +4405,7 @@ async function normalizePptxZip(raw, context) {
   try {
     placeImages(entries, context.images, context.imageOverlays, {
       metadataFor: (part, id) => imageMetadata.get(parseRelationships(entries, part).get(id)?.path), fitImage,
+      finish: (part, xml) => { const slide = /^ppt\/slides\/slide(\d+)\.xml$/.exec(part), entry = slide && context.slideSchemeColors[Number(slide[1]) - 1]; return entry ? writeSchemeColors(xml, entry.table, entry.keep) : xml; },
       // The key of the bytes the package finally holds: the picture's orientation is normalized when the parts are written.
       mediaKeyFor: (part, id) => { const target = parseRelationships(entries, part).get(id)?.path, bytes = entries[target]; return bytes ? mediaKey(imageMetadata.get(target) ? normalizeImageOrientation(bytes, imageMetadata.get(target)) : bytes) : undefined; },
       fail: path => { throw new OPFPptxError("unsupported-image-dimensions", "Image fitting requires readable PNG, JPEG, GIF or WebP dimensions. Supply a supported raster image through imageResolver.", { path }); }
@@ -4259,12 +4427,17 @@ async function normalizePptxZip(raw, context) {
   stampFurnitureImageKeys(entries, context.furnitureManifests, context.furnitureImages, parseRelationships);
   // Charts and notes follow the language and fonts of the slide they belong to.
   context.partSlides = new Map();
+  context.styleSlides = new Map();
   for (const part of Object.keys(entries)) {
     const slide = /^ppt\/slides\/slide(\d+)\.xml$/.exec(part);
     if (!slide) continue;
     context.partSlides.set(part, Number(slide[1]) - 1);
     for (const relationship of parseRelationships(entries, part).values()) {
       if (/\/(?:chart|chartEx|notesSlide)$/.test(relationship.type)) context.partSlides.set(relationship.path, Number(slide[1]) - 1);
+      // The chart style and color style parts of a native chart take the scheme colors of their slide.
+      if (/\/(?:chart|chartEx)$/.test(relationship.type) && entries[relationship.path]) {
+        for (const related of parseRelationships(entries, relationship.path).values()) if (/\/chartStyle$/.test(related.type)) context.styleSlides.set(related.path, Number(slide[1]) - 1);
+      }
     }
   }
   const output = {};
@@ -4410,12 +4583,15 @@ function normalizePartBytes(path, bytes, context, renameMaps, entries, imageMeta
       xml = themeMasterBulletFonts(xml).replace(/<p:cSld\b([^>]*)>/, (_, attributes) =>
         `<p:cSld${attributes.replace(/\s+name="[^"]*"/, '')} name="pptx.gallery">`);
     }
+    if (context.clrMap && /^ppt\/slideMasters\/slideMaster\d+\.xml$/.test(path)) xml = writeColorMap(xml, context.clrMap);
     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/presentation.xml') xml = presentationInSchemaOrder(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 override = context.clrMapOverrides.get(path);
+      if (override) xml = xml.replace('<p:clrMapOvr><a:masterClrMapping/></p:clrMapOvr>', `<p:clrMapOvr><a:overrideClrMapping${Object.entries(override).map(([role, slot]) => ` ${role}="${slot}"`).join('')}/></p:clrMapOvr>`);
       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) {
@@ -4567,6 +4743,11 @@ function normalizePartBytes(path, bytes, context, renameMaps, entries, imageMeta
       xml = nativeTitleAutofit(nativeBodyDefaults(xml, context.nativeBodies), context.nativeTitles);
     }
     // theme1.xml: FF-24 colors and names above, then FF-07 fonts here; they touch disjoint elements.
+    // RR-96: literal colors that are scheme colors become schemeClr (with lumMod/lumOff for the derived neutrals).
+    if (/^ppt\/(?:slides\/slide|charts\/chart(?:Ex)?|charts\/style)\d+\.xml$/.test(path)) {
+      const entry = context.slideSchemeColors[context.partSlides.get(path) ?? context.styleSlides.get(path)];
+      if (entry) xml = writeSchemeColors(xml, entry.table, entry.keep);
+    } else if (/^ppt\/(?:slideMasters\/slideMaster|slideLayouts\/slideLayout)\d+\.xml$/.test(path)) xml = writeSchemeColors(xml, context.deckSchemeColors.table, context.deckSchemeColors.keep);
     if (context.scriptFonts) xml = partScriptFonts(path, xml, context.scriptFonts, context.partSlides.get(path) ?? 0);
     else if (/^ppt\/theme\/theme\d+\.xml$/.test(path)) xml = themeEastAsianFromLatin(xml);
     if (/^ppt\/(?:slides\/slide|notesSlides\/notesSlide)\d+\.xml$/.test(path)) xml = stripRunScriptFonts(xml);

package/dist/theme-colors.js

@@ -18,14 +18,29 @@ export const THEME_SLOTS = Object.freeze([
   ['hyperlink', 'hlink'], ['followedHyperlink', 'folHlink'],
 ]);
 
-// Slide content reaches the theme through the master clrMap. The vendored
-// master maps bg1=lt1, tx1=dk1, bg2=lt2, tx2=dk2 and every other slot to itself.
-const CONTENT_VALUES = Object.freeze({
-  dark1: 'tx1', light1: 'bg1', dark2: 'tx2', light2: 'bg2',
-  accent1: 'accent1', accent2: 'accent2', accent3: 'accent3',
-  accent4: 'accent4', accent5: 'accent5', accent6: 'accent6',
-  hyperlink: 'hlink', followedHyperlink: 'folHlink',
-});
+// Slide content reaches the theme through the clrMap: the master's, and a slide's own override (RR-96). With the default map
+// bg1=lt1, tx1=dk1, bg2=lt2, tx2=dk2 and every other slot maps to itself; a variant swaps or re-points them (core ColorMap, whose
+// slots are named dark1, light1, dark2, light2 and accent1 to accent6).
+const DEFAULT_MAP = Object.freeze({bg1: 'light1', tx1: 'dark1', bg2: 'light2', tx2: 'dark2', accents: ['accent1', 'accent2', 'accent3', 'accent4', 'accent5', 'accent6']});
+const FIXED_VALUES = Object.freeze({hyperlink: 'hlink', followedHyperlink: 'folHlink'});
+// Which scheme role a document color reference prefers when two roles map to one slot (light2 and dark2 variants map bg1 and bg2 to it).
+const PREFERRED_ROLE = Object.freeze({background: 'bg1', surface: 'bg2', text: 'tx1', textSecondary: 'tx2'});
+// The accent a color role names: the variant's first, second and third accent (the scheme's own order by default).
+const ACCENT_ROLE_INDEX = Object.freeze({primary: 0, secondary: 1, accent: 2});
+
+/**
+ * The slide-content scheme value (tx1, bg1, bg2, tx2, accent3, hlink, ...) that reaches a theme slot through a clrMap, or undefined
+ * when no role of the map points at the slot (light1 under a light2 variant). `prefer` names the role to use when several qualify.
+ */
+export function contentValueFor(slot, map = DEFAULT_MAP, prefer) {
+  if (Object.hasOwn(FIXED_VALUES, slot)) return FIXED_VALUES[slot];
+  if (/^accent[1-6]$/.test(slot)) {
+    const index = (map.accents ?? DEFAULT_MAP.accents).indexOf(slot);
+    return index >= 0 ? `accent${index + 1}` : undefined;
+  }
+  const roles = ['bg1', 'tx1', 'bg2', 'tx2'].filter(role => map[role] === slot);
+  return roles.includes(prefer) ? prefer : roles[0];
+}
 // PptxGenJS 4.0.1 createColorElement accepts only these scheme values (pptxgenjs-plus accepts more; the set is kept
 // so exported colours stay as they were).
 const VENDOR_VALUES = new Set(['tx1', 'tx2', 'bg1', 'bg2', 'accent1', 'accent2', 'accent3', 'accent4', 'accent5', 'accent6']);
@@ -111,14 +126,18 @@ export function schemeColorValue(reference, hex, context, {vendor = false} = {})
   const deck = context.themeColors;
   if (!resolved || !deck) return undefined;
   let slots;
+  const map = context.roles?.map;
   if (SLOT_NAMES.has(name)) slots = [name];
-  else if (name === 'background') slots = [backgroundSlot(context.backgroundDefinition)].filter(slot => SLOT_NAMES.has(slot));
+  // RR-96: the slide's own roles come first (a variant puts bg1, tx1, bg2 and tx2 on other slots), then the earlier slot candidates.
+  else if (name === 'background') slots = [map?.bg1, map?.bg2, backgroundSlot(context.backgroundDefinition)].filter(slot => SLOT_NAMES.has(slot));
+  else if (map && ACCENT_ROLE_INDEX[name] !== undefined) slots = [map.accents?.[ACCENT_ROLE_INDEX[name]]].filter(Boolean);
+  else if (map && PREFERRED_ROLE[name]) slots = [map[PREFERRED_ROLE[name]], ...(ROLE_SLOTS[name] ?? [])];
   else slots = ROLE_SLOTS[name] ?? [];
   const effective = themeSlotColors(context.colorScheme);
   for (const slot of slots) {
     if (deck[slot] !== resolved || effective[slot] !== resolved) continue;
-    const value = CONTENT_VALUES[slot];
-    if (!vendor || VENDOR_VALUES.has(value)) return value;
+    const value = contentValueFor(slot, context.roles?.map, PREFERRED_ROLE[name]);
+    if (value && (!vendor || VENDOR_VALUES.has(value))) return value;
   }
   return undefined;
 }
@@ -131,7 +150,9 @@ function backgroundOpacity(definition) {
 /** 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;
+  if (slot) return schemeColorValue(slot, context.colors?.background, context) ?? schemeColorValue('background', context.colors?.background, context);
+  // RR-96: no background of its own (or none named): the slide's bg1 through its variant's map.
+  return definition === undefined ? schemeColorValue('background', context.colors?.background, context) : undefined;
 }
 
 /** Native slide background fill for a theme-slot background, or null when it must stay literal. */
@@ -142,30 +163,15 @@ export function schemeBackgroundFill(definition, context) {
   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.
+ * Scheme values for the exporter's default text and muted text on this slide: the roles tx1 and tx2 of the slide's map (RR-96). A dark
+ * slide is the dark variant's map with light text through tx1 and tx2, not hand-inverted colors; the values are used only where the
+ * resolved color is exactly what the map's slot holds in the deck theme, and a slide without its own scheme.
  */
 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);
+  for (const [role, name, hex] of [['text', 'text', context.colors?.text], ['muted', 'textSecondary', context.colors?.mutedText]]) {
+    const value = schemeColorValue(name, hex, context);
     if (value) values[role] = value;
   }
   return values;
@@ -173,16 +179,17 @@ export function defaultTextSchemeValues(context) {
 
 /**
  * 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
+ * theme reference (`fillValue`, from schemeColorValue). A fill on the background
+ * side (bg1, bg2) pairs with the map's text slot, a text-side fill (tx1, tx2) with its background slot,
+ * and an accent fill has contrast-selected text, which stays a theme reference only
+ * when the selection is exactly one of those two slots. 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 map = context.roles?.map ?? DEFAULT_MAP;
   const light = /^bg[12]$/.test(fillValue), dark = /^tx[12]$/.test(fillValue);
-  const candidates = light ? ['dark1'] : dark ? ['light1'] : /^accent[1-6]$/.test(fillValue) ? ['light1', 'dark1'] : [];
+  const candidates = light ? [map.tx1] : dark ? [map.bg1] : /^accent[1-6]$/.test(fillValue) ? [map.bg1, map.tx1] : [];
   for (const slot of candidates) {
     const value = schemeColorValue(slot, hex, context, {vendor: true});
     if (value) return value;
@@ -190,6 +197,66 @@ export function tableTextSchemeValue(fillValue, hex, context) {
   return undefined;
 }
 
+// ---------------------------------------------------------------------------
+// RR-96: scheme-derived colors in the finished parts
+
+const hex6Of = value => sixDigitHex(value);
+
+/**
+ * The colors of one slide that are scheme colors, keyed by RRGGBB: the roles tx1, bg1, tx2 and bg2 and the accents through the slide's
+ * map, then every neutral core derived (border, gridline, axis line, chart text, outline, neutral trend, code panel, code text and code
+ * comment), each with the scheme value to write and its luminance transform (`lumMod`, `lumOff`, in thousandths of a percent).
+ * A color that two entries share keeps the first (plain roles before accents before neutrals). Empty for a slide with its own color scheme
+ * (its colors stay literal) or one whose roles carry no map (a core older than the variants).
+ */
+export function schemeColorTable(context) {
+  const table = new Map();
+  const map = context.roles?.map;
+  if (!map || context.schemeOverride) return table;
+  const slots = themeSlotColors(context.colorScheme);
+  const roleHex = role => /^accent([1-6])$/.test(role) ? slots[(map.accents ?? [])[Number(role.slice(6)) - 1]] : slots[map[role]];
+  const add = (hex, entry) => { const key = hex6Of(hex); if (key && !table.has(key)) table.set(key, entry); };
+  for (const role of ['tx1', 'bg1', 'tx2', 'bg2']) if (slots[map[role]]) add(slots[map[role]], {value: role});
+  (map.accents ?? []).forEach((slot, index) => { if (slots[slot]) add(slots[slot], {value: `accent${index + 1}`}); });
+  for (const neutral of Object.values(context.roles.neutrals ?? {})) {
+    if (!neutral?.slot || !/^(?:tx[12]|bg[12]|accent[1-6])$/.test(neutral.slot)) continue;
+    // A neutral that is a plain role (no luminance transform) is that role only where the scheme's slot has its color: on a slide with a literal
+    // background the outline is bg1 by name but the literal's color.
+    if (neutral.lumMod === undefined && neutral.lumOff === undefined && hex6Of(neutral.hex) !== roleHex(neutral.slot)) continue;
+    add(neutral.hex, {value: neutral.slot, ...(neutral.lumMod !== undefined ? {lumMod: neutral.lumMod} : {}), ...(neutral.lumOff !== undefined ? {lumOff: neutral.lumOff} : {})});
+  }
+  return table;
+}
+
+/**
+ * Rewrite the literal `a:srgbClr` colors of a finished slide, chart or master part that are scheme colors to `a:schemeClr`: the role with its
+ * `lumMod` and `lumOff` for a derived neutral, keeping any child the literal carried (an alpha). `table` is {@link schemeColorTable}; `keep` holds the
+ * RRGGBB colors the author wrote literally on the slide, which stay literal even when a scheme color happens to equal them, and a literal that
+ * already carries its own luminance transform is left alone.
+ */
+export function writeSchemeColors(xml, table, keep = new Set()) {
+  if (!table.size) return xml;
+  return xml.replace(/<a:srgbClr val="([0-9A-Fa-f]{6})"\s*(?:\/>|>([\s\S]*?)<\/a:srgbClr>)/g, (match, hex, inner = '') => {
+    const key = hex.toUpperCase(), entry = table.get(key);
+    if (!entry || keep.has(key) || /<a:(?:lumMod|lumOff|tint|shade|satMod)\b/.test(inner)) return match;
+    const transforms = `${entry.lumMod !== undefined ? `<a:lumMod val="${entry.lumMod}"/>` : ''}${entry.lumOff !== undefined ? `<a:lumOff val="${entry.lumOff}"/>` : ''}`;
+    return `<a:schemeClr val="${entry.value}">${transforms}${inner}</a:schemeClr>`;
+  });
+}
+
+/** The RRGGBB colors written literally in a slide's authored content (and the document's variables), which a scheme color must not take over. */
+export function authoredLiteralColors(...values) {
+  const found = new Set();
+  const visit = value => {
+    if (typeof value === 'string') { for (const match of value.matchAll(/#([0-9a-f]{6}|[0-9a-f]{3})(?:[0-9a-f]{2})?\b/gi)) found.add(sixDigitHex(`#${match[1]}`)); }
+    else if (Array.isArray(value)) value.forEach(visit);
+    else if (value && typeof value === 'object') Object.values(value).forEach(visit);
+  };
+  values.forEach(visit);
+  found.delete(undefined);
+  return found;
+}
+
 // ---------------------------------------------------------------------------
 // Import
 
@@ -267,6 +334,30 @@ export function recoverTheme({themeName, colors, majorFont, minorFont}, {themes,
   return colorMatch || fontMatch ? {id: theme.id} : {unverified: theme.id};
 }
 
+// ---------------------------------------------------------------------------
+// RR-96: the color map back to a variant
+
+const MAP_BACKGROUNDS = Object.freeze({'lt1,dk1,lt2,dk2': 'light1', 'lt2,dk1,lt2,dk2': 'light2', 'dk1,lt1,dk2,lt2': 'dark1', 'dk2,lt1,dk2,lt2': 'dark2'});
+const ACCENT_KEYS = Object.freeze(['accent1', 'accent2', 'accent3', 'accent4', 'accent5', 'accent6']);
+
+/**
+ * The variant a PowerPoint color map stands for (`mapping`: bg1, tx1, bg2, tx2 as lt1, dk1, lt2, dk2, and the six accents; a missing attribute is
+ * the default). `design.variant` as authored is the background slot alone (`"dark1"`) unless the accents are re-pointed, which needs the object form
+ * `{background, accents}`. Returns `{variant}` (the default map is `light1` with no accent order, written only when `explicit`, a slide
+ * override back to the default), `{} ` for the default map, and `{unsupported: true}` for a map that is no variant (bg1 on an accent, text on a light and
+ * background on a light slot, a repeated accent): the caller reports it and imports nothing.
+ */
+export function variantFromColorMap(mapping, {explicit = false} = {}) {
+  const at = (key, fallback) => (typeof mapping?.[key] === 'string' ? mapping[key] : fallback);
+  const background = MAP_BACKGROUNDS[[at('bg1', 'lt1'), at('tx1', 'dk1'), at('bg2', 'lt2'), at('tx2', 'dk2')].join(',')];
+  const accents = ACCENT_KEYS.map(key => at(key, key));
+  const permutation = accents.length === 6 && new Set(accents).size === 6 && accents.every(slot => ACCENT_KEYS.includes(slot));
+  if (!background || !permutation) return {unsupported: true};
+  const reordered = accents.some((slot, index) => slot !== ACCENT_KEYS[index]);
+  if (!reordered && background === 'light1' && !explicit) return {};
+  return {variant: reordered ? {background, accents} : background};
+}
+
 // ---------------------------------------------------------------------------
 // Slide master
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openpresentation/opf-pptx",
-  "version": "0.22.0",
+  "version": "0.23.0",
   "description": "Pure local OPF to PPTX export and PPTX to OPF import tooling.",
   "license": "MIT",
   "type": "module",
@@ -66,7 +66,7 @@
   "dependencies": {
     "@node-projects/jszip": "4.3.0",
     "@openpresentation/gallery": "^3.0.0",
-    "@openpresentation/opf": "^0.22.1",
+    "@openpresentation/opf": "^0.23.0",
     "@rgrove/parse-xml": "4.2.3",
     "fast-xml-parser": "^5.8.0",
     "fflate": "^0.8.3",
@@ -74,7 +74,7 @@
     "sharp": "0.35.5"
   },
   "peerDependencies": {
-    "@openpresentation/opf-render": "^0.22.1"
+    "@openpresentation/opf-render": "^0.23.0"
   },
   "peerDependenciesMeta": {
     "@openpresentation/opf-render": {
@@ -98,7 +98,7 @@
     "@expo-google-fonts/roboto": "0.4.3",
     "@expo-google-fonts/roboto-mono": "0.4.2",
     "@expo-google-fonts/tinos": "0.4.2",
-    "@openpresentation/opf-render": "0.22.1",
+    "@openpresentation/opf-render": "0.23.0",
     "@resvg/resvg-js": "2.6.2",
     "esbuild": "0.28.2",
     "playwright": "1.64.0"