@openpresentation/opf-pptx 0.20.4 → 0.22.1

package/README.md

@@ -1,5 +1,14 @@
 # OPF PPTX
 
+Source prototype: `toPptx(deck, {bodyText: "native"})` is an opt-in mode and stays a prototype. It writes one editable paragraph, flat-bullet or numbered-list body per text region (the first is the Body placeholder) and a wrapped plain title as one Title placeholder, with an explicit `native-body-fallback` diagnostic for anything it cannot represent; the default measured output is unchanged. Keynote 15.1.1 was checked for Title and Body controls and reflow after an edit ([evidence](docs/evidence/rr-88-keynote/README.md)); PowerPoint has not been checked, and nothing here claims native raster equivalence. See [Choosing body text mode](#choosing-body-text-mode-since-0220) and the [scope and qualification boundaries](docs/native-body-prototype.md).
+
+New since 0.22.0 (each section below says what changed and what is unchanged by default):
+
+- [Choosing body text mode](#choosing-body-text-mode-since-0220): measured (default) or `bodyText: "native"`, with the fallbacks and what Keynote and PowerPoint do.
+- [Slide numbers with words around them](#slide-numbers-with-words-around-them-since-0220): fixed text by default so Keynote shows `2 / 6`; `slideNumberFields: "live"` for PowerPoint-only targets.
+- [Chart colors and value axis](#chart-colors-and-value-axis-since-0220): series from the deck color scheme and `chart.colors`, written as theme colors, and the value axis the preview draws.
+- [Quiet re-import of an unedited export](#quiet-re-import-of-an-unedited-export-since-0220): no per-group diagnostics for a pristine export, and authored image sources come back.
+
 Catalogs (OPF 0.20): export resolves the document's embedded records and host-registered catalogs (`Catalog[]`, never fetched). Register Gallery 3 explicitly for export: `import { gallery } from "@openpresentation/gallery"; toPptx(deck, { catalogs: [gallery] })`. Bare ids resolve in the document's custom/default records, then the registered default catalog; `catalogs.default:false` closes that fallback. When import `catalogs` is omitted, foreign PowerPoint layout type/name mapping uses the default catalog from installed `@openpresentation/gallery`; theme and colour-scheme recovery still requires explicitly registered catalogs; `fromPptx(bytes, { catalogs: [] })` explicitly opts out. An unresolved reference emits core's `unresolved-reference` diagnostic and uses engine defaults; `strictReferences:true` refuses the export with `OPFPptxError`. Native layout tags preserve valid catalog sources and opt-outs, and damaged identity/source metadata emits diagnostics instead of creating invalid catalog groups.
 
 Generated slide masters carry the display name `pptx.gallery`, including masters copied for per-slide script fonts. Individual slide layouts keep their Gallery or authored custom names. The master label is separate from the theme name: authored theme identities stay exact so import can recover them. Archive tests verify the emitted names; PowerPoint menu display is a separate native observation.
@@ -148,6 +157,7 @@ The first importer is mechanical and schema-compatible:
 - Remaining text boxes map to `blocks[]` as text or list payloads, sorted by OOXML position. A measured list writes its size, family, weight and colour on every native run; in `full` provenance the slide record (`OPF_SLIDE_V1.listRuns`, opf-pptx#212) keeps that look per list (entry and description lines, never text), and import removes a run value still equal to it, so an untouched list round trip returns its items as authored instead of baking those values into `TextRun`s. A value edited in PowerPoint differs and comes back as observed; a run colour reference that resolves to the list colour (the `text` role) still returns through the run colour record, but an authored literal colour, size or family equal to the list's own cannot be told from it and returns absent. Without the record (`references-only`, `provenance: false`, a plain PPTX) runs are read as observed.
 - PowerPoint tables map to OPF table blocks, embedded images map to data URI image blocks, and cached chart series map to OPF chart blocks whose `type` is the core chart type id for the native construct (for example a `percentStacked` column chart imports as `100pct-stacked-column`, a filled radar as `filled-radar`; a scatter chart imports as `[Point, X, ...series]`).
 - Chart cache points are placed by their native `c:pt@idx`, with `c:ptCount` retaining trailing gaps. Missing labels and values become `null`; explicitly empty labels and series names stay empty strings, and an actual numeric zero stays zero. Empty numeric cache values remain missing. Malformed or duplicate indices, contradictory counts, competing caches and allocation limits reject with `invalid-chart-cache` and the chart-part/cache path; hierarchical category caches reject with `unsupported-chart-cache` instead of flattening labels. Each cache is limited to 100,000 positions, and combined caches and the emitted table each to 1,000,000 cells. Complete decimal scientific notation in numeric caches is read as a number; exponent overflow or nonzero underflow to zero rejects with `unsupported-chart-cache` and the chart part, series, cache and logical point path. Zero coefficients remain zero. This finite-number boundary does not classify rejected text as invalid OOXML. Malformed exponent strings and other nonblank numeric text retain the existing legacy conversion policy. This cache-only import does not repair embedded worksheets, restore unsupported scatter X/point labels, change exporter/workbook parsing or export/re-export missing-data handling, or establish native chart fidelity.
+- Explicit native solid line-series paint imports with a `chart-option-adapted` diagnostic at the native slide/chart/series locator (`series.N.line.color`). OPF has no per-series color field, so it does not retain that paint override or infer semantic highlight from it. Data, design and restored highlight remain unchanged. This reports unsupported formatting, including an explicit default, rather than establishing a visual mismatch; other series/point/marker paint remains outside this bounded diagnostic. The preservation gap is tracked in [opf-pptx#272](https://github.com/OpenPresentation/opf-pptx/issues/272).
 - Table imports retain empty rows. A native `firstRow` flag of `1` or `true` maps the first row to column labels; absent/false flags retain every row as data. New exports set this flag from OPF columns. Older exports without the flag retain their labels as the first data row rather than inferring headers.
 - Native table text preserves run/field/break order, significant whitespace, and blank paragraphs. Cells return canonical `{value, style}` objects; `value` retains scalar text or supported rich runs. Covered merge positions are `null`. Explicit normal headers override OPF’s bold header default. Numeric/boolean/null source types cannot be reconstructed from native display text.
 - Run `lang` maps back to the presentation `language` as a BCP-47 tag (the run's own tag, for example `ja-JP`); see [Languages, right-to-left text and script fonts](#languages-right-to-left-text-and-script-fonts).
@@ -354,7 +364,7 @@ Image block treatments export from core's normalized geometry as native DrawingM
 - `recolor` becomes `a:grayscl` or `a:duotone`, followed by `a:alphaModFix` for `opacity`, on the blip only.
 - `overlay` becomes one tagged `OPF image N overlay` shape directly above the picture, in the frame's shape or as an edge band.
 
-An image block with any of its own fields (`fit`, `focus`, a treatment, `placement`) carries an `OPF_IMAGE_V1` shape tag with those fields and the exact native picture geometry; its overlay carries `OPF_IMAGE_OVERLAY_V1`. On import an unchanged tagged picture becomes the same image block again, with the embedded bytes as its data URI source. An edited, duplicated or ambiguous tagged picture is imported as an ordinary image block and reports `invalid-image-provenance`; an edited overlay drops only the overlay. Native PowerPoint raster parity for negative `a:srcRect` insets has not been checked with Office yet.
+Every image block carries an `OPF_IMAGE_V1` shape tag with its own fields (`fit`, `focus`, a treatment, `placement`; none for a plain block) and the exact native picture geometry; its overlay carries `OPF_IMAGE_OVERLAY_V1`. On import an unchanged tagged picture becomes the same image block again, with the embedded bytes as its data URI source (RR-94: or, when the block was authored from a relative path or an http(s) URL, that authored `src`, which the tag records beside the media key of the picture's bytes; it is restored only while the bytes still hash the same, and a data URI, an `asset:` reference, an absolute or parent-relative path or a `file:` URL is never recorded). A plain block whose picture was replaced or moved reads as an ordinary picture without a diagnostic. An edited, duplicated or ambiguous tagged picture is imported as an ordinary image block and reports `invalid-image-provenance`; an edited overlay drops only the overlay. Native PowerPoint raster parity for negative `a:srcRect` insets has not been checked with Office yet.
 
 A deck or slide watermark (`design.watermark`) exports as one native picture named `OPF watermark` per slide, after the image background and its overlay, if any, and before all content (placed image blocks included) (the preview's paint order, so a background picture lies beneath the watermark), at the preview's frame: the centered 40% by 40% box at 30%/30% of the slide, fitted without cropping. Its opacity is `a:alphaModFix` (the object form's `opacity`, otherwise the preview default 0.08), and its alt text is the asset's `alt`, otherwise `Watermark`. `design.watermark = false` on a slide exports none. An unchanged export imports back as `design.watermark` (at deck level when every slide carries the same one); an edited picture stays ordinary content and reports `invalid-watermark-provenance`. An unresolved image reports `unresolved-asset`; `src` is required by the schema, so a watermark with no image source is a validation error and not an export diagnostic.
 
@@ -482,14 +492,66 @@ Version 0.9.1 exports core's accepted header/footer text and picture geometry as
 
 A deck-level header or footer that every slide overrides or suppresses has no current native words to recover. Its dormant literal defaults are not stored or restored; each slide's disabled, empty or inactive definition still round-trips. Re-exporting the imported deck keeps those definitions suppressed. Keep the original OPF if you need to edit or reuse never-rendered global defaults later. Adding native furniture imports the new current content rather than bringing back those hidden defaults.
 
-A header or footer zone's `text` is the author's own string (FA-31): generated values are `{{ }}` variables in it. Each `{{slide.number}}` is a native PowerPoint slide-number field (`<a:fld type="slidenum">`) when its line fits one accepted text line, so PowerPoint renumbers it when slides move; the text around it (`"A-{{slide.number}}"`, `"Page {{slide.number}} of {{deck.slideCount}}"`) is ordinary runs. `{{deck.slideCount}}` (the exported slide count after pagination) and `{{slide.section}}` are fixed text, because PowerPoint has no slide-count or section field; the deck-wide variables (`{{organization.name}}`, `{{customer}}`) resolve before export like any other string. In body text every slide-scoped token is fixed text with the slide's value. Each slide is composed and drawn from core's substituted slide, so text is measured with the real value. A current date (`date: true`) needs the host's `date` option (ISO `YYYY-MM-DD`); it becomes a native `datetime1`–`datetime7` field when its `dateFormat` matches that en-US field type, and otherwise fixed text with a `furniture-date-fixed` diagnostic. An eligible date or number range that spans accepted text lines stays static and reports `furniture-field-fixed` at its source path; no native field is created by merging shapes. A string date with `dateFormat` is fixed text. The slide manifest records `dateFormat` settings and, for a zone whose `{{ }}` tokens are all built-in variables, that authored text as given to `toPptx`, before the deck-wide pass (`templates`); it never records rendered dates. Reimport keeps a format or the authored text only while the current native text still matches it (a fixed date that parses back to the same ISO date; the authored text drawn for this slide equals the current words: deck-wide built-ins resolved from the stored organization and speakers, then the slide's number, count and section), and a live date keeps the pattern of its current field type. Otherwise the current words import as literal text, with each native slide-number field as `{{slide.number}}` (typed words that spell a token are escaped as `\{{`). Hiding furniture on a title slide is a slide-level `design.footer: false`/`design.header: false`, which round-trips as before.
+A header or footer zone's `text` is the author's own string (FA-31): generated values are `{{ }}` variables in it. A zone `text` that is only `{{slide.number}}` is a native PowerPoint slide-number field (`<a:fld type="slidenum">`) when its line fits one accepted text line, so PowerPoint renumbers it when slides move. A number with words around it (`"A-{{slide.number}}"`, `"Page {{slide.number}} of {{deck.slideCount}}"`) is fixed text by default since 0.22.0 ([why](#slide-numbers-with-words-around-them-since-0220)); `slideNumberFields: "live"` keeps the field with the words as ordinary runs. `{{deck.slideCount}}` (the exported slide count after pagination) and `{{slide.section}}` are fixed text, because PowerPoint has no slide-count or section field; the deck-wide variables (`{{organization.name}}`, `{{customer}}`) resolve before export like any other string. In body text every slide-scoped token is fixed text with the slide's value. Each slide is composed and drawn from core's substituted slide, so text is measured with the real value. A current date (`date: true`) needs the host's `date` option (ISO `YYYY-MM-DD`); it becomes a native `datetime1`–`datetime7` field when its `dateFormat` matches that en-US field type, and otherwise fixed text with a `furniture-date-fixed` diagnostic. An eligible date or number range that spans accepted text lines stays static and reports `furniture-field-fixed` at its source path; no native field is created by merging shapes. A string date with `dateFormat` is fixed text. The slide manifest records `dateFormat` settings and, for a zone whose `{{ }}` tokens are all built-in variables, that authored text as given to `toPptx`, before the deck-wide pass (`templates`); it never records rendered dates. Reimport keeps a format or the authored text only while the current native text still matches it (a fixed date that parses back to the same ISO date; the authored text drawn for this slide equals the current words: deck-wide built-ins resolved from the stored organization and speakers, then the slide's number, count and section), and a live date keeps the pattern of its current field type. Otherwise the current words import as literal text, with each native slide-number field as `{{slide.number}}` (typed words that spell a token are escaped as `\{{`). Hiding furniture on a title slide is a slide-level `design.footer: false`/`design.header: false`, which round-trips as before.
 
 When a supported current-date field wraps across lines, full provenance records a versioned static-date reason, its format and exact line fingerprints, without cached date words. Complete unchanged soft-wrapped lines can then recover `date: true` and the authored format on reimport, so a later OPF export can use a new host date. The original PPTX date remains static: this does not establish native refresh or Office compatibility. Actual current native date fields take precedence. Edited or cleared text, damaged evidence, older unmarked exports, `references-only` and `provenance: false` remain literal/current-content fallbacks. Fingerprints detect changed text; writable tags are not authentication. Native formatting and geometry are not reconstructed.
 
 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 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).
+`toPptx(deck, {footerText: 'shape'})` omits only the first eligible literal footer's slide-local `ftr` binding, keeping its
+measured editable shape, locks, formatting, geometry, paint order and provenance. The default is `footerText: 'native'`.
+Date and slide-number fields/placeholders and master/layout footer controls remain unchanged. Shape mode gives up native
+Footer-dialog ownership of that literal shape; it does not recover tags stripped by another application or establish
+general native layout parity. See [literal footer text as a shape](docs/native-header-footer.md#literal-footer-text-as-a-shape).
+
+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` that is only `{{slide.number}}` is the `sldNum` placeholder; a number with words around it is an ordinary tagged shape by default since 0.22.0 (`slideNumberFields: "live"` keeps the `sldNum` placeholder with the words as 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).
 
 Multi-series Pareto exports in `chartex: "auto"` as an editable clustered column chart containing every authored series, with a `chart-data-adapted` / `chartex-fallback` diagnostic. This preserves data rather than claiming native multi-series Pareto support. Explicit `chartex: "native"` rejects it with `unsupported-chart-data`; single-series native Pareto is unchanged. `chartex: "fallback"` also retains all series. Native acceptance of any new behavior remains separate.
+
+A narrowly bounded [current-native literal footer fallback](docs/native-footer-classification.md) recognizes a unique generated-name literal only with its accepted same-group live slide-number anchor and exact own bottom-band frame. Current words, literal brace tokens and deletions remain authoritative; unsupported or ambiguous objects stay content with a diagnostic. This does not restore native geometry, paint order or notes fields.
+
+## Choosing body text mode (since 0.22.0)
+
+`toPptx(deck, {bodyText})` chooses how the text of a slide is written. Both modes read back with `fromPptx`. The default is `"measured"`, and it is byte-identical to omitting the option.
+
+| | `"measured"` (default) | `"native"` (opt-in prototype) |
+| --- | --- | --- |
+| Body text, lists, bullets | One native text box per wrapped visual line, at the positions core measured | One native body per eligible text, list or bullets region, with native wrapping and no autofit. The first body of a slide is the Body placeholder; each further region is an ordinary native text box at its region |
+| Numbered lists | Each marker line is its own box with the number core counted | One sequence (same style and suffix, counting up by one) is native auto-numbering on every paragraph; a restarted entry falls back |
+| Wrapped title | One box per line; only a one-line title binds the Title placeholder | A plain-string title that wraps is one Title-placeholder box with native wrap, no autofit and the measured line pitch; a title with a hard break, overflow, rich runs or right-to-left text keeps the measured lines (no diagnostic) |
+| Editing in an application | Editing a line does not reflow, so a longer line overlaps the next | Text reflows inside its frame; the frame is fixed (no autofit), so very long text can overflow it |
+| Wraps and baselines | Exactly the preview's | The application's own, so they can differ from the preview |
+| Falls back to measured shapes | Never | Per region, with a `native-body-fallback` diagnostic and a reason: `complex-composition` (groups, cards, a shared region), `multi-column`, `overflow`, `unsupported-list` (nested entries, descriptions, picture bullets, restarted numbering, a hard break inside an entry), `unsupported-text` (right-to-left text, tabs, unsupported run effects) or `annotated-text` (citations, footnotes) |
+| Keynote 15.1.1 | The title shows only for a one-line title (`title showing=false` on a wrapped one) | `title showing` is true on every slide of the repro deck, Body is a real body, and a lengthened bullet reflows (a copy in memory, nothing saved); [evidence](docs/evidence/rr-88-keynote/README.md) |
+| PowerPoint | Written as before | Not checked here (not available); the XML is standard `p:sp` placeholders and text |
+
+Native bodies keep no per-line recovery tags and no cached source words: `fromPptx` reads the current native paragraphs and runs, and native paragraph separators normalize to LF. The scope, the layout variants and the qualification boundaries are in [docs/native-body-prototype.md](docs/native-body-prototype.md).
+
+## Slide numbers with words around them (since 0.22.0)
+
+A footer or header text such as `{{slide.number}} / {{deck.slideCount}}` or `Page {{slide.number}}` exports its number as **fixed text** in an ordinary tagged shape by default (`slideNumberFields: "static"`): one run, no field, no Slide Number placeholder, so PowerPoint and Keynote both show `2 / 6`.
+
+Why: Keynote has no inline slide-number field. It replaces the whole paragraph that holds a `slidenum` field with the number, in the Slide Number placeholder and in a plain text box alike, so the live `{{slide.number}} / 6` showed only `2` (Keynote Creator Studio 15.1.1, 2026-10-17; text in a separate paragraph or shape is kept). The total is fixed in every mode, because PowerPoint has no slide-count field.
+
+- A text that is only `{{slide.number}}` keeps its live `slidenum` field in the `sldNum` placeholder in both modes; it is the way to get a live number in both apps.
+- `toPptx(deck, {slideNumberFields: "live"})` restores the 0.20 output (a live field with the words as fixed runs, in the Slide Number placeholder for the first footer one) for PowerPoint-only targets. Keynote then shows only the digit.
+- A fixed number does not follow slides reordered, added or deleted in PowerPoint; re-export from OPF to refresh it.
+- Import returns the authored `{{slide.number}} / {{deck.slideCount}}` either way (the furniture manifest stores the template). Details and the placeholder mapping are in [docs/native-header-footer.md](docs/native-header-footer.md#slide-number-with-words-around-it-rr-91).
+
+## Chart colors and value axis (since 0.22.0)
+
+Requires `@openpresentation/opf` ^0.21.0. Classic native charts (column, bar, line, area, pie and the other non-chartex types) now match what core composes:
+
+- **Series colors come from the deck.** Series 1 to 6 are `accent1` to `accent6` of the deck color scheme, then their tints, replacing the fixed palette of earlier versions; the chart's own `chart.colors` entries (a scheme slot, a role or a hex color) replace the entry for their position. The colors are still adjusted for contrast against the chart panel, as in the preview.
+- **Written as theme colors where possible.** A series that keeps an unadjusted theme accent, or a `chart.colors` scheme slot or role, is `<a:schemeClr val="accentN"/>`, so re-theming the deck in PowerPoint recolors it. Hex colors, tints and colors the panel adjustment moved stay `a:srgbClr`.
+- **The value axis matches the preview.** Column, bar, line and area charts write the axis core composed as `c:min`, `c:max` and `c:majorUnit` (a fraction for 100% stacked), so PowerPoint and Keynote draw the preview's gridlines instead of choosing their own. Combo, scatter, radar, pie and chartex charts write no fixed axis.
+- Chart parts of exported decks changed, so archives of chart decks are byte-different from 0.20 (the reviewed fixtures were re-pinned). `chart.highlight` is unchanged (see Chart emphasis above).
+
+## Quiet re-import of an unedited export (since 0.22.0)
+
+`fromPptx` of an unedited OPF export reports nothing. Before 0.22.0 it printed one `*-import-reflow` diagnostic per tagged group (about 14 on a six-slide deck), plus `unsupported-image-crop` for each picture.
+
+- **Text.** Each tagged text shape (heading, plain text, metric, quote, timeline, code and furniture lines) records a fingerprint of its geometry and native paragraphs as exported (`sig` in its tag). The `heading-`, `text-`, `metric-`, `quote-`, `timeline-`, `code-` and `furniture-import-reflow` diagnostics are reported only for a group whose shapes no longer match their fingerprint (a text edit, a moved or resized shape). A tag from an earlier version has no fingerprint and keeps reporting.
+- **Images.** Every image block is tagged (an empty treatment when it has none), so an unchanged picture imports without `unsupported-image-crop`. A block authored from a relative path or an http(s) URL also records that `src` and the picture's media key; import gives the authored `src` back while the picture bytes still hash the same. A data URI, an `asset:` reference, an absolute or parent-relative path and a `file:` URL are never recorded (a crafted PPTX could otherwise point a later export at another file), and a replaced picture keeps its data URI. A plain block whose picture was replaced or moved reads as an ordinary picture without a diagnostic.

package/dist/body-text-import.js

@@ -2,7 +2,8 @@
 // recovers authoring boundaries across separate native text shapes.
 import {XMLParser} from 'fast-xml-parser';
 import {drawingObject, readSlideTheme} from './background-import.js';
-import {nativeRunStyle, mergeNativeRunProperties} from './native-text-style.js';
+import {readBackgroundColor} from './background.js';
+import {nativeRunStyle, mergeNativeRunProperties, nativeTypeface} from './native-text-style.js';
 
 const parser = new XMLParser({ignoreAttributes:false, attributeNamePrefix:'', preserveOrder:true, parseAttributeValue:false, parseTagValue:false, trimValues:false, htmlEntities:true});
 const nodes = (tree, tag) => (tree ?? []).filter(node => Object.hasOwn(node, tag));
@@ -13,6 +14,42 @@ const text = tree => (tree ?? []).map(node => node['#text'] ?? '').join('');
 const shapes = tree => [...nodes(tree, 'p:sp').map(node => node['p:sp']), ...nodes(tree, 'p:grpSp').flatMap(node => shapes(node['p:grpSp']))];
 const LATIN_ONLY = /^[\p{Script=Latin}\p{N}\p{P}\p{S}\p{Z}]*$/u;
 const value = runs => runs.some(run => typeof run !== 'string') ? runs : runs.join('');
+const array = value => value === undefined ? [] : Array.isArray(value) ? value : [value];
+const bulletKeys = ['a:buNone', 'a:buChar', 'a:buBlip', 'a:buAutoNum'];
+
+// Only current, unambiguous body-placeholder bindings can inherit styles.
+// Undefined is an ordinary text box; null is an unresolved Body binding.
+function bodyInheritedStyles(shape, context, archive, slidePath) {
+  const ph = drawingObject(child(shape, 'p:nvSpPr'))['p:nvPr']?.['p:ph'];
+  if (!ph || Array.isArray(ph) || ph.type !== 'body') return undefined;
+  const placeholder = (root, reference) => {
+    const candidates = array(root?.['p:cSld']?.['p:spTree']?.['p:sp']).filter(shape => {
+      const current = shape['p:nvSpPr']?.['p:nvPr']?.['p:ph'];
+      return current && !Array.isArray(current) && current.type === 'body' && String(current.idx ?? '0') === String(reference.idx ?? '0');
+    });
+    return candidates.length === 1 ? candidates[0] : undefined;
+  };
+  const related = (part, type) => [...archive.relationships(part).values()].filter(rel => rel.type.endsWith('/' + type));
+  const layouts = related(slidePath, 'slideLayout');
+  if (layouts.length !== 1 || layouts[0].targetMode === 'External') return null;
+  const masters = related(layouts[0].path, 'slideMaster');
+  if (masters.length !== 1 || masters[0].targetMode === 'External') return null;
+  const layout = context.chain.find(part => part.path === layouts[0].path)?.root;
+  const master = context.chain.find(part => part.path === masters[0].path)?.root;
+  if (!layout || !master) return null;
+  const layoutShape = placeholder(layout, ph);
+  if (!layoutShape) return null;
+  const masterShape = placeholder(master, layoutShape['p:nvSpPr']['p:nvPr']['p:ph']);
+  if (!masterShape) return null;
+  return [layoutShape['p:txBody']?.['a:lstStyle'], masterShape?.['p:txBody']?.['a:lstStyle'], master['p:txStyles']?.['p:bodyStyle']];
+}
+
+function inheritedRunDefaults(styles, level) {
+  if (!styles || !Number.isInteger(level) || level < 1 || level > 9) return undefined;
+  const levels = [...styles].reverse().flatMap(style => [style?.['a:defPPr'], style?.[`a:lvl${level}pPr`]]);
+  if (styles.some(Array.isArray) || levels.some(value => Array.isArray(value) || Array.isArray(value?.['a:defRPr']))) return undefined;
+  return mergeNativeRunProperties(...levels.map(value => value?.['a:defRPr']));
+}
 export const joinNativeParagraphs = paragraphs => value(paragraphs.flatMap((paragraph, index) => [
   ...(index ? ['\n'] : []), ...(Array.isArray(paragraph.richText) ? paragraph.richText : [paragraph.richText ?? paragraph.text])
 ]));
@@ -47,7 +84,10 @@ function bodyRunStyle(properties, context, relationships, report, extras = {}) {
     report('unsupported-body-text-style', `Repeated native ${key} properties are ambiguous; current text was retained.`);
     delete supported[key];
   }
-  for (const key of ['a:ea','a:cs','a:sym']) if (properties[key]?.typeface && properties[key].typeface !== properties['a:latin']?.typeface) {
+  const latin = nativeTypeface(properties['a:latin']?.typeface, context)?.trim().toLowerCase();
+  for (const key of ['a:ea','a:cs','a:sym']) if (properties[key]?.typeface && (extras.inheritedBody
+    ? !latin || nativeTypeface(properties[key].typeface, context)?.trim().toLowerCase() !== latin
+    : properties[key].typeface !== properties['a:latin']?.typeface)) {
     report('unsupported-body-font', 'Script-specific native faces cannot be represented by one OPF run font family; the Latin face and current text were retained.');
   }
   if (properties['a:hlinkMouseOver']) report('unsupported-body-link', 'A native mouse-over action cannot be represented by an OPF run URL.');
@@ -68,12 +108,14 @@ function bodyRunStyle(properties, context, relationships, report, extras = {}) {
 }
 
 export function nativeBodyReader(slidePath, archive, relationships, report, extras = {}) {
-  let bodies, context;
+  let bodies, context, inheritedStyles;
   return index => {
     if (!bodies) {
       const tree = archive.part(slidePath, parser);
-      bodies = shapes(child(child(child(tree, 'p:sld'), 'p:cSld'), 'p:spTree')).map(shape => child(shape, 'p:txBody'));
+      const currentShapes = shapes(child(child(child(tree, 'p:sld'), 'p:cSld'), 'p:spTree'));
+      bodies = currentShapes.map(shape => child(shape, 'p:txBody'));
       context = readSlideTheme(slidePath, archive);
+      inheritedStyles = currentShapes.map(shape => bodyInheritedStyles(shape, context, archive, slidePath));
     }
     const body = bodies[index];
     if (!body) return undefined;
@@ -81,7 +123,17 @@ export function nativeBodyReader(slidePath, archive, relationships, report, extr
     return nodes(body, 'a:p').map((paragraph, paragraphIndex) => {
       const content = paragraph['a:p'], pPr = drawingObject(child(content, 'a:pPr'));
       const level = Number(nodes(content, 'a:pPr')[0]?.[':@']?.lvl ?? 0) + 1;
-      const defaults = mergeNativeRunProperties(listStyle['a:defPPr']?.['a:defRPr'], listStyle[`a:lvl${level}pPr`]?.['a:defRPr'], pPr['a:defRPr']);
+      const inheritedBody = inheritedStyles[index] !== undefined;
+      const defaults = mergeNativeRunProperties(inheritedRunDefaults(inheritedStyles[index], level), listStyle['a:defPPr']?.['a:defRPr'], listStyle[`a:lvl${level}pPr`]?.['a:defRPr'], pPr['a:defRPr']);
+      // Membership alone follows native paragraph/shape/layout/master precedence.
+      // A local buNone cancels all
+      // inherited bullets; missing bindings never recover stored source words.
+      const inherited = Number.isInteger(level) && level >= 1 && level <= 9 ? inheritedStyles[index] ?? [] : [];
+      const bulletProperties = [pPr, listStyle[`a:lvl${level}pPr`], listStyle['a:defPPr'],
+        ...inherited.flatMap(style => [style?.[`a:lvl${level}pPr`], style?.['a:defPPr']])]
+        .find(properties => properties && !Array.isArray(properties) && bulletKeys.some(key => Object.hasOwn(properties, key)));
+      const membership = bulletProperties ? {bullet: !Object.hasOwn(bulletProperties, 'a:buNone'), level: level - 1,
+        ...(bulletProperties['a:buAutoNum'] ? {autoNum: {type: bulletProperties['a:buAutoNum'].type, startAt: bulletProperties['a:buAutoNum'].startAt}} : {})} : {};
       const runs = [];
       let runIndex = 0;
       for (const node of content) {
@@ -92,10 +144,15 @@ export function nativeBodyReader(slidePath, archive, relationships, report, extr
         const properties = mergeNativeRunProperties(defaults, drawingObject(node[tag])['a:rPr']);
         // RR-05: a Latin phrase of a right-to-left paragraph is its own en-US run; its East Asian/complex-script slots can render nothing in it, so the face loss is not reported.
         const phrase = nodes(content, 'a:pPr')[0]?.[':@']?.rtl === '1' && properties.lang === 'en-US' && LATIN_ONLY.test(current);
-        const style = bodyRunStyle(properties, context, relationships, (code, message) => { if (!(phrase && code === 'unsupported-body-font')) report({code,message,path}); }, phrase ? {...extras, deckLang: undefined} : extras);
+        const style = bodyRunStyle(properties, context, relationships, (code, message) => { if (!(phrase && code === 'unsupported-body-font')) report({code,message,path}); }, {...extras, inheritedBody, ...(phrase ? {deckLang: undefined} : {})});
+        // Supported canonical forms may intentionally omit a resolved family
+        // (code:true) or the resolved theme hyperlink color (link without color).
+        const resolvedFill = style.color !== undefined || style.link && properties['a:solidFill'] && readBackgroundColor(properties['a:solidFill'], context);
+        if (current && inheritedBody && (!(style.fontFamily || style.code) || style.fontSize === undefined || !resolvedFill)) report({code: 'unsupported-body-inherited-style', path,
+          message: 'The current Body font family, point size or fill could not be fully resolved from its explicit styles and unambiguous layout/master cascade; current text was retained.'});
         if (current) runs.push(Object.keys(style).length ? {text:current,...style} : current);
       }
-      return {text:runs.map(run => typeof run === 'string' ? run : run.text).join(''), richText:value(runs)};
+      return {text:runs.map(run => typeof run === 'string' ? run : run.text).join(''), richText:value(runs), ...membership};
     });
   };
 }

package/dist/chart-scheme-colors.js

@@ -0,0 +1,47 @@
+// RR-89: chart series colours as theme colours.
+//
+// Core's chartSeriesPalette gives series i the deck scheme's accent (i + 1) for the first six series, or the chart's own
+// `chart.colors` entry. When the chart panel keeps that colour exactly (chartPaletteForFill only adjusts a colour that falls short of 3:1
+// contrast), the series is written as `<a:schemeClr val="accentN"/>` so re-theming the deck in PowerPoint recolours the chart, as
+// chart-highlight.js does for the highlight accent. A hex entry, a tint (series 7 to 12) and an adjusted colour stay `srgbClr`.
+const hex6 = value => String(value).replace(/^#/, '').toUpperCase();
+
+/**
+ * The scheme value (`accent1`, `tx2`, ...) of each palette colour that may be written as a theme colour, or undefined.
+ * `colors` is the chart's authored `colors`, `preferred` and `adjusted` the palette before and after the panel adjustment, `schemeFor`
+ * maps a colour reference and its resolved hex to a scheme value when the deck theme holds that colour (theme-colors.js). A colour the
+ * panel adjusted, a hex or variable entry and a tint (series 7 to 12) have none.
+ */
+export function chartPaletteSchemes(colors, preferred, adjusted, schemeFor) {
+  const authored = Array.isArray(colors) ? colors : [];
+  return preferred.map((color, index) => {
+    if (hex6(color) !== hex6(adjusted[index])) return undefined;
+    const entry = typeof authored[index] === 'string' ? authored[index].trim() : undefined;
+    if (entry !== undefined) return /^[A-Za-z]/.test(entry) ? schemeFor(entry, hex6(color)) : undefined;
+    return index < 6 ? schemeFor(`accent${index + 1}`, hex6(color)) : undefined;
+  });
+}
+
+const srgbIn = (block, hex, scheme) => block.replace(new RegExp(`<a:srgbClr val="${hex}"\\s*/>`, 'gi'), `<a:schemeClr val="${scheme}"/>`);
+
+/**
+ * Rewrite the series fills of a generated classic chart part to scheme colours. Series are matched to the palette by position (the
+ * generated part has one c:ser per plotted series in palette order; pie, doughnut and similar charts colour category i, one c:dPt each).
+ * Only series and point shape properties (c:spPr, and the marker's) are touched, never text properties.
+ */
+export function applyChartSchemeColors(xml, palette, schemes, {circular = false} = {}) {
+  if (!schemes?.some(Boolean)) return xml;
+  let seriesIndex = 0;
+  return xml.replace(/<c:ser>[\s\S]*?<\/c:ser>/g, ser => {
+    const index = seriesIndex++;
+    const rewrite = (block, colorIndex) => {
+      const scheme = schemes[colorIndex], hex = palette[colorIndex];
+      return scheme && hex ? block.replace(/<c:spPr>[\s\S]*?<\/c:spPr>/g, properties => srgbIn(properties, hex6(hex), scheme)) : block;
+    };
+    if (circular) {
+      return ser.replace(/<c:dPt>[\s\S]*?<\/c:dPt>/g, point => rewrite(point, Number(/<c:idx val="(\d+)"\/>/.exec(point)?.[1])));
+    }
+    // The series' own shape properties and markers, then its points (a bar series with several colours carries c:dPt).
+    return rewrite(ser, index);
+  });
+}

package/dist/code-provenance.js

@@ -25,12 +25,42 @@ export function codeManifest(value, layout, group, bands) {
 }
 
 export function attachCodeTags(entries, records) {
-  return attachTextTags(entries,records,TAG,'opfCode','code');
+  return attachTextTags(entries,records,TAG,'opfCode','code',{signed:true});
 }
 
 export {unhex as decodeTextTag, hex as encodeTextTag};
 
-export function attachTextTags(entries, records, tagName, prefix, kind, {pictures = false, descriptions} = {}) {
+// RR-94: a signed tag records a fingerprint of its shape as exported (the geometry and the native paragraphs). On import a group whose
+// shapes all still match their fingerprint is a pristine export: nothing was edited, so there is nothing to tell the user about.
+const cyrb53 = text => {
+  let h1 = 0xdeadbeef, h2 = 0x41c6ce57;
+  for (let i = 0; i < text.length; i++) {
+    const code = text.charCodeAt(i);
+    h1 = Math.imul(h1 ^ code, 2654435761);
+    h2 = Math.imul(h2 ^ code, 1597334677);
+  }
+  h1 = Math.imul(h1 ^ (h1 >>> 16), 2246822507) ^ Math.imul(h2 ^ (h2 >>> 13), 3266489909);
+  h2 = Math.imul(h2 ^ (h2 >>> 16), 2246822507) ^ Math.imul(h1 ^ (h1 >>> 13), 3266489909);
+  return (4294967296 * (2097151 & h2) + (h1 >>> 0)).toString(16).padStart(14, '0');
+};
+const fingerprint = (geometry, paragraphs) => cyrb53(JSON.stringify([geometry, paragraphs]));
+const wrapShape = shape => `<p:sld><p:cSld><p:spTree>${shape}</p:spTree></p:cSld></p:sld>`;
+function exportedSignature(shape) {
+  const frame = /<a:xfrm\b[^>]*>\s*<a:off x="(-?\d+)" y="(-?\d+)"\s*\/>\s*<a:ext cx="(\d+)" cy="(\d+)"\s*\/>/.exec(shape);
+  return fingerprint(frame ? frame.slice(1).map(Number) : [], nativeShapeParagraphs(wrapShape(shape))[0] ?? []);
+}
+/** True when every tagged text shape of an imported group still has the geometry and native text it was exported with. */
+export function groupUnchanged(items, paragraphs) {
+  return items.every(item => {
+    const shape = item.shape;
+    if (!shape || shape['p:nvPicPr']) return true;
+    const frame = shape['p:spPr']?.['a:xfrm'], off = frame?.['a:off'], ext = frame?.['a:ext'];
+    const geometry = off && ext ? [off.x, off.y, ext.cx, ext.cy].map(Number) : [];
+    return typeof item.data?.sig === 'string' && item.data.sig === fingerprint(geometry, paragraphs[item.index] ?? []);
+  });
+}
+
+export function attachTextTags(entries, records, tagName, prefix, kind, {pictures = false, descriptions, signed = false} = {}) {
   if (!records.size) return;
   let count = 0;
   const seen = new Set(), types = [];
@@ -48,7 +78,7 @@ export function attachTextTags(entries, records, tagName, prefix, kind, {picture
       let id = `rId${prefix[0].toUpperCase()+prefix.slice(1)}${count}`;
       while (ids.has(id)) id += '_';
       ids.add(id);
-      entries[part] = enc.encode(`<?xml version="1.0" encoding="UTF-8" standalone="yes"?><p:tagLst xmlns:p="${NS}"><p:tag name="${tagName}" val="${hex(records.get(name))}"/></p:tagLst>`);
+      entries[part] = enc.encode(`<?xml version="1.0" encoding="UTF-8" standalone="yes"?><p:tagLst xmlns:p="${NS}"><p:tag name="${tagName}" val="${hex(signed && shape.startsWith('<p:sp>') ? {...records.get(name), sig: exportedSignature(shape)} : records.get(name))}"/></p:tagLst>`);
       types.push(`<Override PartName="/${part}" ContentType="application/vnd.openxmlformats-officedocument.presentationml.tags+xml"/>`);
       rels = rels.replace('</Relationships>',`<Relationship Id="${id}" Type="${REL}" Target="../tags/${prefix}${count}.xml"/></Relationships>`);
       // Optional alternative text (a:cNvPr descr) for generated decoration such as the metric trend arrow.
@@ -218,7 +248,7 @@ export function importCodeGroups(shapes, paragraphs, relationships, entries, rep
       }
       for (const item of group) consumed.add(item.shape);
       items.push({shape:panel.shape,payload:{type:'code',code:typeof manifest.value === 'string' ? value.source : value}});
-      report({code:'code-import-reflow',message:'Code source boundaries and native text were recovered. Native positioning, formatting and font theme are not reconstructed; review the reflowed OPF.'});
+      if(!groupUnchanged(group,paragraphs))report({code:'code-import-reflow',message:'Code source boundaries and native text were recovered. Native positioning, formatting and font theme are not reconstructed; review the reflowed OPF.'});
     } catch (error) {
       report({code:'invalid-code-provenance',message:`${error.message} Visible native shapes were retained without restoring old source text.`});
     }

package/dist/furniture-fields.js

@@ -118,7 +118,17 @@ export function furniturePartFields(part) {
 /** True when a core text part carries at least one slide-number field. */
 export const hasSlideNumberField = part => furniturePartFields(part).some(field => field.type === 'slideNumber');
 
-export const SLIDE_NUMBER_TOKEN = '{{slide.number}}';
+/**
+ * True when the whole text of a core text part is one slide-number field (`{{slide.number}}` and nothing else): the only shape
+ * a native `sldNum` placeholder can carry. Words around the number (`Page 2 of 6`, `2 / 6`) make it an ordinary text box with the
+ * field, because Keynote (and Google Slides) show only the number of a slide-number placeholder and drop the literal runs.
+ */
+export function isBareSlideNumber(part) {
+  const fields = furniturePartFields(part);
+  return fields.length === 1 && fields[0].type === 'slideNumber' && fields[0].start === 0 && fields[0].end === part.text?.length;
+}
+
+export const SLIDE_NUMBER_TOKEN ='{{slide.number}}';
 // The slide-scoped tokens core substitutes per slide (core SLIDE_TOKEN_BODY): typed text that spells one must be
 // escaped, or the next export would turn it into a live value.
 const literalSlideToken = /\{\{(?=\s*(?:slide(?:\.[A-Za-z0-9_-]+){1,2}|deck\.slideCount)\s*(?:\|[^{}]*)?\}\})/g;
@@ -138,6 +148,9 @@ export function isBuiltinTemplate(text) {
   return true;
 }
 export const escapeSlideTokens = text => text.replace(literalSlideToken, '\\{{');
+// A current native literal is never a template, including already displayed
+// backslashes. Add one escape for each complete token using core's convention.
+export const escapeLiteralTokens = text => text.replace(anyToken, token => token.replace('{{', '\\{{'));
 
 /**
  * The zone `text` a native footer or header line stands for: every native slide-number field (`{type, text, start}`,

package/dist/furniture-provenance.js

@@ -1,11 +1,12 @@
 import {XMLParser} from 'fast-xml-parser';
-import {attachTextTags, decodeTextTag, encodeTextTag} from './code-provenance.js';
+import {attachTextTags, decodeTextTag, encodeTextTag, groupUnchanged} 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 {resolveLogo} from '@openpresentation/opf/composition';
 import {mediaKey} from './media-dedupe.js';
 import {NATIVE_PLACEHOLDERS, footerValue, isNativePlaceholderType, readNativePlaceholders} from './native-furniture.js';
+import {classifyNativeFooters} from './native-footer-classification.js';
 
 const TAG = 'OPF_FURNITURE_V1';
 // A slide has one tag list; it also carries the document's OPF_SLIDE_V1 record.
@@ -126,7 +127,7 @@ export function furnitureManifest(presentation, slide, layout, slideIndex, stati
 }
 
 export function attachFurnitureTags(entries, records, manifests) {
-  attachTextTags(entries, records, TAG, 'opfFurniture', 'furniture', {pictures: true});
+  attachTextTags(entries, records, TAG, 'opfFurniture', 'furniture', {pictures: true, signed: true});
   const types = [];
   for (const [path, manifest] of manifests) {
     const part = `ppt/tags/opfFurnitureSlide${manifest.group}.xml`;
@@ -390,7 +391,8 @@ function readSlide(context, entries, slideIndex, slideCount, report, taggedText,
       if (value !== false) for (const zone of zones) if (definition.value[zone] !== undefined) {
         value[zone] = Object.fromEntries(Object.entries(definition.value[zone]).filter(([, flag]) => flag === false));
       }
-      const candidate = {scope: definition.scope, value, text: [], pictures: [], socials: []};
+      // RR-94: pristine while every tagged text shape still has the geometry and text it was exported with (a picture is not compared).
+      const candidate = {scope: definition.scope, value, text: [], pictures: [], socials: [], pristine: 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('.');
@@ -433,6 +435,7 @@ function readSlide(context, entries, slideIndex, slideCount, report, taggedText,
             check(count === part.count && Number.isSafeInteger(line) && line >= 0 && line < part.count && !ordered[line], 'Ambiguous furniture line.');
             ordered[line] = record;
           }
+          if (!groupUnchanged(ordered.map(record => ({shape: source.shapes?.[record.index] ?? {}, index: record.index, data: record.data})), paragraphs)) candidate.pristine = false;
           const text = sourceLineParagraphs(ordered, paragraphs)[0].text;
           const format = manifest.formats?.[`${kind}.${part.zone}`] ?? {};
           if (part.field === 'socials') {
@@ -446,6 +449,7 @@ function readSlide(context, entries, slideIndex, slideCount, report, taggedText,
         } 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.
+          candidate.pristine = false;
           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') {
@@ -462,6 +466,7 @@ function readSlide(context, entries, slideIndex, slideCount, report, taggedText,
         // The slide no longer follows the deck's definition: it is its own override, and the other slides can still agree.
         candidate.scope = 'local';
         candidate.derived = true;
+        candidate.pristine = false;
         if (value !== false) {
           for (const zone of Object.keys(value)) if (!Object.keys(value[zone]).length) delete value[zone];
           if (!Object.keys(value).length) candidate.value = false;
@@ -527,13 +532,16 @@ export function importFurniture(contexts, entries, onDiagnostic, {sections = [],
     const slide = candidates[index];
     const claimed = new Set([...taggedText[index], ...Object.values(slide).flatMap(candidate => candidate.text)]);
     const fields = readNativePlaceholders(context, claimed, context.relationshipsOf, context.readPart);
-    if (!fields.length) return;
     const existing = slide.footer, accepted = [];
     for (const item of fields) {
       const current = existing && existing.value !== false ? existing.value[item.zone]?.[item.field] : undefined;
+      if (existing) existing.pristine = false;
       if (current !== undefined && current !== false) report(index, `footer.${item.zone}.${item.field}: A native PowerPoint placeholder duplicates a furniture part already read; it stays ordinary current text.`);
       else accepted.push(item);
     }
+    const occupied = new Set(accepted.filter(item => item.field === 'text').map(item => item.zone));
+    for (const zone of zones) if (existing?.value && existing.value[zone]?.text !== undefined && existing.value[zone].text !== false) occupied.add(zone);
+    accepted.push(...classifyNativeFooters(context, claimed, accepted, occupied, diagnostic => onDiagnostic?.({...diagnostic, path: `slides.${index}.${diagnostic.path}`})));
     if (!accepted.length) return;
     const merged = footerValue(accepted), indexes = accepted.map(item => item.index);
     if (!existing) slide.footer = {scope: 'native', value: merged, text: indexes, pictures: [], socials: []};
@@ -580,6 +588,6 @@ export function importFurniture(contexts, entries, onDiagnostic, {sections = [],
       });
     }
   }
-  candidates.forEach((slide, index) => { if (Object.keys(slide).length) onDiagnostic?.({code: 'furniture-import-reflow', path: `slides.${index}.design`, message: 'Complete furniture roles retain current text, source line boundaries, image content and unambiguous metadata. Native formatting, positioning, crop and other presentation metadata are not reconstructed; review the reflowed furniture.'}); });
+  candidates.forEach((slide, index) => { if (Object.values(slide).some(candidate => candidate.pristine !== true)) onDiagnostic?.({code: 'furniture-import-reflow', path: `slides.${index}.design`, message: 'Complete furniture roles retain current text, source line boundaries, image content and unambiguous metadata. Native formatting, positioning, crop and other presentation metadata are not reconstructed; review the reflowed furniture.'}); });
   return result;
 }

package/dist/heading-provenance.js

@@ -1,11 +1,11 @@
 import {XMLParser} from 'fast-xml-parser';
-import {attachTextTags,decodeTextTag} from './code-provenance.js';
+import {attachTextTags,decodeTextTag,groupUnchanged} from './code-provenance.js';
 import {sourceLineParagraphs} from './text-provenance.js';
 import {cleanBase,headingValue,joinRichLines} from './rich-heading.js';
 const TAG='OPF_HEADING_V1',REL='http://schemas.openxmlformats.org/officeDocument/2006/relationships/tags';
 const parser=new XMLParser({ignoreAttributes:false,attributeNamePrefix:'',parseTagValue:false,trimValues:false});
 const decoder=new TextDecoder('utf-8',{fatal:true}),array=value=>value===undefined?[]:Array.isArray(value)?value:[value];
-export const attachHeadingTags=(entries,records)=>attachTextTags(entries,records,TAG,'opfHeading','heading');
+export const attachHeadingTags=(entries,records)=>attachTextTags(entries,records,TAG,'opfHeading','heading',{signed:true});
 
 // Tags carry only roles and line ordering. Current native text always wins;
 // neither original source text nor old geometry can be restored from these tags.
@@ -45,7 +45,7 @@ export function importHeadingGroups(shapes,paragraphs,relationships,entries,repo
     const base=cleanBase(ordered[0].data.base);
     const parts=base?joinRichLines(ordered,readBody,(item,last)=>source?item.data.separator:last?'':'\n'):undefined;
     items.push({field:first.field,shapes:ordered.map(item=>item.shape),paragraphs:restored,...(parts?{richText:headingValue(parts,base)}:{})});
-    report({code:'heading-import-reflow',message:'Complete tagged heading lines retain their roles, order and current native text. New boundary tags also retain authored whitespace and line endings; legacy tags retain native line breaks. Run formatting that differs between words is read back as TextRun[]; geometry is not reconstructed.'});
+    if(!groupUnchanged(ordered,paragraphs))report({code:'heading-import-reflow',message:'Complete tagged heading lines retain their roles, order and current native text. New boundary tags also retain authored whitespace and line endings; legacy tags retain native line breaks. Run formatting that differs between words is read back as TextRun[]; geometry is not reconstructed.'});
   }catch(error){report({code:'invalid-heading-provenance',message:`${error.message} Ordinary import retains visible native text.`});}
   return {consumed,items};
 }