@openpresentation/opf-pptx 0.16.1 → 0.18.0

package/dist/index.js

@@ -24,13 +24,14 @@ 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,quotePhotoName} from './quote-provenance.js';
-import {attachFurnitureTags, furnitureManifest, importFurniture, manifestPartIndex, staticDateFallback} from './furniture-provenance.js';
+import {attachFurnitureTags, furnitureManifest, importFurniture, logoShape, staticDateFallback, stampFurnitureImageKeys} from './furniture-provenance.js';
 import {restoreRunColors} from './run-colors.js';
 import {joinWrappedText} from './content-topology.js';
-import {applyDocumentProvenance, attachDocumentProvenance, documentProvenance, recordContentTopology, restoreDocumentProvenance, joinAuthors, splitAuthors, slideListBreaks, DEFAULT_AUTHOR} from './document-provenance.js';
+import {applyDocumentProvenance, attachDocumentProvenance, documentProvenance, recordContentTopology, restoreDocumentProvenance, joinAuthors, splitAuthors, slideListBreaks, storedMetadata, DEFAULT_AUTHOR, DEFAULT_TITLE} from './document-provenance.js';
 import {INVALID_XML_CHARACTER, nativeSections, writeSectionList} from './sections.js';
 import {attachFurnitureFields, furniturePartFields, lineFields, nativeFieldType} from './furniture-fields.js';
-import {attachNativePlaceholders, defaultPlaceholderGeometry, nativeDateText, nativeFurnitureParts, writeNativeMasters} from './native-furniture.js';
+import {attachNativePlaceholders, defaultPlaceholderGeometry, nativeDateText, nativeFurnitureParts, nativePlaceholderForPart, writeNativeMasters} from './native-furniture.js';
+import {liftMasterFurniture} from './master-furniture.js';
 import {importImageOrientation} from './image-import.js';
 import {extractSignals, normalizeSignalOptions, themeFactsFor} from './import-signals.js';
 import {placeImages, importImages, imageName, imageOverlayName, backgroundImageName, backgroundOverlayName, IMAGE_TREATMENT_KEYS, BACKGROUND_IMAGE_KEYS} from './image-provenance.js';
@@ -59,6 +60,7 @@ import {
   isTemplate,
   OPFCatalogsOptionError,
   resolveSlideContext as resolveCoreSlideContext,
+  resolveSlideVariables,
   resolveVariables,
   validate
 } from "@openpresentation/opf";
@@ -236,7 +238,9 @@ export async function toPptx(input, options = {}) {
   // 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);
+  // The document as given, before the deck-wide variable pass: the furniture manifest records the authored header and footer text.
+  const authored = parseInput(input);
+  const presentation = resolveTemplateInput(authored, options);
   assertValidBoundary(presentation);
   // `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.
@@ -275,11 +279,15 @@ export async function toPptx(input, options = {}) {
   context.quoteTags = new Map();
   context.quotePhotos = new Map();
   context.furnitureTags = new Map();
-  context.furnitureLogoTags = new Map();
+  context.furnitureImages = new Map();
   context.furnitureFields = new Map();
   context.furnitureManifests = new Map();
   context.nativeFurniture = new Map();
+  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 = [];
   context.hostDate = options.date;
+  context.authored = authored;
   context.codeTags = new Map();
   context.captionTags = new Map();
   context.footnoteTags = new Map();
@@ -404,6 +412,19 @@ export async function fromPptx(input, options = {}) {
   // Layouts and the master are read once however many slides inherit a placeholder from them (RR-11).
   const cached = read => { const memo = new Map(); return path => { if (!memo.has(path)) memo.set(path, read(path)); return memo.get(path); }; };
   const cachedRelationships = cached(path => parseRelationships(entries, path)), cachedPart = cached(path => parseOptionalXml(entries, path));
+  // RR-72: the furniture a slide shows from its layout and slide master (src/master-furniture.js), read once per part.
+  const inheritedParts = new Map();
+  const inheritedPart = path => {
+    if (!path) return undefined;
+    if (!inheritedParts.has(path)) {
+      const element = /slideMaster/.test(path) ? 'p:sldMaster' : 'p:sldLayout', root = cachedPart(path)?.[element];
+      const tree = root?.['p:cSld']?.['p:spTree'];
+      inheritedParts.set(path, root ? {path, root, relationships: cachedRelationships(path), shapes: nativeTextShapes(tree), pictures: nativePictures(tree),
+        paragraphs: nativeShapeParagraphs(decodeText(entries[path]), element)} : undefined);
+    }
+    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;
   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});
@@ -413,12 +434,30 @@ export async function fromPptx(input, options = {}) {
       path: slidePath, slideWidth: Number(presentationRoot['p:sldSz']?.cx), relationshipsOf: cachedRelationships, readPart: cachedPart,
       paragraphs: nativeShapeParagraphs(decodeText(entries[slidePath])),
       readPicture: picture => importPicture(entries, picture, slidePath, relationships,
-        diagnostic => options.onDiagnostic?.({...diagnostic, path: `slides.${index}.design`}))};
+        diagnostic => options.onDiagnostic?.({...diagnostic, path: `slides.${index}.design`})),
+      inherited: () => {
+        const layout = relatedPath(slidePath, 'slideLayout'), master = relatedPath(layout, 'slideMaster');
+        return Object.fromEntries([['layout', inheritedPart(layout)], ['master', inheritedPart(master)]].filter(([, part]) => part).map(([on, part]) => [on, {...part,
+          readPicture: picture => importPicture(entries, picture, part.path, part.relationships, diagnostic => options.onDiagnostic?.({...diagnostic, path: `slides.${index}.design`}))}]));
+      }};
   });
-  const furniture = importFurniture(furnitureContexts, entries, options.onDiagnostic);
+  // Native sections (PowerPoint's own section list, `Default Section` = none) name each slide's `{{slide.section}}` for the footer text check
+  // and, after the slides, are reconciled with the stored value in restoreDocumentProvenance.
+  const slideSections = nativeSections(presentationRoot, slideIdsInOrder(presentationRoot, presentationRels, entries, slidePaths));
+  const stored = storedMetadata(entries, presentationRoot, presentationRels);
+  // A stored zone text with built-in variables is drawn from the document's own metadata, as toPptx resolved it: the stored record
+  // (organization, speaker ...) and the observed name, description and author (a default the exporter writes is no value).
+  const importedMetadata = {
+    ...(imported.name && imported.name !== DEFAULT_TITLE ? {name: imported.name} : {}),
+    ...(imported.description ? {description: imported.description} : {}),
+    ...(imported.author && joinAuthors(imported.author) !== DEFAULT_AUTHOR ? {author: imported.author} : {}),
+    ...(stored.organization !== undefined ? {organization: stored.organization} : {}),
+    ...(stored.speaker !== undefined ? {speaker: stored.speaker} : {}),
+  };
+  const furniture = importFurniture(furnitureContexts, entries, options.onDiagnostic, {sections: slideSections ?? [], organizations: asArray(stored.organization).filter(item => isPlainObject(item) && typeof item.id === 'string' && typeof item.name === 'string').map(item => ({id: item.id, name: item.name, ...(typeof item.role === 'string' ? {role: item.role} : {}), ...(logoShape(item.logo) !== undefined ? {logo: logoShape(item.logo)} : {})})),
+    draw: (template, {index, count, section}) => drawFurnitureText(template, {index, count, section}, importedMetadata)});
   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.
@@ -429,9 +468,6 @@ export async function fromPptx(input, options = {}) {
     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)
-  // are reconciled with the footer text and the stored value in restoreDocumentProvenance.
-  const slideSections = nativeSections(presentationRoot, slideIdsInOrder(presentationRoot, presentationRels, entries, slidePaths));
   // A watermark carried identically by every slide is the deck's design.watermark.
   const carried = imported.slides.map(slide => slide.design?.watermark);
   if (carried.length && carried[0] && carried.every(value => JSON.stringify(value) === JSON.stringify(carried[0]))) {
@@ -456,7 +492,7 @@ 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, speakerConflict: furniture.speakerConflict === true,
+    const restored = restoreDocumentProvenance(imported, {entries, presentationRoot, presentationRels,
       // Stored layout ids also resolve in the host's registered catalogs (FA-23).
       catalogs: options.catalogs,
       nativeSections: slideSections,
@@ -516,21 +552,19 @@ function applyRunColors(imported, slideProvenance, restoredGroups, report, optio
   restoreRunColors(imported.slides, info, resolve, report);
 }
 
-// A consumed logo picture (OPF_LOGO_V1) never becomes content. Its own image restores the logo only when nothing else
-// did: the stored document and slide design (or the organization) win and carry LogoSet variants, so a package exported
-// without provenance still keeps its logo. A slide-level logo path restores slide design; every other path the deck's.
+// A consumed logo picture (OPF_LOGO_V1) never becomes content. Its own image restores the organization's logo only when the
+// stored document did not (RR-71: logos live on the organization), so a package exported without provenance still keeps its
+// logo: on the primary organization, else on a new one named after the deck. The picture is one drawn asset, so it becomes the
+// organization's single logo for every shape.
 function restoreLogoFallback(imported, contexts) {
   const organizations = asArray(imported.organization);
-  contexts.forEach((context, index) => {
-    const fallback = context.logoFallback;
-    if (!fallback) return;
-    const slide = imported.slides[index];
-    const image = fallback.image;
-    // A slide's own logo restores whenever the slide states none, whatever the deck logo is; the deck logo only
-    // when neither it nor the organization has one.
-    if (fallback.path.startsWith('slides.')) { if (slide.design?.logo === undefined) slide.design = {...slide.design, logo: image}; }
-    else if (imported.design?.logo === undefined && !organizations.some(item => item?.logo !== undefined)) imported.design = {...imported.design, logo: image};
-  });
+  if (organizations.some(item => item?.logo !== undefined)) return;
+  const image = contexts.map(context => context.logoFallback?.image).find(Boolean);
+  if (!image) return;
+  const primary = organizations.find(item => item?.role === 'primary') ?? organizations[0];
+  if (!primary) { imported.organization = {id: 'brand', name: imported.name ?? 'Brand', logo: image}; return; }
+  const index = organizations.indexOf(primary), withLogo = {...primary, logo: image};
+  imported.organization = Array.isArray(imported.organization) ? imported.organization.map((item, at) => at === index ? withLogo : item) : withLogo;
 }
 
 function readPptxZip(input) {
@@ -614,6 +648,17 @@ function resolveRelationshipTarget(sourcePartPath, target) {
   return parts.join("/");
 }
 
+// A header or footer text as the exporter drew it for one slide: deck-wide built-ins resolved from `metadata` (core
+// resolveVariables), then the slide-scoped tokens for the slide's position, count and section. undefined when core refuses.
+function drawFurnitureText(template, {index, count, section}, metadata) {
+  try {
+    const slide = resolveVariables({...metadata, slides: [{...(section !== undefined ? {section} : {}), text: template}]}).presentation.slides[0];
+    return resolveSlideVariables(slide, {slideNumber: index + 1, slideCount: count}).text;
+  } catch {
+    return undefined;
+  }
+}
+
 function resolveSlidePaths(entries, presentationRoot, relationships) {
   const slideIds = asArray(presentationRoot["p:sldIdLst"]?.["p:sldId"]);
   const paths = [];
@@ -709,7 +754,6 @@ function importSlide(entries, slidePath, slideIndex, presentationDimensions, opt
   }
   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;
   nativeContext.imageBlocks = images.blocks;
   nativeContext.imagePictures = images.consumed;
   // An overlay of a background that was not recovered stays an ordinary shape.
@@ -728,7 +772,7 @@ function importSlide(entries, slidePath, slideIndex, presentationDimensions, opt
     diagnostic => options.onDiagnostic?.({...diagnostic, path: watermarkPath}));
   if (watermark.design) slide.design = {...slide.design, ...watermark.design};
   nativeContext.watermarkPictures = watermark.consumed;
-  // The generated deck logo picture is not content; its value returns from the stored design (or, without one, from the picture).
+  // The generated cover logo picture is not content; the logo returns from the stored organization (or, without one, from the picture).
   const logoPath = `slides.${slideIndex}.design.logo`;
   const logo = importLogo(nativeContext.pictures, relationships, entries, slideIndex,
     picture => importPicture(entries, picture, slidePath, relationships, diagnostic => {
@@ -1903,10 +1947,15 @@ function configurePresentation(pptx, presentation, context) {
   };
 }
 
-async function addSlide(pptx, presentation, opfSlide, slideIndex, context, options) {
+async function addSlide(pptx, presentation, authoredSlide, slideIndex, context, options) {
   options = {...options, textMeasurement: slideTextMeasurement(presentation, slideIndex, options)};
   const slide = pptx.addSlide();
   const slideContext = exportSlideContext(presentation, slideIndex, context, options);
+  // FA-31: the slide is composed and drawn with its slide-scoped variables substituted ({{slide.number}}, {{slide.section}},
+  // {{deck.slideCount}} for this position in the exported deck, in body text as fixed text). The authored slide still holds the
+  // tokens: header and footer text is substituted by core's furniture layout (a slide number stays a native field), and the
+  // furniture manifest records the authored text.
+  const opfSlide = slideContext.core.slide;
   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.
@@ -1919,6 +1968,7 @@ async function addSlide(pptx, presentation, opfSlide, slideIndex, context, optio
   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;
+  slideContext.zoneBand = zoneBands(composeOptions);
   slide.background = { color: slideContext.colors.background };
   // An image background is core's geometry.backgroundImage (slide, deck, then theme background); every other kind is the
   // effective design or theme background definition.
@@ -2009,7 +2059,7 @@ async function addSlide(pptx, presentation, opfSlide, slideIndex, context, optio
   // Core composes furniture above all content and opf-render paints it last, so
   // spTree order (PowerPoint's z-order) matches: header/footer parts come after
   // every content item, and an overlapping footer stays visible over content.
-  await addFurniture(slide,presentation,opfSlide,geometry.furniture,slideContext,options,slideIndex);
+  await addFurniture(slide,presentation,authoredSlide,geometry.furniture,slideContext,options,slideIndex);
 
   if (opfSlide.notes) {
     const notes = String(opfSlide.notes);
@@ -2772,7 +2822,7 @@ function addMeasuredPayloadText(slide, text, box, context, options, config) {
 // The default footer band core composes for a deck with no footer of its own: where a footer added natively lands.
 function defaultFooterParts(composeOptions) {
   try {
-    const slide = {design: {footer: {left: {date: '2026-01-01'}, center: {text: 'Footer'}, right: {slideNumber: true}}}};
+    const slide = {design: {footer: {left: {date: '2026-01-01'}, center: {text: 'Footer'}, right: {text: '{{slide.number}}'}}}};
     // Only the zone boxes and line height are used, and they do not depend on text widths: estimated measurement keeps the host's measurer (and its call count) out of this.
     return (composeSlide(slide, {...composeOptions, textMeasurement: undefined}).furniture?.parts ?? []).filter(part => part.kind === 'footer' && part.type === 'text');
   } catch {
@@ -2780,10 +2830,22 @@ function defaultFooterParts(composeOptions) {
   }
 }
 
+// The band core gives a lone text part in a zone (x and width in pixels): where a footer added natively sits.
+function zoneBands(composeOptions) {
+  let bands;
+  return zone => (bands ??= new Map((defaultFooterParts(composeOptions) ?? []).map(part => [part.zone, {x: part.box.x, width: part.box.width}]))).get(zone);
+}
+
+// The slide and deck as given to toPptx (variables not yet resolved), for the furniture manifest's authored header and footer text.
+const authoredFurniture = (context, slideIndex) => ({presentation: context.authored, slide: context.authored?.slides?.[slideIndex]});
+
 async function addFurniture(slide,presentation,source,layout,context,options,slideIndex) {
+  // RR-72: every slide is listed, a slide without furniture too (it may need a layout that hides the master's).
+  const drawn = [];
+  context.furnitureParts[slideIndex] = {path: `ppt/slides/slide${slideIndex + 1}.xml`, parts: drawn};
   if(!layout){
     if(['header','footer'].some(kind=>(source.design?.[kind]??presentation.design?.[kind])))throw new OPFPptxError('missing-furniture-layout','Header/footer export requires coordinated core furniture geometry.',{path:`slides.${slideIndex}.design`});
-    const manifest = furnitureManifest(presentation, source, {parts: []}, slideIndex);
+    const manifest = furnitureManifest(presentation, source, {parts: []}, slideIndex, undefined, undefined, authoredFurniture(context, slideIndex));
     if (manifest) context.furnitureManifests.set(`ppt/slides/slide${slideIndex + 1}.xml`, manifest);
     return;
   }
@@ -2791,16 +2853,22 @@ async function addFurniture(slide,presentation,source,layout,context,options,sli
   // RR-11: the first footer text, date and slide number that fit one line are native placeholders (src/native-furniture.js).
   const natives = nativeFurnitureParts(layout);
   for(const [index,part]of layout.parts.entries()){
+    const entry = {index, kind: part.kind, zone: part.zone, field: part.field, type: part.type, path: part.path, native: natives.has(index), names: []};
+    drawn.push(entry);
     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,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)});
+      // A logo reference draws the organization's asset: a source that cannot be drawn is reported where the asset is written.
+      const objectName = await addImagePayload(slide,presentation,part.image,region,part.reference!==undefined?part.sourcePath:part.path,context,options);
+      if (objectName) {
+        entry.names.push(objectName);
+        context.furnitureTags.set(objectName, {v:1, role:'image', group:String(slideIndex), part:index});
+        // RR-71: a part drawn from a logo reference (var:organization.logo.icon) records its picture, so import can tell it is unchanged.
+        if (part.reference !== undefined) context.furnitureImages.set(`ppt/slides/slide${slideIndex + 1}.xml|${part.kind}.${part.zone}`, objectName);
+      }
     }else{
       if(!part.fit?.sourceLines)throw new OPFPptxError('missing-furniture-layout','Repeated text requires accepted source lines from core.',{path:part.path});
-      // Slide numbers and current dates become native PowerPoint fields; {total}
-      // and fixed dates stay fixed text. A current date whose pattern has no
+      // Slide numbers ({{slide.number}}) and current dates become native PowerPoint fields; {{deck.slideCount}},
+      // {{slide.section}} and fixed dates stay fixed text. A current date whose pattern has no
       // en-US field type is written as its laid-out text.
       const fields=[];
       for(const field of furniturePartFields(part)){
@@ -2816,11 +2884,18 @@ async function addFurniture(slide,presentation,source,layout,context,options,sli
           if(marker) staticDates.set(index,marker);
         }
       }
-      addMeasuredPayloadText(slide,part.text,part.box,context,options,{path:part.path,fit:part.fit,textStyle:part.style,align:part.alignment,diagnosticsHandled:true,color:context.mutedColor,keepEmpty:true,objectName:`OPF furniture ${slideIndex} part ${index}`,furniture:{group:String(slideIndex),part:manifestPartIndex(layout.parts,index)},liveFields,links:part.links});
-      if(natives.has(index))context.nativeFurniture.set(`OPF furniture ${slideIndex} part ${index} line 0`,natives.get(index));
+      addMeasuredPayloadText(slide,part.text,part.box,context,options,{path:part.path,fit:part.fit,textStyle:part.style,align:part.alignment,diagnosticsHandled:true,color:context.mutedColor,keepEmpty:true,objectName:`OPF furniture ${slideIndex} part ${index}`,furniture:{group:String(slideIndex),part:index},liveFields,links:part.links});
+      entry.names.push(...part.fit.lines.map((line, number) => `OPF furniture ${slideIndex} part ${index} line ${number}`));
+      if(natives.has(index)){
+        const name=`OPF furniture ${slideIndex} part ${index} line 0`;
+        context.nativeFurniture.set(name,natives.get(index));
+        // RR-71: a part in a row with other parts is as wide as its text; the master's placeholder spans the zone.
+        const band=context.zoneBand?.(part.zone);
+        if(band&&part.box.width<band.width-.5)context.nativeFurnitureBands.set(name,band);
+      }
     }
   }
-  const manifest = furnitureManifest(presentation, source, layout, slideIndex, staticDates, natives);
+  const manifest = furnitureManifest(presentation, source, layout, slideIndex, staticDates, natives, authoredFurniture(context, slideIndex));
   if (manifest) context.furnitureManifests.set(`ppt/slides/slide${slideIndex + 1}.xml`, manifest);
 }
 
@@ -3523,7 +3598,7 @@ async function resolveImage(asset, presentation, options, path, outcome = {}) {
   if (raster) return dataUriMediaType(resolved.data) === raster.mediaType ? resolved : {...resolved, data: `data:${raster.mediaType};base64,${bytesToBase64(bytes)}`};
   const svg = svgDataUriBytes(resolved.data);
   if (svg) return resolveSvgImage(svg, options, path, outcome);
-  const message = `The image is not a readable PNG, JPEG, GIF or WebP (${dataUriMediaType(resolved.data) ?? "unknown type"}); supply a raster through imageResolver (for example opf-render svgToPng).`;
+  const message = `The image is not a readable PNG, JPEG, GIF or WebP (${dataUriMediaType(resolved.data) ?? "unknown type"}); supply a raster through imageResolver (for example opf-render toPng).`;
   if (options.strictAssets) throw new OPFPptxError("unsupported-image-dimensions", `Image fitting requires readable PNG, JPEG, GIF or WebP dimensions. ${message}`, { path });
   options.onDiagnostic?.({ code: "unresolved-asset", path, reason: "unsupported-format", message });
   outcome.reported = true;
@@ -3730,7 +3805,7 @@ function normalizeHex(value, fallback = "000000") {
 function writeNativeFurnitureMasters(output, context) {
   const size = /<p:sldSz\b[^>]*\bcx="(\d+)"[^>]*\bcy="(\d+)"/.exec(decodeText(output['ppt/presentation.xml'][0]));
   const defaults = new Map((context.defaultFooterOptions ? defaultFooterParts(context.defaultFooterOptions) ?? [] : []).flatMap(part => {
-    const ph = {date: 'dt', text: 'ftr', slideNumber: 'sldNum'}[part.field];
+    const ph = nativePlaceholderForPart(part);
     const geometry = ph && defaultPlaceholderGeometry(part);
     return geometry ? [[ph, geometry]] : [];
   }));
@@ -3767,9 +3842,9 @@ async function normalizePptxZip(raw, context) {
   attachQuoteTags(entries,context.quoteTags);
   attachAnnotationTags(entries,context);
   attachFurnitureFields(entries,context.furnitureFields);
-  attachFurnitureTags(entries,context.furnitureTags,context.furnitureManifests,context.furnitureLogoTags);
+  attachFurnitureTags(entries,context.furnitureTags,context.furnitureManifests);
   // RR-11: the recorded footer shapes become PowerPoint's date, footer and slide-number placeholders.
-  context.nativePlaceholders = attachNativePlaceholders(entries,context.nativeFurniture);
+  context.nativePlaceholders = attachNativePlaceholders(entries,context.nativeFurniture,context.nativeFurnitureBands);
   // The "Image unavailable" panel of an unresolved logo: identity only, so import does not read it as content.
   attachTextTags(entries,context.logoPlaceholderTags,LOGO_TAG,'opfLogoPlaceholder','logo placeholder');
   for(const [part,bytes]of Object.entries(entries)){
@@ -3873,6 +3948,8 @@ async function normalizePptxZip(raw, context) {
   });
   // A picture repeated across slides embeds once (after fitting, which needs each slide's own relationship).
   dedupeMedia(entries, imageMetadata, resolveRelationshipTarget);
+  // The media keys of the logo-reference pictures, now that the package holds its final media (src/furniture-provenance.js).
+  stampFurnitureImageKeys(entries, context.furnitureManifests, context.furnitureImages, parseRelationships);
   // Charts and notes follow the language and fonts of the slide they belong to.
   context.partSlides = new Map();
   for (const part of Object.keys(entries)) {
@@ -3919,6 +3996,12 @@ async function normalizePptxZip(raw, context) {
     }
     reportPerSlideNotesScriptFonts(context.scriptFonts, slideThemes);
   }
+  // 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));
+  } catch (error) {
+    throw new OPFPptxError('packaging-failed', 'Header and footer furniture could not be written to the slide master and layouts.', {cause: errorMessage(error)});
+  }
   finalizeFontsUsed(output);
   // Document references record evidence from the final normalized parts.
   if (context.documentProvenance) {

package/dist/logo-provenance.js

@@ -3,13 +3,13 @@ import {normalizeCrop, withoutSvgBlip} from './svg-image.js';
 import {decodeTextTag, encodeTextTag} from './code-provenance.js';
 import {pictureTransform} from './image-geometry.js';
 
-// The deck logo (core's `geometry.logo`: design.logo, a slide's own logo or the
-// primary organization's logo on a cover or section slide) exports as one native
+// The cover and section logo (core's `geometry.logo`: the primary organization's full logo, or the
+// organization a `design.logo` reference names, RR-71) exports as one native
 // picture per slide named `OPF logo`, after the watermark and before content. It
 // is fitted into core's box without cropping, anchored left and vertically
 // centered (the preview's `xMinYMid meet`). The native tag records the exact
 // picture, so an unchanged picture is consumed on import (the logo itself returns
-// from the document and slide design records) while an edited one stays an
+// from the document record's organization) while an edited one stays an
 // ordinary picture and reports `invalid-logo-provenance`.
 const TAG = 'OPF_LOGO_V1', REL = 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/tags';
 const EMUS_PER_INCH = 914400;
@@ -19,8 +19,8 @@ const array = value => value === undefined ? [] : Array.isArray(value) ? value :
 // Whitespace-only text between elements is not identity: the vendored writer indents, PowerPoint drops it on save.
 const canonical = value => JSON.stringify(value, (_key, item) => item && typeof item === 'object' && !Array.isArray(item)
   ? Object.fromEntries(Object.keys(item).sort().filter(key => !(key === '#text' && typeof item[key] === 'string' && !item[key].trim())).map(key => [key, item[key]])) : item);
-// The OPF paths core reports for a logo source.
-const LOGO_PATH = /^(?:slides\.\d{1,9}\.design\.logo|design\.logo|organization(?:\.\d{1,9})?\.logo)(?:\.[A-Za-z]{1,16})?$/;
+// The OPF paths core reports for a logo source: the organization's `logo`, then a shape and a tone below it.
+const LOGO_PATH = /^organization(?:\.\d{1,9})?\.logo(?:\.[A-Za-z]{1,16}){0,2}$/;
 
 export const LOGO_TAG = TAG;
 export const logoName = () => 'OPF logo';
@@ -138,10 +138,10 @@ export function importLogoPlaceholders(shapes, relationships, entries, slideInde
 }
 
 /**
- * Consume an unchanged tagged logo picture: it is generated from design.logo (or
- * the organization's logo), never content. Returns the consumed picture indexes
+ * Consume an unchanged tagged logo picture: it is drawn from the organization's
+ * logo, never content. Returns the consumed picture indexes
  * and `fallback`, the picture's own `{path, image}`: the caller uses it for the
- * logo only when the stored document and slide design did not restore one (an
+ * organization's logo only when the stored document did not restore one (an
  * export without provenance, or one that omitted the field), so the logo is never
  * lost. An edited, ambiguous or damaged tagged picture stays an ordinary picture
  * and is reported. readPicture(picture) returns the ordinary imported payload.