@openpresentation/opf-pptx 0.17.0 → 0.18.0

package/README.md

@@ -69,11 +69,11 @@ Embedded picture bytes are a PNG, JPEG, GIF, WebP or SVG. Bytes that are no read
 
 SVG pictures are native SVG pictures, as PowerPoint 2016 and Microsoft 365 store them: a `p:pic` whose `a:blip` embeds a PNG fallback raster and carries the `asvg:svgBlip` extension that points at the SVG media part (`image/svg+xml`, content type registered). PowerPoint 2016+ draws the SVG (crisp at any zoom; Graphics Format, Convert to Shape); older viewers draw the PNG. This covers image blocks (placed or not), the alt-text picture of an image background, the watermark, header and footer images and logos, and cover and section logos. The picture takes the same frame and fit (`cover`, `contain`, `stretch`) as a raster of the same proportions; the SVG's size is its `width` and `height` (any unit), else its `viewBox`. Exceptions, each a raster only: a picture bullet (`a:buBlip` can reference a raster only, so it is the PNG), an image background without alt text (a background picture fill carries no SVG), a tiled background picture, and an image block with a duotone recolor or a non-rectangular shape (the effect is written on the PNG blip, so it applies as in the preview, and `svg-image-rasterized` is reported). Opacity (a translucent watermark, slide image opacity), grayscale and the slide image border stay native SVG pictures: PowerPoint applies them to an SVG picture.
 
-The PNG fallback is drawn at 192 dpi of the displayed size (a multiple of 128 px on its long side, 128 to 2304 px, transparent background) by `options.svgRasterizer(svg, {width, height, scale, text})`. In Node the default is opf-render's `svgToPng` (resvg with the bundled fonts and no system fonts, so the same SVG gives the same bytes on every machine), loaded only when an SVG is exported: it is the optional peer `@openpresentation/opf-render`. Without opf-render and without `svgRasterizer` (a browser build has no default; pass one that draws the SVG deterministically), the SVG picture is the placeholder with `reason: "svg-rasterizer-unavailable"`. From opf-render 0.16 the PNG converter is itself an optional peer of opf-render: install `@resvg/resvg-js` next to it (`npm install @resvg/resvg-js@^2.6.2`; with text, also the font packages of the `base` pack, `@expo-google-fonts/roboto` and `roboto-mono`). When opf-render rejects with `converter-missing` the exporter reports the same `svg-rasterizer-unavailable` and the message carries opf-render's install command; with `strictAssets` the export throws that code. An `imageResolver` that returns a raster for an SVG source still gives a plain raster picture, and one that returns SVG bytes (`mediaType: "image/svg+xml"`) gives a native SVG picture. A local `.svg` path is read in Node.
+The PNG fallback is drawn at 192 dpi of the displayed size (a multiple of 128 px on its long side, 128 to 2304 px, transparent background) by `options.svgRasterizer(svg, {width, height, scale, text})`. In Node the default is opf-render's `toPng` (resvg with the bundled fonts and no system fonts, so the same SVG gives the same bytes on every machine), loaded only when an SVG is exported: it is the optional peer `@openpresentation/opf-render`. Without opf-render and without `svgRasterizer` (a browser build has no default; pass one that draws the SVG deterministically), the SVG picture is the placeholder with `reason: "svg-rasterizer-unavailable"`. From opf-render 0.16 the PNG converter is itself an optional peer of opf-render: install `@resvg/resvg-js` next to it (`npm install @resvg/resvg-js@^2.6.2`; with text, also the font packages of the `base` pack, `@expo-google-fonts/roboto` and `roboto-mono`). When opf-render rejects with `converter-missing` the exporter reports the same `svg-rasterizer-unavailable` and the message carries opf-render's install command; with `strictAssets` the export throws that code. An `imageResolver` that returns a raster for an SVG source still gives a plain raster picture, and one that returns SVG bytes (`mediaType: "image/svg+xml"`) gives a native SVG picture. A local `.svg` path is read in Node.
 
 An SVG is never run or fetched. It is validated as XML and sanitized before it is embedded (and on import): `<script>`, `<foreignObject>`, event-handler attributes, link animations, every `href`/`url()` that is not a `#fragment` or an inline PNG, JPEG, GIF or WebP, `@import` rules, `xml-stylesheet` instructions and DOCTYPE declarations are removed (a DOCTYPE entity that is plain text is expanded; an external or nested entity is refused as `svg-unsafe`), and `svg-sanitized` reports what was removed. An SVG that needs none of that is embedded byte for byte, so import returns the authored source.
 
-`fromPptx` reads a picture that carries `asvg:svgBlip` back as the SVG (a `data:image/svg+xml;base64,` source), not its PNG fallback, from this exporter's files and from PowerPoint's (a damaged or hostile SVG part imports its PNG fallback and reports `invalid-svg-image`, or imports sanitized with `svg-sanitized`). Design fields and blocks with SVG sources (`design.logo`, `design.watermark`, image blocks with their treatments) round-trip as SVG.
+`fromPptx` reads a picture that carries `asvg:svgBlip` back as the SVG (a `data:image/svg+xml;base64,` source), not its PNG fallback, from this exporter's files and from PowerPoint's (a damaged or hostile SVG part imports its PNG fallback and reports `invalid-svg-image`, or imports sanitized with `svg-sanitized`). Design fields, organization logos and blocks with SVG sources (`organization.logo`, `design.watermark`, image blocks with their treatments) round-trip as SVG.
 
 `fromPptx` parses an existing `.pptx` buffer locally and returns an OPF document that validates with `@openpresentation/opf`:
 
@@ -154,7 +154,7 @@ The first importer is mechanical and schema-compatible:
 - Conditional table styles, merged-cell geometry, cell fills/borders/alignment, unsupported text fills/colors, and internal hyperlink actions are not fully reconstructed. `onDiagnostic` reports unsupported table style references, merges, fonts/colors/fills and links with native frame/cell paths. Table paths use the native graphic-frame and row indexes, including a header row. The shared core 0.6.0 layout sizes rows from their content and reports `text-overflow` when text cannot fit at the minimum size. These checks establish native XML conversion, not visual parity with PowerPoint.
 - Unknown non-text shapes and unsupported graphic frames become editable text fallback blocks instead of failing the import.
 - Catalog references (`design.theme`, `colorScheme`, `fontScheme`, `dimensions`, `background`, slide `layout`), slide ids and authoring metadata (`narrative`, `tone`, `audience`, `purpose`, `language`, `organization`, `speaker`, ...) are stored at export in `OPF_DOCUMENT_V1` / `OPF_SLIDE_V1` customer-data tags. Import restores a reference while the theme colors, theme fonts, slide size, background or slide arrangement it produced are unchanged. After an edit, the observed native values stay and `design-reference-changed` / `layout-reference-changed` name the reference. `toPptx` option `provenance: 'references-only' | false` limits or disables these invisible tags. In `full` mode the document tag also lists the document-level defaults the document left to the engine (`$schema`, `name`, `language`, the theme, colour scheme, font scheme and slide size), and import leaves them absent while the package still shows the default, so an untouched round trip is deep-equal to the source (RR-59); a value edited in PowerPoint imports as observed. Slide layout intent (layout reference, type, composition, composition hints and the embedded layout record with its catalogs group and source) lives in each `OPF_SLIDE_V1` record, so a slide keeps its layout even without the document tag, for example when it is pasted into another deck (FF-29). A layout that resolves only in a registered catalog stores no record and restores where `fromPptx` is given that catalog. See [document round trips](docs/document-roundtrip.md) for exactly what is embedded.
-- The slide's content structure is part of `OPF_SLIDE_V1` too (`full` mode): nested `group` blocks, promoted regions (`left`, `top:left`, ...), a root payload (`text`, `items`, `chart`, ...) versus `blocks`, block `id`s and `extensions`, group `composition`, with the reference-pixel box of every leaf from the same composition the export drew. Import matches the native shapes to those boxes and rebuilds the authored form while the slide's arrangement is unchanged, so `slide.type` validates again; a slide whose blocks no longer fit the stored boxes keeps its flat blocks and reports `content-structure-changed` at `slides.N`; a duplicated slide reports `duplicate-block-id` and drops the repeated id. The document tag also stores `filename`, root `extensions`, slide `section` and `extensions`, `design.logo` (deck and slide) and the whole `assets` registry; a `data:` source that is not an exported picture is stored inline up to 256 KiB, so an organization logo or speaker photo given as a data URI round-trips.
+- The slide's content structure is part of `OPF_SLIDE_V1` too (`full` mode): nested `group` blocks, promoted regions (`left`, `top:left`, ...), a root payload (`text`, `items`, `chart`, ...) versus `blocks`, block `id`s and `extensions`, group `composition`, with the reference-pixel box of every leaf from the same composition the export drew. Import matches the native shapes to those boxes and rebuilds the authored form while the slide's arrangement is unchanged, so `slide.type` validates again; a slide whose blocks no longer fit the stored boxes keeps its flat blocks and reports `content-structure-changed` at `slides.N`; a duplicated slide reports `duplicate-block-id` and drops the repeated id. The document tag also stores `filename`, root `extensions`, slide `section` and `extensions`, `design.logo` (deck and slide: a logo reference or `false`), the organizations with their logos and the whole `assets` registry; a `data:` source that is not an exported picture is stored inline up to 256 KiB, so an organization logo or speaker photo given as a data URI round-trips.
 - Slide `section` labels are written as PowerPoint's native section list (`p14:sectionLst` in `ppt/presentation.xml`, whatever the `provenance` option): one section per run of consecutive slides with the same label, runs without a label as `Default Section`, with deterministic ids. Import reads the list back (`Default Section` means no section); it wins over the stored value (a footer's `{{slide.section}}` is only the token, so no footer text names the section), except that the stored label stands while the list still names it. The native PowerPoint check of the sections pane and save/reopen is a separate gate (`scratchpad/spec-gaps-native/`).
 
 There is no AI classification pass in the OSS runtime. Hosts can run optional cleanup or semantic remapping after `fromPptx` returns. A host that wants to rebuild structure (code, metrics, quotes, timelines, regions) in a deck that did not come from OPF can ask for the raw shape facts such a step needs; see [Import signals](#import-signals).
@@ -335,10 +335,10 @@ A deck or slide watermark (`design.watermark`) exports as one native picture nam
 
 ### Brand assets, picture bullets and the accent font (spec-gap closure A)
 
-These design fields need the core that composes them (`resolveLogo`, `geometry.logo`, `item.bulletImage`, `fontScheme.accent`; core 0.11.4 or the coordinated source). On core 0.11.3 the export carries none of them and is byte-identical to the previous output. Each one is drawn at the box core composes, which the preview draws too (see core `docs/design-resolution.md`, "Brand assets and layout hints").
+These design fields need the core that composes them (`resolveLogo`, `geometry.logo`, `item.bulletImage`, `fontScheme.accent`, the organization logo shapes; core 0.18 or the coordinated source). On core 0.11.3 the export carries none of them and is byte-identical to the previous output. Each one is drawn at the box core composes, which the preview draws too (see core `docs/design-resolution.md`, "Brand assets and layout hints").
 
-- **Cover and section logo** (`design.logo`, a slide's own `design.logo`, else the primary organization's `logo`). One native picture named `OPF logo`, after the watermark and before the content, fitted without cropping into core's `geometry.logo` box (56 px high at 720 px, up to four times as wide), anchored at the box's left edge and vertically centered, exactly the preview's `xMinYMid meet`. Its alt text is the asset's `alt`, otherwise `Logo`. A LogoSet picks its variant from the slide background (a dark background takes the light variants); the exporter's dark test is the one that already chooses the text colour. An unresolved or unreadable logo draws the preview's "Image unavailable" panel in the box and reports `unresolved-asset` at the logo's path (`strictAssets` throws). Content slides never get one. The picture carries an `OPF_LOGO_V1` tag (slide, source path, variant, the exact picture properties): an unchanged export consumes the picture on import (it is not content; `design.logo` itself returns from the document tag), and an edited, ambiguous or damaged one stays an ordinary picture and reports `invalid-logo-provenance`. When nothing else restored a logo (an export with `provenance: false`, or with `references-only`, which stores no sources), the consumed picture's own image becomes `design.logo` (the slide's own for a slide-level logo), so the logo is never lost; it is a single image, not the LogoSet. A PPTX with no OPF tags imports the picture as an ordinary image block and invents no `design.logo`.
-- **Header and footer `logo: true`.** A generated image part in the part's box (the icon variant), exported like an `image` part with the furniture picture tag replaced by an `OPF_LOGO_V1` tag with role `furniture`. The slide's furniture manifest lists it under a separate `logos` key (`{kind, zone, drawn}`), never in `parts` or `definitions`, because every released importer validates those two strictly. It re-imports as `logo: true`, never as an `image` data URI; without a resolvable logo core reports `unresolved-content` at `<zone>.logo`, nothing is drawn and `logo: true` still returns (`drawn: false`).
+- **Cover and section logo** (the primary organization's `logo`, in its `full` shape; `design.logo` on the deck or a slide names another organization or shape, `var:organization.beta.logo`, `var:organization.logo.wordmark`, or is `false` for none). One native picture named `OPF logo`, after the watermark and before the content, fitted without cropping into core's `geometry.logo` box (56 px high at 720 px, up to four times as wide), anchored at the box's left edge and vertically centered, exactly the preview's `xMinYMid meet`. Its alt text is the asset's `alt`, otherwise `Logo`. A shape given as `{onLight, onDark}` picks its tone from the slide background (a dark background takes `onDark`); the exporter's dark test is the one that already chooses the text colour. An unresolved or unreadable logo draws the preview's "Image unavailable" panel in the box and reports `unresolved-asset` at the organization's logo path (`organization.logo.full.onDark`; `strictAssets` throws). Content slides never get one. The picture carries an `OPF_LOGO_V1` tag (slide, source path, tone, the exact picture properties): an unchanged export consumes the picture on import (it is not content; the organization, with every shape and tone, and `design.logo` return from the document and slide records), and an edited, ambiguous or damaged one stays an ordinary picture and reports `invalid-logo-provenance`. When nothing else restored the organization's logo (an export with `provenance: false`, or with `references-only`, which stores no sources), the consumed picture's own image becomes the logo of the primary organization (a new organization named after the deck when there is none), so the logo is never lost; it is the one drawn image for every shape. A PPTX with no OPF tags imports the picture as an ordinary image block and invents no organization.
+- **Header and footer logos** (`image: "var:organization.logo.icon"`, or `var:organization.logo`, `.stacked`, `.wordmark`, or a partner's `var:organization.beta.logo`). Core lays the parts of a zone out in one row (image, text, socials, date, each at its natural width, vertically centered, `FURNITURE_GAP` apart) and resolves the reference for each slide's background, so an `{onLight, onDark}` shape draws a different asset on a dark slide. The exporter draws every part at `part.box`; a logo is an ordinary furniture image part (the `OPF_FURNITURE_V1` picture tag) whose slide manifest also records the authored reference and the content key of the bytes it embedded (`images`: `{reference, media}` per `kind.zone`, beside `parts` and `definitions`, which every released importer validates strictly). It re-imports as the reference while the picture still embeds those bytes and the stored organization still has a logo for it; a replaced picture (Change Picture), a foreign picture, `provenance: false` and `references-only` (no stored organization) import it as an ordinary `image`. A reference whose organization has no logo reports `unresolved-content` at `<zone>.image`, draws nothing and still returns as the reference (`drawn: false`). An asset that cannot be drawn reports `unresolved-asset` at the organization's logo path.
 - **Picture bullets** (`design.listBullet: image`, resolved to the icon logo by core as `item.bulletImage`). Every entry's first line carries `<a:buSzPct val="100000"/><a:buBlip><a:blip r:embed=…/></a:buBlip>` in place of the character bullet, so the marker is the text size, like the preview's square marker. PptxGenJS embeds the icon once per slide (a picture named `OPF bullet image`); packaging removes that picture and keeps the media part and its relationship for the `a:buBlip` elements. Marker indent and text positions are those of the character bullets. An icon that cannot be embedded keeps the character bullets and reports `unresolved-asset` once per slide at the logo's path. Import recognizes `a:buBlip` paragraphs as list paragraphs; `design.listBullet` returns from the stored design hint (a PPTX without tags has no hint). PowerPoint shows a picture bullet at the picture's own aspect ratio; use a square icon for the preview's square marker. The released 0.11.6 importer does not know `a:buBlip` and imports such a list as plain text lines.
 - **`fontScheme.accent`.** Core resolves the accent role for the slide tag (eyebrow) and the quote body, so their runs carry the accent typeface in `a:latin`, `a:ea` and `a:cs` with the catalog's pitch family when the family is known; theme major/minor fonts, every other run and the theme are unchanged. The accent family appears in `docProps/app.xml` "Fonts Used" like any other used font; `checkTypefaces` callers list it in `options.fonts`. `design.fontScheme` (with `accent`) returns from the document tag.
 
@@ -461,4 +461,6 @@ When a supported current-date field wraps across lines, full provenance records
 
 Missing, duplicated or inconsistent furniture tags fall back to current native content with an `invalid-furniture-provenance` diagnostic. Social profiles (`socials: true`) belong to the organization the manifest names by id, which only the stored document record can supply, so a file without it (`provenance: false`, another tool) imports the profile lines as ordinary text with an `invalid-furniture-provenance` diagnostic. Inherited definitions become global only when every slide has a valid definition/override and all inherited values agree; otherwise recovered definitions stay local. A moved slide keeps its live slide-number field (it imports as `{{slide.number}}` and renumbers in PowerPoint). Native typography, positioning, crop and unrelated metadata are not reconstructed; `furniture-import-reflow` requests review. `npm run test:furniture` exercises XML conversion and mutation controls. Native Office, visual corpus and clean installed-package acceptance remain separate gates; published tagged-shape furniture (0.9.1 to 0.11.7) does not establish native Header/Footer support.
 
-Native header and footer placeholders (RR-11): the first footer text becomes a `ftr` placeholder, the first footer date a `dt` placeholder (a live `datetime1`-`datetime7` field for `date: true`) and the first footer slide number an `sldNum` placeholder, each at core's exact box with its furniture tag; the slide master and layout carry the three placeholders and `p:hf` flags, and the notes master records that notes pages carry a page number only. A zone `text` with a `{{slide.number}}` is the `sldNum` placeholder (its other words are fixed runs); any other zone `text` is the `ftr` placeholder. Header parts, socials, images, second text/date/number parts and multi-line text stay tagged shapes (PowerPoint has no object for them). `fromPptx` reads the placeholders back with or without provenance, and a deck changed through PowerPoint's Insert > Header & Footer dialog imports the change. Every deck, with or without a footer, carries the three master and layout placeholders (flags off when unused), so Insert > Header & Footer works on a deck with no footer. The mapping table, the dialog-edit table and the vetoable decisions are in [docs/native-header-footer.md](docs/native-header-footer.md).
+Native header and footer placeholders (RR-11): the first footer text becomes a `ftr` placeholder, the first footer date a `dt` placeholder (a live `datetime1`-`datetime7` field for `date: true`) and the first footer slide number an `sldNum` placeholder, each at core's exact box with its furniture tag; the slide master and layout carry the three placeholders and `p:hf` flags, and the notes master records that notes pages carry a page number only. A zone `text` with a `{{slide.number}}` is the `sldNum` placeholder (its other words are fixed runs); any other zone `text` is the `ftr` placeholder. Header parts, socials, images and logos, second text/date/number parts and multi-line text stay tagged shapes (PowerPoint has no object for them). A footer text that shares its zone with a logo is only as wide as its words (core's row layout), so its slide placeholder has that box while the master and layout placeholder spans the zone. `fromPptx` reads the placeholders back with or without provenance, and a deck changed through PowerPoint's Insert > Header & Footer dialog imports the change. Every deck, with or without a footer, carries the three master and layout placeholders (flags off when unused), so Insert > Header & Footer works on a deck with no footer. The mapping table, the dialog-edit table and the vetoable decisions are in [docs/native-header-footer.md](docs/native-header-footer.md).
+
+Master furniture (RR-72): a part with no placeholder (a logo or other zone image, socials, header text, a second footer text) that is drawn the same on two or more slides is written once. It goes on the slide master when every slide that shows such furniture draws it, else on a layout shared by the slides that do (one layout per distinct set, so a logo's `onLight` and `onDark` assets get a layout per background tone); a slide that hides it (`design.footer: false`) uses a layout with `showMasterSp="0"`. A part on one slide only, a part with a live field and a part that slide content covers stay on the slide (the last with `furniture-on-slide`, because PowerPoint draws master shapes beneath slide content). The lifted shapes keep their furniture tags (with the slot in place of the slide part), and each slide manifest lists them under `shared`, so `fromPptx` reads them from the layout or master: a master logo returns as its `var:organization.logo.*` reference on every slide. Importers before 0.18 ignore `shared`; shapes on a master or layout without OPF tags (a third-party template) are not imported. See [Master furniture](docs/native-header-footer.md#master-furniture-rr-72).

package/dist/document-provenance.js

@@ -108,10 +108,12 @@ export function splitAuthors(creator) {
 export const DEFAULT_AUTHOR = 'OpenPresentation';
 // Stored only when the native creator cannot carry the authored form by itself (or would read as the default).
 const authorNeedsRecord = author => Array.isArray(author) || (typeof author === 'string' && (author === DEFAULT_AUTHOR || Array.isArray(splitAuthors(author))));
-// Brand images have no native gate: they return from the stored value once
-// their media and asset references resolve. The P2 logo picture (`OPF_LOGO_V1`)
-// consumes the drawn logo; `design.logo` itself always returns from here.
+// `design.logo` (RR-71: a logo reference such as `var:organization.beta.logo`, or `false`) has no native gate: it returns
+// from the stored value. The logo image itself lives on the organization (metadata `organization`); the cover picture
+// (`OPF_LOGO_V1`) only consumes the drawn logo.
 export const BRAND_ASSETS = Object.freeze(['logo']);
+// A logo reference names an organization's logo, which 'references-only' mode does not store: the reference stays out with it.
+const storesOnlyWithOrganization = (key, value) => key === 'logo' && typeof value === 'string';
 const STYLE_REFERENCES = ['theme', 'colorScheme', 'fontScheme'];
 const SLIDE_STRUCTURE = ['layout', 'type', 'composition'];
 // Slide fields with no native counterpart, restored from the stored value.
@@ -471,7 +473,7 @@ export function documentProvenance(presentation, {mode = 'full', layoutOf = () =
   const design = {}, metadata = {};
   for (const key of DESIGN_FIELDS) {
     if (!own(presentation.design, key)) continue;
-    if (referencesOnly && carriesSource(presentation.design[key])) continue;
+    if (referencesOnly && (carriesSource(presentation.design[key]) || storesOnlyWithOrganization(key, presentation.design[key]))) continue;
     design[key] = clone(presentation.design[key]);
   }
   for (const key of METADATA) {
@@ -499,7 +501,7 @@ export function documentProvenance(presentation, {mode = 'full', layoutOf = () =
     }
     const slideDesign = {};
     for (const key of SLIDE_DESIGN_FIELDS) {
-      if (!own(slide.design, key) || (referencesOnly && carriesSource(slide.design[key]))) continue;
+      if (!own(slide.design, key) || (referencesOnly && (carriesSource(slide.design[key]) || storesOnlyWithOrganization(key, slide.design[key])))) continue;
       slideDesign[key] = clone(slide.design[key]);
     }
     if (Object.keys(slideDesign).length) record.design = slideDesign;

package/dist/furniture-provenance.js

@@ -3,7 +3,8 @@ import {attachTextTags, decodeTextTag, encodeTextTag} from './code-provenance.js
 import {sourceLineParagraphs} from './text-provenance.js';
 import {DEFAULT_DATE_FORMAT, NATIVE_DATE_FIELDS, isBuiltinTemplate, mentionsSlideToken, parseDate, slideNumberTemplate} from './furniture-fields.js';
 import {schemas} from '@openpresentation/opf';
-import {LOGO_TAG} from './logo-provenance.js';
+import {resolveLogo} from '@openpresentation/opf/composition';
+import {mediaKey} from './media-dedupe.js';
 import {NATIVE_PLACEHOLDERS, footerValue, isNativePlaceholderType, readNativePlaceholders} from './native-furniture.js';
 
 const TAG = 'OPF_FURNITURE_V1';
@@ -26,6 +27,8 @@ const platformId = new RegExp(schemas.presentation.$defs.Socials.propertyNames.p
 const socialLines = part => part.links.map(link => ({platform: link.platform,
   scheme: link.href && !/^[a-z][a-z0-9+.-]*:/i.test(link.text) ? 'https://' : ''}));
 const object = value => value !== null && typeof value === 'object' && !Array.isArray(value);
+const LOGO_REFERENCE = /^var:organization(?:\.[A-Za-z0-9_-]{1,64}){1,3}$/;
+const isLogoReference = value => typeof value === 'string' && value.length <= 200 && LOGO_REFERENCE.test(value);
 const key = part => `${part.kind}.${part.zone}.${part.field}`;
 // Key order is not meaning: a value merged from native placeholders equals the same value read from a manifest.
 const canonical = value => JSON.stringify(value, (key, item) => object(item) ? Object.fromEntries(Object.entries(item).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0)) : item);
@@ -72,11 +75,13 @@ function unchangedStaticDate(marker, format, ordered, paragraphs) {
   }), 'Current static date text or boundaries differ from the exported lines.');
 }
 
-// This manifest contains topology, identities, inactive flags, format settings and the authored text of a zone whose
-// `text` uses built-in variables (`templates`, FA-31; `authored` is the document as given to toPptx, before the deck-wide pass). Current native shapes supply all words, image bytes and
-// alt text, even after edits; a recorded format or template is kept only while the current text still matches it exactly.
+// This manifest contains topology, identities, inactive flags, format settings, the authored text of a zone whose `text` uses
+// built-in variables (`templates`, FA-31; `authored` is the document as given to toPptx, before the deck-wide pass) and the
+// organization logo reference of a zone `image` (`images`, RR-71: `{reference, media?, drawn?}` per `kind.zone`). Current native
+// shapes supply all words, image bytes and alt text, even after edits; a recorded format, template or logo reference is kept
+// only while the current text or picture still matches it exactly.
 export function furnitureManifest(presentation, slide, layout, slideIndex, staticDates = new Map(), natives = new Map(), authored) {
-  const definitions = {}, formats = {}, templates = {};
+  const definitions = {}, formats = {}, templates = {}, images = {};
   for (const kind of kinds) {
     const local = slide.design?.[kind] !== undefined;
     const source = local ? slide.design[kind] : presentation.design?.[kind];
@@ -84,8 +89,14 @@ export function furnitureManifest(presentation, slide, layout, slideIndex, stati
     const value = source === false ? false : {};
     if (value !== false) for (const zone of zones) if (source[zone] !== undefined) {
       value[zone] = {};
+      // An organization logo reference (`var:organization.logo.icon`): core lays out an image part with `reference`; the manifest keeps
+      // the authored string. With no part (the organization has no logo) the reference is all there is, and import restores it.
+      const reference = isLogoReference(source[zone].image) ? source[zone].image : undefined;
+      const imagePart = layout.parts.find(part => part.kind === kind && part.zone === zone && part.type === 'image');
+      if (reference !== undefined) images[`${kind}.${zone}`] = imagePart ? {reference} : {reference, drawn: false};
       for (const field of fields) if (source[zone][field] !== undefined) {
         const current = source[zone][field];
+        if (field === 'image' && reference !== undefined && !imagePart) continue;
         value[zone][field] = field === 'image' ? 'native' : typeof current === 'string' ? 'literal' : current;
       }
       const format = Object.fromEntries(settings.filter(setting => typeof source[zone][setting] === 'string').map(setting => [setting, source[zone][setting]]));
@@ -103,35 +114,19 @@ export function furnitureManifest(presentation, slide, layout, slideIndex, stati
   if (!Object.keys(definitions).length) return null;
   const organizations = array(presentation.organization);
   const organization = organizations.find(item => item.role === 'primary') ?? organizations[0];
-  // Generated deck logos (logo: true) are listed beside the topology, never inside it: the part list and the field
-  // definitions are validated strictly by every released importer (0.11.6 and earlier reject an unknown field there),
-  // so they keep describing only what those importers know. `drawn` is false when no logo resolved at export.
-  const logos = [];
-  for (const kind of kinds) {
-    const source = (slide.design?.[kind] !== undefined ? slide.design : presentation.design)?.[kind];
-    for (const zone of zones) if (definitions[kind]?.value?.[zone] && source?.[zone]?.logo === true) {
-      logos.push({kind, zone, drawn: layout.parts.some(part => part.field === 'logo' && part.kind === kind && part.zone === zone)});
-    }
-  }
   return {v: 1, role: 'slide', group: String(slideIndex), definitions, ...(Object.keys(formats).length ? {formats} : {}),
-    ...(Object.keys(templates).length ? {templates} : {}),
+    ...(Object.keys(templates).length ? {templates} : {}), ...(Object.keys(images).length ? {images} : {}),
     ...(layout.parts.some(part => part.field === 'socials') ? {organizationId: organization?.id} : {}),
-    parts: layout.parts.flatMap((part, index) => part.field === 'logo' ? [] : [{kind: part.kind, zone: part.zone, field: part.field,
+    parts: layout.parts.map((part, index) => ({kind: part.kind, zone: part.zone, field: part.field,
       type: part.type, count: part.type === 'image' ? 1 : part.fit.lines.length,
       ...(part.field === 'socials' ? {socials: socialLines(part)} : {}),
       ...(staticDates.has(index) ? {staticDate: staticDates.get(index)} : {}),
       // RR-11: this part is a native PowerPoint placeholder (dt, ftr or sldNum); deleting it in PowerPoint's dialog is then intent.
-      ...(natives.has(index) ? {ph: natives.get(index)} : {})}]),
-    ...(logos.length ? {logos} : {})};
+      ...(natives.has(index) ? {ph: natives.get(index)} : {})}))};
 }
 
-// The manifest index of a layout part: logo parts are not in the manifest, so later parts shift down.
-export const manifestPartIndex = (parts, index) => parts.slice(0, index).filter(part => part.field !== 'logo').length;
-
-export function attachFurnitureTags(entries, records, manifests, logoRecords = new Map()) {
+export function attachFurnitureTags(entries, records, manifests) {
   attachTextTags(entries, records, TAG, 'opfFurniture', 'furniture', {pictures: true});
-  // A generated logo picture carries the logo tag (never the furniture tag): see logo-provenance.js.
-  attachTextTags(entries, logoRecords, LOGO_TAG, 'opfFurnitureLogo', 'furniture logo', {pictures: true});
   const types = [];
   for (const [path, manifest] of manifests) {
     const part = `ppt/tags/opfFurnitureSlide${manifest.group}.xml`;
@@ -153,6 +148,49 @@ export function attachFurnitureTags(entries, records, manifests, logoRecords = n
   if (types.length) entries['[Content_Types].xml'] = enc.encode(dec.decode(entries['[Content_Types].xml']).replace('</Types>', types.join('') + '</Types>'));
 }
 
+/**
+ * An organization `logo` value reduced to what logo resolution needs (RR-71): the shapes and tones that exist, each as a
+ * placeholder string (a stored picture, an asset reference and a path all count), or undefined when it has none.
+ */
+export function logoShape(value) {
+  if (typeof value === 'string') return value.trim() ? 'x' : undefined;
+  if (!object(value)) return undefined;
+  if (typeof value.src === 'string') return value.src.trim() ? 'x' : undefined;
+  if (typeof value.$opfMedia === 'string') return 'x';
+  const kept = Object.fromEntries(Object.entries(value).map(([name, item]) => [name, logoShape(item)]).filter(([, item]) => item !== undefined));
+  return Object.keys(kept).length ? kept : undefined;
+}
+
+// The content key of the embedded bytes of a picture: its main blip's media part.
+function pictureKey(picture, relationships, entries) {
+  const target = relationships.get(picture?.['p:blipFill']?.['a:blip']?.['r:embed'])?.path;
+  return target && entries[target] ? mediaKey(entries[target]) : undefined;
+}
+
+/**
+ * Finish the `images` of each slide manifest once the package is final (SVG parts, format conversion and media de-duplication
+ * change what a picture embeds): the media key of every logo-reference picture, or `drawn: false` when the picture could not be
+ * embedded. Rewrites the slide's furniture tag part. `names` maps `<slide part>|<kind>.<zone>` to the picture's object name.
+ */
+export function stampFurnitureImageKeys(entries, manifests, names, relationshipsOf) {
+  for (const [path, manifest] of manifests) {
+    if (!manifest.images) continue;
+    const xml = dec.decode(entries[path]), relationships = relationshipsOf(entries, path);
+    const pictures = [...xml.matchAll(/<p:pic>[\s\S]*?<\/p:pic>/g)].map(match => match[0]);
+    for (const [slot, entry] of Object.entries(manifest.images)) {
+      if (entry.drawn === false) continue;
+      const name = names.get(`${path}|${slot}`);
+      const embed = name === undefined ? undefined : pictures.find(picture => picture.match(/<p:cNvPr\b[^>]*\bname="([^"]+)"/)?.[1] === name)?.match(/<a:blip\b[^>]*r:embed="([^"]+)"/)?.[1];
+      const target = embed === undefined ? undefined : relationships.get(embed)?.path;
+      if (target && entries[target]) entry.media = mediaKey(entries[target]);
+      else entry.drawn = false;
+    }
+    const part = `ppt/tags/opfFurnitureSlide${manifest.group}.xml`;
+    if (!entries[part]) throw Error('Missing furniture tag part.');
+    entries[part] = enc.encode(dec.decode(entries[part]).replace(/\bval="[^"]*"/, () => `val="${encodeTextTag(manifest)}"`));
+  }
+}
+
 function readTags(container, relationships, entries) {
   const tags = [];
   let unreadable = false;
@@ -167,6 +205,29 @@ function readTags(container, relationships, entries) {
     ambiguous: unreadable || tags.filter(tag => /^OPF_/i.test(tag.name) && tag.name.toUpperCase() !== SLIDE_TAG).length !== 1};
 }
 
+// RR-72: a part written once on the slide master or a layout is stored under `shared` (keyed by slot, with `on`, the definition's
+// flag and its text template or logo reference), so importers that read only slide shapes ignore it. Put it back in place, as a
+// part marked `on`, before the manifest is validated as one record.
+function withSharedParts(manifest) {
+  if (manifest?.shared === undefined) return manifest;
+  check(object(manifest.shared) && object(manifest.definitions) && Array.isArray(manifest.parts), 'Invalid shared furniture.');
+  const result = {...manifest, definitions: structuredClone(manifest.definitions), parts: [...manifest.parts],
+    ...(manifest.templates ? {templates: {...manifest.templates}} : {}), ...(manifest.images ? {images: {...manifest.images}} : {})};
+  delete result.shared;
+  for (const [slot, entry] of Object.entries(manifest.shared)) {
+    check(object(entry) && ['master', 'layout'].includes(entry.on) && slot === key(entry) && entry.ph === undefined, 'Invalid shared furniture part.');
+    const {on, flag, template, image, ...part} = entry;
+    const zone = result.definitions[entry.kind]?.value?.[entry.zone];
+    check(object(zone) && zone[entry.field] === undefined && flag !== undefined, 'Invalid shared furniture part.');
+    zone[entry.field] = flag;
+    const place = `${entry.kind}.${entry.zone}`;
+    if (template !== undefined) { check(entry.field === 'text' && result.templates?.[place] === undefined, 'Invalid shared furniture text.'); (result.templates ??= {})[place] = template; }
+    if (image !== undefined) { check(entry.field === 'image' && result.images?.[place] === undefined, 'Invalid shared furniture image.'); (result.images ??= {})[place] = image; }
+    result.parts.push({...part, on});
+  }
+  return result;
+}
+
 function validateManifest(manifest) {
   check(manifest?.v === 1 && manifest.role === 'slide' && /^\d{1,10}$/.test(manifest.group), 'Invalid slide identity.');
   check(object(manifest.definitions) && Object.keys(manifest.definitions).length > 0 && Object.keys(manifest.definitions).every(kind => kinds.includes(kind)), 'Invalid furniture definitions.');
@@ -187,14 +248,16 @@ function validateManifest(manifest) {
       }
     }
   }
-  if (manifest.logos !== undefined) {
-    check(Array.isArray(manifest.logos) && manifest.logos.length <= 6, 'Invalid furniture logos.');
-    const seen = new Set();
-    for (const logo of manifest.logos) {
-      const slot = `${logo?.kind}.${logo?.zone}`;
-      check(object(logo) && kinds.includes(logo.kind) && zones.includes(logo.zone) && typeof logo.drawn === 'boolean' && Object.keys(logo).length === 3 &&
-        object(manifest.definitions[logo.kind]?.value?.[logo.zone]) && !seen.has(slot), 'Invalid furniture logo.');
-      seen.add(slot);
+  if (manifest.images !== undefined) {
+    check(object(manifest.images), 'Invalid furniture images.');
+    for (const [slot, entry] of Object.entries(manifest.images)) {
+      const [kind, zone, extra] = slot.split('.');
+      const flag = manifest.definitions[kind]?.value?.[zone]?.image;
+      check(extra === undefined && object(manifest.definitions[kind]?.value?.[zone]) && object(entry) && Object.keys(entry).every(name => ['reference', 'media', 'drawn'].includes(name)) &&
+        isLogoReference(entry.reference) && (entry.media === undefined || (typeof entry.media === 'string' && /^\d{1,12}:[0-9a-f]{1,32}$/.test(entry.media))) &&
+        (entry.drawn === undefined || (entry.drawn === false && entry.media === undefined)) &&
+        // A reference with no part at all has no image flag; one with a part has the part's flag.
+        (flag === 'native' || (flag === undefined && entry.drawn === false)), 'Invalid furniture image.');
     }
   }
   if (manifest.templates !== undefined) {
@@ -218,6 +281,8 @@ function validateManifest(manifest) {
     check(object(part) && expected.get(key(part)) === part.type, 'Ambiguous furniture part.');
     check(Number.isSafeInteger(part.count) && part.count >= 1 && part.count <= 10000 && (part.type !== 'image' || part.count === 1), 'Invalid furniture line count.');
     // RR-11: a footer part that is a native PowerPoint placeholder (dt, ftr, sldNum), unique per slide.
+    // RR-72: a part drawn once on the slide master or a layout.
+    check(part.on === undefined || (['master', 'layout'].includes(part.on) && part.ph === undefined), 'Invalid shared furniture part.');
     if (part.ph !== undefined) check(isNativePlaceholderType(part.ph) && part.kind === 'footer' && part.type === 'text' && part.count === 1 &&
       NATIVE_PLACEHOLDERS[part.ph].field === part.field && manifest.parts.filter(other => other.ph === part.ph).length === 1, 'Invalid native placeholder part.');
     if (part.field === 'socials') check(Array.isArray(part.socials) && part.socials.length >= 1 && part.socials.length <= 100
@@ -229,17 +294,6 @@ function validateManifest(manifest) {
   if (manifest.parts.some(part => part.field === 'socials')) check(typeof manifest.organizationId === 'string' && /^[a-zA-Z0-9_-]+$/.test(manifest.organizationId), 'Invalid organization identity.');
 }
 
-// The logo tags of a picture: any other OPF tag next to one is not an identity conflict for the furniture reader.
-function readLogoTags(container, relationships, entries) {
-  const found = [];
-  for (const link of array(container?.['p:tags'])) {
-    const rel = relationships.get(link['r:id']);
-    if (rel?.type !== REL || rel.targetMode === 'External' || !entries[rel.path]) continue;
-    found.push(...array(parser.parse(dec.decode(entries[rel.path]))['p:tagLst']?.['p:tag']).filter(tag => tag.name?.toUpperCase() === LOGO_TAG));
-  }
-  return found;
-}
-
 // The native fields of the lines of one tagged text part, with offsets into the text sourceLineParagraphs joins from them.
 function orderedFields(ordered, paragraphs) {
   const fields = [];
@@ -270,8 +324,37 @@ function importedZoneText(text, nativeFields, template, position) {
   return slideNumberTemplate(text, nativeFields);
 }
 
-function readSlide(context, entries, slideIndex, slideCount, report, taggedText, section, draw) {
-  const {root, shapes, paragraphs, pictures, relationships, readPicture} = context;
+// RR-72: the tagged furniture shapes of the slide's layout and master, by `on` and slot, and whether the slide shows them: a slide
+// whose "Hide background graphics" is on (showMasterSp="0") shows neither; a layout with it hides the master's.
+function inheritedRecords(context, entries) {
+  const inherited = context.inherited?.() ?? {};
+  const records = new Map(), damaged = {};
+  for (const on of ['layout', 'master']) {
+    const source = inherited[on];
+    if (!source) continue;
+    for (const [type, nodes, properties] of [['text', source.shapes, 'p:nvSpPr'], ['image', source.pictures, 'p:nvPicPr']]) {
+      for (const [index, node] of nodes.entries()) {
+        const container = node[properties]?.['p:nvPr']?.['p:custDataLst'];
+        const result = readTags(container, source.relationships, entries);
+        // A tag that cannot be read (a missing part, two identities) leaves the part's shape unknown: that is damage, not a removal.
+        if (array(container?.['p:tags']).length && result.tags.length !== 1 && result.ambiguous) damaged[on] = true;
+        for (const tag of result.tags) {
+          let data;
+          try { data = decodeTextTag(tag.val); } catch { damaged[on] = true; continue; }
+          if (result.ambiguous || data?.v !== 1 || typeof data.slot !== 'string' || data.role !== type) { damaged[on] = true; continue; }
+          const slot = `${on}|${data.slot}`;
+          records.set(slot, [...(records.get(slot) ?? []), {type, index, data}]);
+        }
+      }
+    }
+  }
+  const hiddenSlide = context.root?.showMasterSp === '0' || context.root?.showMasterSp === 'false';
+  const hiddenLayout = inherited.layout?.root?.showMasterSp === '0' || inherited.layout?.root?.showMasterSp === 'false';
+  return {sources: inherited, records, damaged, hidden: {layout: hiddenSlide, master: hiddenSlide || hiddenLayout}};
+}
+
+function readSlide(context, entries, slideIndex, slideCount, report, taggedText, section, draw, logoOwner) {
+  const {root, shapes, pictures, relationships} = context;
   const candidates = {};
   const records = [];
   let invalidRecord = false;
@@ -285,26 +368,19 @@ function readSlide(context, entries, slideIndex, slideCount, report, taggedText,
       } catch { invalidRecord = true; }
     }
   }
-  // Generated logo pictures: identity only, the bytes come from design.logo.
-  const logoPictures = [];
-  for (const [index, node] of pictures.entries()) try {
-    for (const tag of readLogoTags(node['p:nvPicPr']?.['p:nvPr']?.['p:custDataLst'], relationships, entries)) {
-      const data = decodeTextTag(tag.val);
-      if (data?.role === 'furniture') logoPictures.push({index, data});
-    }
-  } catch { invalidRecord = true; }
   const tags = readTags(root['p:cSld']?.['p:custDataLst'], relationships, entries);
-  if (!tags.tags.length && !records.length && !invalidRecord && !logoPictures.length) return candidates;
+  if (!tags.tags.length && !records.length && !invalidRecord) return candidates;
   let manifest;
   try {
     check(!tags.ambiguous && tags.tags.length === 1 && !invalidRecord, 'Missing or ambiguous furniture manifest/shape tags.');
-    manifest = decodeTextTag(tags.tags[0].val);
+    manifest = withSharedParts(decodeTextTag(tags.tags[0].val));
     validateManifest(manifest);
     for (const record of records) {
       const data = record.data, part = manifest.parts[data?.part];
       check(data?.v === 1 && data.group === manifest.group && Number.isSafeInteger(data.part) && part && data.role === record.type && part.type === record.type, 'Unmatched furniture identity.');
     }
   } catch (error) { report(slideIndex, error.message); return candidates; }
+  const inherited = manifest.parts.some(part => part.on) ? inheritedRecords(context, entries) : undefined;
   for (const kind of kinds) {
     const definition = manifest.definitions[kind];
     if (!definition) continue;
@@ -315,24 +391,41 @@ function readSlide(context, entries, slideIndex, slideCount, report, taggedText,
         value[zone] = Object.fromEntries(Object.entries(definition.value[zone]).filter(([, flag]) => flag === false));
       }
       const candidate = {scope: definition.scope, value, text: [], pictures: [], socials: []};
-      // logo: true returns as its flag; the generated picture is consumed, never content or an image field.
-      for (const logo of (manifest.logos ?? []).filter(item => item.kind === kind)) {
-        const found = logoPictures.filter(item => item.data.v === 1 && item.data.group === manifest.group && item.data.furniture === kind && item.data.zone === logo.zone);
-        check(found.length <= 1, 'Duplicated furniture logo.');
-        if (found.length) { candidate.pictures.push(found[0].index); value[logo.zone].logo = true; }
-        else if (!logo.drawn) value[logo.zone].logo = true;
+      // A logo reference with no part (the organization had no logo to draw) returns as the reference.
+      for (const [slot, entry] of Object.entries(manifest.images ?? {})) {
+        const [slotKind, slotZone] = slot.split('.');
+        if (slotKind === kind && entry.drawn === false && !definition.value?.[slotZone]?.image && value !== false) value[slotZone].image = entry.reference;
       }
       for (const [partIndex, part] of manifest.parts.entries()) {
         if (part.kind !== kind) continue;
-        const group = records.filter(record => record.data.part === partIndex);
+        // A part on the master or a layout is read there; the slide's own shapes otherwise.
+        const source = part.on ? inherited.sources[part.on] : context;
+        const group = part.on ? (inherited.hidden[part.on] || !source ? [] : inherited.records.get(`${part.on}|${key(part)}`) ?? []) : records.filter(record => record.data.part === partIndex);
+        const {paragraphs, relationships} = source ?? context;
+        const logo = part.type === 'image' ? manifest.images?.[`${kind}.${part.zone}`] : undefined;
+        // The picture of a logo reference could not be embedded at export: the reference is all there is.
+        if (logo?.drawn === false && group.length === 0) { value[part.zone].image = logo.reference; continue; }
         // A native placeholder PowerPoint's Header & Footer dialog removed is a deliberate removal, not damage.
         if (part.ph !== undefined && group.length === 0) { removedNative = true; continue; }
+        // So is a master or layout part the slide no longer shows (deleted there, another layout, or the slide's background graphics hidden).
+        if (part.on !== undefined && group.length === 0) {
+          check(inherited.hidden[part.on] || !inherited.damaged[part.on], 'Damaged furniture tags on the slide master or layout.');
+          removedNative = true;
+          continue;
+        }
+        try {
         check(group.length === part.count, 'Incomplete or duplicated furniture part.');
         if (part.type === 'image') {
-          const current = readPicture(pictures[group[0].index]);
-          check(current?.kind === 'image', 'Furniture image is no longer recoverable.');
-          value[part.zone].image = current.payload.image;
-          candidate.pictures.push(group[0].index);
+          // An unchanged picture of an organization logo returns as its reference (the organization is stored with its logo, and the
+          // picture still embeds the bytes export drew); an edited, replaced or foreign one is an ordinary image.
+          const picture = source.pictures[group[0].index];
+          if (logo && logoOwner(logo.reference) && logo.media !== undefined && logo.media === pictureKey(picture, relationships, entries)) value[part.zone].image = logo.reference;
+          else {
+            const current = source.readPicture(picture);
+            check(current?.kind === 'image', 'Furniture image is no longer recoverable.');
+            value[part.zone].image = current.payload.image;
+          }
+          if (!part.on) candidate.pictures.push(group[0].index);
         } else {
           const ordered = Array(part.count);
           for (const record of group) {
@@ -348,7 +441,20 @@ function readSlide(context, entries, slideIndex, slideCount, report, taggedText,
             candidate.socials.push({id: manifest.organizationId, socials: Object.fromEntries(part.socials.map((line, index) => [line.platform, line.scheme + lines[index]]))});
           }
           value[part.zone][part.field] = part.field === 'text' ? importedZoneText(text, orderedFields(ordered, paragraphs), manifest.templates?.[`${kind}.${part.zone}`], {index: slideIndex, count: slideCount, section, draw}) : part.field === 'date' ? importedDate(definition.value[part.zone].date, format, text, ordered.flatMap(record => (paragraphs[record.index] ?? []).flatMap(paragraph => paragraph.fields ?? [])), value[part.zone], part.staticDate, ordered, paragraphs, message => report(slideIndex, `${kind}.${part.zone}.date: ${message}`)) : true;
-          candidate.text.push(...ordered.map(record => record.index));
+          if (!part.on) candidate.text.push(...ordered.map(record => record.index));
+        }
+        } catch (error) {
+          // A part on the slide master or a layout is never slide content: when its record no longer reads, its current words (or
+          // picture) stay the part's value, as literal text, and the damage is reported.
+          if (!part.on) throw error;
+          report(slideIndex, `${kind}.${part.zone}.${part.field}: ${error.message} The current ${part.type === 'image' ? 'picture' : 'words'} on the slide master or layout are kept.`);
+          if (part.type === 'image') {
+            const current = source.readPicture(source.pictures[group[0].index]);
+            if (current?.kind === 'image') value[part.zone].image = current.payload.image;
+          } else if (part.field !== 'socials') {
+            const lines = [...group].sort((a, b) => (Number.isSafeInteger(a.data.line) ? a.data.line : 0) - (Number.isSafeInteger(b.data.line) ? b.data.line : 0) || a.index - b.index);
+            value[part.zone][part.field] = lines.map(record => (paragraphs[record.index] ?? []).map(paragraph => paragraph.text).join('\n')).join('\n');
+          }
         }
       }
       check(new Set(candidate.text).size === candidate.text.length && new Set(candidate.pictures).size === candidate.pictures.length, 'Repeated furniture shape identity.');
@@ -398,9 +504,13 @@ function importedDate(flag, format, text, nativeFields, zone, marker, ordered, p
 // `options.organizations` the stored organizations (OPF_DOCUMENT_V1) a socials part can name by id, and `options.draw(template,
 // {index, count, section})` draws a stored zone text for a slide (its built-in variables resolved from the document's metadata).
 export function importFurniture(contexts, entries, onDiagnostic, {sections = [], organizations = [], draw = () => undefined} = {}) {
+  // A logo reference returns only while the stored organizations still give it a logo (RR-71): `organizations` carry `logo`.
+  const logoOwner = reference => {
+    try { return resolveLogo({organization: organizations.filter(item => item.logo !== undefined)}, {}, {reference}) !== null; } catch { return false; }
+  };
   const report = (index, message) => onDiagnostic?.({code: 'invalid-furniture-provenance', path: `slides.${index}.design`, message: `${message} Ordinary import retains current native content; no old source words are restored.`});
   const taggedText = contexts.map(() => new Set());
-  const candidates = contexts.map((context, index) => readSlide(context, entries, index, contexts.length, report, taggedText[index], sections[index], draw));
+  const candidates = contexts.map((context, index) => readSlide(context, entries, index, contexts.length, report, taggedText[index], sections[index], draw, logoOwner));
   // Social profiles belong to the organization the manifest names by id, which only the stored document metadata can supply
   // (no furniture part shows the organization's name any more); without it (or with disagreeing values) the lines stay
   // ordinary current text.

package/dist/image-fallback-node.js

@@ -13,12 +13,12 @@ export async function webpToPng(bytes) {
 // not installed, and also when it is installed but its PNG converter (`@resvg/resvg-js`, an optional peer of opf-render
 // 0.16) is not: opf-render's `converter-missing` error maps to the same code, with its install command on `install`.
 //
-// This is the one place the exporter calls the renderer. opf-render's svgToPng(svg, {fonts, scale, background}) takes the
+// This is the one place the exporter calls the renderer. opf-render's toPng(svg, {fonts, scale, background}) takes the
 // fonts handle for the faces it may draw with: here only the bundled ones, never the system's.
 export async function svgToPng(svg, {scale, text}) {
   let render;
   try {
-    ({svgToPng: render} = await import('@openpresentation/opf-render'));
+    ({toPng: render} = await import('@openpresentation/opf-render'));
   } catch (error) {
     const unavailable = new Error('SVG pictures need the optional peer @openpresentation/opf-render (or an options.svgRasterizer).', {cause: error});
     unavailable.code = 'svg-rasterizer-unavailable';

package/dist/index.d.ts

@@ -97,7 +97,7 @@ export interface ToPptxOptions {
   /**
    * OPF_DOCUMENT_V1 / OPF_SLIDE_V1 customer-data tags that let fromPptx restore
    * catalog references, layout ids, authoring metadata (`filename` and `extensions`
-   * included), `design.logo`, the asset registry, slide `section`/`extensions` and
+   * included), `design.logo` (a logo reference or `false`), the organizations with their logos, the asset registry, slide `section`/`extensions` and
    * the slide content structure: nested groups, promoted regions, the root payload
    * form, block ids and extensions, group composition (docs/document-roundtrip.md).
    * Tags are not shown in PowerPoint's UI. Default "full"; "references-only"
@@ -131,7 +131,7 @@ export interface ToPptxOptions {
   /**
    * Draws the PNG fallback of an SVG picture (the raster older viewers show; PowerPoint 2016 and Microsoft 365 draw the SVG itself). It receives the
    * sanitized SVG text and the pixel size to draw (the SVG's own aspect, about 192 dpi of the displayed size) and returns PNG bytes with a transparent
-   * background. It must be deterministic for the export to be. Default in Node: opf-render's `svgToPng` (resvg with the bundled fonts), loaded only when an
+   * background. It must be deterministic for the export to be. Default in Node: opf-render's `toPng` (resvg with the bundled fonts), loaded only when an
    * SVG is exported (optional peer `@openpresentation/opf-render`). Without it, and without opf-render, an SVG picture exports as the "Image unavailable"
    * placeholder with an `unresolved-asset` diagnostic (`reason: "svg-rasterizer-unavailable"`); a browser build has no default.
    */