@openpresentation/opf-pptx 0.20.4 → 0.22.1

package/dist/native-body.js

@@ -0,0 +1,147 @@
+// RR-86 opt-in prototype. Native paragraphs trade measured line positions for a
+// single editable body. No source words or per-line recovery tags are stored.
+import {paragraphDirection, resolveTextStyle} from '@openpresentation/opf/composition';
+import {autoNumScheme} from './numbered-list.js';
+
+const FIELDS = new Set(['text', 'items', 'bullets']);
+const RUN_KEYS = new Set(['text', 'bold', 'italic', 'underline', 'strikethrough', 'color', 'fontFamily', 'fontSize', 'lang', 'link']);
+const runsOf = value => typeof value === 'string' ? [{text: value}] : value;
+const ownText = value => Array.isArray(value) ? value.map(run => typeof run === 'string' ? run : run?.text ?? '').join('') : value;
+const richSupported = value => typeof value === 'string' || Array.isArray(value) && value.every(run => typeof run === 'string' || run && typeof run.text === 'string' && Object.keys(run).every(key => RUN_KEYS.has(key)) && (run.link === undefined || /^(https?:|mailto:|tel:)/i.test(run.link)));
+// An LTR deck does not ask core for paragraph directions. Conservatively reject
+// RTL letters anywhere (including an embedded phrase), using core's own script rule.
+const hasRtl = text => [...text].some(char => /\p{L}/u.test(char) && paragraphDirection(char, 'rtl') === 'rtl');
+const escapeXml = value => String(value).replace(/[&<>"']/g, char => ({'&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&apos;'}[char]));
+
+/**
+ * Plan the native bodies of one slide: every text, list or bullets item that can be one editable body, in composition order.
+ * The first is returned with the rest as `others`; the first alone binds to the Body placeholder, each other one is an ordinary
+ * native text box at its region (RR-88). An item that cannot be a native body falls back to measured shapes with a visible diagnostic.
+ */
+export function planNativeBody(slide, geometry, {automatic = false, report = () => {}} = {}) {
+  const candidates = geometry.items.filter(item => FIELDS.has(item.field));
+  const reject = (item, reason) => report({code: 'native-body-fallback', path: item.path, reason,
+    message: `Native body export cannot represent this ${reason.replaceAll('-', ' ')}; the current measured shapes were exported.`});
+  if (!candidates.length) return undefined;
+  if (geometry.groups.length) {
+    candidates.forEach(item => reject(item, 'complex-composition'));
+    return undefined;
+  }
+  const plans = [];
+  for (const item of candidates) {
+    const plan = planOne(item, geometry, automatic, reason => reject(item, reason));
+    if (plan) plans.push(plan);
+  }
+  return plans.length ? {...plans[0], others: plans.slice(1)} : undefined;
+}
+
+function planOne(item, geometry, automatic, reject) {
+  const region = geometry.regions?.find(region => region.name === item.region);
+  if (!/^slides\.\d+\.(?:blocks\.\d+\.|[A-Za-z][A-Za-z0-9+_-]*\.)?(?:text|items|bullets)$/.test(item.path) || !automatic && (!region || region.collapsed || region.content.length !== 1 || region.overflow?.length) || item.frameBox) {
+    reject('complex-composition'); return undefined;
+  }
+  if (item.listColumns?.length > 1) { reject('multi-column'); return undefined; }
+  if (item.text?.overflow) { reject('overflow'); return undefined; }
+  if (geometry.direction === 'rtl' || item.text?.directions?.includes('rtl')) { reject('unsupported-text'); return undefined; }
+  const list = item.field !== 'text';
+  let values, numbering;
+  if (list) {
+    const entries = item.text?.listEntries;
+    if (item.bulletImage || !entries?.length || entries.some(entry => entry.level !== 0 || entry.description) ||
+      item.value.some(entry => entry && !Array.isArray(entry) && typeof entry === 'object' && Object.keys(entry).some(key => key !== 'text' && key !== 'level'))) {
+      reject('unsupported-list'); return undefined;
+    }
+    if (item.payload?.numbering !== undefined) {
+      // One native numbered sequence: every entry has a number of one style and suffix, counting up from the first by one.
+      numbering = nativeNumbering(entries);
+      if (!numbering) { reject('unsupported-list'); return undefined; }
+    }
+    values = item.value.map(entry => entry && !Array.isArray(entry) && typeof entry === 'object' ? entry.text : entry);
+    if (values.some(value => /[\r\n]/.test(ownText(value)))) { reject('unsupported-list'); return undefined; }
+  } else values = [item.value];
+  if (values.some(value => !richSupported(value))) {
+    reject(values.some(value => Array.isArray(value) && value.some(run => run?.cite !== undefined || run?.footnote !== undefined)) ? 'annotated-text' : 'unsupported-text');
+    return undefined;
+  }
+  if (values.some(value => hasRtl(ownText(value)) || /\t|[\u0000-\u0008\u000B\u000C\u000E-\u001F\u061C\u200E\u200F\u202A-\u202E\u2066-\u2069]/.test(ownText(value))) || !values.some(value => ownText(value).length)) {
+    reject('unsupported-text'); return undefined;
+  }
+  return {item, values, list, ...(numbering ? {numbering} : {}), region: region?.name ?? 'Body', box: {...(region?.box ?? item.box)}, anchor: region?.anchor ?? 'top'};
+}
+
+// RR-88: the native auto-number (`a:buAutoNum`) that reproduces core's markers, or undefined when the entries are not one sequence.
+function nativeNumbering(entries) {
+  const first = entries[0]?.marker?.number;
+  if (!first || !Number.isInteger(first.value) || first.value < 1) return undefined;
+  const scheme = autoNumScheme(first.style, first.suffix);
+  return entries.every((entry, index) => {
+    const number = entry.marker?.number;
+    return number && number.value === first.value + index && autoNumScheme(number.style, number.suffix) === scheme;
+  }) ? {style: scheme, startAt: first.value} : undefined;
+}
+
+/** Whole authored paragraphs, retaining hard breaks only. Styling uses selected native families. */
+export function addNativeBody(slide, plan, context, options, helpers) {
+  const {item, values, list, box, anchor} = plan;
+  const base = item.textStyle;
+  const baseFont = helpers.nativeFontOptions(base);
+  const paragraphs = [];
+  for (const value of values) {
+    let paragraph = [];
+    paragraphs.push(paragraph);
+    for (const source of runsOf(value)) {
+      const run = typeof source === 'string' ? {text: source} : source;
+      const style = resolveTextStyle({...base, fontFamily: run.fontFamily ?? base.fontFamily,
+        fontWeight: run.bold === undefined ? base.fontWeight : run.bold ? 700 : 400, italic: run.italic ?? base.italic}, options.textMeasurement);
+      const hex = helpers.exportColor(run.color, context, context.colors.text);
+      const color = helpers.linkColor(run, helpers.nativeColor(run.color, hex, context, context.textColor), context);
+      const runOptions = {...helpers.nativeFontOptions(style), fontSize: run.fontSize ?? item.text.fontSize * .75,
+        color, transparency: hex.length === 8 ? (1 - parseInt(hex.slice(6), 16) / 255) * 100 : 0,
+        underline: run.underline ? {style: 'sng', color} : {style: 'none'}, strike: run.strikethrough ? 'sngStrike' : undefined,
+        hyperlink: run.link && /^(https?:|mailto:|tel:)/i.test(run.link) ? {url: run.link} : undefined, ...helpers.langOptions(context, run.lang)};
+      const pieces = run.text.split(/\r\n|\r|\n/);
+      pieces.forEach((text, index) => {
+        if (index) { paragraph = []; paragraphs.push(paragraph); }
+        paragraph.push({text, options: {...runOptions}});
+      });
+    }
+  }
+  const indent = list ? item.text.listEntries[0].marker.indent * .75 : undefined;
+  const paragraphOptions = !list ? {bullet: false} : plan.numbering ? {bullet: {type: 'number', style: plan.numbering.style, startAt: plan.numbering.startAt, indent}, hanging: indent / 4, indentLevel: 0}
+    : {bullet: {characterCode: '2022', indent}, hanging: indent / 4, indentLevel: 0};
+  const runs = paragraphs.flatMap((paragraph, index) => {
+    if (!paragraph.length) paragraph = [{text: '', options: {}}];
+    return paragraph.map((run, position) => ({...run, options: {...run.options, ...paragraphOptions,
+      breakLine: position === paragraph.length - 1 && index < paragraphs.length - 1}}));
+  });
+  const objectName = `OPF native body ${item.path}`;
+  slide.addText(runs, {...helpers.textBoxOptions({x: box.x / 96, y: box.y / 96, w: box.width / 96, h: box.height / 96}, context, item.text.fontSize * .75),
+    ...baseFont, ...paragraphOptions, objectName, align: item.alignment ?? 'left', valign: {top: 'top', middle: 'mid', bottom: 'bottom'}[anchor],
+    fit: 'none', wrap: true, lineSpacingMultiple: 1.22, bold: false, italic: false});
+  // Defaults for blank/appended paragraphs must name the selected family too.
+  const defaults = `<a:defRPr sz="${Math.round(item.text.fontSize * 75)}" b="${baseFont.bold ? 1 : 0}" i="${baseFont.italic ? 1 : 0}"><a:solidFill>${helpers.solidColorXml(context.textColor)}</a:solidFill><a:latin typeface="${escapeXml(baseFont.fontFace)}"/></a:defRPr>`;
+  return {objectName, defaults};
+}
+
+/** RR-88: a native title is written with an explicit no-autofit body, so the Title placeholder's own autofit cannot shrink or move it. */
+export function nativeTitleAutofit(xml, names) {
+  if (!names?.size) return xml;
+  return xml.replace(/<p:sp>[\s\S]*?<\/p:sp>/g, shape => names.has(shape.match(/<p:cNvPr\b[^>]*\bname="([^"]*)"/)?.[1])
+    ? shape.replace(/(<a:bodyPr\b[^>]*>)[\s\S]*?<\/a:bodyPr>/, '$1<a:noAutofit/></a:bodyPr>') : shape);
+}
+
+/** Only prototype objects receive explicit no-autofit and paragraph typing defaults. */
+export function nativeBodyDefaults(xml, records) {
+  if (!records?.size) return xml;
+  return xml.replace(/<p:sp>[\s\S]*?<\/p:sp>/g, shape => {
+    const name = shape.match(/<p:cNvPr\b[^>]*\bname="([^"]*)"/)?.[1];
+    const defaults = records.get(name);
+    if (!defaults) return shape;
+    shape = shape.replace(/(<a:bodyPr\b[^>]*>)[\s\S]*?<\/a:bodyPr>/, '$1<a:noAutofit/></a:bodyPr>');
+    const pPr = shape.match(/<a:pPr\b[^>]*(?:\/>|>[\s\S]*?<\/a:pPr>)/)?.[0] ?? '<a:pPr/>';
+    const paragraphDefault = pPr.replace(/<a:pPr\b/, '<a:defPPr').replace(/<\/a:pPr>/, '</a:defPPr>').replace(/<a:defRPr\b[^>]*(?:\/>|>[\s\S]*?<\/a:defRPr>)/g, '');
+    const withDefaults = paragraphDefault.endsWith('/>') ? paragraphDefault.slice(0, -2) + `>${defaults}</a:defPPr>` : paragraphDefault.replace('</a:defPPr>', `${defaults}</a:defPPr>`);
+    shape = shape.replace(/<a:lstStyle\s*\/>/, `<a:lstStyle>${withDefaults}</a:lstStyle>`);
+    return shape.replace(/<a:endParaRPr\b[^>]*(?:\/>|>[\s\S]*?<\/a:endParaRPr>)/g, defaults.replaceAll('a:defRPr', 'a:endParaRPr'));
+  });
+}

package/dist/native-footer-classification.js

@@ -0,0 +1,104 @@
+// Bounded current-native fallback for generated literals whose ftr role was
+// stripped. No source words, tags, geometry or fonts are replayed.
+import {escapeLiteralTokens} from './furniture-fields.js';
+
+const array = value => value === undefined ? [] : Array.isArray(value) ? value : [value];
+const object = value => value !== null && typeof value === 'object' && !Array.isArray(value);
+const nameOf = shape => shape?.['p:nvSpPr']?.['p:cNvPr']?.name;
+const generatedName = name => {
+  const match = typeof name === 'string' && /^OPF furniture (0|[1-9]\d*) part (0|[1-9]\d*) line 0$/.exec(name);
+  return match && match.slice(1).every(value => Number.isSafeInteger(Number(value))) ? {group: match[1], part: match[2]} : undefined;
+};
+const contains = (node, keys) => object(node) ? Object.entries(node).some(([key, value]) => keys.includes(key) || contains(value, keys)) : Array.isArray(node) && node.some(value => contains(value, keys));
+const integer = value => (typeof value === 'number' || typeof value === 'string' && /^-?\d+$/.test(value)) && Number.isSafeInteger(Number(value));
+const disabled = value => value === undefined || ['0','false','off'].includes(String(value));
+
+function frame(shape, width, height) {
+  const transform = shape['p:spPr']?.['a:xfrm'];
+  if (!object(transform) || transform.rot !== undefined && (!integer(transform.rot) || Number(transform.rot) !== 0) || !disabled(transform.flipH) || !disabled(transform.flipV)) return undefined;
+  if (![transform['a:off']?.x, transform['a:off']?.y, transform['a:ext']?.cx, transform['a:ext']?.cy].every(integer)) return undefined;
+  const x = Number(transform['a:off']?.x), y = Number(transform['a:off']?.y), cx = Number(transform['a:ext']?.cx), cy = Number(transform['a:ext']?.cy);
+  if (![x,y,cx,cy,width,height].every(Number.isSafeInteger) || !(cx > 0 && cy > 0 && width > 0 && height > 0)) return undefined;
+  const [X,Y,CX,CY,W,H] = [x,y,cx,cy,width,height].map(BigInt);
+  if (X < 0n || Y < 0n || X + CX > W || Y + CY > H || 10n * Y < 9n * H || 20n * CY > H || 3n * CX > W) return undefined;
+  const center = 3n * (2n * X + CX);
+  return {x,y,cx,cy,zone: center < 2n * W ? 'left' : center > 4n * W ? 'right' : 'center'};
+}
+
+function plainFrame(shape) {
+  const body = shape['p:txBody'], raw = body?.['a:bodyPr'], props = raw === '' ? {} : raw;
+  if (!object(body) || !object(props) || props.rot !== undefined && (!integer(props.rot) || Number(props.rot) !== 0) || ![undefined,'horz'].includes(props.vert) || ![undefined,'none'].includes(props.wrap) ||
+    ['lIns','tIns','rIns','bIns'].some(key => !Number.isFinite(Number(props[key] ?? 0)) || Number(props[key] ?? 0) < 0) ||
+    !disabled(shape['p:nvSpPr']?.['p:cNvPr']?.hidden) || contains(shape, ['a:hlinkClick','a:hlinkMouseOver','a:br','a:tab','a:fld','a:effectLst','a:effectDag','a14:m','m:oMath','m:oMathPara','mc:AlternateContent'])) return false;
+  return true;
+}
+
+function plainShape(shape, context) {
+  if (!plainFrame(shape) || shape['p:txBody']['a:bodyPr'].wrap !== 'none') return undefined;
+  const body = shape['p:txBody'];
+  const paragraphs = array(body['a:p']);
+  if (paragraphs.length !== 1 || !object(paragraphs[0])) return undefined;
+  const paragraph = paragraphs[0], run = paragraph['a:r'], pPr = paragraph['a:pPr'];
+  if ([pPr, body['a:lstStyle'], run?.['a:rPr']].some(value => value !== undefined && value !== '' && !object(value))) return undefined;
+  if (!object(run) || paragraph['a:fld'] !== undefined || Number(pPr?.lvl ?? 0) !== 0) return undefined;
+  const text = typeof run['a:t'] === 'string' ? run['a:t'] : object(run['a:t']) && typeof run['a:t']['#text'] === 'string' ? run['a:t']['#text'] : undefined;
+  if (text === undefined || /[\r\n\t]/.test(text)) return undefined;
+  const other = context.inherited?.().master?.root?.['p:txStyles']?.['p:otherStyle'];
+  const defaults = style => style === undefined || style === '' || object(style)
+    ? [style?.['a:lvl1pPr'], style?.['a:defPPr']] : [style];
+  const sources = [pPr, ...defaults(body['a:lstStyle']), ...defaults(other), ...defaults(context.defaultTextStyle)];
+  for (const source of sources) {
+    if (source === undefined || source === '') continue;
+    if (!object(source)) return undefined;
+    const membership = ['a:buNone','a:buChar','a:buAutoNum','a:buBlip'].filter(key => Object.hasOwn(source, key));
+    if (membership.length) return membership.length === 1 && membership[0] === 'a:buNone' ? text : undefined;
+  }
+  return undefined;
+}
+
+/** Native number witnesses must already have passed higher-priority collision checks. */
+export function classifyNativeFooters(context, claimed, accepted, occupied, report) {
+  const result = [], candidates = [], topLevel = new Set(array(context.root?.['p:cSld']?.['p:spTree']?.['p:sp']));
+  const names = new Map();
+  const inventory = node => {
+    if (Array.isArray(node)) return node.forEach(inventory);
+    if (!object(node)) return;
+    for (const [key, value] of Object.entries(node)) {
+      if (key === 'p:cNvPr' && typeof value?.name === 'string') names.set(value.name, (names.get(value.name) ?? 0) + 1);
+      inventory(value);
+    }
+  };
+  inventory(context.root);
+  // No complete cross-role ownership registry exists here. Any surviving
+  // customer binding conservatively reserves the whole slide from this fallback.
+  const tagged = contains(context.root, ['p:custDataLst']);
+  const witnesses = accepted.filter(field => field.ph === 'sldNum').map(field => {
+    const shape = context.shapes[field.index], name = nameOf(shape), identity = generatedName(name);
+    const p = shape?.['p:txBody']?.['a:p'], fld = p?.['a:fld'];
+    const withoutField = object(p) ? {...p} : {};
+    delete withoutField['a:fld'];
+    const bounds = shape && frame(shape, context.slideWidth, context.slideHeight);
+    return !claimed.has(field.index) && !contains(fld, ['a:hlinkClick','a:hlinkMouseOver','a:br','a:tab','a14:m','m:oMath','m:oMathPara']) && identity && names.get(name) === 1 && topLevel.has(shape) && object(p) && object(fld) && plainFrame({...shape, 'p:txBody': {...shape['p:txBody'], 'a:p': withoutField}}) && fld.type === 'slidenum' && p['a:r'] === undefined && bounds
+      ? {identity, bounds, index: field.index} : undefined;
+  }).filter(Boolean);
+  for (const [index, shape] of context.shapes.entries()) {
+    const name = nameOf(shape), identity = generatedName(name);
+    if (!identity || claimed.has(index) || shape['p:nvSpPr']?.['p:nvPr']?.['p:ph'] !== undefined) continue;
+    const refuse = reason => report({code: 'unclassified-native-footer', path: `shapes.${index}`, message: `The current generated-name literal remains content: ${reason}.`});
+    // A cleared shape is not a reason to recover words or warn about absence.
+    const current = (context.paragraphs[index] ?? []).map(value => value.text).join('\n');
+    if (!current.trim()) continue;
+    if (tagged) {refuse('a current customer-tag binding reserves ownership'); continue;}
+    const bounds = frame(shape, context.slideWidth, context.slideHeight), text = plainShape(shape, context);
+    if (names.get(name) !== 1 || !topLevel.has(shape) || !bounds || text === undefined) {refuse('identity, own footer-band frame or plain unbulleted text is unsupported'); continue;}
+    const anchors = witnesses.filter(anchor => anchor.identity.group === identity.group && anchor.identity.part !== identity.part && anchor.bounds.y === bounds.y && anchor.bounds.cy === bounds.cy);
+    if (anchors.length !== 1) {refuse('there is no unique accepted same-group live-number row'); continue;}
+    if (occupied.has(bounds.zone)) {refuse('higher-priority furniture already owns this zone'); continue;}
+    candidates.push({index, identity, bounds, text, refuse});
+  }
+  for (const item of candidates) {
+    if (candidates.filter(other => other.identity.group === item.identity.group).length !== 1 || candidates.filter(other => other.bounds.zone === item.bounds.zone).length !== 1) {item.refuse('several current literal candidates are ambiguous'); continue;}
+    result.push({index: item.index, zone: item.bounds.zone, ph: 'ftr', field: 'text', value: escapeLiteralTokens(item.text), settings: {}});
+  }
+  return result;
+}

package/dist/native-furniture.js

@@ -16,7 +16,7 @@
 // or where core would draw a default footer when no slide has one.
 
 import {XMLParser} from 'fast-xml-parser';
-import {DEFAULT_DATE_FORMAT, NATIVE_DATE_FIELDS, formatDate, hasSlideNumberField, slideNumberTemplate} from './furniture-fields.js';
+import {DEFAULT_DATE_FORMAT, NATIVE_DATE_FIELDS, formatDate, hasSlideNumberField, isBareSlideNumber, slideNumberTemplate} from './furniture-fields.js';
 
 const enc = new TextEncoder(), dec = new TextDecoder('utf-8', {fatal: true});
 const parser = new XMLParser({ignoreAttributes: false, attributeNamePrefix: '', parseTagValue: false, trimValues: false});
@@ -35,11 +35,14 @@ export const isNativePlaceholderType = value => Object.hasOwn(NATIVE_PLACEHOLDER
 /**
  * The placeholder type a core footer part maps to: a date is `dt`; a zone `text` with a slide-number field
  * (`{{slide.number}}`) is `sldNum`, its words around the field fixed runs; any other zone `text` is `ftr`.
+ * With `staticNumbers` (`slideNumberFields: 'static'`, the default, RR-91) a number with words around it is written as fixed text in an
+ * ordinary shape, so it has no placeholder: Keynote shows only the number of a slide-number placeholder or field.
  */
-export function nativePlaceholderForPart(part) {
+export function nativePlaceholderForPart(part, {staticNumbers = false} = {}) {
   if (part.type !== 'text') return undefined;
   if (part.field === 'date') return 'dt';
   if (part.field !== 'text') return undefined;
+  if (staticNumbers && hasSlideNumberField(part) && !isBareSlideNumber(part)) return undefined;
   return hasSlideNumberField(part) ? 'sldNum' : 'ftr';
 }
 const ZONES = ['left', 'center', 'right'];
@@ -50,10 +53,10 @@ const ALIGN = {left: 'l', center: 'ctr', right: 'r'};
  * footer text, the first footer date and the first footer text with a slide-number
  * field whose text fits one accepted line. Returns Map<partIndex, 'dt'|'ftr'|'sldNum'>.
  */
-export function nativeFurnitureParts(layout) {
+export function nativeFurnitureParts(layout, options) {
   const chosen = new Map(), taken = new Set();
   for (const [index, part] of (layout?.parts ?? []).entries()) {
-    const ph = nativePlaceholderForPart(part);
+    const ph = nativePlaceholderForPart(part, options);
     if (part.kind !== 'footer' || !ph || taken.has(ph)) continue;
     // One native shape holds one line; a part that wraps or breaks stays tagged shapes.
     if (part.fit?.sourceLines?.length !== 1 || part.fit.lines?.length !== 1 || !part.text || part.links?.length) continue;
@@ -79,9 +82,11 @@ const guid = (kind, n) => `{0F0F2701-${kind}-4000-8000-${n.toString(16).toUpperC
  * attached: the shape keeps its name, geometry, runs, fields and tags, and gains
  * `p:ph` (a placeholder is a text shape the layout can supply defaults for).
  * `bands` maps a generated object name to its zone's band (`{x, width}` in pixels) for a part narrower than its zone.
+ * `footerText: 'shape'` omits only the slide-local literal ftr binding. Keep locks, selection and master/layout bookkeeping
+ * unchanged: the measured shape stays on its slide and all other generated package parts retain their normal semantics.
  * Returns the placeholders in use and the first geometry/alignment seen per type.
  */
-export function attachNativePlaceholders(entries, records, bands = new Map()) {
+export function attachNativePlaceholders(entries, records, bands = new Map(), footerText = 'native') {
   const used = new Set(), first = new Map(), seen = new Set();
   if (!records.size) return {used, first};
   const slides = Object.keys(entries).filter(path => /^ppt\/slides\/slide\d+\.xml$/.test(path)).sort((a, b) => Number(a.match(/\d+/)[0]) - Number(b.match(/\d+/)[0]));
@@ -97,7 +102,7 @@ export function attachNativePlaceholders(entries, records, bands = new Map()) {
       if (!/<p:cNvSpPr\b[^>]*\/>/.test(shape)) throw new Error('Generated furniture shape has no plain shape properties.');
       shape = shape.replace(/<p:cNvSpPr\b([^>]*)\/>/, '<p:cNvSpPr$1><a:spLocks noGrp="1"/></p:cNvSpPr>').replace(/<p:nvPr\s*\/>/, '<p:nvPr></p:nvPr>');
       if (!shape.includes('<p:nvPr>')) throw new Error('Generated furniture shape has no native application properties.');
-      shape = shape.replace('<p:nvPr>', `<p:nvPr><p:ph type="${ph}" sz="${properties.sz}" idx="${properties.idx}"/>`);
+      if (ph !== 'ftr' || footerText !== 'shape') shape = shape.replace('<p:nvPr>', `<p:nvPr><p:ph type="${ph}" sz="${properties.sz}" idx="${properties.idx}"/>`);
       used.add(ph);
       if (!first.has(ph)) {
         const geometry = shape.match(/<a:off x="(-?\d+)" y="(-?\d+)"\/><a:ext cx="(\d+)" cy="(\d+)"\/>/);
@@ -235,28 +240,58 @@ function xfrmBounds(xfrm) {
   return [x, y, cx, cy].every(Number.isFinite) && cx > 0 ? {x, y, cx, cy} : undefined;
 }
 
-// A placeholder without its own xfrm inherits it: slide -> layout (same idx, else same
+// A placeholder without its own xfrm (or alignment) inherits it: slide -> layout (same idx, else same
 // type) -> master (same type). Parsed layout/master trees are cached per package read.
-function inheritedBounds(shape, ph, slidePath, relationships, readPart) {
-  const own = xfrmBounds(shape['p:spPr']?.['a:xfrm']);
-  if (own) return own;
+function placeholderChain(shape, ph, slidePath, relationships, readPart) {
+  const chain = [shape];
   const index = shape['p:nvSpPr']?.['p:nvPr']?.['p:ph']?.idx;
   const find = (path, byIdx) => {
     const tree = readPart(path)?.[path.includes('slideMaster') ? 'p:sldMaster' : 'p:sldLayout']?.['p:cSld']?.['p:spTree'];
     const candidates = array(tree?.['p:sp']).filter(candidate => candidate['p:nvSpPr']?.['p:nvPr']?.['p:ph']?.type === ph);
-    const match = (byIdx && index !== undefined ? candidates.find(candidate => candidate['p:nvSpPr']['p:nvPr']['p:ph'].idx === index) : undefined) ?? candidates[0];
-    return match ? xfrmBounds(match['p:spPr']?.['a:xfrm']) : undefined;
+    return (byIdx && index !== undefined ? candidates.find(candidate => candidate['p:nvSpPr']['p:nvPr']['p:ph'].idx === index) : undefined) ?? candidates[0];
   };
   const layout = [...relationships(slidePath).values()].find(relationship => relationship.type === REL_LAYOUT)?.path;
-  if (!layout) return undefined;
+  if (!layout) return chain;
   const fromLayout = find(layout, true);
-  if (fromLayout) return fromLayout;
+  if (fromLayout) chain.push(fromLayout);
   const master = [...relationships(layout).values()].find(relationship => relationship.type === REL_MASTER)?.path;
-  return master ? find(master, false) : undefined;
+  const fromMaster = master ? find(master, false) : undefined;
+  if (fromMaster) chain.push(fromMaster);
+  return chain;
 }
 
-function zoneOf(bounds, slideWidth, fallback) {
+function inheritedBounds(chain) {
+  for (const shape of chain) {
+    const bounds = xfrmBounds(shape['p:spPr']?.['a:xfrm']);
+    if (bounds) return bounds;
+  }
+  return undefined;
+}
+
+const ALIGN_ZONES = {l: 'left', ctr: 'center', r: 'right'};
+// The paragraph alignment of a footer shape: its first paragraph, else its list style, else what the layout and master
+// placeholder say. Read as the physical edge, as the exporter writes it (an RTL zone is `algn="r"` with `rtl="1"`).
+function inheritedAlignment(chain) {
+  for (const shape of chain) {
+    const body = shape['p:txBody'];
+    const paragraph = array(body?.['a:p']).find(item => item?.['a:pPr']?.algn !== undefined);
+    const algn = paragraph?.['a:pPr']?.algn ?? body?.['a:lstStyle']?.['a:lvl1pPr']?.algn;
+    if (ALIGN_ZONES[algn]) return ALIGN_ZONES[algn];
+  }
+  return undefined;
+}
+
+/** A box wider than this share of the slide spans more than one zone, so its centre says nothing about the zone. */
+const WIDE_ZONE_SHARE = .36;
+// A narrow box keeps the zone its centre is in; a box wider than a zone (core gives a lone zone the content width) takes the
+// zone its paragraphs align to, and keeps the centre when nothing says how they align.
+function zoneOf(chain, slideWidth, fallback) {
+  const bounds = inheritedBounds(chain);
   if (!bounds || !(slideWidth > 0)) return fallback;
+  if (bounds.cx / slideWidth > WIDE_ZONE_SHARE) {
+    const aligned = inheritedAlignment(chain);
+    if (aligned) return aligned;
+  }
   const center = (bounds.x + bounds.cx / 2) / slideWidth;
   return center < 1 / 3 ? 'left' : center > 2 / 3 ? 'right' : 'center';
 }
@@ -282,7 +317,7 @@ export function readNativePlaceholders(context, claimed, relationships, readPart
       for (const field of paragraph.fields ?? []) nativeFields.push({...field, start: base + (field.start ?? text.indexOf(field.text, base) - base)});
       base += paragraph.text.length + 1;
     }
-    const zone = zoneOf(inheritedBounds(shape, ph, context.path, relationships, readPart), context.slideWidth, NATIVE_PLACEHOLDERS[ph].zone);
+    const zone = zoneOf(placeholderChain(shape, ph, context.path, relationships, readPart), context.slideWidth, NATIVE_PLACEHOLDERS[ph].zone);
     const properties = NATIVE_PLACEHOLDERS[ph];
     if (ph === 'sldNum') {
       // The words around a native slide-number field are the zone text and the field is `{{slide.number}}`.

package/dist/native-text-style.js

@@ -5,6 +5,12 @@ const boolean = value => ['1','true','on'].includes(value) ? true : ['0','false'
 
 const themeFamilies = context => ['a:majorFont', 'a:minorFont'].map(key => context.fonts?.[key]?.['a:latin']?.typeface?.trim().toLowerCase()).filter(Boolean);
 
+export function nativeTypeface(font, context) {
+  if (typeof font !== 'string') return undefined;
+  const match = font.match(/^\+(mj|mn)-(lt|ea|cs)$/);
+  return match ? context.fonts?.[match[1] === 'mj' ? 'a:majorFont' : 'a:minorFont']?.[{lt:'a:latin',ea:'a:ea',cs:'a:cs'}[match[2]]]?.typeface : font;
+}
+
 // A run painted with a bare theme slot (a:schemeClr, no color transform) remembers the slot as the OPF color name: the
 // transient `_opfScheme` marker is read, and always removed, by restoreRunColors (run-colors.js) once the document's own
 // colour scheme can confirm the slot holds that colour.
@@ -36,8 +42,7 @@ export function nativeRunStyle(properties, context, relationships, report, kind
   const font = properties['a:latin']?.typeface;
   if (properties['a:latin'] && !font) report(`unsupported-${kind}-font`, 'The native text font has no usable Latin face or theme reference.');
   if (font) {
-    const match = font.match(/^\+(mj|mn)-(lt|ea|cs)$/);
-    const family = match ? context.fonts?.[match[1] === 'mj' ? 'a:majorFont' : 'a:minorFont']?.[{lt:'a:latin',ea:'a:ea',cs:'a:cs'}[match[2]]]?.typeface : font;
+    const family = nativeTypeface(font, context);
     if (family) {
       result.fontFamily = family;
       // The exporter writes a bundled family's weight faces (Roboto SemiBold) under their

package/dist/quote-provenance.js

@@ -1,6 +1,6 @@
 import {XMLParser} from 'fast-xml-parser';
 import {isValidFormat} from './format-check.js';
-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,unwrapQuoteRuns} from './rich-heading.js';
 
@@ -18,7 +18,7 @@ const FOOTERS=['["attribution"]','["role"]','["source"]','["attribution","role"]
 const separatorBefore=field=>field==='role'?'\n':SEPARATOR;
 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 attachQuoteTags=(entries,records)=>attachTextTags(entries,records,TAG,'opfQuote','quote',{pictures:true});
+export const attachQuoteTags=(entries,records)=>attachTextTags(entries,records,TAG,'opfQuote','quote',{pictures:true,signed:true});
 export const quotePhotoName=group=>`OPF quote photo ${group}`;
 
 // The manifest rides on the first body line. `footer` lists which fields the footer part joins (core writes the attribution, the role
@@ -127,7 +127,7 @@ export function importQuoteGroups(shapes,paragraphs,relationships,entries,report
     for(const item of photos)consumedPictures.add(item.picture);
     items.push({shapes:group.map(item=>item.shape),pictures:photos.map(item=>item.picture),payload:{type:'quote',quote}});
     for(const diagnostic of local)report(diagnostic);
-    report({code:'quote-import-reflow',message:'Quote text, attribution, role, source and photo were recovered from the current native text and picture. Native formatting, positions and font theme are not reconstructed; review the reflowed quote.'});
+    if(!groupUnchanged(group,paragraphs))report({code:'quote-import-reflow',message:'Quote text, attribution, role, source and photo were recovered from the current native text and picture. Native formatting, positions and font theme are not reconstructed; review the reflowed quote.'});
   }catch(error){report({code:'invalid-quote-provenance',message:`${error.message} Ordinary import retains current native text without restoring old source words.`});}
   return {consumed,consumedPictures,items};
 }

package/dist/template-layouts.js

@@ -78,18 +78,27 @@ export function placeholderType(region) {
 }
 
 /** Which slide objects a placeholder of each type takes (binding a `none` region's lone object). */
-const BINDS = {title: ['title'], ctrTitle: ['title'], pic: ['picture'], chart: ['chart'], tbl: ['table'], obj: ['picture', 'chart', 'table']};
+const BINDS = {title: ['title'], ctrTitle: ['title'], body: ['body'], pic: ['picture'], chart: ['chart'], tbl: ['table'], obj: ['picture', 'chart', 'table']};
 export const bindsObject = (type, object) => (BINDS[type] ?? []).includes(object);
 
 /** The placeholder index of each region: its kind's base plus its position among the regions of that kind (REGION_IDX_BASE). */
-export function regionIndexes(record) {
+export function regionIndexes(record, nativeBodyRegion) {
   const regions = new Map(layoutTemplate(record).regions.map(region => [region.name, region]));
   const counts = {};
-  return Object.fromEntries(Object.keys(record?.regions ?? {}).filter(name => regions.has(name)).map(name => {
+  const indexes = Object.fromEntries(Object.keys(record?.regions ?? {}).filter(name => regions.has(name)).map(name => {
     const type = placeholderType(regions.get(name));
     counts[type] = (counts[type] ?? -1) + 1;
     return [name, REGION_IDX_BASE[type] + counts[type]];
   }));
+  // A native variant changes only its selected slot. Other object kinds retain
+  // their original indexes, so Change Layout cannot move a neighbouring picture.
+  if (nativeBodyRegion !== undefined && regions.has(nativeBodyRegion) && placeholderType(regions.get(nativeBodyRegion)) !== 'body') {
+    const used = new Set(Object.values(indexes));
+    let idx = REGION_IDX_BASE.body;
+    while (used.has(idx)) idx++;
+    indexes[nativeBodyRegion] = idx;
+  }
+  return indexes;
 }
 
 // FNV-1a (64-bit) of the record's canonical JSON: evidence of which record the layout was made from.
@@ -196,7 +205,7 @@ export function layoutPlaceholders(template) {
   const parsed = layoutTemplate(record);
   const {areas} = composeLayoutAreas(record, {...template.areaOptions, textMeasurement: undefined});
   const regions = new Map(parsed.regions.map(region => [region.name, region]));
-  const indexes = regionIndexes(record);
+  const indexes = regionIndexes(record, template.nativeBodyRegion);
   const emu = box => ({x: Math.round(box.x * EMU), y: Math.round(box.y * EMU), cx: Math.max(0, Math.round(box.width * EMU)), cy: Math.max(0, Math.round(box.height * EMU))});
   const result = [];
   for (const area of areas) {
@@ -210,7 +219,8 @@ export function layoutPlaceholders(template) {
     }
     if (area.name === 'subtitle') { result.push({name: 'Subtitle', type: 'subTitle', idx: SUBTITLE_IDX, anchor: 't', ...emu(area.box)}); continue; }
     const region = regions.get(area.name);
-    if (region) result.push({name: region.name, type: placeholderType(region), idx: indexes[region.name], ...emu(area.box)});
+    if (region) result.push({name: region.name, type: region.name === template.nativeBodyRegion ? 'body' : placeholderType(region), idx: indexes[region.name],
+      ...(region.name === template.nativeBodyRegion ? {anchor: {top: 't', middle: 'ctr', bottom: 'b'}[region.anchor]} : {}), ...emu(area.box)});
   }
   const sample = composeSlide({title: 'Title', subtitle: 'Subtitle', blocks: [{text: 'Body'}]}, {...template.areaOptions, layout: record, textMeasurement: undefined});
   for (const placeholder of result) {
@@ -244,7 +254,7 @@ function placeholderShape(placeholder, id) {
  */
 export function layoutTagValue(template, {record = false} = {}) {
   return {v: 1, id: template.id, group: template.group, ...(template.source !== undefined ? {source: template.source} : {}), reference: template.reference,
-    hash: recordHash(template.record), regions: Object.fromEntries(Object.entries(regionIndexes(template.record)).map(([name, idx]) => [String(idx), name])),
+    hash: recordHash(template.record), regions: Object.fromEntries(Object.entries(regionIndexes(template.record, template.nativeBodyRegion)).map(([name, idx]) => [String(idx), name])),
     ...(record && template.origin === 'document' ? {record: template.record} : {})};
 }
 
@@ -297,6 +307,7 @@ export function writeTemplateLayouts(output, slides, templates, bindings = new M
       const key = `${master}\u0001${template.key}`;
       const path = `ppt/slideLayouts/slideLayout${nextLayout++}.xml`, tagPath = `ppt/tags/opfLayout${nextTag++}.xml`;
       let name = typeof template.record.name === 'string' && template.record.name.trim() ? template.record.name : template.id;
+      if (template.nativeBodyRegion) name += ' (native body)';
       if (taken.has(name)) name = `${name} (${template.group}:${template.id})`;
       taken.add(name);
       const type = POWERPOINT_LAYOUT_TYPES[template.id] ?? 'cust';
@@ -329,17 +340,22 @@ export function writeTemplateLayouts(output, slides, templates, bindings = new M
     }
   }
   // Automatic composition is its own titleOnly layout, independently of catalog region templates.
-  for (const [master, base] of masters) {
-    const first = automaticSlides.find((plan, index) => plan && related(related(slidePaths[index], 'slideLayout'), 'slideMaster') === master);
+  for (const [master, base] of masters) for (const native of [false, true]) {
+    const first = automaticSlides.find((plan, index) => plan && Boolean(plan.nativeBody) === native && related(related(slidePaths[index], 'slideLayout'), 'slideMaster') === master);
     if (!first) continue;
     const path = `ppt/slideLayouts/slideLayout${nextLayout++}.xml`, tagPath = `ppt/tags/opfLayout${nextTag++}.xml`;
     // Reuse accepted title geometry; an empty slide needs only the engine's default prompt, never a re-fit through the caller's measurement provider.
     const title = first.title ?? composeSlide({title: 'Title'}, {...first.areaOptions, layout: undefined, textMeasurement: undefined}).items.find(item => item.field === 'title');
     const placeholder = {name: 'Title', type: 'title', x: Math.round(title.box.x * EMU), y: Math.round(title.box.y * EMU), cx: Math.round(title.box.width * EMU), cy: Math.round(title.box.height * EMU), style: {...title.textStyle, fontSize: title.text.fontSize, alignment: title.alignment}};
-    let xml = read(base).replace(/<p:sldLayout\b[^>]*>/, open => `${open.slice(0, -1).replace(/\s+(?:type|userDrawn|showMasterSp)="[^"]*"/g, '')} type="titleOnly" userDrawn="1">`);
-    xml = xml.replace(/(<p:cSld\b[^>]*?)(\s+name="[^"]*")?(\s*>)/, (match, open, _name, close) => `${open} name="OPF auto"${close}`);
+    const body = native ? {name: 'Body', type: 'body', idx: REGION_IDX_BASE.body,
+      ...Object.fromEntries(['x', 'y'].map(key => [key, Math.round(first.nativeBody.box[key] * EMU)])),
+      cx: Math.round(first.nativeBody.box.width * EMU), cy: Math.round(first.nativeBody.box.height * EMU),
+      anchor: {top: 't', middle: 'ctr', bottom: 'b'}[first.nativeBody.anchor],
+      style: {...first.nativeBody.item.textStyle, fontSize: first.nativeBody.item.text.fontSize, alignment: first.nativeBody.item.alignment}} : undefined;
+    let xml = read(base).replace(/<p:sldLayout\b[^>]*>/, open => `${open.slice(0, -1).replace(/\s+(?:type|userDrawn|showMasterSp)="[^"]*"/g, '')} type="${native ? 'tx' : 'titleOnly'}" userDrawn="1">`);
+    xml = xml.replace(/(<p:cSld\b[^>]*?)(\s+name="[^"]*")?(\s*>)/, (match, open, _name, close) => `${open} name="${native ? 'OPF auto (native body)' : 'OPF auto'}"${close}`);
     const nextId = Math.max(1, ...[...xml.matchAll(/<p:cNvPr\b[^>]*\bid="(\d+)"/g)].map(match => Number(match[1]))) + 1;
-    xml = xml.replace('</p:grpSpPr>', `</p:grpSpPr>${placeholderShape(placeholder, nextId)}`);
+    xml = xml.replace('</p:grpSpPr>', `</p:grpSpPr>${placeholderShape(placeholder, nextId)}${body ? placeholderShape(body, nextId + 1) : ''}`);
     const masterRel = relationships(read(relsOf(base))).find(rel => rel.type === `${REL}/slideMaster`);
     const tagged = addRelationship(`<?xml version="1.0" encoding="UTF-8" standalone="yes"?><Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">${masterRel.node}</Relationships>`, `${REL}/tags`, relativeTarget(path, tagPath));
     xml = xml.replace('</p:spTree>', `</p:spTree><p:custDataLst><p:tags r:id="${tagged.rid}"/></p:custDataLst>`);
@@ -349,13 +365,13 @@ export function writeTemplateLayouts(output, slides, templates, bindings = new M
     const added = addRelationship(read(relsOf(master)), `${REL}/slideLayout`, relativeTarget(master, path));
     write(relsOf(master), added.relsXml);
     write(master, read(master).replace('</p:sldLayoutIdLst>', `<p:sldLayoutId id="${nextLayoutId++}" r:id="${added.rid}"/></p:sldLayoutIdLst>`));
-    created.set(`${master}\u0001auto`, {path, placeholders: new Map([['Title', placeholder]])});
+    created.set(`${master}\u0001${native ? 'auto-native-body' : 'auto'}`, {path, placeholders: new Map([['Title', placeholder], ...(body ? [['Body', body]] : [])])});
   }
   for (const [index, plan] of slidePaths.map((_, index) => slides[index]).entries()) {
     if (!plan && !automaticSlides[index]) continue;
     const slidePath = slidePaths[index];
     const master = related(related(slidePath, 'slideLayout'), 'slideMaster');
-    const layout = created.get(`${master}\u0001${plan ? plan.template.key : 'auto'}`);
+    const layout = created.get(`${master}\u0001${plan ? plan.template.key : automaticSlides[index].nativeBody ? 'auto-native-body' : 'auto'}`);
     if (!layout) throw new Error(`Slide ${index + 1} has no template layout.`);
     const slideRels = relsOf(slidePath);
     write(slideRels, read(slideRels).replace(/<Relationship\b[^>]*\/>/g, node => attribute(node, 'Type') === `${REL}/slideLayout` ? node.replace(/\sTarget="[^"]*"/, ` Target="${relativeTarget(slidePath, layout.path)}"`) : node));
@@ -366,7 +382,7 @@ export function writeTemplateLayouts(output, slides, templates, bindings = new M
       const placeholder = layout.placeholders.get(binding.region);
       if (!placeholder || !bindsObject(placeholder.type, binding.object)) continue;
       const ph = `<p:ph${placeholder.type === 'obj' ? '' : ` type="${placeholder.type}"`}${placeholder.idx !== undefined ? ` idx="${placeholder.idx}"` : ''}/>`;
-      const element = binding.object === 'picture' ? 'pic' : binding.object === 'title' ? 'sp' : 'graphicFrame';
+      const element = binding.object === 'picture' ? 'pic' : ['title', 'body'].includes(binding.object) ? 'sp' : 'graphicFrame';
       const pattern = new RegExp(`<p:${element}>[\\s\\S]*?<\\/p:${element}>`, 'g');
       slideXml = slideXml.replace(pattern, shape => {
         if (unescapeAttribute(shape.match(/<p:cNvPr\b[^>]*\bname="([^"]*)"/)?.[1] ?? '') !== objectName || /<p:ph\b/.test(shape)) return shape;

package/dist/text-provenance.js

@@ -1,9 +1,9 @@
 import {XMLParser} from 'fast-xml-parser';
-import {attachTextTags,decodeTextTag} from './code-provenance.js';
+import {attachTextTags,decodeTextTag,groupUnchanged} from './code-provenance.js';
 const TAG='OPF_TEXT_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 attachPlainTextTags=(entries,records)=>attachTextTags(entries,records,TAG,'opfText','plain text');
+export const attachPlainTextTags=(entries,records)=>attachTextTags(entries,records,TAG,'opfText','plain text',{signed:true});
 
 // Only boundaries are stored. Current native characters, including edits and
 // empty lines, always supply the text; tags cannot restore discarded old words.
@@ -48,7 +48,7 @@ export function importPlainTextGroups(shapes,paragraphs,relationships,entries,re
   const restored=sourceLineParagraphs(ordered,paragraphs);
   for(const item of ordered)consumed.add(item.shape);
   items.push({shapes:ordered.map(item=>item.shape),paragraphs:restored});
-  report({code:'text-import-reflow',message:'Complete tagged lines retain current native text, whitespace and authored line boundaries. Native formatting, geometry and OPF nesting are not reconstructed; review the reflowed text.'});
+  if(!groupUnchanged(ordered,paragraphs))report({code:'text-import-reflow',message:'Complete tagged lines retain current native text, whitespace and authored line boundaries. Native formatting, geometry and OPF nesting are not reconstructed; review the reflowed text.'});
  }catch(error){report({code:'invalid-text-provenance',message:`${error.message} Ordinary import retains current native text without restoring old source words.`});}
  return {consumed,items};
 }

package/dist/timeline-provenance.js

@@ -1,13 +1,13 @@
 import {XMLParser} from 'fast-xml-parser';
 import {isValidFormat} from './format-check.js';
-import {attachTextTags,decodeTextTag} from './code-provenance.js';
+import {attachTextTags,decodeTextTag,groupUnchanged} from './code-provenance.js';
 import {sourceLineParagraphs} from './text-provenance.js';
 
 const STATUSES=['done','current','planned'];
 const TAG='OPF_TIMELINE_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 attachTimelineTags=(entries,records)=>attachTextTags(entries,records,TAG,'opfTimeline','timeline');
+export const attachTimelineTags=(entries,records)=>attachTextTags(entries,records,TAG,'opfTimeline','timeline',{signed:true});
 
 // Only topology and line boundaries are retained. Every field value comes from
 // current native text; clearing or editing a field cannot restore old words.
@@ -86,7 +86,7 @@ export function importTimelineGroups(shapes,paragraphs,relationships,entries,rep
     if(!isValidFormat({slides:[{timeline}]}))throw Error('Current native text does not form a valid timeline.');
     for(const item of group)consumed.add(item.shape);
     items.push({shapes:group.map(item=>item.shape),payload:{type:'timeline',timeline}});
-    report({code:'timeline-import-reflow',message:'Timeline field order, source boundaries and current native text were recovered. Native formatting, positions, marker styling and font theme are not reconstructed; review the reflowed timeline.'});
+    if(!groupUnchanged(group,paragraphs))report({code:'timeline-import-reflow',message:'Timeline field order, source boundaries and current native text were recovered. Native formatting, positions, marker styling and font theme are not reconstructed; review the reflowed timeline.'});
   }catch(error){report({code:'invalid-timeline-provenance',message:`${error.message} Ordinary import retains current native text without restoring old source words.`});}
   return {consumed,items};
 }