@openpresentation/opf-pptx 0.18.2 → 0.20.0

package/dist/index.js

@@ -32,6 +32,8 @@ import {INVALID_XML_CHARACTER, nativeSections, writeSectionList} from './section
 import {attachFurnitureFields, furniturePartFields, lineFields, nativeFieldType} from './furniture-fields.js';
 import {attachNativePlaceholders, defaultPlaceholderGeometry, nativeDateText, nativeFurnitureParts, nativePlaceholderForPart, writeNativeMasters} from './native-furniture.js';
 import {liftMasterFurniture} from './master-furniture.js';
+import {gallery} from '@openpresentation/gallery';
+import {applyTemplateLayouts, deckTemplates, foreignLayoutReference, placeholderRegion, readLayoutTag, slideTemplate, writeTemplateLayouts} from './template-layouts.js';
 import {importImageOrientation} from './image-import.js';
 import {extractSignals, normalizeSignalOptions, themeFactsFor} from './import-signals.js';
 import {placeImages, importImages, importImagePlaceholders, isImagePlaceholderGroup, imageName, imageOverlayName, imagePlaceholderGroupName, backgroundImageName, backgroundOverlayName, IMAGE_TREATMENT_KEYS, BACKGROUND_IMAGE_KEYS, IMAGE_PLACEHOLDER_TAG} from './image-provenance.js';
@@ -290,6 +292,10 @@ export async function toPptx(input, options = {}) {
   context.nativeFurnitureBands = new Map();
   // RR-72: each slide's furniture parts and the object names of their shapes, for the slide master and layouts.
   context.furnitureParts = [];
+  // RR-81: the 0.19 template each slide uses (its native slide layout) and the objects bound to a region placeholder.
+  context.templateSlides = [];
+  context.automaticSlides = [];
+  context.placeholderBindings = new Map();
   context.hostDate = options.date;
   context.authored = authored;
   context.codeTags = new Map();
@@ -345,6 +351,22 @@ export async function toPptx(input, options = {}) {
     await addSlide(pptx, presentation, presentation.slides[index], index, context, options);
   }
 
+  // RR-81: when a slide uses a template, every template the deck reaches gets its native layout (registered catalogs, then embedded).
+  // A template's placeholders are composed with the options of the first slide that uses it; a template no slide uses, with the
+  // options of a slide that would (the deck's header and footer, the template's own design) and no placed-image band.
+  const reachableTemplates = deckTemplates(presentation, options.catalogs, reference => resolveReference(presentation, 'layouts', reference, options.catalogs !== undefined ? {catalogs: options.catalogs} : {}));
+  if (context.templateSlides.some(Boolean) || reachableTemplates.length || context.automaticSlides.some(Boolean)) {
+    const plans = context.templateSlides.filter(Boolean), first = plans[0] ?? context.automaticSlides.find(Boolean) ?? {areaOptions: context.firstSlideOptions};
+    const reachable = reachableTemplates;
+    for (const plan of plans) if (!reachable.some(template => template.key === plan.template.key)) reachable.push(plan.template);
+    context.deckTemplates = reachable.map(template => {
+      const used = plans.find(plan => plan.template.key === template.key);
+      if (used) return {...template, areaOptions: used.areaOptions};
+      const core = coreContext({...presentation, slides: [{layout: template.reference}]}, 0, options).options;
+      return {...template, areaOptions: {...core, fontFamilies: first.areaOptions.fontFamilies, textRasterPadding: options.textRasterPadding, placements: []}};
+    });
+  }
+
   // 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),
@@ -429,11 +451,26 @@ export async function fromPptx(input, options = {}) {
     return inheritedParts.get(path);
   };
   const relatedPath = (path, type) => path ? [...cachedRelationships(path).values()].find(rel => rel.type === `http://schemas.openxmlformats.org/officeDocument/2006/relationships/${type}` && rel.targetMode !== 'External' && entries[rel.path])?.path : undefined;
+  // RR-81: the OPF_LAYOUT_V1 tag of each slide's layout (a 0.19 template layout), read once per layout part.
+  const layoutTags = new Map();
+  const layoutTagOf = (layoutPath, index) => {
+    if (!layoutPath) return undefined;
+    if (!layoutTags.has(layoutPath)) layoutTags.set(layoutPath, readLayoutTag(entries, layoutPath, message => options.onDiagnostic?.({code: 'invalid-layout-provenance', path: `slides.${index}.layout`, message})));
+    return layoutTags.get(layoutPath);
+  };
   const furnitureContexts = slidePaths.map((slidePath, index) => {
     const root = parseRequiredXml(entries, slidePath)['p:sld'];
     if (!root) throw new OPFPptxError('invalid-pptx', `PPTX slide is not a PresentationML slide: ${slidePath}.`, {path: slidePath});
     const tree = root['p:cSld']?.['p:spTree'], relationships = parseRelationships(entries, slidePath);
-    return {root, relationships, shapes: nativeTextShapes(tree), pictures: nativePictures(tree),
+    const layoutPath = relatedPath(slidePath, 'slideLayout'), layoutTag = layoutTagOf(layoutPath, index);
+    return {root, relationships, shapes: nativeTextShapes(tree), pictures: nativePictures(tree), layoutTag, foreignLayout: layoutTag ? undefined : foreignLayoutReference(cachedPart(layoutPath)?.['p:sldLayout'], options.catalogs),
+      // RR-81: a region placeholder typed into in PowerPoint has no xfrm of its own; it sits where the template layout puts it.
+      layoutBounds: layoutTag ? shape => {
+        const ph = shape?.['p:nvSpPr']?.['p:nvPr']?.['p:ph'];
+        if (ph?.idx === undefined) return undefined;
+        const match = asArray(cachedPart(layoutPath)?.['p:sldLayout']?.['p:cSld']?.['p:spTree']?.['p:sp']).find(candidate => candidate?.['p:nvSpPr']?.['p:nvPr']?.['p:ph']?.idx === ph.idx);
+        return match ? shapeBounds(match['p:spPr']?.['a:xfrm']) ?? undefined : undefined;
+      } : undefined,
       // RR-11: native footer placeholders resolve their position through the layout and master.
       path: slidePath, slideWidth: Number(presentationRoot['p:sldSz']?.cx), relationshipsOf: cachedRelationships, readPart: cachedPart,
       paragraphs: nativeShapeParagraphs(decodeText(entries[slidePath])),
@@ -512,11 +549,34 @@ export async function fromPptx(input, options = {}) {
     report({code: "invalid-document-provenance", path: "", message: `${errorMessage(error)} Ordinary import keeps the values observed in the PPTX.`});
   }
   if (slideProvenance.length !== imported.slides.length) throw new OPFPptxError("invalid-import-opf", "Slide provenance does not match the imported slides.");
+  // RR-81: a slide on a 0.19 template layout takes that layout's reference (a slide added in PowerPoint, Change Layout), and a
+  // block read from a region placeholder keeps its region with a pin where plain binding would move it (src/template-layouts.js).
+  // Every tagged layout of the package, used or not: an embedded template no slide uses comes back from its tag.
+  const packageLayoutTags = Object.keys(entries).filter(path => /^ppt\/slideLayouts\/slideLayout\d+\.xml$/.test(path)).sort((a, b) => Number(a.match(/\d+/)[0]) - Number(b.match(/\d+/)[0]))
+    .map(path => layoutTagOf(path, 0)).filter(Boolean);
+  if (packageLayoutTags.length) {
+    const restoredContent = new Set(restoredGroups.filter(group => group.applied && group.contentPaths).map(group => group.contentPaths.slide));
+    applyTemplateLayouts(imported, furnitureContexts.map((context, index) => ({tag: context.layoutTag, blockRegions: context.blockRegions, restored: restoredContent.has(index), preservedAutomatic: slideProvenance[index]?.structure !== 'untagged', storedLayout: slideProvenance[index]?.layout})),
+      index => resolveCoreSlideContext(imported, index, options.catalogs !== undefined ? {catalogs: options.catalogs} : {}).resolved.layout, report, packageLayoutTags);
+  }
+  for (const [index, context] of furnitureContexts.entries()) {
+    if (!context.layoutTag && slideProvenance[index]?.structure === 'untagged' && context.foreignLayout !== undefined && imported.slides[index].layout === undefined)
+      {
+        if (context.foreignLayout.startsWith('default:')) {
+          const found = resolveReference({}, 'layouts', context.foreignLayout, {catalogs: options.catalogs ?? [gallery]});
+          const existing = imported.catalogs?.default;
+          if (existing === false || (existing?.source !== undefined && existing.source !== found?.source)) continue;
+          if (found?.source) imported.catalogs = {...imported.catalogs, default: {...imported.catalogs?.default, source: found.source}};
+        }
+        imported.slides[index].layout = context.foreignLayout;
+      }
+  }
   // RR-34: marker runs become cite/footnote on the runs before them, and the references list is rebuilt
   // from the stored record and the footnote boxes (an edited note keeps its edited text).
   restoreCitations(imported, furnitureContexts.map(context => context.annotations?.notes ?? []), report);
   restoreLogoFallback(imported, furnitureContexts);
   applyRunColors(imported, slideProvenance, restoredGroups, report, options);
+  applyNativeImageFits(imported, furnitureContexts, restoredGroups, options);
   if (imported.design?.theme === undefined) for (const diagnostic of themeDesign.diagnostics) if (diagnostic.code === "theme-unverified") report(diagnostic);
   languageDiagnostics(imported, observedLanguage, options.onDiagnostic && report);
 
@@ -820,10 +880,22 @@ function importSlide(entries, slidePath, slideIndex, presentationDimensions, opt
     }
   }
   const listRecord = slideListRecord(entries, slidePath, slideRoot, relationships);
-  const content = mergeAdjacentBulletShapes(mergeOpfListShapes(items, listRecord.breaks, diagnostic => options.onDiagnostic?.({...diagnostic, path: `slides.${slideIndex}`}), listRecord.runs))
-    .map((item) => ({payload: payloadFromSlideItem(item, diagnostic => options.onDiagnostic?.({...diagnostic, path: `slides.${slideIndex}`})), bounds: item.visualBounds ?? item.bounds, sources: item.sources ?? []}))
+  const content = mergeAdjacentBulletShapes(mergeOpfListShapes(items, listRecord.breaks, diagnostic => options.onDiagnostic?.({...diagnostic, path: `slides.${slideIndex}`}), listRecord.runs, listRecord.roles))
+    .map((item) => ({payload: payloadFromSlideItem(item, diagnostic => options.onDiagnostic?.({...diagnostic, path: `slides.${slideIndex}`})), bounds: item.visualBounds ?? item.bounds, sources: item.sources ?? [], inferredStretch: item.inferredStretch}))
     .filter((entry) => entry.payload);
   const blocks = content.map((entry) => entry.payload);
+  // RR-81: the region of each block read from one region placeholder of the slide's 0.19 template layout (its p:ph idx).
+  if (nativeContext.layoutTag) {
+    const frames = asArray(slideRoot['p:cSld']?.['p:spTree']?.['p:graphicFrame']);
+    const nodeOf = source => {
+      const [kind, position] = source.split(':');
+      return kind === 'sp' ? nativeContext.shapes[position] : kind === 'pic' ? nativeContext.pictures[position] : kind === 'frame' ? frames[position] : undefined;
+    };
+    nativeContext.blockRegions = content.map(entry => {
+      const regions = new Set(entry.sources.map(source => placeholderRegion(nodeOf(source), nativeContext.layoutTag)));
+      return regions.size === 1 ? [...regions][0] : undefined;
+    });
+  }
   // RR-34: a tagged caption re-attaches to the block whose native media shape it names (never by position).
   const annotations = nativeContext.annotations;
   if (annotations?.captions.size) {
@@ -850,6 +922,7 @@ function importSlide(entries, slidePath, slideIndex, presentationDimensions, opt
   // Which native shapes fed each field and block (import signals); never part of the document.
   nativeContext.signalSources = {tag: tagItem?.sources ?? [], title: titleItem?.sources ?? [], subtitle: subtitleItem?.sources ?? [],
     blocks: content.map(entry => ({sources: entry.sources, type: entry.payload.type})), roles: nativeContext.signalRoles ?? new Map()};
+  nativeContext.inferredImageFits = content.flatMap((entry,index)=>entry.inferredStretch?[index]:[]);
   nativeContext.contentBounds = content.map((entry) => entry.bounds ? {x: entry.bounds.x * 96, y: entry.bounds.y * 96, width: entry.bounds.w * 96, height: entry.bounds.h * 96} : null);
 
   const notes = readSlideNotes(entries, relationships);
@@ -932,9 +1005,13 @@ function collectSlideItems(entries, slideRoot, slidePath, relationships, dimensi
     if (furniture.text.has(index) || nativeContext.imageShapes?.has(index) || nativeContext.watermarkShapes?.has(index) || nativeContext.logoPlaceholderShapes?.has(index) || placeholders.consumed.has(index)) continue;
     if (annotations.consumed.has(shape)) { roles.set(shapeKeys.get(shape), 'annotation'); continue; }
     if (code.consumed.has(shape)||metric.consumed.has(shape)||cards.has(shape)||media.consumed.has(shape)||headings.consumed.has(shape)||plainText.consumed.has(shape)||timelines.consumed.has(shape)||quotes.consumed.has(shape)) continue;
+    // RR-81: a placeholder with no text (no runs, or only empty paragraphs) is PowerPoint's prompt ("Click to add text" on a slide
+    // added from a layout), not content. A picture, chart or table in a placeholder is a p:pic or p:graphicFrame, read below.
+    if (shape['p:nvSpPr']?.['p:nvPr']?.['p:ph'] !== undefined && !(paragraphs[index] ?? []).some(paragraph => paragraph.text)) { roles.set(shapeKeys.get(shape), 'prompt'); continue; }
     const ordinaryBody = Object.hasOwn(shape, 'p:txBody') && !shape['p:nvSpPr']?.['p:nvPr']?.['p:custDataLst']?.['p:tags'];
     const item = importShape(shape, dimensions, paragraphs[index], ordinaryBody || furniture.taggedText.has(index) || media.captionShapes.has(shape));
     if (item && ordinaryBody) item.readNativeBody = () => readBody(index);
+    if (item && !item.bounds && nativeContext.layoutBounds) item.bounds = nativeContext.layoutBounds(shape) ?? item.bounds;
     // A damaged/edited furniture group falls back to current native text,
     // including cleared text boxes, without inventing a title or shape label.
     if (item && (furniture.taggedText.has(index) || media.captionShapes.has(shape))) item.sourceText = true;
@@ -972,6 +1049,8 @@ function collectSlideItems(entries, slideRoot, slidePath, relationships, dimensi
     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)};
+    else if (item?.nativeStretch) { item.payload.fit='stretch'; item.inferredStretch=true; }
+    else if (item?.nativeFitUnsupported) report({code:'unsupported-image-fit',message:'Native picture tiling or an offset stretch fill is not represented by the imported image block; review the reflowed image.'});
     if (item) items.push({...item, sources: [`pic:${index}`]});
   }
 
@@ -1127,6 +1206,8 @@ function importPicture(entries, picture, slidePath, relationships, report) {
 
   return {
     kind: "image",
+    nativeStretch: nativePictureStretch(picture, bytes, bounds, Boolean(svg)),
+    nativeFitUnsupported: picture['p:blipFill']?.['a:tile']!==undefined || ['l','r','t','b'].some(key=>Number(picture['p:blipFill']?.['a:stretch']?.['a:fillRect']?.[key]??0)!==0),
     bounds,
     visualBounds: visualBounds(picture["p:spPr"]?.["a:xfrm"]),
     name,
@@ -1141,6 +1222,46 @@ function importPicture(entries, picture, slidePath, relationships, report) {
   };
 }
 
+// A full-source native stretch is distinguishable from cover only when the
+// intrinsic aspect differs from its frame. No crop, tile, offset fill or turn is
+// inferred; those require their existing diagnostics/separate fidelity review.
+function nativePictureStretch(picture,bytes,bounds,svg) {
+  const fill=picture['p:blipFill'],crop=fill?.['a:srcRect'],stretch=fill?.['a:stretch'];
+  const rect=stretch?.['a:fillRect'],transform=picture['p:spPr']?.['a:xfrm'];
+  const metadata=svg?null:rasterMetadata(bytes);
+  if(!bounds||!(bounds.w>0&&bounds.h>0)||!metadata||!(metadata.width>0&&metadata.height>0)||metadata.orientation>1) return false;
+  if(stretch===undefined||fill?.['a:tile']!==undefined||Number(transform?.rot??0)!==0) return false;
+  if([crop,rect].some(value=>value&&['l','r','t','b'].some(key=>Number(value[key]??0)!==0)))return false;
+  // Compare dimensions in native EMUs, without a new geometry tolerance.
+  const ext=transform?.['a:ext'];
+  const cx=Number(ext?.cx),cy=Number(ext?.cy);
+  if(!Number.isFinite(cx)||!Number.isFinite(cy))return false;
+  // Equal-aspect dimensions can round by one EMU when serialized. A dimension
+  // reproduced by rounding the intrinsic ratio is still the same aspect.
+  return Math.round(cx*metadata.height/metadata.width)!==cy&&Math.round(cy*metadata.width/metadata.height)!==cx;
+}
+
+// Provenance may rebuild flat blocks into groups or scalar fields. Remove only
+// our inferred fit when restored design already supplies stretch, preserving an
+// unchanged authored default rather than adding an unsolicited block override.
+function applyNativeImageFits(imported,contexts,groups,options) {
+  for(const [slideIndex,context] of contexts.entries()) {
+    if(!context.inferredImageFits?.length)continue;
+    const slide=imported.slides[slideIndex];
+    const resolved=resolveCoreSlideContext(imported,slideIndex,options.catalogs!==undefined?{catalogs:options.catalogs}:{}).resolved;
+    const fit=slide.design?.imageFit??imported.design?.imageFit??resolved.theme?.design?.imageFit??resolved.layout?.design?.imageFit??'cover';
+    const restored=groups.find(group=>group.applied&&group.contentPaths?.slide===slideIndex)?.contentPaths?.paths;
+    for(const index of context.inferredImageFits) {
+      const path=restored?.get(index)??`blocks.${index}`;
+      const value=path.split('.').reduce((item,key)=>item?.[key],slide);
+      if(value&&typeof value==='object'&&value.image!==undefined) {
+        if(fit==='stretch')delete value.fit;
+        else value.fit='stretch';
+      }
+    }
+  }
+}
+
 function readParagraphs(txBody) {
   return withDisplayedNumbers(asArray(txBody?.["a:p"])
     .map((paragraph) => {
@@ -1257,7 +1378,7 @@ function joinRich(a, b) {
 // `runs` (opf-pptx#212) holds the look export wrote on every run of a list ({text, description?}): a run value still equal to
 // it is inherited formatting, not authored run style, and is removed (as for a tagged heading), so an untouched round trip
 // adds no explicit sizes, families or colours; a value edited in PowerPoint differs and is kept. Without it runs are as read.
-function mergeOpfListShapes(items, breaks = null, report = () => {}, runs = null) {
+function mergeOpfListShapes(items, breaks = null, report = () => {}, runs = null, roles = null) {
   const lists = new Map();
   for (const item of items) {
     const match = /^OPF list (.+) line (\d+)$/.exec(item.name ?? '');
@@ -1270,6 +1391,10 @@ function mergeOpfListShapes(items, breaks = null, report = () => {}, runs = null
   for (const [path, entries] of lists) {
     entries.sort((a, b) => a.line - b.line);
     if (!entries[0].item.paragraphs[0].bullet) continue;
+    const expectedRoles = roles?.get(path);
+    const validRoles = expectedRoles && expectedRoles.length === entries.length && entries.every(({item, line}, index) => line === index && Boolean(item.paragraphs[0].bullet) === expectedRoles[index][2]);
+    const lineRoles = validRoles ? expectedRoles : null;
+    if (expectedRoles && !validRoles) report({code: 'list-line-role-changed', message: `The line topology of ${path} changed; list roles were not restored.`});
     const look = runs?.get(path), textLook = cleanBase(look?.text), descriptionLook = cleanBase(look?.description);
     // The line's runs without the inherited look, or the paragraph's own richText when there is no record for this kind of line.
     // Each run is cleaned on its own and none merge, so the runs stay the slots the run colour record counts (src/run-colors.js);
@@ -1299,7 +1424,7 @@ function mergeOpfListShapes(items, breaks = null, report = () => {}, runs = null
       const join = (a, b) => gap === undefined ? joinRich(a, b) : joinWrappedText([a, b], [gap]);
       if (paragraph.bullet) { paragraphs.push({...paragraph, richText: own(paragraph, textLook)}); size = paragraph.maxFontSize; }
       else if (paragraph.text === '') { /* a blank line of the entry: no text, no description */ }
-      else if (paragraph.maxFontSize < size - 0.01) {
+      else if (lineRoles ? lineRoles[line][1] === 'description' : paragraph.maxFontSize < size - 0.01) {
         const text = own(paragraph, descriptionLook) ?? paragraph.text;
         if (current.description === undefined) current.description = text;
         else { current.description = join(current.description, text); applied.add(line); }
@@ -1810,7 +1935,7 @@ function resolvePresentationContext(presentation, options, core = coreContext({.
       // 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")
+      border: normalizeHex(roles.border)
     },
     variables
   };
@@ -2002,6 +2127,17 @@ async function addSlide(pptx, presentation, authoredSlide, slideIndex, context,
   // 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);
+  if (slideIndex === 0) context.firstSlideOptions = composeOptions;
+  // RR-81: a list core broke into columns (listColumns) is drawn as one measured list whose lines sit in their columns: each line
+  // is its own shape at core's geometry, as in every list, and line names, numbering and provenance run across the columns.
+  // Core's item.text is the whole list (every entry at its column's position); the lines are taken from listColumns, which replace
+  // the entries rather than add to them, so each entry is drawn once.
+  for (const item of geometry.items) if (item.listColumns?.length > 1 && item.text?.listEntries) item.text = {...item.text, listEntries: item.listColumns.flatMap(column => column.text?.listEntries ?? [])};
+  // RR-81: a slide on a 0.19 template uses that template's native slide layout (src/template-layouts.js), whose placeholders
+  // core composes with this slide's options (canvas, the deck's header and footer, direction) and its placed-image bands.
+  const template = slideTemplate(slideContext.core);
+  if (template) context.templateSlides[slideIndex] = {template, areaOptions: {...composeOptions, placements: placedImageBands(opfSlide)}};
+  else if (opfSlide.layout === undefined || opfSlide.layout === 'auto') context.automaticSlides[slideIndex] = {areaOptions: composeOptions, title: geometry.items.find(item => item.field === 'title')};
   // The default footer band (date left, text center, number right): where a footer added natively lands (RR-11).
   if (slideIndex === 0) context.defaultFooterOptions = composeOptions;
   slideContext.zoneBand = zoneBands(composeOptions);
@@ -2035,6 +2171,13 @@ async function addSlide(pptx, presentation, authoredSlide, slideIndex, context,
   // 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);
   for (const item of geometry.items) {
+    // RR-81: the lone picture, chart or table of a `none` region binds to that region's placeholder on the slide layout. A captioned
+    // object or one drawn on a card stays a free shape: Change Layout would move it away from its caption or card.
+    const boundRegion = template && item.region !== undefined && ['image', 'chart', 'table'].includes(item.field) && !item.caption && !item.frameBox
+      ? geometry.regions?.find(region => region.name === item.region && region.flow === 'none' && region.content?.length === 1 && !region.overflow?.length) : undefined;
+    if ((template || context.automaticSlides[slideIndex]) && item.field === 'title' && typeof item.value === 'string' && item.text?.lines?.length === 1 && !item.text.overflow && !item.text.richLines)
+      context.placeholderBindings.set(`OPF heading ${item.path} line 0`, {slide: slideIndex, region: 'Title', object: 'title'});
+    const drawnBefore = boundRegion && {images: context.images.size, placeholders: context.imagePlaceholders.size, charts: context.chartHeadings.size, tables: context.tableHeaders.size};
     // Card text sits on a literal card fill, not the slide background: keep it literal.
     const itemContext = item.frameBox ? {...slideContext, textColor: slideContext.colors.text, mutedColor: slideContext.colors.mutedText} : slideContext;
     const region = { x: item.box.x / 96, y: item.box.y / 96, w: item.box.width / 96, h: item.box.height / 96 };
@@ -2045,7 +2188,7 @@ async function addSlide(pptx, presentation, authoredSlide, slideIndex, context,
       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}`});
+        fill:paint(surface),line:{...paint(`#${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:item.alignment,diagnosticsHandled:true,heading:['title','subtitle','tag'].includes(item.field)?item.field:undefined,color:item.field==='tag'?tagColor(itemContext):itemContext.textColor});
@@ -2085,12 +2228,18 @@ async function addSlide(pptx, presentation, authoredSlide, slideIndex, context,
     } 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.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);
+      await addPayload(slide, presentation, item.payload, region, item.path, { ...itemContext, composition: item.composition, contentAlignment: item.alignment ?? "left", tableAlignment: geometry.design.contentAlignment, 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.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}));
       }
     }
+    if (drawnBefore) {
+      const added = (map, size) => [...map.keys()].slice(size);
+      const names = item.field === 'image' ? (context.imagePlaceholders.size === drawnBefore.placeholders ? added(context.images, drawnBefore.images) : [])
+        : item.field === 'chart' ? added(context.chartHeadings, drawnBefore.charts).filter(name => !context.chartex.has(name)) : added(context.tableHeaders, drawnBefore.tables);
+      if (names.length === 1) context.placeholderBindings.set(names[0], {slide: slideIndex, region: boundRegion.name, object: item.field === 'image' ? 'picture' : item.field});
+    }
   }
   // RR-34: the footnote area core reserved above the footer band (rule plus one tagged text box per listed line).
   addFootnotes(slide, geometry.footnotes, slideIndex, slideContext, exportHelpers, (code, message) => new OPFPptxError(code, message, {path: `slides.${slideIndex}`}));
@@ -2106,6 +2255,13 @@ async function addSlide(pptx, presentation, authoredSlide, slideIndex, context,
   }
 }
 
+// RR-81: the placed-image bands of a slide (its image blocks with a `placement`), which a template layout reserves as the slide does.
+function placedImageBands(slide) {
+  return (Array.isArray(slide?.blocks) ? slide.blocks : [])
+    .filter(block => isPlainObject(block) && isPlainObject(block.placement) && typeof block.placement.edge === 'string' && (block.image !== undefined || block.type === 'image'))
+    .map(({placement}) => ({edge: placement.edge, ...(placement.size !== undefined ? {size: placement.size} : {}), ...(placement.inset !== undefined ? {inset: placement.inset} : {})}));
+}
+
 // 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) {
@@ -2536,7 +2692,7 @@ function applyChartTextSize(xml, size) {
 }
 
 function addChartPayload(slide, chart, region, context, options = {}, path = "chart", presentation) {
-  const chartData = toPptxChartData(chart, context.chartexMode, presentation);
+  const chartData = toPptxChartData(chart, context.chartexMode, presentation, path);
   if (!chartData.series) {
     // Never lose a chart silently: the placeholder frame stands in for it, and a diagnostic names the reason.
     options.onDiagnostic?.({code: "chart-data-unplottable", path, message: chartData.message, reason: chartData.reason});
@@ -2569,7 +2725,9 @@ function addChartPayload(slide, chart, region, context, options = {}, path = "ch
     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);
+  // Synthetic row-number categories are a native adaptation, not an authored
+  // data column. Full provenance restores the source form only on unchanged caches.
+  recordPayloadData(context, objectName, 'chart', presentation, path, undefined, {rowNumbers: chart.data?.columns?.length === 1 && chartData.adaptations?.some(entry => entry.adaptation === 'row-numbers') === true});
   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.frameAlts.set(objectName, chart.alt);
@@ -2622,6 +2780,11 @@ function addChartPayload(slide, chart, region, context, options = {}, path = "ch
     dataLabelFontSize: textSize / 100,
     showValue: false,
     valGridLine: { color: context.colors.border, transparency: 30, size: 1 },
+    // Magnitude bars/columns/areas must not let Office auto-truncate a near-equal range.
+    ...(chartData.spec.family === "category" && ["bar", "area"].includes(chartData.type) && chartData.spec.grouping !== "percentStacked" ? {
+      ...(chartData.series.every(entry => entry.values.every(value => value == null || value >= 0)) ? {valAxisMinVal: 0} : {}),
+      ...(chartData.series.some(entry => entry.values.some(value => value < 0)) && chartData.series.every(entry => entry.values.every(value => value == null || value <= 0)) ? {valAxisMaxVal: 0} : {})
+    } : {}),
     barDir: chartData.barDir,
     barGrouping: chartData.barGrouping,
     // Right to left (RR-05): column, line and area charts reverse their categories (c:catAx orientation maxMin), which also moves the
@@ -2668,11 +2831,11 @@ function comboChart(chartData, options, {palette, chartOptions, labelColor, font
 // RR-54: a chart or table that uses a dataset, DataColumn objects, a mapping, a data source or number formats records its
 // authored data form on its native frame (src/data-provenance.js), in `full` provenance mode only. `path` is the composed
 // item's path ("slides.0.blocks.1.chart"), which names the authored value (composition hands over the inline copy).
-function recordPayloadData(context, objectName, kind, presentation, path, layout) {
+function recordPayloadData(context, objectName, kind, presentation, path, layout, chartRecordOptions) {
   if (context.provenanceMode !== 'full' || !context.dataRecords || !presentation) return;
   let authored = presentation;
   for (const key of String(path).split('.')) authored = authored !== null && typeof authored === 'object' ? authored[Array.isArray(authored) ? Number(key) : key] : undefined;
-  const record = kind === 'chart' ? chartDataRecord(authored, presentation.datasets) : tableDataRecord(authored, layout);
+  const record = kind === 'chart' ? chartDataRecord(authored, presentation.datasets, chartRecordOptions) : tableDataRecord(authored, layout);
   if (record) {
     context.dataRecords.set(objectName, record);
     context.dataRecordPaths.set(objectName, String(path));
@@ -2694,7 +2857,7 @@ function addTablePayload(slide, authoredTable, region, context, options, path, p
   }
 
   const layout = layoutTable(table, {x:region.x*96,y:region.y*96,width:region.w*96,height:region.h*96}, {
-    scale, minFontSize:context.composition?.minFontSize, fontFamily:context.fonts.body, textMeasurement:options.textMeasurement, path,
+    scale, minFontSize:context.composition?.minFontSize, fontFamily:context.fonts.body, textMeasurement:options.textMeasurement, path, alignment:context.tableAlignment,
     ...(context.direction === 'rtl' ? {direction: 'rtl'} : {}), ...(presentation ? {presentation} : {})
   });
   const columnCount = layout.columnCount;
@@ -2744,7 +2907,7 @@ function addTablePayload(slide, authoredTable, region, context, options, path, p
         ...(rich ? {bold:false,italic:false} : {}),
         lineSpacing: fit.lineHeight * 0.75,
         paraSpaceAfter: 0,
-        align: physicalAlignment(cellStyle.align ?? context.contentAlignment, cell.direction),
+        align: physicalAlignment(cell.alignment, cell.direction),
         valign: cellStyle.verticalAlign ?? 'top',
         ...(cell.colSpan > 1 ? {colspan:cell.colSpan} : {}),
         ...(cell.rowSpan > 1 ? {rowspan:cell.rowSpan} : {}),
@@ -2761,7 +2924,7 @@ function addTablePayload(slide, authoredTable, region, context, options, path, p
   recordPayloadData(context, objectName, 'table', presentation, path, layout);
   // FA-27: the table's text alternative (the frame's descr; the empty string is PowerPoint's decorative marker).
   if (typeof authoredTable?.alt === 'string') context.frameAlts.set(objectName, authoredTable.alt);
-  if (layout.rows.some(row => row.cells.some(cell => Object.keys(cell.style ?? {}).length))) context.tableCells.set(objectName, {layout, scale, context, defaultBorder:{color:"accent5",width:1/scale}});
+  if (layout.rows.some(row => row.cells.some(cell => Object.keys(cell.style ?? {}).length))) context.tableCells.set(objectName, {layout, scale, context, defaultBorder:{color:`#${context.colors.border}`,width:1/scale}});
   slide.addTable(rows, {
     objectName,
     x: region.x,
@@ -2777,7 +2940,7 @@ function addTablePayload(slide, authoredTable, region, context, options, path, p
     fontFace: context.fonts.body,
     fontSize: 15 * scale * 0.75,
     color: context.colors.text,
-    border: { type: "solid", color: nativeColor("accent5", context.colors.border, context), pt: 0.75 },
+    border: { type: "solid", color: context.colors.border, pt: 0.75 },
     margin: [6 * scale, 7.5 * scale, 3 * scale, 7.5 * scale],
     valign: "top"
   });
@@ -3454,7 +3617,7 @@ function textRuns(value, context, fallbackFontSize) {
  * goes through core's strict `chartNumber` (a string that is not a plain decimal is a gap, reported once per chart as
  * `chart-value-not-numeric`). `formats` holds the Excel codes of the columns' number formats per exported series.
  */
-function toPptxChartData(chart, chartexMode = 'auto', presentation) {
+function toPptxChartData(chart, chartexMode = 'auto', presentation, path = 'chart') {
   const unplottable = (reason, summary, message) => ({reason, summary, message: `${message} No native chart was exported; a placeholder frame stands in for it.`});
   // A dataset reference is inlined from the document first (composition normally hands over the inline copy already).
   const source = isDatasetRef(chart?.data) ? inlineChartData(chart, presentation) : chart;
@@ -3473,19 +3636,25 @@ function toPptxChartData(chart, chartexMode = 'auto', presentation) {
   const columnCodes = (resolvedData.formats ?? []).map(excelCode);
   const diagnostics = resolvedData.diagnostics.filter((entry) => entry.severity === 'warning' && entry.code !== 'chart-value-not-numeric');
   const rejected = resolvedData.diagnostics.filter((entry) => entry.code === 'chart-value-not-numeric');
-  const resolved = resolveChartType(chart.type).spec;
+  const {id: chartId, spec: resolved} = resolveChartType(chart.type);
   // A chartex type (treemap, histogram, pareto, box & whisker, waterfall, funnel, map) has no classic construct. Natively
   // it is written as its cx:chartSpace part and the clustered column chart of the same data is its mc:Fallback
   // (src/chartex.js). 'auto' (the default) does that for the constructs the native PowerPoint check confirmed and keeps
   // the unconfirmed map on the clustered column chart alone; 'fallback' keeps every chartex id there. The fallback is
   // reported as chartex-fallback, never silent.
-  const native = chartexMode === 'native' || (chartexMode === 'auto' && resolved.family === 'chartex' && !resolved.unconfirmed);
+  const multiSeriesPareto = chartId === 'pareto' && data.columns.length > 2;
+  if (multiSeriesPareto && chartexMode === 'native') {
+    throw new OPFPptxError('unsupported-chart-data', 'Native Pareto supports one value series. Use chartex auto or fallback to export every series as an editable clustered column chart.', {path, series: data.columns.slice(1)});
+  }
+  const native = chartexMode === 'native' || (chartexMode === 'auto' && resolved.family === 'chartex' && !resolved.unconfirmed && !multiSeriesPareto);
   const chartex = resolved.family === 'chartex' && native ? resolved : null;
   const spec = resolved.family === 'chartex' ? CHARTEX_FALLBACK : resolved;
   const typeName = stringifyText(chart.type);
   const adaptations = [];
   if (resolved.family === 'chartex' && !native) {
-    const reason = chartexMode === 'fallback'
+    const reason = multiSeriesPareto && chartexMode === 'auto'
+      ? 'that cannot represent multiple value series natively; all authored series are preserved in the fallback'
+      : chartexMode === 'fallback'
       ? 'that this exporter does not write'
       : '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.`});
@@ -4059,6 +4228,16 @@ async function normalizePptxZip(raw, context) {
     }
     reportPerSlideNotesScriptFonts(context.scriptFonts, slideThemes);
   }
+  // RR-81: one native slide layout per 0.19 template the slides use, under each slide's master, and the objects bound to its
+  // placeholders (src/template-layouts.js). Before RR-72, which copies a slide's own layout for a furniture variant.
+  if (context.templateSlides.some(Boolean) || context.deckTemplates?.length || context.automaticSlides.some(Boolean)) {
+    try {
+      writeTemplateLayouts(output, context.templateSlides, context.deckTemplates ?? [], context.placeholderBindings,
+        (path, xml) => context.scriptFonts ? partScriptFonts(path, xml, context.scriptFonts, 0) : xml, {records: context.provenanceMode === 'full', automaticSlides: context.automaticSlides});
+    } catch (error) {
+      throw new OPFPptxError('packaging-failed', 'Native slide layouts for the layout templates could not be written.', {cause: errorMessage(error)});
+    }
+  }
   // RR-72: furniture drawn the same on several slides moves to the slide master or a layout (src/master-furniture.js).
   try {
     liftMasterFurniture(output, context.furnitureParts, diagnostic => context.reportDiagnostic?.(diagnostic));

package/dist/master-furniture.js

@@ -157,7 +157,7 @@ export function liftMasterFurniture(output, slides, report = () => {}) {
       const showsMaster = plan.candidates.size ? common.every(slot => free(plan, slot)) : !common.length;
       const extras = [...plan.candidates.keys()].filter(slot => free(plan, slot) && (showsMaster ? !common.includes(slot) && counts.get(id(slot, value(plan, slot))) >= 2
         : common.includes(slot) || counts.get(id(slot, value(plan, slot))) >= 2)).sort();
-      const key = `${showsMaster ? 1 : 0}\u0001${extras.map(slot => id(slot, value(plan, slot))).join('\u0001')}`;
+      const key = `${plan.layout}\u0002${showsMaster ? 1 : 0}\u0001${extras.map(slot => id(slot, value(plan, slot))).join('\u0001')}`;
       plan.extras = extras;
       plan.lifted = new Map([...(showsMaster ? common.map(slot => [slot, 'master']) : []), ...extras.map(slot => [slot, 'layout'])]);
       plan.layoutKey = showsMaster && !extras.length ? undefined : key;
@@ -228,20 +228,38 @@ export function liftMasterFurniture(output, slides, report = () => {}) {
   for (const {master, group, common, layouts} of assignments) {
     const showing = group.find(plan => common.every(slot => free(plan, slot)) && plan.candidates.size);
     for (const slot of common) transplant(master, showing, slot);
-    // The layout the slides use now (each master has one), copied once per layout key.
-    const base = group[0].layout;
+    // The layout a slide uses now, copied once per layout key: the master's one layout, or the slide's 0.19 template layout (RR-81),
+    // whose variant keeps its placeholders and its OPF_LAYOUT_V1 tag (`Pillars (no furniture)`).
     let masterXml = partXml(master), masterRels = partRels(master);
     let number = 0;
+    const templateNumbers = new Map();
     for (const layout of layouts.values()) {
+      const base = layout.source.layout;
       const path = `ppt/slideLayouts/slideLayout${nextLayout++}.xml`;
-      const name = layout.source.extras.length ? `OPF furniture ${++number}` : 'OPF no furniture';
+      const baseRels = has(relsOf(base)) ? read(relsOf(base)) : '';
+      const tagRels = relationships(baseRels).filter(rel => rel.type === `${REL}/tags` && !rel.external);
+      const baseName = unescapeAttribute(read(base).match(/<p:cSld\b[^>]*\bname="([^"]*)"/)?.[1] ?? '');
+      let name;
+      if (tagRels.length) {
+        const count = (templateNumbers.get(base) ?? 0) + (layout.source.extras.length ? 1 : 0);
+        templateNumbers.set(base, count);
+        name = layout.source.extras.length ? `${baseName} (furniture ${count})` : `${baseName} (no furniture)`;
+      } else name = layout.source.extras.length ? `OPF furniture ${++number}` : 'OPF no furniture';
       let xml = read(base).replace(/(<p:cSld\b[^>]*?\bname=")[^"]*(")/, `$1${escapeAttribute(name)}$2`);
       if (!layout.showsMaster) xml = xml.replace(/<p:sldLayout\b[^>]*>/, open => `${open.slice(0, -1).replace(/\s+showMasterSp="[^"]*"/, '')} showMasterSp="0">`);
-      const baseRels = has(relsOf(base)) ? read(relsOf(base)) : '';
-      // A copied layout keeps only its master relationship; the furniture brings its own.
+      // A copied layout keeps only its master relationship and its own tags (a copy of each tag part); the furniture brings its own.
       const masterRel = relationships(baseRels).find(rel => rel.type === `${REL}/slideMaster`);
       if (!masterRel) throw new Error(`${base} has no slide master relationship.`);
-      stage(path, xml, `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">${masterRel.node}</Relationships>`);
+      let copiedRels = masterRel.node;
+      for (const rel of tagRels) {
+        const source = resolvePart(base, rel.target);
+        let n = 0, copy;
+        do copy = `ppt/tags/opfLayoutVariant${++n}.xml`; while (has(copy));
+        output[copy] = [output[source][0], options];
+        types = types.replace('</Types>', `<Override PartName="/${copy}" ContentType="${TAGS_TYPE}"/></Types>`);
+        copiedRels += `<Relationship Id="${rel.id}" Type="${REL}/tags" Target="${escapeAttribute(relativeTarget(path, copy))}"/>`;
+      }
+      stage(path, xml, `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">${copiedRels}</Relationships>`);
       types = types.replace('</Types>', `<Override PartName="/${path}" ContentType="${LAYOUT_TYPE}"/></Types>`);
       for (const slot of layout.source.extras) transplant(path, layout.source, slot);
       const result = relationshipId(masterRels, `${REL}/slideLayout`, relativeTarget(master, path), false);

package/dist/source-run-styles.js

@@ -0,0 +1,71 @@
+// Full provenance stores style spans, never source words. Native edits win.
+const keys = ['fontSize', 'fontFamily', 'color'];
+const literalColor = value => typeof value === 'string' && /^#(?:[a-f0-9]{3}|[a-f0-9]{6}|[a-f0-9]{8})$/i.test(value);
+export function sourceRunStyles(value) {
+  if (!Array.isArray(value) || !value.length) return undefined;
+  const spans = value.map(run => typeof run === 'string' ? {length: run.length, string: true} : {
+    length: run.text.length, ...(run.color !== undefined && !literalColor(run.color) ? {keepColor: true} : {}), ...Object.fromEntries(keys.filter(key => run[key] !== undefined && (key !== 'color' || literalColor(run.color))).map(key => [key, run[key]]))
+  });
+  if (spans.some(span => !span.length)) return undefined;
+  try { validateSourceRunStyles(spans); } catch { return undefined; }
+  return spans;
+}
+export function validateSourceRunStyles(spans) {
+  if (!Array.isArray(spans) || !spans.length || spans.length > 10000) throw Error('Invalid source style spans.');
+  let length = 0;
+  for (const span of spans) {
+    if (!span || typeof span !== 'object' || Array.isArray(span) || Object.keys(span).some(key => !['length', 'string', 'keepColor', ...keys].includes(key))
+      || !Number.isSafeInteger(span.length) || span.length < 1 || (length += span.length) > 1000000
+      || (span.keepColor !== undefined && (span.keepColor !== true || span.color !== undefined))
+      || (span.string !== undefined && span.string !== true)
+      || (span.fontSize !== undefined && (!Number.isFinite(span.fontSize) || span.fontSize <= 0))
+      || (span.fontFamily !== undefined && (typeof span.fontFamily !== 'string' || !span.fontFamily || span.fontFamily.length > 256))
+      || (span.color !== undefined && !literalColor(span.color))) throw Error('Invalid source style span.');
+  }
+}
+export function restoreSourceRunStyles(value, spans, intact) {
+  if (!spans || !Array.isArray(value) || !keys.some(key => intact[key])) return value;
+  const runs = value.map(run => typeof run === 'string' ? {text: run} : run);
+  if (runs.some(run => typeof run.text !== 'string') || runs.reduce((n, run) => n + run.text.length, 0) !== spans.reduce((n, span) => n + span.length, 0)) return value;
+  const result = []; let runIndex = 0, offset = 0;
+  for (const span of spans) {
+    let left = span.length; const pieces = [];
+    while (left) {
+      const run = runs[runIndex], take = Math.min(left, run.text.length - offset);
+      if (!take) { runIndex++; offset = 0; continue; }
+      const piece = {...run, text: run.text.slice(offset, offset + take)};
+      for (const key of keys) if (intact[key] && !(key === 'color' && span.keepColor)) { if (span[key] === undefined) delete piece[key]; else piece[key] = span[key]; }
+      pieces.push(piece); left -= take; offset += take;
+    }
+    for (const piece of pieces) {
+      const previous = result.at(-1);
+      if (pieces.indexOf(piece) > 0 && previous && typeof previous === 'object' && JSON.stringify({...previous, text: ''}) === JSON.stringify({...piece, text: ''})) previous.text += piece.text;
+      else result.push(piece);
+    }
+    if (span.string && pieces.length && Object.keys(result.at(-1)).length === 1 && keys.every(key => intact[key])) result[result.length - 1] = result.at(-1).text;
+  }
+  return result;
+}
+// Property-specific evidence includes every native run/default property in order.
+// A change anywhere conservatively disables that property's source restoration.
+export function nativeRunStyleEvidence(tree, hash) {
+  const values = {fontSize: [], fontFamily: [], color: []};
+  const visit = (node, path = []) => {
+    if (Array.isArray(node)) { node.forEach((item, index) => visit(item, [...path, index])); return; }
+    if (!node || typeof node !== 'object') return;
+    for (const [key, value] of Object.entries(node)) {
+      if (key === 'sz') values.fontSize.push([[...path, key], value]);
+      if (/^a:(latin|ea|cs|sym)$/.test(key)) values.fontFamily.push([[...path, key], value]);
+      if (/^a:(srgbClr|schemeClr|sysClr|prstClr)$/.test(key)) values.color.push([[...path, key], value]);
+      visit(value, [...path, key]);
+    }
+  };
+  visit(tree);
+  return Object.fromEntries(keys.map(key => [key, hash(JSON.stringify(values[key]))]));
+}
+
+export function hasSourceRunStyles(topology) {
+  if (!topology || typeof topology !== 'object') return false;
+  if (Array.isArray(topology)) return topology.some(hasSourceRunStyles);
+  return topology.sourceStyles !== undefined || Object.values(topology).some(hasSourceRunStyles);
+}