@openpresentation/opf-pptx 0.13.2 → 0.15.0

package/dist/index.js

@@ -8,8 +8,9 @@ import {legacyVendorOutput} from './vendor-compat.js';
 import {readChartCategoryHeading,writeChartCategoryHeading,writeChartWorkbookFormats,repairChartWorkbookRanges} from './chart-workbook.js';
 import {applyChartNumberFormats,chartNumber,excelCode,formattedColumns,inlineChartData,inlineTableData,isDatasetRef,numericRanges,resolveChartData} from './chart-data.js';
 import {attachDataProvenance,chartDataRecord,chartEvidence,readDataTag,readDatasetsTag,restoreChartData,restoreTableData,tableDataRecord} from './data-provenance.js';
-import {CHARTEX_FALLBACK,resolveChartType,chartTypeFromNative,applyChartConstruct,NATIVE_CHART_ELEMENTS} from './chart-types.js';
+import {CHARTEX_FALLBACK,resolveChartType,chartTypeFromNative,applyChartConstruct,comboFromNative,NATIVE_CHART_ELEMENTS} from './chart-types.js';
 import {attachChartexParts,chartFromChartex,CHARTEX_GRAPHIC_DATA_URI} from './chartex.js';
+import {applyChartAlt,readFrameAlt} from './chart-alt.js';
 import {applyDataLabels,chartOptionsFromClassic,chartTargetFor,classicChartOptions,reportChartOptionDiagnostics,resolveChartOptionsFor} from './chart-options.js';
 import {attachCodeTags, attachTextTags, codeManifest, importCodeGroups, nativeShapeParagraphs, nativeTextShapes} from './code-provenance.js';
 import {attachMetricTags,metricManifest,importMetricGroups} from './metric-provenance.js';
@@ -19,9 +20,10 @@ import {attachMediaTags,importMediaGroups,mediaCaption,mediaFrameRecord,mediaTex
 import {addCaption, addFootnotes} from './annotation-export.js';
 import {attachAnnotationTags, captionValue, importAnnotations, restoreCitations} from './annotation-provenance.js';
 import {attachHeadingTags,importHeadingGroups} from './heading-provenance.js';
+import {headingValue,joinRichLines} from './rich-heading.js';
 import {attachPlainTextTags,importPlainTextGroups} from './text-provenance.js';
 import {attachTimelineTags,timelineManifest,importTimelineGroups} from './timeline-provenance.js';
-import {attachQuoteTags,quoteManifest,importQuoteGroups} from './quote-provenance.js';
+import {attachQuoteTags,quoteManifest,importQuoteGroups,quotePhotoName} from './quote-provenance.js';
 import {attachFurnitureTags, furnitureManifest, importFurniture, manifestPartIndex, staticDateFallback} from './furniture-provenance.js';
 import {restoreRunColors} from './run-colors.js';
 import {joinWrappedText} from './content-topology.js';
@@ -31,35 +33,38 @@ import {attachFurnitureFields, furniturePartFields, lineFields, nativeFieldType}
 import {attachNativePlaceholders, defaultPlaceholderGeometry, nativeDateText, nativeFurnitureParts, writeNativeMasters} from './native-furniture.js';
 import {importImageOrientation} from './image-import.js';
 import {extractSignals, normalizeSignalOptions, themeFactsFor} from './import-signals.js';
-import {placeSlideImages, importSlideImage, slideImageName, slideImageOverlayName} from './slide-image-provenance.js';
+import {placeImages, importImages, imageName, imageOverlayName, backgroundImageName, backgroundOverlayName, IMAGE_TREATMENT_KEYS, BACKGROUND_IMAGE_KEYS} from './image-provenance.js';
 import {dedupeMedia} from './media-dedupe.js';
-import {placeWatermarks, importWatermark, watermarkName, watermarkBox, watermarkOpacity} from './watermark-provenance.js';
+import {placeWatermarks, importWatermark, importTextWatermark, tagTextWatermarks, watermarkName, watermarkTextName, watermarkBox, watermarkOpacity} from './watermark-provenance.js';
 import {placeLogos, importLogo, importLogoPlaceholders, logoName, LOGO_TAG} from './logo-provenance.js';
 import {nativeBackgroundFill, nativeImageBackgroundFill, nativePatternPreset} from './background.js';
 import {importBackground} from './background-import.js';
+import {chartHighlightPlan, applyChartHighlight} from './chart-highlight.js';
 import {themeSlotColors, writeThemeColors, schemeColorValue, schemeBackgroundFill, schemeBackgroundValue, defaultTextSchemeValues, tableTextSchemeValue, solidColorXml, writeMasterBackground, inheritLayoutBackground, readThemeSlotColors, recoverColorScheme, recoverTheme, presentationThemePath} from './theme-colors.js';
-import {languageDiagnostics, observeLanguage, observedRtl, partScriptFonts, physicalAlignment, planScriptFonts, planSlideThemes, reconcileLanguage, reportPerSlideNotesScriptFonts, stripRunScriptFonts, themeEastAsianFromLatin} from './script-fonts.js';
+import {languageDiagnostics, observeLanguage, observedRtl, partScriptFonts, physicalAlignment, planScriptFonts, planSlideThemes, reconcileLanguage, reportPerSlideNotesScriptFonts, runLanguageFonts, runLanguageTag, stripRunScriptFonts, themeEastAsianFromLatin} from './script-fonts.js';
 import { webpToPng, svgToPng, readLocalFile } from '#image-fallback';
 import { prepareSvg, svgDataUriBytes, svgRasterScale, svgBlipRelationship, attachSvgPictures } from './svg-image.js';
 import { rasterMetadata, pictureTransform, normalizeImageOrientation } from './image-geometry.js';
-import { layoutTable, composeSlide, fitText, fitRichText, textWidthMeasurer, resolveCanvasDimensions, resolveFontFamilies, resolveTextStyle, textColorForFill, chartColorForFill } from "@openpresentation/opf/composition";
-// chartPaletteForFill ships with core RR-29 (opf#270); an older published core still loads and clamps each colour on its own.
-import * as opfComposition from "@openpresentation/opf/composition";
+import {
+  catalogRecords, chartPaletteForFill, codeHighlightBands, codeHighlightColors, codeHighlightLines, codeLineNumbers, codeLineRuns, codeSyntaxPaletteForScheme, composeSlide,
+  ENGINE_DEFAULT_FONT_SCHEME, defaultSlideBackground, fitImage, fitText, layoutTable, layoutWatermark, metricTrendMark, resolveCanvasDimensions, resolveColorRoles, resolveFontFamilies,
+  resolveReference, resolveTextStyle, textColorForFill, textWidthMeasurer, timelineMarkerShapes, timelineTextColor, tokenizeCode
+} from "@openpresentation/opf/composition";
 import { colorContext, resolveColorRefValue, resolveExportColor, resolveVariableColors } from "./color-ref.js";
 import PptxGenJS from "../vendor/pptxgenjs/pptxgen.es.js";
 import { unzipSync, zipSync } from "fflate";
 import { XMLParser } from "fast-xml-parser";
 import {
-  catalogs as bundledCatalogs,
-  validatePresentation
+  hasContentVariables,
+  isTemplate,
+  OPFCatalogsOptionError,
+  resolveSlideContext as resolveCoreSlideContext,
+  resolveVariables,
+  validate
 } from "@openpresentation/opf";
-// Optional core exports (RR-07 syntax colours, trend marks) are read from the namespace so an older published core still loads.
-
-// Optional core exports are read from the namespace so an older published core still loads;
-// resolveVariables ships with core RR-32.
-import * as opfCore from "@openpresentation/opf";
+import {checkFormat, isValidFormat} from "./format-check.js";
 
-export {checkPptxTypefaces, inventoryPptxTypefaces, packageFontsUsed, THEME_SCRIPT_SUPPLEMENTS} from './typeface-inventory.js';
+export {checkTypefaces, inventoryTypefaces, packageFontsUsed, THEME_SCRIPT_SUPPLEMENTS} from './typeface-inventory.js';
 export {DEFAULT_SIGNAL_LIMITS, SIGNALS_VERSION, isMonospaceFamily} from './import-signals.js';
 
 export const packageName = "@openpresentation/opf-pptx";
@@ -87,7 +92,8 @@ export class OPFPptxError extends Error {
     this.name = "OPFPptxError";
     this.code = code;
     this.details = details;
-    if (details.issues) this.issues = details.issues;
+    if (details.findings) this.findings = details.findings;
+    if (details.diagnostics) this.diagnostics = details.diagnostics;
     if (details.path) this.path = details.path;
   }
 }
@@ -191,16 +197,12 @@ const DIMENSION_PRESETS = Object.freeze({
   "4:3": Object.freeze({ widthInches: 10, heightInches: 7.5 }),
   "16:10": Object.freeze({ widthInches: 10, heightInches: 6.25 }),
   letter: Object.freeze({ widthInches: 11, heightInches: 8.5 }),
+  "1:1": Object.freeze({ widthInches: 7.5, heightInches: 7.5 }),
+  "4:5": Object.freeze({ widthInches: 7.5, heightInches: 9.375 }),
+  "9:16": Object.freeze({ widthInches: 7.5, heightInches: 40 / 3 }),
   a4: Object.freeze({ widthInches: 11.69, heightInches: 8.27 })
 });
 
-const DEFAULTS = Object.freeze({
-  theme: "minimal",
-  colorScheme: "cool-horizon",
-  // Shared last-resort font scheme (core DEFAULT_FONT_SCHEME): every engine uses aptos.
-  fontScheme: "aptos"
-});
-
 const CHART_COLORS = [
   "2874A6",
   "1B4F72",
@@ -216,6 +218,12 @@ const CHART_COLORS = [
   "64748B"
 ];
 
+// The `catalogs` option is core's registered catalogs (`Catalog[]`). A value that is no array is core's
+// OPFCatalogsOptionError (code `invalid-catalogs`) up front; core checks each entry where it resolves a reference.
+function checkCatalogs(entry, catalogs) {
+  if (catalogs !== undefined && !Array.isArray(catalogs)) throw new OPFCatalogsOptionError(entry, `got ${catalogs === null ? 'null' : typeof catalogs}`);
+}
+
 export async function toPptx(input, options = {}) {
   if (options.imageFormat !== undefined && !['compatible', 'preserve'].includes(options.imageFormat)) {
     throw new OPFPptxError('invalid-image-format', 'imageFormat must be compatible or preserve.', {path: 'options.imageFormat'});
@@ -223,20 +231,30 @@ export async function toPptx(input, options = {}) {
   if (options.provenance !== undefined && !['full', 'references-only', false].includes(options.provenance)) {
     throw new OPFPptxError('invalid-provenance-option', "provenance must be 'full', 'references-only' or false.", {path: 'options.provenance'});
   }
+  // OPF 0.15 (FA-23): the host's registered catalogs (core `Catalog[]`, matched by `source`, never fetched) reach every core
+  // call that resolves a reference. Strict export (`strictReferences`, default `strictAssets`) fails on a reference that
+  // resolves nowhere instead of composing automatically or drawing with the engine default.
+  checkCatalogs('toPptx', options.catalogs);
+  options = {...options, strictReferences: options.strictReferences ?? options.strictAssets === true};
   const presentation = resolveTemplateInput(parseInput(input), options);
   assertValidBoundary(presentation);
-  options = {...options, textMeasurement: chosenFamilyMeasurement(options.textMeasurement), svgRasters: new Map()};
+  // `options.fonts` is the fonts handle (the renderer's loadFonts()); the exporter reads its measurement, wrapped so the package names the
+  // chosen family (FF-31). Internally `options.textMeasurement` is that wrapped measurement; it is not a public option.
+  options = {...options, textMeasurement: chosenFamilyMeasurement(options.fonts?.textMeasurement), svgRasters: new Map()};
 
   const context = resolvePresentationContext(presentation, {...options,textMeasurement:undefined});
   context.listMarkers = new Map();
   context.imagePlaceholders = new Map();
   context.tableHeaders = new Map();
   context.tableCells = new Map();
-  context.imagePlacements = new Map();
+  // FA-23: every exported image picture (image blocks, the alt-text form of an image background, timeline pictures) and
+  // every image overlay shape, by object name (src/image-provenance.js).
+  context.images = new Map();
+  context.imageOverlays = new Map();
   context.svgPictures = new Map();
   context.pictureText = new Map();
-  context.slideImages = new Map();
   context.watermarks = new Map();
+  context.textWatermarks = new Map();
   context.logos = new Map();
   context.logoPlaceholderTags = new Map();
   context.bulletImages = new Map();
@@ -249,6 +267,7 @@ export async function toPptx(input, options = {}) {
   context.plainTextTags = new Map();
   context.timelineTags = new Map();
   context.quoteTags = new Map();
+  context.quotePhotos = new Map();
   context.furnitureTags = new Map();
   context.furnitureLogoTags = new Map();
   context.furnitureFields = new Map();
@@ -261,6 +280,7 @@ export async function toPptx(input, options = {}) {
   context.metricTags = new Map();
   context.metricDescriptions = new Map();
   context.chartHeadings = new Map();
+  context.chartAlts = new Map();
   context.chartFonts = new Map();
   context.chartPalettes = new Map();
   context.chartex = new Map();
@@ -277,15 +297,19 @@ export async function toPptx(input, options = {}) {
     throw new OPFPptxError('invalid-chartex-mode', 'chartex must be auto, native or fallback.', {path: 'options.chartex'});
   }
   context.chartexMode = options.chartex ?? 'auto';
-  Object.assign(context, exportTheme(presentation, context));
-  context.reportedFontSchemes = new Set();
+  Object.assign(context, exportTheme(presentation, context, options));
+  context.reportedReferences = new Set();
   // Document references and metadata tags (FF-32, docs/document-roundtrip.md).
   context.documentProvenance = options.provenance === false ? null : documentProvenance(presentation, {
     mode: options.provenance ?? "full",
-    isCatalogId: (kind, id) => !!(findById(normalizeRecords(presentation.catalogs?.[kind]), id) ?? findById(defaultCatalog(kind), id)),
+    // Core's provenance of each slide's resolved layout (resolveSlideContext().resolved.provenance.layout) with its record.
+    layoutOf: index => {
+      const {resolved} = coreContext(presentation, index, options);
+      return resolved.provenance?.layout && resolved.layout ? {...resolved.provenance.layout, record: resolved.layout} : undefined;
+    },
     report: diagnostic => options.onDiagnostic?.(diagnostic)
   });
-  context.scriptFonts = planScriptFonts(presentation, options.onDiagnostic);
+  context.scriptFonts = planScriptFonts(presentation, options.onDiagnostic, {catalogs: options.catalogs});
   // Slide section labels become PowerPoint's native section list (src/sections.js).
   // A label is an XML attribute: the characters text runs reject are rejected here too.
   context.sections = presentation.slides.map((slide, index) => {
@@ -297,15 +321,16 @@ export async function toPptx(input, options = {}) {
   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});
+  configurePresentation(pptx, presentation, {...context,fonts:exportSlideContext(presentation,0,context,options).fonts});
 
   for (let index = 0; index < presentation.slides.length; index += 1) {
     await addSlide(pptx, presentation, presentation.slides[index], index, context, options);
   }
 
-  // FF-08: pitchFamily per exported family, from each slide's resolved scheme.
-  context.fontPitch = fontPitchFamilies(presentation.slides.map((slide, index) => resolveSlideContext(presentation, slide, context, options, index).fonts),
-    [...normalizeRecords(presentation.catalogs?.fontSchemes), ...defaultCatalog("fontSchemes")]);
+  // FF-08: pitchFamily per exported family, from each slide's resolved scheme, then the font schemes the document embeds
+  // and the registered catalogs its groups name (core catalogRecords).
+  context.fontPitch = fontPitchFamilies(presentation.slides.map((slide, index) => exportSlideContext(presentation, index, context, options).fonts),
+    catalogRecords(presentation, "fontSchemes", {catalogs: options.catalogs}).map(entry => entry.record));
 
   let raw;
   try {
@@ -325,6 +350,9 @@ export async function toPptx(input, options = {}) {
 export async function fromPptx(input, options = {}) {
   // Opt-in raw shape signals (import-signals.js). Validated first so a bad option fails before any work.
   const signalLimits = normalizeSignalOptions(options.signals, (code, message, details) => new OPFPptxError(code, message, details));
+  // OPF 0.15 (FA-23): catalogs the host registered (core `Catalog[]`, never fetched). Theme and colour-scheme recovery and
+  // stored layout ids resolve against them; with none, a colour scheme imports inline and no theme id is recovered.
+  checkCatalogs('fromPptx', options.catalogs);
   const entries = readPptxZip(input);
   const presentationDoc = parseRequiredXml(entries, "ppt/presentation.xml");
   const presentationRoot = presentationDoc["p:presentation"];
@@ -358,12 +386,12 @@ export async function fromPptx(input, options = {}) {
       const theme = relatedPart(relatedPart(relatedPart(path, 'slideLayout'), 'slideMaster'), 'theme');
       return theme ? {path: theme, xml: decodeText(entries[theme])} : null;
     }),
-    catalogs: bundledCatalogs
+    catalogs: options.catalogs
   });
   if (observedLanguage.language !== undefined) imported.language = observedLanguage.language;
   if (core.description) imported.description = core.description;
   if (core.author) imported.author = splitAuthors(core.author);
-  const themeDesign = importThemeDesign(entries, presentationRoot, presentationRels);
+  const themeDesign = importThemeDesign(entries, presentationRoot, presentationRels, options.catalogs);
   const design = {...themeDesign.design, ...(dimensions ? {dimensions} : {})};
   if (Object.keys(design).length) imported.design = design;
 
@@ -384,6 +412,7 @@ export async function fromPptx(input, options = {}) {
   const furniture = importFurniture(furnitureContexts, entries, options.onDiagnostic);
   if (Object.keys(furniture.design).length) imported.design = {...imported.design, ...furniture.design};
   if (furniture.organization) imported.organization = furniture.organization;
+  if (furniture.speaker) imported.speaker = furniture.speaker;
 
   // RR-54: the datasets recorded at export (OPF_DATASETS_V1). Chart and table frames restore their dataset references against
   // them, so the document carries them before document provenance validates the restored document.
@@ -391,7 +420,7 @@ export async function fromPptx(input, options = {}) {
   const mediaRegistry = Object.create(null);
   for (let index = 0; index < slidePaths.length; index += 1) {
     furnitureContexts[index].mediaRegistry = mediaRegistry;
-    imported.slides.push(importSlide(entries, slidePaths[index], index, dimensions, {...options, rtlDeck: observedRtl(observedLanguage), dataProvenance: {datasets}}, furniture.slides[index], furnitureContexts[index]));
+    imported.slides.push(importSlide(entries, slidePaths[index], index, dimensions, {...options, rtlDeck: observedRtl(observedLanguage), deckLang: observedLanguage.lang, codeFamily: Object.keys(entries).some(path => /^ppt\/tags\/opf/i.test(path)) ? importedCodeFamily(imported, options.catalogs) : undefined, dataProvenance: {datasets}}, furniture.slides[index], furnitureContexts[index]));
   }
   if (datasets) imported.datasets = datasets;
   // Native sections (PowerPoint's own section list, `Default Section` = none)
@@ -421,14 +450,14 @@ export async function fromPptx(input, options = {}) {
   let slideProvenance = slidePaths.map(() => ({structure: "untagged"}));
   let restoredGroups = [];
   try {
-    const restored = restoreDocumentProvenance(imported, {entries, presentationRoot, presentationRels, organizationConflict: furniture.organizationConflict === true,
-      // Host catalogs format stored socials exactly as export did (FF-34).
-      socialPlatformRecords: catalogs => socialPlatformRecords({catalogs}, options),
+    const restored = restoreDocumentProvenance(imported, {entries, presentationRoot, presentationRels, organizationConflict: furniture.organizationConflict === true, speakerConflict: furniture.speakerConflict === true,
+      // Stored layout ids also resolve in the host's registered catalogs (FA-23).
+      catalogs: options.catalogs,
       nativeSections: slideSections,
       slides: slidePaths.map((path, index) => ({path, root: furnitureContexts[index].root, relationships: furnitureContexts[index].relationships, contentBounds: furnitureContexts[index].contentBounds}))}, report);
     // The stored language wins while the runs still carry its tag (FF-07).
     restored.groups = reconcileLanguage(restored.groups, observedLanguage, report);
-    imported = applyDocumentProvenance(imported, restored, validatePresentation, report);
+    imported = applyDocumentProvenance(imported, restored, checkFormat, report);
     slideProvenance = restored.slides;
     restoredGroups = restored.groups;
   } catch (error) {
@@ -443,11 +472,11 @@ export async function fromPptx(input, 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);
 
-  const result = validatePresentation(imported);
-  if (!result.valid) {
+  const validation = checkFormat(imported);
+  if (!validation.valid) {
     throw new OPFPptxError("invalid-import-opf", "Imported PPTX did not produce valid OPF.", {
-      issues: result.errors,
-      result
+      findings: validation.findings.filter(finding => finding.severity === "error"),
+      report: validation
     });
   }
 
@@ -458,7 +487,7 @@ export async function fromPptx(input, options = {}) {
   const archive = {part: (path, parser) => parseRequiredXml(entries, path, parser), relationships: path => parseRelationships(entries, path), bytes: path => entries[path]};
   const signals = extractSignals({archive, presentationRoot, slidePaths, themeFacts: themeFactsFor(slidePaths[0], archive), limits: signalLimits,
     recorded: furnitureContexts.map(context => context.signalSources), slideProvenance, contentPaths});
-  return {document: imported, signals};
+  return {presentation: imported, signals};
 }
 
 // RR-08: run colours named by a ColorRef (variable, scheme slot, role) come back as that name where the document's own
@@ -623,6 +652,17 @@ function readCoreProperties(entries) {
   };
 }
 
+// FA-13: the code family of the imported design's font scheme (a run in it is an inline code run). The scheme's own `code` role,
+// else that of the record the reference resolves to (in the imported document or the host's registered catalogs), else the
+// engine default's; heading and body families are never code. Only a package the exporter wrote (it carries OPF tag parts) is
+// read this way; a deck from another tool keeps its runs' font families as they are.
+function importedCodeFamily(imported, catalogs) {
+  const reference = imported.design?.fontScheme;
+  const id = referenceId(reference);
+  const found = id ? resolveReference(imported, "fontSchemes", id, {catalogs: catalogs ?? []}) : undefined;
+  return resolveFontFamilies({...(found ? found.record : ENGINE_DEFAULT_FONT_SCHEME), ...(isPlainObject(reference) ? reference : {})}).code;
+}
+
 function dimensionsFromPresentation(presentationRoot) {
   const size = presentationRoot["p:sldSz"];
   const width = emuToInches(size?.cx);
@@ -644,21 +684,34 @@ function importSlide(entries, slidePath, slideIndex, presentationDimensions, opt
   const background = importBackground(slidePath, resolveCanvasDimensions(dimensions), {
     part: (path, parser) => parseRequiredXml(entries, path, parser), relationships: path => parseRelationships(entries, path), bytes: path => entries[path]
   }, diagnostic => options.onDiagnostic?.({...diagnostic, path: `slides.${slideIndex}.design.background`}));
-  if (background) slide.design = {background};
+  // FA-23: tagged image pictures and overlays (OPF_IMAGE_V1, OPF_IMAGE_OVERLAY_V1). An unchanged full-slide back picture is
+  // the slide's image background (its native fill is then only the canvas colour); an unchanged overlay of a native image
+  // background fill joins that background; an unchanged image block picture returns its treatment and placement.
+  const images = importImages({pictures: nativeContext.pictures, shapes: nativeContext.shapes, relationships, entries, slideIndex,
+    readPicture: picture => importPicture(entries, picture, slidePath, relationships, diagnostic => {
+      // The recorded crop, fit and focus are re-derived from the restored background.
+      if (diagnostic.code !== 'unsupported-image-crop') options.onDiagnostic?.({...diagnostic, path: `slides.${slideIndex}.design.background`});
+    }),
+    valid: (kind, value) => isValidFormat({slides: [kind === 'background' ? {design: {background: value}} : {blocks: [value]}]}),
+    report: diagnostic => options.onDiagnostic?.(diagnostic)});
+  const imageBackground = images.background ?? (background?.type === 'image' && images.backgroundOverlay ? {...background, overlay: images.backgroundOverlay} : background);
+  if (images.backgroundOverlay && imageBackground === background) {
+    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};
   if (Object.keys(furniture.design).length) slide.design = {...slide.design, ...furniture.design};
   if (furniture.section !== undefined) slide.section = furniture.section;
-  const slideImagePath = `slides.${slideIndex}.design.slideImage`;
-  const slideImage = importSlideImage(nativeContext.pictures, nativeContext.shapes, relationships, entries, slideIndex,
-    picture => importPicture(entries, picture, slidePath, relationships, diagnostic => {
-      // The recorded crop/fit is re-derived from design.slideImage.
-      if (diagnostic.code !== 'unsupported-image-crop') options.onDiagnostic?.({...diagnostic, path: slideImagePath});
-    }),
-    diagnostic => options.onDiagnostic?.({...diagnostic, path: slideImagePath}));
-  if (slideImage.design) slide.design = {...slide.design, ...slideImage.design};
-  if (slideImage.image) slide.image = slideImage.image;
-  nativeContext.slideImagePictures = slideImage.consumed;
-  nativeContext.slideImageShapes = slideImage.consumedShapes;
+  nativeContext.imageBlocks = images.blocks;
+  nativeContext.imagePictures = images.consumed;
+  // An overlay of a background that was not recovered stays an ordinary shape.
+  nativeContext.imageShapes = images.consumedShapes;
   const watermarkPath = `slides.${slideIndex}.design.watermark`;
+  // FA-13: a text watermark is a tagged native text box; it is not content and never imports as a text block.
+  const textWatermark = importTextWatermark(nativeContext.shapes, nativeContext.paragraphs.map(shapeParagraphs => shapeParagraphs.map(paragraph => ({text: paragraph.text}))), relationships, entries, slideIndex,
+    diagnostic => options.onDiagnostic?.({...diagnostic, path: watermarkPath}));
+  if (textWatermark.design) slide.design = {...slide.design, ...textWatermark.design};
+  nativeContext.watermarkShapes = textWatermark.consumed;
   const watermark = importWatermark(nativeContext.pictures, relationships, entries, slideIndex,
     picture => importPicture(entries, picture, slidePath, relationships, diagnostic => {
       // The recorded fit is re-derived from design.watermark.
@@ -684,12 +737,22 @@ function importSlide(entries, slidePath, slideIndex, presentationDimensions, opt
   // fill an absent role by geometry; explicit native placeholders still apply.
   const inferHeadings = !items.some(item => item.heading||item.sourceText);
   const heading = field => {const index=items.findIndex(item=>item.heading===field);return index<0?null:items.splice(index,1)[0];};
+  // FA-10: a heading is its plain text, or TextRun[] when its native runs are formatted differently from one another (the way
+  // body text reads current native runs). A tagged line group brings its own value; one native shape (a title placeholder, or the
+  // shape the importer took for the title) is read through the native body reader.
+  const headingText = item => {
+    const key = item.sources?.length === 1 ? /^sp:(\d+)$/.exec(item.sources[0]) : null;
+    const parts = item.richText === undefined && key ? joinRichLines([{index: Number(key[1])}], nativeContext.readBody, () => '') : undefined;
+    const value = item.richText ?? (parts ? headingValue(parts) : undefined);
+    // Only when it reads as the same words as the plain path: the native text is authoritative.
+    return Array.isArray(value) && value.map(run => typeof run === 'string' ? run : run.text).join('') === item.text ? value : item.text;
+  };
   const tagItem=heading('tag');
-  if(tagItem)slide.tag=tagItem.text;
+  if(tagItem)slide.tag=headingText(tagItem);
   const titleItem = heading('title')??takeTitleItem(items, dimensions, inferHeadings);
-  if (titleItem) slide.title = titleItem.text;
+  if (titleItem) slide.title = headingText(titleItem);
   const subtitleItem = heading('subtitle')??takeSubtitleItem(items, titleItem, dimensions, inferHeadings);
-  if (subtitleItem) slide.subtitle = subtitleItem.text;
+  if (subtitleItem) slide.subtitle = headingText(subtitleItem);
 
   // Heading inference keeps its existing scalar/native metrics. Only remaining
   // ordinary body shapes gain current rich values; tagged recovery is separate.
@@ -760,16 +823,21 @@ function collectSlideItems(entries, slideRoot, slidePath, relationships, dimensi
   nativeContext.signalRoles = roles;
   const readBody = nativeBodyReader(slidePath, {
     part: (path, parser) => parseRequiredXml(entries, path, parser), relationships: path => parseRelationships(entries, path), bytes: path => entries[path]
-  }, relationships, diagnostic => options.onDiagnostic?.({...diagnostic,path:`slides.${slideIndex}.${diagnostic.path}`}));
+  }, relationships, diagnostic => options.onDiagnostic?.({...diagnostic,path:`slides.${slideIndex}.${diagnostic.path}`}), {deckLang: options.deckLang, codeFamily: options.codeFamily});
   const code = importCodeGroups(shapes, paragraphs, relationships, entries, diagnostic => options.onDiagnostic?.({...diagnostic,path:`slides.${slideIndex}.code`}));
   const metric = importMetricGroups(shapes, paragraphs, relationships, entries, diagnostic => options.onDiagnostic?.({...diagnostic,path:`slides.${slideIndex}.metric`}));
   const cards = importCardFrames(shapes, paragraphs, relationships, entries, diagnostic => options.onDiagnostic?.({...diagnostic,path:`slides.${slideIndex}`}));
   const media = importMediaGroups(shapes, paragraphs, relationships, entries, slideIndex, diagnostic => options.onDiagnostic?.(diagnostic), nativeContext.mediaRegistry);
   nativeContext.mediaAssets = media.assets;
-  const headings=importHeadingGroups(shapes,paragraphs,relationships,entries,diagnostic=>options.onDiagnostic?.({...diagnostic,path:`slides.${slideIndex}`}));
+  nativeContext.readBody=readBody;
+  const headings=importHeadingGroups(shapes,paragraphs,relationships,entries,diagnostic=>options.onDiagnostic?.({...diagnostic,path:`slides.${slideIndex}`}),readBody);
   const plainText=importPlainTextGroups(shapes,paragraphs,relationships,entries,diagnostic=>options.onDiagnostic?.({...diagnostic,path:`slides.${slideIndex}`}));
   const timelines=importTimelineGroups(shapes,paragraphs,relationships,entries,diagnostic=>options.onDiagnostic?.({...diagnostic,path:`slides.${slideIndex}`}));
-  const quotes=importQuoteGroups(shapes,paragraphs,relationships,entries,diagnostic=>options.onDiagnostic?.({...diagnostic,path:`slides.${slideIndex}.quote`}));
+  const quotes=importQuoteGroups(shapes,paragraphs,relationships,entries,diagnostic=>options.onDiagnostic?.({...diagnostic,path:`slides.${slideIndex}.quote`}),nativeContext.pictures,
+    picture=>importPicture(entries,picture,slidePath,relationships,diagnostic=>{
+      // The recorded crop is re-derived from the circular frame of the quote photo.
+      if(diagnostic.code!=='unsupported-image-crop')options.onDiagnostic?.({...diagnostic,path:`slides.${slideIndex}.quote.photo`});
+    }),readBody);
   // RR-34: tagged caption and footnote lines are not content; captions re-attach to their media block and notes rebuild cite/footnote.
   const annotations=importAnnotations({shapes,paragraphs,relationships,entries,slideIndex,readBody,report:diagnostic=>options.onDiagnostic?.(diagnostic)});
   nativeContext.annotations=annotations;
@@ -778,7 +846,7 @@ function collectSlideItems(entries, slideRoot, slidePath, relationships, dimensi
     if(item){
       const bounds=group.shapes.map(shape=>shapeBounds(shape['p:spPr']?.['a:xfrm'])).filter(Boolean);
       if(bounds.length){const x=Math.min(...bounds.map(b=>b.x)),y=Math.min(...bounds.map(b=>b.y));item.bounds={x,y,w:Math.max(...bounds.map(b=>b.x+b.w))-x,h:Math.max(...bounds.map(b=>b.y+b.h))-y};}
-      items.push({...item,heading:group.field,sourceText:!group.field,sources:sourcesOf(group.shapes)});
+      items.push({...item,heading:group.field,sourceText:!group.field,sources:sourcesOf(group.shapes),...(group.richText!==undefined?{richText:group.richText}:{})});
     }
   }
   for(const group of timelines.items){
@@ -787,18 +855,18 @@ function collectSlideItems(entries, slideRoot, slidePath, relationships, dimensi
     items.push({kind:'timeline',sourceText:true,bounds:union,payload:group.payload,sources:sourcesOf(group.shapes)});
   }
   for(const group of quotes.items){
-    const bounds=group.shapes.map(shape=>shapeBounds(shape['p:spPr']?.['a:xfrm'])).filter(Boolean);
+    const bounds=[...group.shapes.map(shape=>shapeBounds(shape['p:spPr']?.['a:xfrm'])),...group.pictures.map(picture=>shapeBounds(picture['p:spPr']?.['a:xfrm']))].filter(Boolean);
     let union;for(const bound of bounds){if(!union)union={...bound};else{const x=Math.min(union.x,bound.x),y=Math.min(union.y,bound.y);union={x,y,w:Math.max(union.x+union.w,bound.x+bound.w)-x,h:Math.max(union.y+union.h,bound.y+bound.h)-y};}}
-    items.push({kind:'quote',bounds:union,payload:group.payload,sources:sourcesOf(group.shapes)});
+    items.push({kind:'quote',bounds:union,payload:group.payload,sources:[...sourcesOf(group.shapes),...group.pictures.map(picture=>`pic:${nativeContext.pictures.indexOf(picture)}`)]});
   }
   for (const item of code.items) items.push({kind:'code',bounds:shapeBounds(item.shape['p:spPr']?.['a:xfrm']),payload:item.payload,sources:sourcesOf([item.shape])});
   for (const item of metric.items) items.push({kind:'metric',bounds:shapeBounds(item.shape['p:spPr']?.['a:xfrm']),payload:item.payload,sources:sourcesOf([item.shape])});
   for (const item of media.items) items.push({kind:'media',sourceText:item.payload.type==='text',bounds:shapeBounds(item.shape['p:spPr']?.['a:xfrm']),payload:item.payload,sources:sourcesOf([item.shape])});
   for (const [index,shape] of shapes.entries()) {
-    const role = furniture.text.has(index) ? 'furniture' : nativeContext.slideImageShapes?.has(index) ? 'slide-image' : nativeContext.logoPlaceholderShapes?.has(index) ? 'logo' : cards.has(shape) ? 'card-frame'
+    const role = furniture.text.has(index) ? 'furniture' : nativeContext.imageShapes?.has(index) ? 'image-overlay' : nativeContext.watermarkShapes?.has(index) ? 'watermark' : nativeContext.logoPlaceholderShapes?.has(index) ? 'logo' : cards.has(shape) ? 'card-frame'
       : code.consumed.has(shape) ? 'code' : metric.consumed.has(shape) ? 'metric' : media.consumed.has(shape) ? 'media' : timelines.consumed.has(shape) ? 'timeline' : quotes.consumed.has(shape) ? 'quote' : undefined;
     if (role) roles.set(shapeKeys.get(shape), role);
-    if (furniture.text.has(index) || nativeContext.slideImageShapes?.has(index) || nativeContext.logoPlaceholderShapes?.has(index)) continue;
+    if (furniture.text.has(index) || nativeContext.imageShapes?.has(index) || nativeContext.watermarkShapes?.has(index) || nativeContext.logoPlaceholderShapes?.has(index)) continue;
     if (annotations.consumed.has(shape)) { roles.set(shapeKeys.get(shape), 'annotation'); continue; }
     if (code.consumed.has(shape)||metric.consumed.has(shape)||cards.has(shape)||media.consumed.has(shape)||headings.consumed.has(shape)||plainText.consumed.has(shape)||timelines.consumed.has(shape)||quotes.consumed.has(shape)) continue;
     const ordinaryBody = Object.hasOwn(shape, 'p:txBody') && !shape['p:nvSpPr']?.['p:nvPr']?.['p:custDataLst']?.['p:tags'];
@@ -834,10 +902,13 @@ function collectSlideItems(entries, slideRoot, slidePath, relationships, dimensi
   }
 
   for (const [index, picture] of nativeContext.pictures.entries()) {
-    const pictureRole = furniture.pictures.has(index) ? 'furniture' : nativeContext.slideImagePictures?.has(index) ? 'slide-image' : nativeContext.watermarkPictures?.has(index) ? 'watermark' : nativeContext.logoPictures?.has(index) ? 'logo' : undefined;
+    const pictureRole = furniture.pictures.has(index) ? 'furniture' : nativeContext.imagePictures?.has(index) ? 'background' : nativeContext.watermarkPictures?.has(index) ? 'watermark' : nativeContext.logoPictures?.has(index) ? 'logo' : quotes.consumedPictures.has(picture) ? 'quote' : undefined;
     if (pictureRole) { roles.set(`pic:${index}`, pictureRole); continue; }
-    const report = diagnostic => options.onDiagnostic?.({...diagnostic, path: `slides.${slideIndex}.pictures.${index}`});
+    // A tagged, unchanged image block brings back its own fields (fit, focus, treatment, placement); its crop is theirs.
+    const treatment = nativeContext.imageBlocks?.get(index);
+    const report = diagnostic => { if (!(treatment && diagnostic.code === 'unsupported-image-crop')) options.onDiagnostic?.({...diagnostic, path: `slides.${slideIndex}.pictures.${index}`}); };
     const item = importPicture(entries, picture, slidePath, relationships, report);
+    if (item?.payload && treatment) item.payload = {...item.payload, ...structuredClone(treatment)};
     if (item) items.push({...item, sources: [`pic:${index}`]});
   }
 
@@ -916,15 +987,18 @@ function importGraphicFrame(entries, frame, slidePath, relationships, importedTa
       : chartFromRelationship(entries, slidePath, relationships, chartRelId, report);
     const stored = imported && record('chart');
     const part = relationships.get(chartRelId)?.path;
-    const chart = stored && part && entries[part]
+    const restored = stored && part && entries[part]
       ? restore('chart', imported, () => restoreChartData(imported, stored, chartEvidence(decodeText(entries[part])), {datasets: data.datasets, report: diagnostic => data.report?.('chart', diagnostic)}))
       : imported;
+    const chart = restored?.type === 'combo' ? elideComboDefault(restored, data.datasets) : restored;
+    // FA-09: the frame's descr (or PowerPoint's decorative marker) is the chart's text alternative.
+    const alt = chart ? readFrameAlt(frame["p:nvGraphicFramePr"]?.["p:cNvPr"]) : undefined;
     return {
       kind: "chart",
       bounds,
       name,
       payload: chart
-        ? { type: "chart", chart }
+        ? { type: "chart", chart: alt === undefined ? chart : { ...chart, alt } }
         : { type: "text", text: `PowerPoint chart: ${name || chartRelId}` }
     };
   }
@@ -1211,9 +1285,12 @@ function chartFromRelationship(entries, slidePath, relationships, relId, report)
   const plotArea = doc["c:chartSpace"]?.["c:chart"]?.["c:plotArea"];
   if (!plotArea) return null;
 
-  const chartNode = firstChartNode(plotArea);
+  // FA-15: a clustered column group with one or two line groups is a combo chart; its series are read in c:order.
+  const combo = comboFromNative(plotArea);
+  const comboSeries = combo ? comboSeriesOf(combo) : undefined;
+  const chartNode = combo ? {node: combo.bar, type: 'combo'} : firstChartNode(plotArea);
   if (!chartNode) return null;
-  const series = asArray(chartNode.node["c:ser"]);
+  const series = comboSeries ? comboSeries.map(entry => entry.ser) : asArray(chartNode.node["c:ser"]);
   if (series.length === 0) return null;
   if (series.length > MAX_CHART_CACHE_POINTS) {
     throw new OPFPptxError('invalid-chart-cache', 'Chart cache exceeds the 100,000-series import limit; reduce its series before importing.', {path: relationship.path});
@@ -1226,7 +1303,8 @@ function chartFromRelationship(entries, slidePath, relationships, relId, report)
   const xCode = chartNode.type === 'scatter' ? cacheFormatCode(series[0]?.["c:xVal"]) : undefined;
   // RR-35: axis titles, legend position and data labels read back into the chart's option fields.
   const withOptions = chart => {
-    const {options, notes} = chartOptionsFromClassic(doc["c:chartSpace"], {chartNode: chartNode.node, target: chartTargetFor(chartNode.type), seriesCount: series.length, circular: chartNode.type === 'pie' || chartNode.type === 'doughnut', scatter: chartNode.type === 'scatter', seriesFormats: valueCodes});
+    const {options, notes} = chartOptionsFromClassic(doc["c:chartSpace"], {chartNode: chartNode.node, target: chartTargetFor(chartNode.type), seriesCount: series.length, circular: chartNode.type === 'pie' || chartNode.type === 'doughnut', scatter: chartNode.type === 'scatter', seriesFormats: valueCodes,
+      ...(combo ? {combo: {lineNode: combo.lines[0]?.node, secondaryValueAxis: secondaryValueAxisOf(plotArea, combo)}} : {})});
     for (const note of notes) report?.(note);
     if (budget.rejected?.length) report?.({code: 'chart-value-not-numeric', option: 'data', message: `${budget.rejected.length} cached chart ${budget.rejected.length === 1 ? 'value is' : 'values are'} not a number (first at ${budget.rejected[0]}) and ${budget.rejected.length === 1 ? 'imports as a gap' : 'import as gaps'}, never as a guessed value.`});
     return chart && Object.keys(options).length ? {...chart, ...options} : chart;
@@ -1257,10 +1335,57 @@ function chartFromRelationship(entries, slidePath, relationships, relId, report)
     data: {
       columns: formattedColumns([readChartCategoryHeading(entries,relationship.path) ?? "Category", ...names], [undefined, ...valueCodes], report),
       rows
-    }
+    },
+    ...(comboSeries ? comboFields(comboSeries, names, report) : {})
   });
 }
 
+// FA-15: the series of a combo plot area with their role and axis, in c:order (document order breaks ties).
+function comboSeriesOf(combo) {
+  const entries = [
+    ...asArray(combo.bar["c:ser"]).map(ser => ({ser, role: 'bar', secondary: false})),
+    ...combo.lines.flatMap(group => asArray(group.node["c:ser"]).map(ser => ({ser, role: 'line', secondary: group.secondary}))),
+  ];
+  const order = (entry, index) => {
+    const value = Number(entry.ser?.["c:order"]?.val);
+    return Number.isFinite(value) ? value : index;
+  };
+  return entries.map((entry, index) => ({...entry, key: order(entry, index), index})).sort((a, b) => a.key - b.key || a.index - b.index);
+}
+
+// The c:valAx a secondary line group plots against (its axis that the column group does not use), or undefined.
+function secondaryValueAxisOf(plotArea, combo) {
+  const group = combo.lines.find(entry => entry.secondary);
+  if (!group) return undefined;
+  const ids = new Set(asArray(group.node["c:axId"]).map(axis => String(axis?.val)));
+  return asArray(plotArea["c:valAx"]).find(axis => ids.has(String(axis?.["c:axId"]?.val)));
+}
+
+// `line` and `secondaryAxis` of an imported combo chart by series name (elideComboDefault drops a `line` that is the default).
+// Combo lines always draw markers in OPF; a native line without markers is reported, never silently changed.
+function comboFields(comboSeries, names, report) {
+  const line = names.filter((_, index) => comboSeries[index].role === 'line');
+  const secondaryAxis = names.filter((_, index) => comboSeries[index].secondary);
+  const unmarked = names.filter((_, index) => comboSeries[index].role === 'line' && comboSeries[index].ser?.["c:marker"]?.["c:symbol"]?.val === 'none');
+  if (unmarked.length) report?.({option: 'line', message: `The combo chart's line ${unmarked.length === 1 ? 'series' : 'series'} ${unmarked.map(name => `'${name}'`).join(', ')} ${unmarked.length === 1 ? 'has' : 'have'} no markers; OPF combo lines always draw markers, so ${unmarked.length === 1 ? 'it imports' : 'they import'} with markers.`});
+  if (new Set(line).size !== line.length || new Set(names).size !== names.length) {
+    report?.({option: 'line', message: 'Two series of the combo chart share a name, so which of them is a line cannot be said by name; the chart imports with its default line (the last series).'});
+    return {};
+  }
+  return {...(line.length ? {line} : {}), ...(secondaryAxis.length ? {secondaryAxis} : {})};
+}
+
+// An imported combo chart writes `line` only when it differs from the default (the last plotted series), judged on the final
+// data (a restored data record can order the columns differently from the native series).
+function elideComboDefault(chart, datasets) {
+  if (!Array.isArray(chart.line)) return chart;
+  const {line, ...rest} = chart;
+  const resolved = resolveChartData(rest, {datasets: datasets ?? {}});
+  if (!resolved.ok || !Array.isArray(resolved.combo)) return chart;
+  const defaults = resolved.columns.slice(1).filter((_, index) => resolved.combo[index]?.role === 'line');
+  return defaults.length === line.length && defaults.every(name => line.includes(name)) ? rest : chart;
+}
+
 // The format code of a numeric cache (c:numRef/c:numCache or c:numLit), or undefined.
 function cacheFormatCode(node) {
   const cache = node?.["c:numRef"]?.["c:numCache"] ?? node?.["c:numLit"];
@@ -1505,60 +1630,72 @@ function parseInput(input) {
 // required variable is refused. Decks without content variables are returned untouched. The package stores the resolved
 // deck, not the template form, so fromPptx returns the filled deck.
 function resolveTemplateInput(presentation, options) {
-  if (typeof opfCore.resolveVariables !== "function" || !isPlainObject(presentation)) return presentation;
+  if (!isPlainObject(presentation)) return presentation;
   const values = options.variables;
   if (values !== undefined && !isPlainObject(values)) {
     throw new OPFPptxError("invalid-variables", "The variables option must be an object keyed by variable id.", {path: "options.variables"});
   }
-  const template = opfCore.isTemplate(presentation);
-  if (!template && !opfCore.hasContentVariables(presentation) && !(values && Object.keys(values).length)) return presentation;
-  const result = opfCore.resolveVariables(presentation, values ?? {}, {examples: template});
+  const template = isTemplate(presentation);
+  if (!template && !hasContentVariables(presentation) && !(values && Object.keys(values).length)) return presentation;
+  const result = resolveVariables(presentation, values ?? {}, {examples: template});
   const errors = result.diagnostics.filter(entry => entry.severity === "error");
   if (errors.length) {
-    throw new OPFPptxError(errors.some(entry => entry.code === "variable-unfilled") ? "unfilled-variables" : "invalid-variables", errors[0].message, {issues: errors, path: errors[0].path});
+    throw new OPFPptxError(errors.some(entry => entry.code === "variable-unfilled") ? "unfilled-variables" : "invalid-variables", errors[0].message, {findings: errors, path: errors[0].path});
   }
   for (const entry of result.diagnostics) {
-    if (entry.code === "variable-example-used") options.onDiagnostic?.({code: "variable-example-used", path: entry.path, message: entry.message, id: entry.id});
+    if (entry.code === "variable-example-used" || entry.code === "variable-builtin-missing") options.onDiagnostic?.({code: entry.code, path: entry.path, message: entry.message, id: entry.id});
   }
   return result.presentation;
 }
 
 function assertValidBoundary(presentation) {
-  const result = validatePresentation(presentation);
-  if (!result.valid) {
+  const report = checkFormat(presentation);
+  if (!report.valid) {
     throw new OPFPptxError("invalid-opf", "OPF validation failed.", {
-      issues: result.errors,
-      result
+      findings: report.findings.filter(finding => finding.severity === "error"),
+      report
     });
   }
 }
 
-function resolvePresentationContext(presentation, options) {
+// RR-55: what a slide (or, for the deck level, an empty slide) resolves to in core, the one chain every engine shares: canvas,
+// layout, font families, alignment and content box as composeSlide's options, plus the theme, colour scheme and font scheme
+// records they came from. `diagnostics` names references that matched no record.
+// Core's slide context with the host's registered catalogs. Under strict export core throws OPFUnresolvedReferenceError for a
+// reference that resolves nowhere; the export fails with `unresolved-reference` naming the first one (its path and every diagnostic).
+function coreContext(presentation, index, options) {
+  try {
+    return resolveCoreSlideContext(presentation, index, {fonts: options.textMeasurement ? {textMeasurement: options.textMeasurement} : undefined, date: options.date,
+      ...(options.catalogs !== undefined ? {catalogs: options.catalogs} : {}), strictReferences: options.strictReferences === true});
+  } catch (error) {
+    if (error?.name !== "OPFUnresolvedReferenceError" || !Array.isArray(error.diagnostics)) throw error;
+    const [first] = error.diagnostics;
+    throw new OPFPptxError("unresolved-reference", `Strict export: ${error.message}`, {path: first?.path, diagnostics: error.diagnostics});
+  }
+}
+
+// The families composition and the package use: core's, with the measurement provider's own resolution of the chosen family
+// (FF-31) applied to the three roles the exporter writes.
+function exportFonts(core, textMeasurement) {
+  const {fontFamilies} = core.options, scheme = core.resolved.fontScheme;
+  const fonts = {id: scheme.id, ...fontFamilies, scheme: {type: scheme.type, major: scheme.major, minor: scheme.minor}};
+  for (const role of ["heading", "body", "code"]) fonts[role] = resolveTextStyle({fontFamily: fonts[role], fontWeight: role === "heading" ? 700 : 400}, textMeasurement).fontFamily;
+  return fonts;
+}
+
+function resolvePresentationContext(presentation, options, core = coreContext({...presentation, slides: [{}]}, 0, {...options, textMeasurement: undefined})) {
   const design = presentation.design ?? {};
-  const theme = resolveDesignRecord(presentation, "themes", design.theme, DEFAULTS.theme);
-  const colorScheme = resolveDesignRecord(
-    presentation,
-    "colorSchemes",
-    design.colorScheme ?? theme?.colorScheme,
-    DEFAULTS.colorScheme
-  );
-  const fontScheme = resolveDesignRecord(
-    presentation,
-    "fontSchemes",
-    design.fontScheme ?? theme?.fontScheme,
-    DEFAULTS.fontScheme
-  );
-  // Shared rule (core resolveFontSchemeReference): an unresolved id falls back to the
-  // DEFAULTS.fontScheme record as the base; resolveSlideContext reports it once per path.
-  const fontSchemeId = referenceId(design.fontScheme ?? theme?.fontScheme);
-  const unresolvedFontScheme = fontSchemeId && !findById(normalizeRecords(presentation.catalogs?.fontSchemes), fontSchemeId) && !findById(defaultCatalog("fontSchemes"), fontSchemeId) ? fontSchemeId : null;
-  const dimensions = resolveDimensions(design.dimensions ?? theme?.dimensions);
+  // `core` defaults to the deck level: the resolution of a slide that sets nothing of its own.
+  // The theme and colour scheme records come from core, which falls back to the engine defaults (reporting unresolved-reference)
+  // for a reference that resolves nowhere.
+  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 fonts = resolveFonts(fontScheme);
-  for (const role of ["heading","body","code"]) fonts[role] = resolveTextStyle({fontFamily:fonts[role],fontWeight:role === "heading" ? 700 : 400},options.textMeasurement).fontFamily;
-  const textColor = readableTextColor(background, colorScheme);
-  const darkBackground = isDarkHex(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}`});
+  const textColor = normalizeHex(roles.text);
 
   return {
     seed: Number.isInteger(options.seed) ? options.seed : DEFAULT_SEED,
@@ -1568,16 +1705,19 @@ function resolvePresentationContext(presentation, options) {
     compressionLevel: Number.isInteger(options.compressionLevel) ? options.compressionLevel : 6,
     layoutName: "OPF_CANVAS",
     dimensions,
+    theme,
     colorScheme,
     backgroundDefinition: design.background ?? theme?.background,
     fonts,
-    unresolvedFontScheme,
+    // The color roles a ColorRef names (primary, secondary, accent, background, surface, text, textSecondary, hyperlink).
+    roles,
     colors: {
       background,
       text: textColor,
-      mutedText: normalizeHex(colorScheme.textSecondary ?? (darkBackground ? colorScheme.light2 : colorScheme.dark2) ?? "#475569"),
-      accent: normalizeHex(colorScheme.primary ?? colorScheme.accent1 ?? "#2874A6"),
-      surface: normalizeHex(colorScheme.surface ?? (darkBackground ? colorScheme.dark2 : colorScheme.light2) ?? "#F8FAFC"),
+      mutedText: normalizeHex(roles.textSecondary),
+      // The primary color, which the exporter draws accent fills (table headers, tag, media badge) in. The `accent` ColorRef role is roles.accent.
+      accent: normalizeHex(roles.primary),
+      surface: normalizeHex(roles.surface),
       border: normalizeHex(colorScheme.accent5 ?? "#CBD5E1")
     },
     variables
@@ -1618,11 +1758,31 @@ function contrastRatio(first, second) {
   const a = relativeLuminance(first), b = relativeLuminance(second);
   return (Math.max(a, b) + 0.05) / (Math.min(a, b) + 0.05);
 }
+// The tag's color as a literal (the one tagColor writes, resolved).
+function tagHex(context) {
+  return contrastRatio(context.colors.accent, context.colors.background) < TAG_MIN_CONTRAST ? context.colors.text : context.colors.accent;
+}
+
+// The defaults a rich heading or quote body is exported with on every run (weight, color, size, family). The tag records them so that
+// import can tell the heading's own look from run formatting the author chose.
+function richBase(fit, style, color) {
+  const font = nativeFontOptions(style);
+  return {bold: font.bold === true, color: `#${normalizeHex(color)}`, fontSize: Math.round(fit.fontSize * .75 * 100) / 100, fontFamily: font.fontFace};
+}
+
 function tagColor(context) {
   if (contrastRatio(context.colors.accent, context.colors.background) < TAG_MIN_CONTRAST) return context.textColor;
   return nativeColor('primary', context.colors.accent, context);
 }
 
+// A link run with no color of its own is written in the theme hyperlink color (a:schemeClr hlink where the deck theme
+// holds that exact color, else the literal), underlined by PowerPoint, as the preview draws it. A run color is kept.
+function linkColor(run, color, context) {
+  const link = typeof run?.link === 'string' && /^(https?:|mailto:|tel:)/i.test(run.link);
+  if (!link || !(run.color === undefined || run.color === null || run.color === '')) return color;
+  return nativeColor('hyperlink', normalizeHex(context.roles.hyperlink), context);
+}
+
 // 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']];
@@ -1658,20 +1818,28 @@ function masterBackground(context) {
 }
 
 // The theme part carries the deck-level scheme (slide overrides stay literal)
-// and, for an explicit catalog theme, that theme's name.
-function exportTheme(presentation, context) {
+// and, for a theme reference that resolves (embedded or in a registered catalog), that theme's name, which import
+// recovery matches against the registered catalogs (FF-24).
+function exportTheme(presentation, context, options) {
   const reference = presentation.design?.theme;
-  const id = referenceId(reference);
-  const theme = id ? resolveDesignRecord(presentation, "themes", reference, DEFAULTS.theme) : null;
+  const theme = typeof reference === "string" ? resolveReference(presentation, "themes", reference, {catalogs: options.catalogs}) : undefined;
   const scheme = context.colorScheme;
   return {
     themeColors: themeSlotColors(scheme),
     schemeName: scheme.name ?? scheme.id ?? "OpenPresentation",
-    themeName: theme?.id === id ? theme.name ?? theme.id : undefined
+    themeName: theme ? theme.record.name ?? theme.id : undefined
   };
 }
 
-function importThemeDesign(entries, presentationRoot, presentationRels) {
+// FF-24 recovery against the host's registered catalogs (FA-23). Only the first registered catalog, the host default, can be
+// named by a bare id in a document that declares no catalogs, so only its records are matched: an exact match imports as
+// that bare id. Everything else (no catalog registered, a scheme from another registered catalog, no exact match) imports
+// as an inline colour scheme, and no theme id is recovered.
+function hostDefaultRecords(kind, catalogs) {
+  return catalogRecords({}, kind, {catalogs: catalogs ?? []}).filter(entry => entry.group === "default").map(entry => ({...entry.record, id: entry.id}));
+}
+
+function importThemeDesign(entries, presentationRoot, presentationRels, catalogs) {
   const diagnostics = [], design = {};
   const report = (code, path, message) => diagnostics.push({code, path, message});
   const themePath = presentationThemePath(presentationRoot, presentationRels, path => parseRelationships(entries, path), entries);
@@ -1683,16 +1851,22 @@ function importThemeDesign(entries, presentationRoot, presentationRels) {
     return {design, diagnostics};
   }
   const {colors, unreadable} = readThemeSlotColors(clrScheme);
-  const records = defaultCatalog("colorSchemes");
+  const records = hostDefaultRecords("colorSchemes", catalogs);
   if (Object.keys(colors).length) design.colorScheme = recoverColorScheme({colors, unreadable, name: scalarText(clrScheme.name)}, records).value;
   if (unreadable.length) report("unsupported-theme-colors", "design.colorScheme", `Theme color slot(s) ${unreadable.join(", ")} do not resolve to an opaque sRGB color and were not imported.`);
   const latin = font => scalarText(elements?.["a:fontScheme"]?.[font]?.["a:latin"]?.typeface);
+  // A theme's own colour and font scheme references resolve in the theme's group first (core resolveReference).
+  const themeReference = (kind, reference) => {
+    const id = referenceId(reference);
+    const found = id ? resolveReference({}, kind, id, {catalogs: catalogs ?? [], group: "default"}) : undefined;
+    return found ? {...found.record, ...(isPlainObject(reference) ? reference : {})} : null;
+  };
   const recoveredTheme = recoverTheme({themeName: scalarText(theme?.name), colors, majorFont: latin("a:majorFont"), minorFont: latin("a:minorFont")}, {
-    themes: defaultCatalog("themes"),
-    colorSchemes: records,
-    fontFamilies: id => {
-      const record = findById(defaultCatalog("fontSchemes"), id);
-      return record ? resolveFontFamilies(record) : null;
+    themes: hostDefaultRecords("themes", catalogs),
+    colorScheme: record => themeReference("colorSchemes", record.colorScheme),
+    fontFamilies: record => {
+      const scheme = themeReference("fontSchemes", record.fontScheme);
+      return scheme ? resolveFontFamilies(scheme) : null;
     }
   });
   if (recoveredTheme.unverified) report("theme-unverified", "design.theme", `The native theme has the name of OPF catalog theme '${recoveredTheme.unverified}', but neither its color scheme nor its heading/body fonts match that theme, so design.theme was not set.`);
@@ -1719,59 +1893,45 @@ function configurePresentation(pptx, presentation, context) {
 
 async function addSlide(pptx, presentation, opfSlide, slideIndex, context, options) {
   const slide = pptx.addSlide();
-  const slideContext = resolveSlideContext(presentation, opfSlide, context, options, slideIndex);
+  const slideContext = exportSlideContext(presentation, slideIndex, context, options);
+  const { widthInches, heightInches } = slideContext.dimensions;
+  // A slide with no layout, or one whose layout resolves nowhere, is composed with no layout record (automatic composition),
+  // as in the preview; core reports the reference as unresolved-reference.
+  // Core's resolved options (canvas, layout, families, alignment, content box, darkBackground), with the exporter's own additions:
+  // the families after the measurement provider's resolution of the chosen family and the raster padding. Core formats socials
+  // handles from its own SOCIAL_PLATFORMS vocabulary.
+  const composeOptions = { ...slideContext.core.options, fontFamilies: slideContext.composeFonts, textRasterPadding:options.textRasterPadding };
+  // Core resolves every shared design key once (slide design, deck design, then the layout record's design): the text alignment of
+  // each item (item.alignment), and each image item's own fit and treatment (item.image).
+  const geometry = composeSlide(opfSlide, composeOptions);
+  // The default footer band (date left, text center, number right): where a footer added natively lands (RR-11).
+  if (slideIndex === 0) context.defaultFooterOptions = composeOptions;
   slide.background = { color: slideContext.colors.background };
-  const backgroundDefinition = slideContext.backgroundDefinition;
+  // An image background is core's geometry.backgroundImage (slide, deck, then theme background); every other kind is the
+  // effective design or theme background definition.
+  const backgroundDefinition = geometry.backgroundImage ? undefined : slideContext.backgroundDefinition;
   const backgroundPath = `${opfSlide.design?.background !== undefined ? `slides.${slideIndex}.` : ''}design.background`;
-  const backgroundFill = schemeBackgroundFill(backgroundDefinition, slideContext) ?? nativeBackgroundFill(backgroundDefinition, {
+  const backgroundFill = backgroundDefinition === undefined ? null : schemeBackgroundFill(backgroundDefinition, slideContext) ?? nativeBackgroundFill(backgroundDefinition, {
     width: slideContext.dimensions.widthInches, height: slideContext.dimensions.heightInches
   }, slideContext.colors.background, slideContext.colors.text, (reference, hex) => schemeColorValue(reference, hex, slideContext), reference => resolveBackgroundColorRef(reference, slideContext.colorScheme, slideContext.variables));
   if (backgroundFill) context.backgroundFills.set(`ppt/slides/slide${slideIndex + 1}.xml`, backgroundFill);
   if (backgroundDefinition?.type === 'pattern' && !nativePatternPreset(backgroundDefinition.pattern?.preset)) {
     options.onDiagnostic?.({code: 'unsupported-pattern', path: `${backgroundPath}.pattern.preset`, message: `Pattern ${backgroundDefinition.pattern?.preset} has no DrawingML preset; only its background color was exported.`});
   }
-  if (backgroundDefinition?.type === 'image') {
-    const imagePath = `${backgroundPath}.image`;
-    // An SVG background is its PNG raster at the slide's size: a slide background picture fill carries no SVG.
-    const outcome = { box: { w: slideContext.dimensions.widthInches, h: slideContext.dimensions.heightInches }, cover: (backgroundDefinition.image?.fit ?? 'cover') !== 'contain' };
-    const resolved = await resolveImage(backgroundDefinition.image, presentation, options, imagePath, outcome);
-    if (resolved) {
-      // PptxGenJS embeds the raster and its relationship; packaging replaces
-      // its stretched fill with the fitted native picture fill.
-      slide.background = { ...resolved };
-      context.backgroundFills.set(`ppt/slides/slide${slideIndex + 1}.xml`, { image: {
-        fit: backgroundDefinition.image?.fit ?? 'cover', opacity: backgroundDefinition.opacity ?? 1, imageFill: slideContext.imageFill, path: imagePath,
-        width: slideContext.dimensions.widthInches * 96, height: slideContext.dimensions.heightInches * 96, report: options.onDiagnostic
-      } });
-    } else if (!outcome.reported) {
-      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.textColor;
   if (opfSlide.hidden === true) slide.hidden = true;
 
-  const { widthInches, heightInches } = slideContext.dimensions;
-  const layout = resolveCatalogRecord(presentation, "layouts", opfSlide.layout, "blank") ?? {};
-  if (opfSlide.layout && layout.id !== opfSlide.layout) throw new OPFPptxError("catalog-resolution-failed", `Layout '${opfSlide.layout}' needs an inline or bundled catalog record.`, { path: `slides.${slideIndex}.layout` });
-  // design.titleAlignment/contentAlignment are Design properties (slide design
-  // overrides the deck). Core only returns an accepted `placement.alignment`
-  // with outline measurement, so the same effective values must also drive
-  // text without placement, exactly as the renderer's preview does.
-  const titleAlignment=opfSlide.design?.titleAlignment??presentation.design?.titleAlignment;
-  const contentAlignment=opfSlide.design?.contentAlignment??presentation.design?.contentAlignment;
-  const fieldAlignment=field=>field==='title'?titleAlignment:contentAlignment;
-  // Core composition resolves one alignment per composed item for every engine
-  // (FF-29); the design fallback keeps cores published before item.alignment working.
-  const alignmentFor=item=>item.alignment??fieldAlignment(item.field);
-  const composeOptions = { width: widthInches * 96, height: heightInches * 96, layout, presentation, slideIndex, fonts: slideContext.fonts, contentAlignment, titleAlignment, textRasterPadding:options.textRasterPadding, contentBox:opfSlide.design?.contentBox??presentation.design?.contentBox, darkBackground: isDarkHex(slideContext.colors.background), textMeasurement: options.textMeasurement, date: options.date, socialPlatforms: socialPlatformRecords(presentation, options) };
-  const geometry = composeSlide(opfSlide, composeOptions);
-  // The default footer band (date left, text center, number right): where a footer added natively lands (RR-11).
-  if (slideIndex === 0) context.defaultFooterOptions = composeOptions;
   for (const diagnostic of geometry.diagnostics) options.onDiagnostic?.(diagnostic);
   // The content topology (groups, regions, root form, block ids) with the leaf boxes this geometry draws.
   recordContentTopology(context.documentProvenance, opfSlide, slideIndex, geometry.items);
-  // The preview paints background, slide image (and its overlay), then design.watermark, then content.
-  if (geometry.slideImage) await addSlideImage(slide, presentation, geometry.slideImage, slideIndex, slideContext, options);
+  // Paint order, as in the preview (FA-22 contract): canvas colour, the background picture and its overlay, design.watermark,
+  // the logo, then the items in core's order: the headings, the placed image blocks at their bands, then the flowed body.
+  if (geometry.backgroundImage) await addBackgroundImage(slide, presentation, geometry.backgroundImage, slideIndex, slideContext, context, options);
+  // RR-34: a captioned image's caption band follows its picture as tagged text boxes linked to the picture by name.
+  const drawImage = async (item, itemContext) => {
+    const name = await addImageItem(slide, presentation, item, slideIndex, itemContext, options);
+    if (item.caption) addCaption(slide, item, name, itemContext, exportHelpers, (code, message) => new OPFPptxError(code, message, {path: item.caption.path}));
+  };
   await addWatermark(slide, presentation, opfSlide, slideIndex, slideContext, context, options);
   // Cover and section slides: the deck logo core composed at the top-left of the free area, after the watermark and before content.
   if (geometry.logo) await addLogo(slide, presentation, geometry.logo, slideIndex, slideContext, context, options);
@@ -1783,14 +1943,14 @@ async function addSlide(pptx, presentation, opfSlide, slideIndex, context, optio
       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=itemContext.colorScheme[isDarkHex(itemContext.colors.background)?'dark2':'light2']??`#${itemContext.colors.surface}`;
+      const surface=itemContext.colorScheme.surface??itemContext.colorScheme[itemContext.roles.dark?'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(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,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'?tagColor(itemContext):itemContext.textColor});
-    } else if (["title", "subtitle", "tag"].includes(item.field)) {
+      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:item.alignment,diagnosticsHandled:true,heading:['title','subtitle','tag'].includes(item.field)?item.field:undefined,color:item.field==='tag'?tagColor(itemContext):itemContext.textColor});
+    } else if (["title", "subtitle", "tag"].includes(item.field) && !item.text?.richLines) {
       // 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`;
@@ -1799,36 +1959,34 @@ async function addSlide(pptx, presentation, opfSlide, slideIndex, context, optio
         ...textBoxOptions(region, itemContext, item.text.fontSize * 0.75),
         ...nativeFontOptions(item.textStyle),
         color: item.field === "tag" ? tagColor(itemContext) : itemContext.textColor,
-        align: physicalAlignment(alignmentFor(item), item.text.directions?.[0]),
+        align: physicalAlignment(item.alignment, item.text.directions?.[0]),
         ...(item.text.directions?.[0] === 'rtl' ? {rtlMode: true} : {}),
         objectName,
         breakLine: false
       });
     } else if ((item.field === "items" || item.field === "bullets") && item.text?.listEntries) {
       await addMeasuredList(slide,item.text,itemContext,item.path,item.bulletImage,presentation,slideIndex,options,item.payload?.numbering!==undefined);
-    } else if (item.field === "text" && item.text?.richLines) {
-      const logicalAlignment=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,itemContext,itemContext.colors.text);
-          const color=nativeColor(fragment.run.color,runColor,itemContext,itemContext.textColor);
-          return {text:fragment.text,options:{...nativeFontOptions(fragment.style),fontSize:(fragment.nominalSize??fragment.fontSize)*.75,color,underline:fragment.run.underline?{style:'sng',color}:undefined,strike:fragment.run.strikethrough?'sngStrike':undefined,baseline:fragment.baselineShift?-fragment.baselineShift/(fragment.nominalSize??fragment.fontSize)*2000:undefined,hyperlink:fragment.run.link&&/^(https?:|mailto:)/i.test(fragment.run.link)?{url:fragment.run.link}:undefined}};
-        });
-        // Logical alignment (RR-05): a right-to-left paragraph starts at the right edge; every wrapped line shares its paragraph's direction.
-        const placed=item.text.placement?.lines[index],alignment=placed?.alignment??physicalAlignment(logicalAlignment,item.text.directions?.[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};
-        // PptxGenJS reads the paragraph direction from the first run's options, not from the shape options.
-        if(item.text.directions?.[index]==='rtl')for(const run of runs)run.options.rtlMode=true;
-        if(runs.length)slide.addText(runs,{...textBoxOptions(area,itemContext,item.text.fontSize*.75),align:alignment,fit:'none',wrap:false,lineSpacingMultiple:1});
-      }
+    } else if (["text", "title", "subtitle", "tag"].includes(item.field) && item.text?.richLines) {
+      // FA-10: a TextRun[] heading draws and exports like rich body text; its lines are named and tagged as a heading (the body's are not).
+      const heading = item.field !== 'text';
+      addRichFitLines(slide, item.text, item.box, itemContext, {
+        value: item.value, alignment: item.text.placement?.alignment ?? item.alignment ?? 'left',
+        fallback: item.field === 'tag' ? tagColor(itemContext) : itemContext.textColor,
+        ...(heading ? {
+          objectName: index => `OPF heading ${item.path} line ${index}`,
+          tag: (name, index, count, boundary) => context.headingTags.set(name, {v: 1, group: item.path, field: item.field, line: index, count, ...boundary, base: richBase(item.text, item.textStyle, item.field === 'tag' ? tagHex(itemContext) : itemContext.colors.text)})
+        } : {})
+      });
     } else if (item.field === "text" && typeof item.value === "string") {
-      slide.addText(item.text.lines.join("\n"), {...textBoxOptions(region, itemContext, item.text.fontSize * 0.75),...nativeFontOptions(item.textStyle),align:physicalAlignment(alignmentFor(item), item.text.directions?.[0])});
+      slide.addText(item.text.lines.join("\n"), {...textBoxOptions(region, itemContext, item.text.fontSize * 0.75),...nativeFontOptions(item.textStyle),align:physicalAlignment(item.alignment, item.text.directions?.[0])});
+    } else if (item.field === "image" && item.image) {
+      await drawImage(item, itemContext);
     } else {
       // RR-34: a captioned item draws its media in item.box; the caption band follows as tagged text boxes linked to the media shape by name.
-      const mediaNames = item.caption ? new Set([...context.imagePlacements.keys(), ...context.imagePlaceholders.keys(), ...context.chartHeadings.keys(), ...context.tableHeaders.keys()]) : undefined;
-      await addPayload(slide, presentation, item.payload, region, item.path, { ...itemContext, composition: item.composition, contentAlignment: alignmentFor(item) ?? "left", direction: geometry.direction }, options, item.quoteLayout, item.codeLayout,item.metricLayout,item.timelineLayout);
+      const mediaNames = item.caption ? new Set([...context.images.keys(), ...context.imagePlaceholders.keys(), ...context.chartHeadings.keys(), ...context.tableHeaders.keys()]) : undefined;
+      await addPayload(slide, presentation, item.payload, region, item.path, { ...itemContext, composition: item.composition, contentAlignment: item.alignment ?? "left", direction: geometry.direction }, options, item.quoteLayout, item.codeLayout,item.metricLayout,item.timelineLayout);
       if (item.caption) {
-        const mediaName = item.field === 'video' ? `OPF media ${item.path} frame` : [...context.imagePlacements.keys(), ...context.imagePlaceholders.keys(), ...context.chartHeadings.keys(), ...context.tableHeaders.keys()].find(name => !mediaNames.has(name));
+        const mediaName = item.field === 'video' ? `OPF media ${item.path} frame` : [...context.images.keys(), ...context.imagePlaceholders.keys(), ...context.chartHeadings.keys(), ...context.tableHeaders.keys()].find(name => !mediaNames.has(name));
         addCaption(slide, item, mediaName, itemContext, exportHelpers, (code, message) => new OPFPptxError(code, message, {path: item.caption.path}));
       }
     }
@@ -1847,24 +2005,24 @@ async function addSlide(pptx, presentation, opfSlide, slideIndex, context, optio
   }
 }
 
-function resolveSlideContext(presentation, slide, baseContext, options, slideIndex = 0) {
+// One slide's export context: core's resolveSlideContext (`core`: composeSlide's options, the records and the diagnostics) and
+// the exporter's colours and measurement-resolved families derived from it.
+function exportSlideContext(presentation, slideIndex, baseContext, options) {
+  const slide = presentation.slides[slideIndex];
   const effective = { ...presentation, design: { ...presentation.design, ...slide.design } };
-  const resolved = resolvePresentationContext(effective, options);
-  if (resolved.unresolvedFontScheme) {
-    const path = slide.design?.fontScheme !== undefined ? `slides.${slideIndex}.design.fontScheme`
-      : presentation.design?.fontScheme !== undefined ? "design.fontScheme"
-      : slide.design?.theme !== undefined ? `slides.${slideIndex}.design.theme` : "design.theme";
-    if (!baseContext.reportedFontSchemes?.has(path)) {
-      baseContext.reportedFontSchemes?.add(path);
-      const id = resolved.unresolvedFontScheme;
-      options.onDiagnostic?.({ code: "unresolved-font-scheme", path, id, fallback: DEFAULTS.fontScheme, message: `Font scheme '${id}' is not in the inline or bundled catalogs; using the default font scheme '${DEFAULTS.fontScheme}'.` });
-    }
+  const core = coreContext(presentation, slideIndex, options);
+  const resolved = resolvePresentationContext(effective, options, core);
+  // A reference that matched no record is reported once per place it is written.
+  for (const diagnostic of core.diagnostics) {
+    if (baseContext.reportedReferences?.has(diagnostic.path)) continue;
+    baseContext.reportedReferences?.add(diagnostic.path);
+    options.onDiagnostic?.(diagnostic);
   }
   if (Math.abs(resolved.dimensions.widthInches - baseContext.dimensions.widthInches) > 1e-6
     || 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.");
   }
-  const slideContext = { ...baseContext, backgroundDefinition: resolved.backgroundDefinition, colorScheme: resolved.colorScheme, fonts: resolved.fonts, colors: resolved.colors, variables: resolved.variables, imageFill: effective.design.imageFill ?? "fit" };
+  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 };
   // 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 ?? {};
@@ -1909,7 +2067,7 @@ async function addPayload(slide, presentation, payload, region, path, context, o
       addMetricPayload(slide, payload.metric,metricLayout,context,path,options);
       break;
     case "quote":
-      addQuotePayload(slide, payload.quote, quoteLayout, context, options, path);
+      await addQuotePayload(slide, presentation, payload.quote, quoteLayout, context, options, path);
       break;
     case "timeline":
       addTimelinePayload(slide, payload.timeline, timelineLayout, context, options, path);
@@ -1946,7 +2104,7 @@ 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,native);
-    return {text:fragment.text,options:{...nativeFontOptions(fragment.style),fontSize:(fragment.nominalSize??fragment.fontSize)*.75,color,underline:fragment.run.underline?{style:'sng',color}:undefined,strike:fragment.run.strikethrough?'sngStrike':undefined,baseline:fragment.baselineShift?-fragment.baselineShift/(fragment.nominalSize??fragment.fontSize)*2000:undefined,hyperlink:fragment.run.link&&/^(https?:|mailto:)/i.test(fragment.run.link)?{url:fragment.run.link}:undefined}};
+    return {text:fragment.text,options:{...nativeFontOptions(fragment.style),fontSize:(fragment.nominalSize??fragment.fontSize)*.75,color:linkColor(fragment.run,color,context),underline:fragment.run.underline?{style:'sng',color:linkColor(fragment.run,color,context)}:undefined,strike:fragment.run.strikethrough?'sngStrike':undefined,baseline:fragment.baselineShift?-fragment.baselineShift/(fragment.nominalSize??fragment.fontSize)*2000:undefined,hyperlink:fragment.run.link&&/^(https?:|mailto:|tel:)/i.test(fragment.run.link)?{url:fragment.run.link}:undefined,...langOptions(context,fragment.style.lang)}};
   });
 }
 // Every native line of a list, marker paragraph or not, is named for the list's
@@ -2044,27 +2202,131 @@ function addListPayload(slide, items, region, context) {
   slide.addText(runs, textBoxOptions(region, context, 15));
 }
 
+// A content picture outside an image block (a timeline event image): one native picture contained in its region.
 async function addImagePayload(slide, presentation, asset, region, path, context, options) {
-  const outcome = { box: region, cover: context.imageFill === 'crop' };
+  const name = await addImagePicture(slide, presentation, asset, region, path, context, options, {fit: 'contain'});
+  if (!name) addImagePlaceholder(slide, presentation, asset, region, path, context, options);
+  return name;
+}
+
+// One native image picture at `box` (inches), fitted at packaging (src/image-provenance.js placeImages). `treatment` is
+// what OPF_IMAGE_V1 stores (the authored block fields); without it the picture is untagged. Returns the picture's object
+// name, or undefined when the source could not be embedded (the caller draws the unavailable-image panel).
+async function addImagePicture(slide, presentation, asset, box, path, context, options, {fit, focus, effects = null, shrink = true, treatment, alt, role = 'block', objectName} = {}) {
+  const outcome = { box, cover: fit === 'cover' };
   const resolved = await resolveImage(asset, presentation, options, path, outcome);
-  if (!resolved) {
-    addImagePlaceholder(slide, presentation, asset, region, path, context, options);
-    return;
+  if (!resolved) return undefined;
+  const name = objectName ?? imageName(1 + [...context.images.keys()].filter(key => /^OPF image \d+$/.test(key)).length);
+  // PowerPoint applies opacity (a:alphaModFix), grayscale (a:grayscl) and the border (a:ln) to an SVG picture (native check
+  // 2026-10-01). A duotone recolor and a non-rectangular mask are not confirmed on an SVG picture, and a tiled picture fill
+  // cannot carry an SVG: with any of them the SVG stays its PNG raster, so the effect applies as in the preview.
+  if (outcome.svg) {
+    const treated = [effects?.recolor?.type === 'duotone' && 'duotone recolor', effects?.shape && effects.shape.preset !== 'rect' && 'shape', fit === 'tile' && 'tile fit'].filter(Boolean);
+    if (treated.length) options.onDiagnostic?.({ code: 'svg-image-rasterized', path, message: `An SVG image with ${treated.join(', ')} exports as its PNG raster, so the effect applies as in the preview; PowerPoint has not been confirmed to apply it to an SVG picture.` });
+    else context.svgPictures.set(name, outcome.svg);
   }
-  const objectName = `OPF image ${context.imagePlacements.size + 1}`;
-  context.imagePlacements.set(objectName, { region, mode: context.imageFill, path });
-  if (outcome.svg) context.svgPictures.set(objectName, outcome.svg);
-  context.pictureText.set(objectName, pictureText(assetAlt(asset, presentation), asset, presentation));
-  slide.addImage({
-    ...resolved,
-    objectName,
-    x: region.x,
-    y: region.y,
-    w: region.w,
-    h: region.h,
-    altText: assetAlt(asset, presentation)
+  const text = alt !== undefined ? alt : assetAlt(asset, presentation);
+  context.images.set(name, { slide: context.slidePath, role, path, box, fit, focus, shrink, effects, ...(treatment !== undefined ? {treatment} : {}) });
+  context.pictureText.set(name, pictureText(text, asset, presentation));
+  slide.addImage({ ...resolved, objectName: name, x: box.x, y: box.y, w: box.w, h: box.h, altText: text });
+  return name;
+}
+
+// The native effects of an image treatment, resolved in the slide's colour context: core's mask (item.image.shape), the
+// border line, opacity and recolor.
+function imageEffects(image, context) {
+  const paint = (entry, fallback) => {
+    const raw = exportColor(entry, context, fallback).replace(/^#/, '');
+    return { hex: normalizeHex(raw, fallback), alpha: /^[0-9a-f]{8}$/i.test(raw) ? parseInt(raw.slice(6), 16) / 255 : 1 };
+  };
+  return {
+    shape: image.shape ?? null,
+    border: image.border ? { ...paint(image.border.color, context.colors.border), width: image.border.width } : null,
+    opacity: image.opacity ?? null,
+    recolor: image.recolor?.type === 'grayscale' ? { type: 'grayscale' }
+      : image.recolor?.type === 'duotone' ? { type: 'duotone', dark: paint(image.recolor.dark, '000000'), light: paint(image.recolor.light, 'FFFFFF') } : null,
+    paint
+  };
+}
+
+// An overlay (core ComposedOverlay) as one native shape directly above its picture: the frame's shape, or an edge band.
+function addImageOverlay(slide, overlay, authored, name, owner, context, effects) {
+  const {hex, alpha} = effects.paint(overlay.color, context.colors.text);
+  context.imageOverlays.set(name, { slide: context.slidePath, owner, box: overlay.box, shape: overlay.shape, hex, alpha, opacity: overlay.opacity, overlay: authored });
+  slide.addShape('rect', { x: overlay.box.x / 96, y: overlay.box.y / 96, w: overlay.box.width / 96, h: overlay.box.height / 96, objectName: name, fill: { color: hex } });
+}
+
+// The authored value at an OPF path the composition names (`slides.N.blocks.I`, `slides.N.design.background`,
+// `design.background`); `theme` is the resolved theme record's background.
+function authoredAt(presentation, path, slideContext) {
+  if (path === 'theme') return slideContext.core?.resolved?.theme?.background;
+  let value = presentation;
+  for (const key of path.split('.')) value = value?.[/^\d+$/.test(key) ? Number(key) : key];
+  return value;
+}
+
+// An image block (core ComposedItem.image): the picture at core's frame with its fit, focus and treatment, then its
+// overlay directly above. An unchanged picture and overlay import back as the same block (OPF_IMAGE_V1).
+async function addImageItem(slide, presentation, item, slideIndex, context, options) {
+  const image = item.image;
+  const box = { x: image.box.x / 96, y: image.box.y / 96, w: image.box.width / 96, h: image.box.height / 96 };
+  const block = isPlainObject(item.payload) ? item.payload : {};
+  const treatment = Object.fromEntries(IMAGE_TREATMENT_KEYS.filter(key => key !== 'overlay' && block[key] !== undefined).map(key => [key, structuredClone(block[key])]));
+  const effects = imageEffects(image, context);
+  const treated = Boolean(effects.border || effects.opacity !== null || effects.recolor || image.overlay || (effects.shape && effects.shape.preset !== 'rect'));
+  const tagged = Object.keys(treatment).length > 0 || block.overlay !== undefined;
+  // A plain contained picture in the flow is framed by the picture itself (0.14 content images); a treated or placed one
+  // keeps core's frame (0.14 slide images), so its mask, line and overlay apply to that frame.
+  const name = await addImagePicture(slide, presentation, item.value, box, item.path, { ...context, slidePath: `slides.${slideIndex}` }, options, {
+    fit: image.fit, focus: image.focus, effects: treated ? effects : null, shrink: !treated && !image.placement, treatment: tagged ? treatment : undefined
   });
-  return objectName;
+  if (!name) {
+    addImagePlaceholder(slide, presentation, item.value, box, item.path, context, options);
+    return `OPF image placeholder ${context.imagePlaceholders.size}`;
+  }
+  if (image.overlay) addImageOverlay(slide, image.overlay, structuredClone(block.overlay), imageOverlayName(name), name, { ...context, slidePath: `slides.${slideIndex}` }, effects);
+  return name;
+}
+
+// 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.
+async function addBackgroundImage(slide, presentation, background, slideIndex, slideContext, context, options) {
+  const slidePath = `slides.${slideIndex}`, part = `ppt/slides/slide${slideIndex + 1}.xml`;
+  const box = { x: 0, y: 0, w: slideContext.dimensions.widthInches, h: slideContext.dimensions.heightInches };
+  const authored = authoredAt(presentation, background.path, slideContext);
+  const effects = imageEffects({ opacity: background.opacity, recolor: background.recolor }, slideContext);
+  let owner = 'background', overlayName = backgroundOverlayName(slidePath);
+  // Only the background's own alt text makes it meaningful (FA-22): a referenced asset's alt does not count.
+  const alt = background.alt;
+  if (typeof alt === 'string' && alt) {
+    const treatment = isPlainObject(authored) ? Object.fromEntries(BACKGROUND_IMAGE_KEYS.filter(key => key !== 'overlay' && authored[key] !== undefined).map(key => [key, structuredClone(authored[key])])) : {};
+    const name = await addImagePicture(slide, presentation, background.src, box, background.path, { ...slideContext, slidePath }, options, {
+      fit: background.fit, focus: background.focus, effects: background.opacity === undefined && !background.recolor ? null : effects, shrink: false,
+      treatment, alt, role: 'background', objectName: backgroundImageName(slidePath)
+    });
+    if (!name) {
+      options.onDiagnostic?.({code: 'unresolved-asset', path: background.path, message: 'The background image needs an embedded raster, a declared asset or a host imageResolver; the slide background color was exported instead.'});
+      return;
+    }
+    owner = name;
+    overlayName = imageOverlayName(name);
+  } else {
+    // An SVG background is its PNG raster at the slide's size: a slide background picture fill carries no SVG.
+    const outcome = { box, cover: background.fit === 'cover' };
+    const resolved = await resolveImage(background.src, presentation, options, background.path, outcome);
+    if (!resolved) {
+      if (!outcome.reported) options.onDiagnostic?.({code: 'unresolved-asset', path: background.path, message: 'The background image needs an embedded raster, a declared asset or a host imageResolver; the slide background color was exported instead.'});
+      return;
+    }
+    // PptxGenJS embeds the raster and its relationship; packaging replaces its stretched fill with the fitted native fill.
+    slide.background = { ...resolved };
+    context.backgroundFills.set(part, { image: {
+      fit: background.fit, focus: background.focus, opacity: background.opacity ?? 1, recolor: effects.recolor, path: background.path,
+      width: box.w * 96, height: box.h * 96, report: options.onDiagnostic
+    } });
+  }
+  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);
 }
 
 // design.watermark: one native picture per slide, added after the slide image
@@ -2076,13 +2338,14 @@ async function addWatermark(slide, presentation, opfSlide, slideIndex, slideCont
   const watermark = local ? opfSlide.design.watermark : presentation.design?.watermark;
   if (watermark === undefined || watermark === null || watermark === false) return;
   const path = local ? `slides.${slideIndex}.design.watermark` : 'design.watermark';
-  const notExported = message => options.onDiagnostic?.({code: 'watermark-not-exported', path, message});
-  const asset = isPlainObject(watermark) || typeof watermark === 'string' ? watermark : null;
-  if (asset === null || (isPlainObject(asset) && typeof asset.src !== 'string')) {
-    notExported('The watermark needs an image source (a string, or an object with src); no watermark was exported for this slide.');
+  // The schema requires exactly one of src and text, so there is no source-less watermark to report.
+  const asset = watermark;
+  const {widthInches, heightInches} = slideContext.dimensions;
+  // FA-13: a text watermark is one native text box with the opacity as text alpha, centered and rotated as core's layoutWatermark says.
+  if (isPlainObject(asset) && typeof asset.text === 'string') {
+    addTextWatermark(slide, asset, slideIndex, {width: widthInches * 96, height: heightInches * 96}, slideContext, context, options, path);
     return;
   }
-  const {widthInches, heightInches} = slideContext.dimensions;
   const box = watermarkBox(widthInches, heightInches);
   const outcome = {box};
   const resolved = await resolveImage(asset, presentation, options, path, outcome);
@@ -2097,6 +2360,23 @@ async function addWatermark(slide, presentation, opfSlide, slideIndex, slideCont
   slide.addImage({...resolved, objectName: watermarkName(), ...box, altText: assetAlt(asset, presentation) ?? 'Watermark'});
 }
 
+// The stamp takes the slide's own resolved fonts and default text color (readable on that slide's background), as the preview does.
+function addTextWatermark(slide, watermark, slideIndex, size, slideContext, context, options, path) {
+  const layout = layoutWatermark(watermark.text, size, {fontFamily: slideContext.fonts.heading, fontWeight: 700, textMeasurement: options.textMeasurement});
+  // The schema requires text, so this is null only for text that draws nothing (the preview draws nothing either).
+  if (!layout) return;
+  const opacity = watermarkOpacity(watermark);
+  const {box} = layout;
+  slide.addText(layout.text, {
+    ...textBoxOptions({x: box.x / 96, y: box.y / 96, w: box.width / 96, h: box.height / 96}, slideContext, layout.fontSize * .75),
+    ...nativeFontOptions(layout.style), bold: true,
+    color: slideContext.textColor, transparency: Math.round((1 - opacity) * 100000) / 1000,
+    align: 'center', valign: 'middle', fit: 'none', wrap: false, lineSpacingMultiple: 1,
+    rotate: (layout.rotation + 360) % 360, objectName: watermarkTextName()
+  });
+  context.textWatermarks.set(`ppt/slides/slide${slideIndex + 1}.xml`, {slide: `slides.${slideIndex}`, text: layout.text, opacity});
+}
+
 // The deck logo (design.logo, a slide's own logo or the primary organization's) on a cover or section slide: one native
 // picture per slide at core's geometry.logo box, fitted without cropping, anchored left and vertically centered, after
 // the watermark and before content (the preview's paint order). The frame and the provenance tag are written after
@@ -2116,54 +2396,6 @@ async function addLogo(slide, presentation, logo, slideIndex, slideContext, cont
   slide.addImage({...resolved, objectName: logoName(), ...region, altText: assetAlt(logo.source, presentation) ?? 'Logo'});
 }
 
-// design.slideImage: one native picture at the shared frame, beneath content.
-// Crop/fit and treatments are written after PptxGenJS embeds the bytes.
-async function addSlideImage(slide, presentation, image, slideIndex, context, options) {
-  const box = { x: image.box.x / 96, y: image.box.y / 96, w: image.box.width / 96, h: image.box.height / 96 };
-  const outcome = { box, cover: image.fill === 'crop' };
-  const resolved = await resolveImage(image.value, presentation, options, image.sourcePath, outcome);
-  if (!resolved) {
-    addImagePlaceholder(slide, presentation, image.value, box, image.sourcePath, context, options);
-    return;
-  }
-  const objectName = slideImageName(`slides.${slideIndex}`);
-  const configured = image.path === 'design.slideImage' ? presentation.design?.slideImage : presentation.slides[slideIndex].design?.slideImage;
-  const { src: _source, ...treatment } = isPlainObject(configured) && 'position' in configured ? configured : {};
-  const paint = (entry, fallback) => {
-    const hex = normalizeHex(exportColor(entry, context, fallback), fallback);
-    const raw = exportColor(entry, context, fallback).replace(/^#/, '');
-    return { hex, alpha: /^[0-9a-f]{8}$/i.test(raw) ? parseInt(raw.slice(6), 16) / 255 : 1 };
-  };
-  // Native effects are resolved here, in the slide's color context.
-  const effects = {
-    shape: image.shape ?? null,
-    border: image.border ? { ...paint(image.border.color, context.colors.border), width: image.border.width } : null,
-    opacity: image.opacity ?? null,
-    recolor: image.recolor?.type === 'grayscale' ? { type: 'grayscale' }
-      : image.recolor?.type === 'duotone' ? { type: 'duotone', dark: paint(image.recolor.dark, '000000'), light: paint(image.recolor.light, 'FFFFFF') } : null,
-    overlay: image.overlay ? { ...paint(image.overlay.color, context.colors.text), opacity: image.overlay.opacity, box: image.overlay.box, shape: image.overlay.shape } : null,
-  };
-  // FF-53: a root `image` with the slide image's source is the slide image (core `replacesContent`); the
-  // manifest records that so an unchanged picture imports back as both design.slideImage and slide.image.
-  context.slideImages.set(objectName, { slide: `slides.${slideIndex}`, box, fill: image.fill, path: image.sourcePath, treatment: { ...treatment, position: image.position }, effects, content: image.replacesContent === true });
-  // PowerPoint applies opacity (a:alphaModFix), grayscale (a:grayscl) and the border (a:ln) to an SVG picture (native check
-  // 2026-10-01). A duotone recolor and a non-rectangular mask are not confirmed on an SVG picture: with either the SVG stays its
-  // PNG raster, so the effect applies as in the preview.
-  if (outcome.svg) {
-    const treated = [effects.recolor?.type === 'duotone' && 'duotone recolor', effects.shape && effects.shape.preset !== 'rect' && 'shape'].filter(Boolean);
-    if (treated.length) options.onDiagnostic?.({ code: 'svg-image-rasterized', path: image.sourcePath, message: `An SVG slide image with ${treated.join(', ')} exports as its PNG raster, so the effect applies as in the preview; PowerPoint has not been confirmed to apply it to an SVG picture.` });
-    else context.svgPictures.set(objectName, outcome.svg);
-  }
-  const slideImageAlt = image.alt ?? assetAlt(image.value, presentation);
-  context.pictureText.set(objectName, pictureText(slideImageAlt, image.value, presentation));
-  slide.addImage({ ...resolved, objectName, ...box, altText: slideImageAlt });
-  // The overlay scrim is a separate native shape directly above the picture.
-  if (effects.overlay) {
-    const overlay = effects.overlay.box;
-    slide.addShape('rect', { x: overlay.x / 96, y: overlay.y / 96, w: overlay.width / 96, h: overlay.height / 96, objectName: slideImageOverlayName(`slides.${slideIndex}`), fill: { color: effects.overlay.hex } });
-  }
-}
-
 // 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`).
@@ -2202,7 +2434,7 @@ 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[isDarkHex(context.colors.background) ? 'dark2' : 'light2'] ?? `#${context.colors.surface}`;
+  const panelFill = context.colorScheme.surface ?? context.colorScheme[context.roles.dark ? 'dark2' : 'light2'] ?? `#${context.colors.surface}`;
   const labelColor = normalizeHex(textColorForFill(panelFill, `#${context.colors.text}`));
   const transparency = /^#[0-9a-f]{8}$/i.test(panelFill) ? (1 - parseInt(panelFill.slice(7), 16) / 255) * 100 : 0;
   const fill = {color:normalizeHex(panelFill),transparency};
@@ -2211,15 +2443,25 @@ function addChartPayload(slide, chart, region, context, options = {}, path = "ch
   const textSize = chartTextSize(context);
   // 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).
+  const secondaryIndex = chartData.combo?.findIndex((entry) => entry.axis === 'secondary') ?? -1;
   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,
     options:chartOptions,kind:chartTargetFor(chart.type)?.kind,pointCount:chartData.pointCount,numberFormats});
   recordPayloadData(context, objectName, 'chart', presentation, path);
   context.chartFonts.set(objectName,{heading:context.fonts.heading,body:context.fonts.body});
+  // FA-09: the chart's text alternative (the frame's descr; the empty string is PowerPoint's decorative marker), applied before the chartex frame copies the head.
+  if (typeof chart.alt === 'string') context.chartAlts.set(objectName, chart.alt);
   const preferredPalette = CHART_COLORS.map(color=>`#${color}`);
-  const palette = (typeof opfComposition.chartPaletteForFill === "function" ? opfComposition.chartPaletteForFill(panelFill, preferredPalette) : preferredPalette.map(color=>chartColorForFill(panelFill,color))).map(color=>normalizeHex(color));
-  context.chartPalettes.set(objectName,palette);
+  const palette = chartPaletteForFill(panelFill, preferredPalette).map(color=>normalizeHex(color));
+  // 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}`,
+    schemeFor: hex => schemeColorValue('primary', hex, context)});
+  context.chartPalettes.set(objectName,highlight ? highlight.seriesFills : palette);
+  if (highlight) context.chartHeadings.get(objectName).highlight = highlight;
   if (chartData.chartex) {
     // 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.
@@ -2235,7 +2477,7 @@ function addChartPayload(slide, chart, region, context, options = {}, path = "ch
   // bar chart with one series whenever chartColors is a custom array of more than one colour, so PowerPoint drew each
   // column of a single-series column or bar chart in a different colour. One colour for that series writes no c:dPt.
   const chartColors = chartData.type === 'bar' && chartData.series.length === 1 ? palette.slice(0, 1) : palette;
-  slide.addChart(chartData.type, chartData.series, {
+  const chartOptionsXml = {
     objectName,
     x: region.x,
     y: region.y,
@@ -2271,7 +2513,37 @@ function addChartPayload(slide, chart, region, context, options = {}, path = "ch
     ...(chartData.spec.radarStyle ? { radarStyle: chartData.spec.radarStyle } : {}),
     // ScatterWithMarkers: markers only, no connecting line.
     ...(chartData.type === 'scatter' ? { lineSize: 0, lineDataSymbol: 'circle' } : {})
-  });
+  };
+  if (chartData.combo?.length && chartData.combo.length === chartData.series.length) {
+    slide.addChart(...comboChart(chartData, chartOptionsXml, {palette, chartOptions, labelColor, font: context.fonts.body, textSize}));
+    return;
+  }
+  slide.addChart(chartData.type, chartData.series, chartOptionsXml);
+}
+
+// FA-15: a combo chart is one PptxGenJS multi-type chart: a clustered column c:barChart on the primary axes, a c:lineChart with
+// markers for the primary-axis lines, and one for the secondary-axis lines on a second c:valAx (at the right, crossing at the
+// maximum of a deleted second c:catAx). Each series keeps its palette colour by its index in the whole chart (PptxGenJS restarts
+// the colour cycle per chart type), and the embedded workbook holds every series. The secondary axis has no gridlines and only
+// its own title; applyComboConstruct puts the line groups into schema order afterwards.
+function comboChart(chartData, options, {palette, chartOptions, labelColor, font, textSize}) {
+  const series = chartData.series.map((entry, index) => ({...entry, color: palette[index % palette.length]}));
+  const part = (role, axis) => series.filter((_, index) => chartData.combo[index].role === role && (role === 'bar' || chartData.combo[index].axis === axis));
+  const bars = part('bar'), primaryLines = part('line', 'primary'), secondaryLines = part('line', 'secondary');
+  const lineOptions = {lineDataSymbol: 'circle'};
+  const types = [
+    // The column group's own colour list: with one column series, a longer list would make PptxGenJS colour each column (c:dPt, RR-36).
+    ...(bars.length ? [{type: 'bar', data: bars, options: {barDir: 'col', barGrouping: 'clustered', chartColors: bars.map((entry) => entry.color)}}] : []),
+    ...(primaryLines.length ? [{type: 'line', data: primaryLines, options: lineOptions}] : []),
+    ...(secondaryLines.length ? [{type: 'line', data: secondaryLines, options: {...lineOptions, secondaryValAxis: true, secondaryCatAxis: true}}] : []),
+  ];
+  // A gap in a line series breaks the line, as the preview draws it (PptxGenJS defaults to span).
+  const {barGrouping: _grouping, ...rest} = options;
+  const shared = {...rest, displayBlanksAs: 'gap'};
+  if (!secondaryLines.length) return [types, {...shared, barDir: 'col'}];
+  const title = chartOptions?.axisTitles?.secondary;
+  const secondaryValue = {valGridLine: {style: 'none'}, showValAxisTitle: Boolean(title), ...(title ? {valAxisTitle: title, valAxisTitleColor: labelColor, valAxisTitleFontFace: font, valAxisTitleFontSize: textSize / 100} : {})};
+  return [types, {...shared, barDir: 'col', valAxes: [{}, secondaryValue], catAxes: [{}, {catAxisHidden: true, showCatAxisTitle: false}]}];
 }
 
 // RR-54: a chart or table that uses a dataset, DataColumn objects, a mapping, a data source or number formats records its
@@ -2330,9 +2602,9 @@ function addTablePayload(slide, authoredTable, region, context, options, path, p
       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,
-        color,transparency,baseline:fragment?.baselineShift ? -fragment.baselineShift / fragment.fontSize * 2000 : undefined,
-        hyperlink:run.link && /^(https?:|mailto:)/i.test(run.link) ? {url:run.link} : undefined,
+        underline:run.underline ? {style:'sng',color:linkColor(run,color,context)} : undefined,strike:run.strikethrough ? 'sngStrike' : undefined,
+        color:linkColor(run,color,context),transparency,baseline:fragment?.baselineShift ? -fragment.baselineShift / fragment.fontSize * 2000 : undefined,
+        hyperlink:run.link && /^(https?:|mailto:|tel:)/i.test(run.link) ? {url:run.link} : undefined,
       };
       // PptxGenJS marks every part of a newline-containing run as a paragraph
       // break, including its final part. Split explicitly so the next styled
@@ -2394,6 +2666,39 @@ function pixelBox(region) {
   return {x: region.x * 96, y: region.y * 96, width: region.w * 96, height: region.h * 96};
 }
 
+// One native text box per laid-out rich line (core's richLines), each carrying its runs: run color, size, weight, underline, strike,
+// super/subscript (a citation marker is a baseline run) and http(s)/mailto links. The body's lines stay untagged; a heading or quote
+// body passes `objectName` and `tag`, which name and tag every line with the boundary between wrapped lines (a soft wrap inserts
+// nothing, a hard line break keeps its separator), recovered from the flattened text. `fallback` is the color of runs without one.
+function addRichFitLines(slide, fit, box, context, {value, alignment: logicalAlignment, fallback, objectName, tag}) {
+  const region = {x: box.x / 96, y: box.y / 96, w: box.width / 96, h: box.height / 96};
+  const runText = run => typeof run === 'string' ? run : run.text;
+  const whole = typeof value === 'string' ? value : value.map(runText).join('');
+  const count = fit.richLines.length;
+  let cursor = 0;
+  for (const [index, line] of fit.richLines.entries()) {
+    const runs = line.fragments.map(fragment => {
+      const runColor = exportColor(fragment.run.color, context, context.colors.text);
+      const color = nativeColor(fragment.run.color, runColor, context, fallback);
+      return {text: fragment.text, options: {...nativeFontOptions(fragment.style), fontSize: (fragment.nominalSize ?? fragment.fontSize) * .75, color: linkColor(fragment.run, color, context), underline: fragment.run.underline ? {style: 'sng', color: linkColor(fragment.run, color, context)} : undefined, strike: fragment.run.strikethrough ? 'sngStrike' : undefined, baseline: fragment.baselineShift ? -fragment.baselineShift / (fragment.nominalSize ?? fragment.fontSize) * 2000 : undefined, hyperlink: fragment.kind !== 'marker' && fragment.run.link && /^(https?:|mailto:|tel:)/i.test(fragment.run.link) ? {url: fragment.run.link} : undefined, ...langOptions(context, fragment.style.lang)}};
+    });
+    // Logical alignment (RR-05): a right-to-left paragraph starts at the right edge; every wrapped line shares its paragraph's direction.
+    const placed = fit.placement?.lines[index], alignment = placed?.alignment ?? physicalAlignment(logicalAlignment, fit.directions?.[index]), factor = alignment === 'right' ? 1 : alignment === 'center' ? .5 : 0;
+    const area = placed ? {...region, x: (placed.x + line.width * factor - box.width * factor) / 96, y: placed.y / 96, h: placed.height / 96} : {...region, y: region.y + line.y / 96, h: line.height / 96};
+    // PptxGenJS reads the paragraph direction from the first run's options, not from the shape options.
+    if (fit.directions?.[index] === 'rtl') for (const run of runs) run.options.rtlMode = true;
+    let name;
+    if (tag) {
+      const text = fit.lines[index] ?? '', end = cursor + text.length;
+      const newline = index < count - 1 && whole.startsWith(text, cursor) ? /^(\r\n|\r|\n)/.exec(whole.slice(end)) : null;
+      name = objectName(index);
+      tag(name, index, count, {boundary: index === count - 1 ? 'end' : newline ? 'hard' : 'soft', separator: newline ? newline[0] : ''});
+      cursor = end + (newline ? newline[0].length : 0);
+    }
+    if (runs.length) slide.addText(runs, {...textBoxOptions(area, context, fit.fontSize * .75), align: alignment, fit: 'none', wrap: false, lineSpacingMultiple: 1, ...(name ? {objectName: name} : {})});
+  }
+}
+
 // Match the published renderer's payload geometry and shared core text fitting.
 // Each fitted line remains native editable text, without PowerPoint rewrapping it.
 function addMeasuredPayloadText(slide, text, box, context, options, config) {
@@ -2405,7 +2710,7 @@ function addMeasuredPayloadText(slide, text, box, context, options, config) {
   if (fit.overflow && !config.diagnosticsHandled) {
     const diagnostic = {code: 'text-overflow', path: config.path, message: 'Text exceeds its cell at the minimum font size; shorten it, increase its space, or split the slide.'};
     options.onDiagnostic?.(diagnostic);
-    if (context.composition?.overflow === 'error') throw new OPFPptxError('layout-overflow', diagnostic.message, {path: config.path, issues: [diagnostic]});
+    if (context.composition?.overflow === 'error') throw new OPFPptxError('layout-overflow', diagnostic.message, {path: config.path, diagnostics: [diagnostic]});
   }
   // Generated socials carry one link per explicit source line; wrapped lines share it.
   let sourceLineIndex = 0;
@@ -2469,7 +2774,7 @@ async function addFurniture(slide,presentation,source,layout,context,options,sli
   for(const [index,part]of layout.parts.entries()){
     if(part.type==='image'){
       const region={x:part.box.x/96,y:part.box.y/96,w:part.box.width/96,h:part.box.height/96};
-      const objectName = await addImagePayload(slide,presentation,part.image,region,part.path,{...context,imageFill:'fit'},options);
+      const objectName = await addImagePayload(slide,presentation,part.image,region,part.path,context,options);
       // A generated deck logo is listed beside the manifest topology (see furnitureManifest) and tagged as a logo.
       if (objectName && part.field === 'logo') context.furnitureLogoTags.set(objectName, {v:1, role:'furniture', group:String(slideIndex), furniture:part.kind, zone:part.zone});
       else if (objectName) context.furnitureTags.set(objectName, {v:1, role:'image', group:String(slideIndex), part:manifestPartIndex(layout.parts, index)});
@@ -2511,52 +2816,76 @@ function addCodePayload(slide, value, layout, region, context, path, options) {
     if (invalid) throw new OPFPptxError('invalid-code-text', `Code text contains U+${invalid[0].codePointAt(0).toString(16).toUpperCase().padStart(4,'0')} at UTF-16 offset ${invalid.index}, which XML cannot represent; edit that character before exporting.`, {path:part.path});
   }
   const group = String(context.codeTags.size + 1), panelName = `OPF code ${group} panel`;
-  for (const part of layout.parts) if (!part.fit) throw new OPFPptxError('layout-overflow', 'Code content has no usable internal space; increase its cell size before exporting.', {path:part.path,issues:layout.diagnostics});
-  context.codeTags.set(panelName,codeManifest(value,layout,group));
+  for (const part of layout.parts) if (!part.fit) throw new OPFPptxError('layout-overflow', 'Code content has no usable internal space; increase its cell size before exporting.', {path:part.path,diagnostics:layout.diagnostics});
+  // FA-13: code.highlight is one native rectangle per run of marked lines, between the panel and the line text boxes; marked
+  // lines keep the syntax colours, the others are dimmed, from the same core helpers the preview calls.
+  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});
+  if (highlight) {
+    const bodyPart = layout.parts.find(part => part.role === 'body');
+    highlight.bands.forEach((band, bandIndex) => {
+      const lineHeight = bodyPart.fit.lineHeight;
+      const bandName = `OPF code ${group} highlight ${bandIndex + 1}`;
+      context.codeTags.set(bandName, {v:1, group, role:'highlight', index:bandIndex});
+      slide.addShape('rect', {x: region.x + .01, y: (bodyPart.box.y + band.first * lineHeight) / 96, w: region.w - .02, h: (band.last - band.first + 1) * lineHeight / 96,
+        fill: {color: highlight.colors.band.slice(1)}, line: {type: 'none'}, objectName: bandName});
+    });
+  }
   for (const [partIndex,part] of layout.parts.entries()) {
-    if (!part.fit) throw new OPFPptxError('layout-overflow', 'Code content has no usable internal space; increase its cell size before exporting.', {path:part.path,issues:layout.diagnostics});
+    if (!part.fit) throw new OPFPptxError('layout-overflow', 'Code content has no usable internal space; increase its cell size before exporting.', {path:part.path,diagnostics:layout.diagnostics});
     for (const [index,line] of part.fit.sourceLines.entries()) {
       const tabStops=line.segments.filter(segment=>segment.kind==='tab').map(segment=>({position:(segment.x+segment.width)/96,alignment:'l'}));
       const objectName = `OPF code ${group} ${part.role} line ${index+1}`;
       context.codeTags.set(objectName,{v:1,group,role:'line',part:partIndex,line:index});
       // RR-07: the same token ranges and palette the preview paints; the text of the runs is the line text, unchanged.
-      const runs = syntax && part.role==='body' ? opfCore.codeLineRuns(syntax.tokens,line.start,line.end,part.text) : undefined;
+      const runs = syntax && part.role==='body' ? codeLineRuns(syntax.tokens,line.start,line.end,part.text) : undefined;
+      const lineColors = highlight && part.role==='body' ? (highlight.marked.has(highlight.numbers[index]) ? highlight.colors.lit : highlight.colors.dim) : undefined;
       const lineText = part.text.slice(line.start,line.end);
       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'?'E5E7EB':'93C5FD',align:'left',fit:'none',wrap:false,lineSpacingMultiple:1,
+        color:part.role==='body'?(lineColors?.plain.slice(1)??'E5E7EB'):'93C5FD',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.
-      slide.addText(runs?.some(run=>run.kind) ? runs.map(run=>({text:part.text.slice(run.start,run.end),options:{...lineOptions,color:syntax.palette[run.kind??'plain'].slice(1)}})) : lineText,lineOptions);
+      slide.addText(runs?.some(run=>run.kind) ? runs.map(run=>({text:part.text.slice(run.start,run.end),options:{...lineOptions,color:(lineColors??syntax.palette)[run.kind??'plain'].slice(1)}})) : lineText,lineOptions);
     }
   }
 }
 
+// FA-13: the marked lines of code.highlight, their bands (runs of displayed lines) and the lit/dimmed colours, from core (the preview
+// calls the same functions); undefined when the code marks no line.
+function codeHighlight(value, layout, context) {
+  if (!value || typeof value !== 'object' || !Array.isArray(value.highlight)) return undefined;
+  const body = layout.parts.find(part => part.role === 'body');
+  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)};
+}
+
 // Token ranges and palette for the code body, from core (the preview calls the same functions); undefined for plain code.
 function codeSyntax(value, layout, context, path, options) {
   const body = layout.parts.find(part => part.role === 'body');
   const language = typeof value?.language === 'string' ? value.language : layout.parts.find(part => part.role === 'language')?.text;
   if (!body || !language) return undefined;
-  if (typeof opfCore.tokenizeCode !== 'function') return undefined;
-  const tokens = opfCore.tokenizeCode(body.text, language);
-  return tokens.length ? {tokens, palette: opfCore.codeSyntaxPaletteForScheme(context.colorScheme)} : undefined;
+  const tokens = tokenizeCode(body.text, language);
+  return tokens.length ? {tokens, palette: codeSyntaxPaletteForScheme(context.colorScheme)} : undefined;
 }
 
 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=typeof opfCore.metricTrendMark==='function'?opfCore.metricTrendMark(layout,{background:`#${normalizeHex(context.colors.background)}`}):undefined;
+  const trendMark=metricTrendMark(layout,{background:`#${normalizeHex(context.colors.background)}`});
   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);
     if (invalid) throw new OPFPptxError('invalid-metric-text',`Metric text contains U+${invalid[0].codePointAt(0).toString(16).toUpperCase().padStart(4,'0')} at UTF-16 offset ${invalid.index}, which XML cannot represent; edit that character before exporting.`,{path:part.path});
     if (!part.visible) continue;
-    if (!part.fit||part.linePositions?.length!==part.fit.sourceLines.length) throw new OPFPptxError('layout-overflow','Metric content has no accepted internal line positions; increase its cell size or coordinate package versions.',{path:part.path,issues:layout.diagnostics});
+    if (!part.fit||part.linePositions?.length!==part.fit.sourceLines.length) throw new OPFPptxError('layout-overflow','Metric content has no accepted internal line positions; increase its cell size or coordinate package versions.',{path:part.path,diagnostics:layout.diagnostics});
     for (const [index,line] of part.fit.sourceLines.entries()) {
       const origin=part.linePositions[index],objectName=`OPF metric ${group} ${part.role} line ${index+1}`;
       context.metricTags.set(objectName,partIndex===0&&index===0?manifest:{v:1,group,role:'line',part:partIndex,line:index});
@@ -2582,37 +2911,80 @@ function addMetricPayload(slide,value,layout,context,path,options) {
   }
 }
 
-function addQuotePayload(slide, value, layout, context, options, path) {
+async function addQuotePayload(slide, presentation, value, layout, context, options, path) {
   if (!layout) throw new OPFPptxError('missing-quote-layout', 'Quote export requires a coordinated core build with shared quote geometry.', {path});
-  for (const part of layout.parts) 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});
+  for (const part of layout.parts) if (!part.fit) throw new OPFPptxError('layout-overflow', 'Quote content has no usable internal space; increase its cell size before exporting.', {path:part.path,diagnostics:layout.diagnostics});
   // Every line shape is tagged (OPF_QUOTE_V1) so an unchanged export re-imports as a quote payload (FF-57).
   const group=String(context.quoteTags.size),anchor=quoteManifest(value,layout);
   for (const [index,part] of layout.parts.entries()) {
+    // FA-10: a TextRun[] quote body (core's rich lines, quotation marks joined to its first and last run) is exported line by line like rich body text, with the same quote tags.
+    if (part.runs && part.fit.richLines) {
+      addRichFitLines(slide, part.fit, part.box, context, {
+        value: part.text, alignment: part.fit.placement?.alignment ?? context.contentAlignment ?? 'left', fallback: context.textColor,
+        objectName: line => `OPF quote ${group} part ${index} line ${line}`,
+        tag: (name, line, count, boundary) => context.quoteTags.set(name, {v: 1, role: 'text', group, part: index, line, count, ...boundary, base: richBase(part.fit, part.style, context.colors.text), ...(index === 0 && line === 0 ? {anchor} : {})})
+      });
+      continue;
+    }
     addMeasuredPayloadText(slide,part.text,part.box,context,options,{
       path:part.path,fit:part.fit,textStyle:part.style,diagnosticsHandled:true,
       color:part.role==='footer'?context.mutedColor:context.textColor,
       quote:{group,part:index,anchor},
     });
   }
+  if (layout.photo) await addQuotePhoto(slide, presentation, layout.photo, group, context, options);
+}
+
+// FA-12: the attributed person's headshot is a native picture in the core circle frame: cropped to fill it (a:srcRect after the bytes
+// are embedded) with the `ellipse` preset geometry, the alt text as its description, tagged into the quote's provenance group.
+async function addQuotePhoto(slide, presentation, photo, group, context, options) {
+  const box = { x: photo.box.x / 96, y: photo.box.y / 96, w: photo.box.width / 96, h: photo.box.height / 96 };
+  const outcome = { box, cover: true };
+  const resolved = await resolveImage(photo.value, presentation, options, photo.path, outcome);
+  if (!resolved) {
+    addImagePlaceholder(slide, presentation, photo.value, box, photo.path, context, options);
+    return;
+  }
+  const objectName = quotePhotoName(group);
+  // PowerPoint is not confirmed to apply a non-rectangular mask to an SVG picture, so an SVG photo exports as its PNG raster (as a masked slide image does).
+  if (outcome.svg) options.onDiagnostic?.({ code: 'svg-image-rasterized', path: photo.path, message: 'An SVG quote photo exports as its PNG raster so the circular mask applies as in the preview; PowerPoint has not been confirmed to apply it to an SVG picture.' });
+  context.quotePhotos.set(objectName, { region: box, mode: 'crop', path: photo.path, shape: photo.shape });
+  context.quoteTags.set(objectName, { v: 1, role: 'photo', group });
+  const alt = assetAlt(photo.value, presentation);
+  context.pictureText.set(objectName, pictureText(alt, photo.value, presentation));
+  slide.addImage({ ...resolved, objectName, ...box, altText: alt });
 }
 
 function addTimelinePayload(slide, value, layout, context, options, path) {
   if(!layout)throw new OPFPptxError('missing-timeline-layout','Timeline export requires a coordinated core build with shared timeline geometry.',{path});
   // Validate optional field fits before the provenance manifest dereferences
   // source lines or any drawing/tag mutation is performed.
-  for(const part of layout.parts)if(!part.fit)throw new OPFPptxError('layout-overflow','Timeline field has no usable space; change the arrangement or paginate events.',{path:part.path,issues:layout.diagnostics});
+  for(const part of layout.parts)if(!part.fit)throw new OPFPptxError('layout-overflow','Timeline field has no usable space; change the arrangement or paginate events.',{path:part.path,diagnostics:layout.diagnostics});
   const scale=Math.min(context.dimensions.widthInches,context.dimensions.heightInches)*96/720;
   const group=String(context.timelineTags.size),anchor=timelineManifest(value,layout),connectorName=`OPF timeline ${group} connector`;
   const {x1,y1,x2,y2}=layout.connector;
   slide.addShape('line',{objectName:connectorName,x:x1/96,y:y1/96,w:(x2-x1)/96,h:(y2-y1)/96,line:{color:context.colors.border,width:3*scale*.75}});
   context.timelineTags.set(connectorName,{v:1,group,role:'connector'});
+  // FA-11: a status draws from the deck's colors through core's shared shapes: native ellipses (solid fill, or the
+  // background fill plus a line for a hollow marker or a ring) and a muted text color for a planned event.
+  const statusColors={background:`#${normalizeHex(context.colors.background)}`,primary:`#${context.colors.accent}`,text:`#${normalizeHex(context.colors.text)}`,mutedText:`#${context.colors.mutedText}`};
   for(const marker of layout.markers){
-    const objectName=`OPF timeline ${group} marker ${marker.eventIndex}`;
-    slide.addShape('ellipse',{objectName,x:(marker.x-marker.radius)/96,y:(marker.y-marker.radius)/96,w:marker.radius*2/96,h:marker.radius*2/96,fill:{color:context.colors.accent},line:{transparency:100}});
-    context.timelineTags.set(objectName,{v:1,group,role:'marker',eventIndex:marker.eventIndex});
+    if(!marker.status){
+      const objectName=`OPF timeline ${group} marker ${marker.eventIndex}`;
+      slide.addShape('ellipse',{objectName,x:(marker.x-marker.radius)/96,y:(marker.y-marker.radius)/96,w:marker.radius*2/96,h:marker.radius*2/96,fill:{color:context.colors.accent},line:{transparency:100}});
+      context.timelineTags.set(objectName,{v:1,group,role:'marker',eventIndex:marker.eventIndex});
+      continue;
+    }
+    for(const shape of timelineMarkerShapes(marker,statusColors)){
+      const objectName=`OPF timeline ${group} ${shape.role} ${marker.eventIndex}`;
+      slide.addShape(shape.shape,{objectName,x:(shape.cx-shape.radius)/96,y:(shape.cy-shape.radius)/96,w:shape.radius*2/96,h:shape.radius*2/96,
+        fill:{color:normalizeHex(shape.fill)},line:shape.stroke?{color:normalizeHex(shape.stroke.color),width:shape.stroke.width*.75}:{transparency:100}});
+      context.timelineTags.set(objectName,{v:1,group,role:shape.role,eventIndex:marker.eventIndex,...(shape.role==='marker'?{status:marker.status}:{})});
+    }
   }
   for(const [index,part]of layout.parts.entries()){
-    addMeasuredPayloadText(slide,part.text,part.box,context,options,{path:part.path,fit:part.fit,textStyle:part.style,align:part.alignment,diagnosticsHandled:true,timeline:{group,part:index,anchor}});
+    const statusColor=part.status==='planned'?normalizeHex(timelineTextColor(part,statusColors)):undefined;
+    addMeasuredPayloadText(slide,part.text,part.box,context,options,{path:part.path,fit:part.fit,textStyle:part.style,align:part.alignment,diagnosticsHandled:true,timeline:{group,part:index,anchor},...(statusColor?{color:statusColor}:{})});
   }
 }
 
@@ -2777,6 +3149,12 @@ function chosenFamilyMeasurement(measurement) {
   return wrapped;
 }
 
+// FA-13: TextRun.lang as the run's own proofing language (a:rPr lang), when it differs from the deck language.
+function langOptions(context, tag) {
+  const lang = runLanguageTag(context.scriptFonts, tag);
+  return lang ? {lang} : {};
+}
+
 function nativeFontOptions(style) {
   const face=style.fontFace;
   if(face!==undefined) {
@@ -2826,14 +3204,15 @@ 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, context.textColor) } : undefined,
+        underline: run?.underline ? { style: "sng", color: linkColor(run, nativeColor(run?.color, exportColor(run?.color, context, context.colors.text), context, context.textColor), context) } : undefined,
         strike: run?.strikethrough ? "sngStrike" : undefined,
-        color: nativeColor(run?.color, exportColor(run?.color, context, context.colors.text), context, context.textColor),
+        color: linkColor(run, nativeColor(run?.color, exportColor(run?.color, context, context.colors.text), context, context.textColor), context),
         fontFace: run?.fontFamily ?? context.fonts.body,
         fontSize: run?.fontSize ?? fallbackFontSize,
         superscript: run?.superscript,
         subscript: !run?.superscript && run?.subscript,
-        hyperlink: run?.link && /^(https?:|mailto:)/i.test(run.link) ? { url: run.link } : undefined
+        hyperlink: run?.link && /^(https?:|mailto:|tel:)/i.test(run.link) ? { url: run.link } : undefined,
+        ...langOptions(context, run?.lang)
       }
     };
   });
@@ -2860,7 +3239,7 @@ function toPptxChartData(chart, chartexMode = 'auto', presentation) {
     return unplottable("dataset-unknown", "The chart's dataset is missing, so it cannot be drawn here.", `The chart references dataset '${stringifyText(authored.dataset)}', which the document does not hold (or a field it names).`);
   }
   if (!authored || !Array.isArray(authored.columns) || !Array.isArray(authored.rows)) {
-    return unplottable("data-not-inline", "Chart data is not inline, so it cannot be drawn here.", "The chart data is not inline columns and rows (for example an external data source). Supply inline columns and rows.");
+    return unplottable("no-columns", "The chart has no inline data, so it cannot be drawn here.", "The chart data is not inline columns and rows. Supply inline columns and rows or a dataset.");
   }
   if (authored.rows.length === 0) return unplottable("no-rows", "The chart has no data rows.", "The chart data has no rows.");
   if (authored.columns.length === 0) return unplottable("no-columns", "The chart has no data columns.", "The chart data has no columns.");
@@ -2887,14 +3266,16 @@ function toPptxChartData(chart, chartexMode = 'auto', presentation) {
       : 'that PowerPoint has not yet accepted natively from this exporter (pass chartex: \'native\' to write its chartex part)';
     adaptations.push({adaptation: "chartex-fallback", message: `The '${typeName}' chart is a PowerPoint extension (chartex) chart ${reason}; its data is exported as a native clustered column chart instead.`});
   }
-  const mapped = {type: spec.pptx, spec, chartex, barDir: spec.barDir, barGrouping: spec.pptx === 'bar' || spec.pptx === 'area' ? spec.grouping : undefined, diagnostics, heading: data.columns[0], pointCount: data.rows.length};
+  // FA-14: the resolved table (category, X, series columns), which chart.highlight names its series and categories in.
+  const mapped = {resolved: {columns: data.columns, hasX: resolvedData.hasX === true, rows: data.rows}, type: spec.pptx, spec, chartex, barDir: spec.barDir, barGrouping: spec.pptx === 'bar' || spec.pptx === 'area' ? spec.grouping : undefined, diagnostics, heading: data.columns[0], pointCount: data.rows.length,
+    // FA-15: core's combo plan (column series, then the primary-axis lines, then the secondary-axis lines), aligned with the series.
+    ...(spec.family === 'combo' ? {combo: comboPlanOf(resolvedData, data.columns.length - 1)} : {})};
   // Number formats only when a column has one: a chart without formats carries no `formats` and is written as before.
   const withFormats = (result, formats) => formats.series.some((code) => code !== undefined) || formats.x !== undefined ? {...result, formats} : result;
   if (data.columns.length === 1) {
     const heading = data.columns[0];
-    // The lone column holds the chart's values. Core (opf#376) already reads it with chartNumber and reports each
-    // non-numeric cell; a core without RR-54 hands it over as authored, so it is read (and its rejects counted) here. A
-    // cell that holds no number is skipped, never plotted as 0.
+    // The lone column holds the chart's values. Each cell is read with chartNumber and each non-numeric cell is counted
+    // as rejected. A cell that holds no number is skipped, never plotted as 0.
     const points = data.rows.map((row, index) => ({row: index + 1, value: chartNumber(row?.[0]), cell: row?.[0]}));
     for (const point of points) if (point.value === null && point.cell !== null && point.cell !== undefined && point.cell !== '') rejected.push({path: `/data/rows/${point.row - 1}/0`, cell: point.cell});
     const plottedPoints = points.filter((point) => point.value !== null);
@@ -2964,6 +3345,12 @@ function toPptxChartData(chart, chartexMode = 'auto', presentation) {
   return withFormats({...mapped, series, hasCategories: true, adaptations, notNumeric}, formats);
 }
 
+/** Core's combo plan; a core without one draws every series as columns except the last, a line on the primary axis (the preview's rule). */
+function comboPlanOf(resolved, count) {
+  if (Array.isArray(resolved.combo) && resolved.combo.length === count) return resolved.combo;
+  return Array.from({length: count}, (_, index) => ({role: count > 1 && index === count - 1 ? 'line' : 'bar', axis: 'primary'}));
+}
+
 /** A chart column's name: the string, or a DataColumn's `name`. */
 function dataColumnName(column) {
   return typeof column === 'string' ? column : column !== null && typeof column === 'object' && typeof column.name === 'string' ? column.name : undefined;
@@ -3193,71 +3580,12 @@ function assetAlt(asset, presentation) {
   return undefined;
 }
 
-function resolveCatalogRecord(presentation, kind, reference, fallbackId) {
-  const id = referenceId(reference) ?? fallbackId;
-  const inlineRecords = normalizeRecords(presentation.catalogs?.[kind]);
-  return findById(inlineRecords, id)
-    ?? findById(defaultCatalog(kind), id)
-    ?? findById(defaultCatalog(kind), fallbackId)
-    ?? null;
-}
-
-function resolveDesignRecord(presentation, kind, reference, fallbackId) {
-  const base = resolveCatalogRecord(presentation, kind, reference, fallbackId) ?? {};
-  return {
-    ...base,
-    ...(isPlainObject(reference) ? withoutSchema(reference) : {})
-  };
-}
-
 function referenceId(reference) {
   if (typeof reference === "string") return reference;
   if (isPlainObject(reference) && typeof reference.id === "string") return reference.id;
   return null;
 }
 
-const DEFAULT_SOURCE_PREFIX = "https://www.pptx.gallery/";
-
-// Same order as opf-render's socialPlatformRecords so preview and export format
-// socials identically. Core applies inline document records first; then the
-// document catalog source (host-supplied options.catalogSources, or the bundled
-// catalog for pptx.gallery/pkg sources), injected options.catalogs, and the
-// bundled catalog (the engine default source also resolves to it).
-function socialPlatformRecords(presentation, options) {
-  const kind = "socialPlatforms", declared = presentation.catalogs?.[kind]?.source;
-  // `source` is one source or an ordered search path (an array): records of each source in order, first match wins.
-  const sourceRecords = (Array.isArray(declared) ? declared : [declared]).filter(source => typeof source === "string").flatMap(source => {
-    const bySource = options.catalogSources?.[source];
-    return bySource ? normalizeRecords(bySource)
-      : source.startsWith(DEFAULT_SOURCE_PREFIX) || source.startsWith("pkg:@openpresentation/opf/") ? defaultCatalog(kind) : [];
-  });
-  return [...sourceRecords, ...normalizeRecords(options.catalogs?.[kind]), ...defaultCatalog(kind)];
-}
-
-function defaultCatalog(kind) {
-  return Array.isArray(bundledCatalogs[kind]) ? bundledCatalogs[kind] : [];
-}
-
-function normalizeRecords(catalog) {
-  if (!catalog) return [];
-  if (Array.isArray(catalog)) return catalog;
-  if (Array.isArray(catalog.records)) return catalog.records;
-  return [];
-}
-
-function findById(records, id) {
-  return records.find((record) => record?.id === id) ?? null;
-}
-
-function withoutSchema(value) {
-  return Object.fromEntries(Object.entries(value).filter(([key]) => key !== "$schema"));
-}
-
-function resolveDimensions(value) {
-  const { width, height } = resolveCanvasDimensions(value);
-  return { widthInches: width / 96, heightInches: height / 96 };
-}
-
 // 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.
 function resolveBackgroundColorRef(entry, colorScheme, variables = {}) {
@@ -3269,29 +3597,18 @@ function resolveBackground(value, colorScheme, variables = {}) {
   const reference = entry => normalizeHex(resolveBackgroundColorRef(entry, colorScheme, variables) ?? entry, fallback);
   if (typeof value === "string") {
     if (value.startsWith("#")) return normalizeHex(value, fallback);
-    return normalizeHex(colorScheme[value] ?? colorScheme.background ?? colorScheme.light1 ?? "#FFFFFF", fallback);
+    return normalizeHex(colorScheme[value] ?? defaultSlideBackground(colorScheme), fallback);
   }
   if (isPlainObject(value)) {
     if (value.type === "solid" && value.color) return reference(value.color);
     if (value.type === "theme" && value.slot) {
-      return normalizeHex(colorScheme[value.slot] ?? colorScheme.light1 ?? "#FFFFFF", fallback);
+      return normalizeHex(colorScheme[value.slot] ?? defaultSlideBackground(colorScheme), fallback);
     }
     // Like the SVG preview, text contrast follows a pattern's background color.
     if (value.type === "pattern") return reference(value.pattern?.backgroundColor ?? "#FFFFFF");
     if (value.backgroundColor) return normalizeHex(value.backgroundColor, fallback);
   }
-  return normalizeHex(colorScheme.background ?? colorScheme.light1 ?? "#FFFFFF", fallback);
-}
-
-function resolveFonts(fontScheme) {
-  return {id:fontScheme.id,...resolveFontFamilies(fontScheme),scheme:{type:fontScheme.type,major:fontScheme.major,minor:fontScheme.minor}};
-}
-
-
-function readableTextColor(background, colorScheme) {
-  return isDarkHex(background)
-    ? normalizeHex(colorScheme.light1 ?? "#FFFFFF")
-    : normalizeHex(colorScheme.text ?? colorScheme.dark1 ?? "#0F172A");
+  return normalizeHex(defaultSlideBackground(colorScheme), fallback);
 }
 
 function normalizeHex(value, fallback = "000000") {
@@ -3306,15 +3623,6 @@ function normalizeHex(value, fallback = "000000") {
   return fallback.replace(/^#/, "").toUpperCase().slice(0, 6);
 }
 
-function isDarkHex(value) {
-  const hex = normalizeHex(value);
-  if (!/^[0-9A-F]{6}$/.test(hex)) return false;
-  const red = Number.parseInt(hex.slice(0, 2), 16);
-  const green = Number.parseInt(hex.slice(2, 4), 16);
-  const blue = Number.parseInt(hex.slice(4, 6), 16);
-  return (red * 299 + green * 587 + blue * 114) / 1000 < 128;
-}
-
 // The master, layout and notes master half of the native header/footer (RR-11): placeholders and p:hf on the finished parts.
 // Every deck gets them (flags off when no slide uses a type), so Insert > Header & Footer works on a deck with no footer too.
 function writeNativeFurnitureMasters(output, context) {
@@ -3373,13 +3681,18 @@ async function normalizePptxZip(raw, context) {
       const {heading,labelColor,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;
+      if(highlight){
+        try{entries[chartPart]=encodeText(applyChartHighlight(decodeText(entries[chartPart]),highlight));}
+        catch(error){throw new OPFPptxError('packaging-failed',`Chart highlight could not be written: ${errorMessage(error)}`);}
+      }
       // 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>`)));
       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}));
+      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}));
       // 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){
@@ -3390,6 +3703,7 @@ async function normalizePptxZip(raw, context) {
     }
   }
   applyChartFonts(entries,context.chartFonts,parseRelationships);
+  if (context.chartAlts.size) for (const [part, bytes] of Object.entries(entries)) if (/^ppt\/slides\/slide\d+\.xml$/.test(part)) { const xml = decodeText(bytes), next = applyChartAlt(xml, context.chartAlts); if (next !== xml) entries[part] = encodeText(next); }
   // Chartex charts: the native cx:chartSpace part, its style parts and the mc:AlternateContent frame (the classic chart above is the fallback).
   try {
     attachChartexParts(entries, context.chartex, parseRelationships);
@@ -3408,7 +3722,7 @@ async function normalizePptxZip(raw, context) {
     const relationships = parseRelationships(entries, part);
     for (const [picture] of decodeText(bytes).matchAll(/<p:pic>[\s\S]*?<\/p:pic>/g)) {
       const name = picture.match(/<p:cNvPr\b[^>]*\bname="([^"]+)"/)?.[1];
-      const placement = context.imagePlacements.get(name) ?? context.slideImages.get(name) ?? (name === watermarkName() ? context.watermarks.get(part) : name === logoName() ? context.logos.get(part) : undefined);
+      const placement = context.images.get(name) ?? context.quotePhotos.get(name) ?? (name === watermarkName() ? context.watermarks.get(part) : name === logoName() ? context.logos.get(part) : undefined);
       const id = picture.match(/<a:blip\b[^>]*r:embed="([^"]+)"/)?.[1];
       if (placement) imageSources.set(relationships.get(id)?.path, placement.path);
     }
@@ -3437,11 +3751,18 @@ async function normalizePptxZip(raw, context) {
     }
     imageMetadata.set(part, metadata);
   }
-  // Slide images need the embedded dimensions; document provenance (FF-32)
+  // Image pictures need the embedded dimensions (core's fitImage crops and pads them); document provenance (FF-32)
   // later records the placed frames as slide geometry evidence.
-  placeSlideImages(entries, context.slideImages, (part, id) => imageMetadata.get(parseRelationships(entries, part).get(id)?.path), 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 });
-  });
+  try {
+    placeImages(entries, context.images, context.imageOverlays, {
+      metadataFor: (part, id) => imageMetadata.get(parseRelationships(entries, part).get(id)?.path), fitImage,
+      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 }); }
+    });
+  } catch (error) {
+    if (error instanceof OPFPptxError) throw error;
+    throw new OPFPptxError("packaging-failed", `Image pictures could not be placed: ${errorMessage(error)}`);
+  }
+  tagTextWatermarks(entries, context.textWatermarks);
   placeWatermarks(entries, context.watermarks, (part, id) => imageMetadata.get(parseRelationships(entries, part).get(id)?.path), 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 });
   });
@@ -3599,7 +3920,7 @@ function normalizePartBytes(path, bytes, context, renameMaps, entries, imageMeta
           const metadata = imageMetadata.get(backgroundRelationships.get(id)?.path);
           if (!id || !metadata) throw new OPFPptxError("unsupported-image-dimensions", "Background image fitting requires readable PNG, JPEG, GIF or WebP dimensions. Supply a supported raster image through imageResolver.", { path: fill.image.path });
           if ((metadata.orientation ?? 1) !== 1) fill.image.report?.({code: 'unsupported-background-image-orientation', path: fill.image.path, message: 'A slide background picture fill cannot rotate or mirror its image; the JPEG EXIF orientation is not applied in the native background.'});
-          return `<p:bg><p:bgPr>${nativeImageBackgroundFill(id, metadata, fill.image)}<a:effectLst/></p:bgPr></p:bg>`;
+          return `<p:bg><p:bgPr>${nativeImageBackgroundFill(id, metadata, {...fill.image, fitImage})}<a:effectLst/></p:bgPr></p:bg>`;
         });
       }
       // PptxGenJS table IDs can collide with other objects on the same slide.
@@ -3685,7 +4006,8 @@ function normalizePartBytes(path, bytes, context, renameMaps, entries, imageMeta
         }
         const text = context.pictureText.get(picture.match(/<p:cNvPr\b[^>]*\bname="([^"]+)"/)?.[1]);
         if (text) picture = writePictureText(picture, text);
-        const placement = context.imagePlacements.get(picture.match(/name="(OPF image \d+)"/)?.[1]);
+        // Image pictures were placed with the slide's other pictures (placeImages); quote photos are fitted here.
+        const placement = context.quotePhotos.get(picture.match(/name="(OPF quote photo \d+)"/)?.[1]);
         if (!placement) return picture;
         const id = picture.match(/<a:blip\b[^>]*r:embed="([^"]+)"/)?.[1];
         const dimensions = imageMetadata.get(relationships.get(id)?.path);
@@ -3698,6 +4020,8 @@ function normalizePartBytes(path, bytes, context, renameMaps, entries, imageMeta
           const attrs = Object.entries(fitted.crop).map(([key, value]) => `${key}="${value}"`).join(' ');
           picture = picture.replace('<a:stretch>', `<a:srcRect ${attrs}/><a:stretch>`);
         }
+        // The circular headshot mask: the core frame's DrawingML preset (ellipse) instead of the rectangle.
+        if (placement.shape) picture = picture.replace(/<a:prstGeom\b[\s\S]*?<\/a:prstGeom>/, `<a:prstGeom prst="${placement.shape.preset}"><a:avLst/></a:prstGeom>`);
         return picture;
       });
       // Native bullets otherwise inherit the first rich run's size, font and
@@ -3733,6 +4057,7 @@ function normalizePartBytes(path, bytes, context, renameMaps, entries, imageMeta
     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);
+    if (context.scriptFonts && /^ppt\/slides\/slide\d+\.xml$/.test(path)) xml = runLanguageFonts(xml, context.scriptFonts, context.partSlides.get(path) ?? 0);
     return encodeText(normalizePartReferences(xml, renameMaps));
   }
   return bytes;