@openpresentation/opf-pptx 0.9.1 → 0.10.0

package/dist/furniture-fields.js

@@ -0,0 +1,176 @@
+// Native PowerPoint fields inside OPF furniture shapes. Core supplies the
+// displayed text plus half-open UTF-16 ranges for live values; this module turns
+// those ranges into <a:fld> runs and maps them back on import. It never reads a
+// clock: the cached field text is whatever core laid out.
+
+const enc = new TextEncoder(), dec = new TextDecoder('utf-8', {fatal: true});
+
+// PowerPoint's en-US date field types (ECMA-376 ST_TextField "datetime1".."datetime7").
+// Exported runs carry lang="en-US", so these patterns are what PowerPoint displays.
+export const NATIVE_DATE_FIELDS = Object.freeze({
+  'M/d/yyyy': 'datetime1',
+  'EEEE, MMMM d, yyyy': 'datetime2',
+  'd MMMM yyyy': 'datetime3',
+  'MMMM d, yyyy': 'datetime4',
+  'd-MMM-yy': 'datetime5',
+  'MMMM yy': 'datetime6',
+  'MMM-yy': 'datetime7',
+});
+export const DEFAULT_DATE_FORMAT = 'M/d/yyyy';
+export const DEFAULT_SLIDE_NUMBER_FORMAT = '{current}';
+
+const months = ['January','February','March','April','May','June','July','August','September','October','November','December'];
+const weekdays = ['Sunday','Monday','Tuesday','Wednesday','Thursday','Friday','Saturday'];
+const widths = {y: [1, 2, 4], M: [1, 2, 3, 4], d: [1, 2], E: [1, 2, 3, 4]};
+const escapeRegExp = value => value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+const escapeXml = value => value.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+const unescapeXml = value => value.replace(/&(lt|gt|quot|apos|amp|#x[0-9A-Fa-f]+|#\d+);/g, (match, entity) =>
+  entity === 'lt' ? '<' : entity === 'gt' ? '>' : entity === 'quot' ? '"' : entity === 'apos' ? "'" : entity === 'amp' ? '&' :
+  String.fromCodePoint(entity[1] === 'x' ? parseInt(entity.slice(2), 16) : Number(entity.slice(1))));
+
+/** Tokenize the same LDML-style subset core formats; null when unsupported. */
+function tokens(pattern) {
+  if (typeof pattern !== 'string' || !pattern) return null;
+  const out = [];
+  for (let index = 0; index < pattern.length;) {
+    const character = pattern[index];
+    if (character === "'") {
+      if (pattern[index + 1] === "'") { out.push({text: "'"}); index += 2; continue; }
+      let end = index + 1, text = '';
+      for (;;) {
+        if (end >= pattern.length) return null;
+        if (pattern[end] === "'") { if (pattern[end + 1] === "'") { text += "'"; end += 2; continue; } break; }
+        text += pattern[end++];
+      }
+      out.push({text}); index = end + 1; continue;
+    }
+    if (/[A-Za-z]/.test(character)) {
+      let end = index;
+      while (pattern[end] === character) end++;
+      if (!widths[character]?.includes(end - index)) return null;
+      out.push({letter: character, width: end - index}); index = end; continue;
+    }
+    out.push({text: character}); index++;
+  }
+  return out;
+}
+
+function isoParts(value) {
+  const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(value ?? '');
+  if (!match) return null;
+  const [year, month, day] = match.slice(1).map(Number), date = new Date(Date.UTC(2000, month - 1, day));
+  date.setUTCFullYear(year);
+  return date.getUTCFullYear() === year && date.getUTCMonth() === month - 1 && date.getUTCDate() === day ? {year, month, day, weekday: date.getUTCDay()} : null;
+}
+
+export function formatDate(iso, pattern) {
+  const date = isoParts(iso), list = tokens(pattern);
+  if (!date || !list) return null;
+  const pad = (value, width) => String(value).padStart(width, '0');
+  return list.map(token => token.text ?? (
+    token.letter === 'y' ? (token.width === 2 ? pad(date.year % 100, 2) : token.width === 4 ? pad(date.year, 4) : String(date.year)) :
+    token.letter === 'M' ? (token.width >= 3 ? months[date.month - 1].slice(0, token.width === 4 ? undefined : 3) : pad(date.month, token.width)) :
+    token.letter === 'd' ? pad(date.day, token.width) :
+    weekdays[date.weekday].slice(0, token.width === 4 ? undefined : 3))).join('');
+}
+
+/**
+ * Recover the ISO date that `pattern` formats as exactly `text`. Returns null when
+ * the pattern omits the day, month or a four-digit year, or the text no longer
+ * matches; callers then keep the current text as a literal date.
+ */
+export function parseDate(text, pattern) {
+  const list = tokens(pattern);
+  if (!list || typeof text !== 'string') return null;
+  const letters = new Set(list.filter(token => token.letter).map(token => `${token.letter}${token.letter === 'y' ? token.width : ''}`));
+  if (!letters.has('M') || !letters.has('d') || !(letters.has('y4') || letters.has('y1'))) return null;
+  const groups = [];
+  const source = list.map(token => {
+    if (token.text !== undefined) return escapeRegExp(token.text);
+    groups.push(token);
+    if (token.letter === 'M' && token.width >= 3) return `(${months.map(name => token.width === 4 ? name : name.slice(0, 3)).join('|')})`;
+    if (token.letter === 'E') return `(${weekdays.map(name => token.width === 4 ? name : name.slice(0, 3)).join('|')})`;
+    return token.width === 1 ? '(\\d+)' : `(\\d{${token.width}})`;
+  }).join('');
+  const match = new RegExp(`^${source}$`).exec(text);
+  if (!match) return null;
+  let year, month, day;
+  for (const [index, token] of groups.entries()) {
+    const value = match[index + 1];
+    if (token.letter === 'y' && token.width !== 2) year = Number(value);
+    else if (token.letter === 'M') month = token.width >= 3 ? months.findIndex(name => (token.width === 4 ? name : name.slice(0, 3)) === value) + 1 : Number(value);
+    else if (token.letter === 'd') day = Number(value);
+  }
+  if (!(year >= 0 && year <= 9999)) return null;
+  const iso = `${String(year).padStart(4, '0')}-${String(month).padStart(2, '0')}-${String(day).padStart(2, '0')}`;
+  // Reformatting must reproduce the current text exactly, including the weekday.
+  return formatDate(iso, pattern) === text ? iso : null;
+}
+
+export function formatSlideNumber(format, current, total) {
+  if (typeof format !== 'string' || !format.includes('{current}') || (format.includes('{total}') && !Number.isSafeInteger(total))) return null;
+  return format.split(/(\{current\}|\{total\})/).map(piece => piece === '{current}' ? String(current) : piece === '{total}' ? String(total) : piece).join('');
+}
+
+/**
+ * Live field ranges for one accepted furniture text part. Core >= FF-27 supplies
+ * `part.fields`; earlier cores only supply a bare generated number, which is
+ * still a whole slide-number field.
+ */
+export function furniturePartFields(part) {
+  if (Array.isArray(part.fields)) return part.fields;
+  return part.field === 'slideNumber' && /^\d+$/.test(part.text) ? [{type: 'slideNumber', start: 0, end: part.text.length}] : [];
+}
+
+/** Native <a:fld> type for a core field, or null when the value must stay fixed text. */
+export function nativeFieldType(field) {
+  if (field.type === 'slideNumber') return 'slidenum';
+  if (field.type === 'date') return NATIVE_DATE_FIELDS[field.format ?? DEFAULT_DATE_FORMAT] ?? null;
+  return null;
+}
+
+/** Split fitted lines into per-line field ranges; a field broken across lines stays fixed text. */
+export function lineFields(text, fields, sourceLines, lines) {
+  return lines.map((line, index) => {
+    const source = sourceLines?.[index];
+    if (!source) return [];
+    return fields.filter(field => field.start >= source.start && field.end <= source.end && field.end > field.start)
+      .map(field => ({...field, start: field.start - source.start, end: field.end - source.start}))
+      .filter(field => line.slice(field.start, field.end) === text.slice(field.start + source.start, field.end + source.start));
+  });
+}
+
+/**
+ * Rewrite the single generated run of each recorded furniture shape into runs and
+ * <a:fld> elements. Field ids are deterministic so exports stay byte-stable.
+ */
+export function attachFurnitureFields(entries, records) {
+  if (!records.size) return;
+  let count = 0;
+  const seen = new Set();
+  for (const path of 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]))) {
+    const xml = dec.decode(entries[path]).replace(/<p:sp>[\s\S]*?<\/p:sp>/g, shape => {
+      const name = shape.match(/<p:cNvPr\b[^>]*\bname="([^"]+)"/)?.[1];
+      const record = records.get(name);
+      if (!record) return shape;
+      if (seen.has(name)) throw new Error('Duplicate generated furniture field shape.');
+      seen.add(name);
+      const runs = [...shape.matchAll(/<a:r>(<a:rPr\b[^>]*\/>|<a:rPr\b[^>]*>[\s\S]*?<\/a:rPr>)<a:t>([^<]*)<\/a:t><\/a:r>/g)];
+      if (runs.length !== 1 || unescapeXml(runs[0][2]) !== record.text) throw new Error('Generated furniture field text does not match its accepted line.');
+      const [run, properties] = runs[0];
+      let cursor = 0, body = '';
+      const literal = text => { if (text) body += `<a:r>${properties}<a:t>${escapeXml(text)}</a:t></a:r>`; };
+      for (const field of [...record.fields].sort((a, b) => a.start - b.start)) {
+        if (field.start < cursor) throw new Error('Overlapping furniture fields.');
+        literal(record.text.slice(cursor, field.start));
+        const id = `{0F0F2700-0000-4000-8000-${(++count).toString(16).toUpperCase().padStart(12, '0')}}`;
+        body += `<a:fld id="${id}" type="${field.nativeType}">${properties}<a:t>${escapeXml(record.text.slice(field.start, field.end))}</a:t></a:fld>`;
+        cursor = field.end;
+      }
+      literal(record.text.slice(cursor));
+      return shape.replace(run, body);
+    });
+    entries[path] = enc.encode(xml);
+  }
+  if (seen.size !== records.size) throw new Error('Missing generated furniture field shapes.');
+}

package/dist/furniture-provenance.js

@@ -1,24 +1,79 @@
 import {XMLParser} from 'fast-xml-parser';
 import {attachTextTags, decodeTextTag, encodeTextTag} from './code-provenance.js';
 import {sourceLineParagraphs} from './text-provenance.js';
+import {DEFAULT_DATE_FORMAT, NATIVE_DATE_FIELDS, formatSlideNumber, parseDate} from './furniture-fields.js';
+import {schemas} from '@openpresentation/opf';
 
 const TAG = 'OPF_FURNITURE_V1';
+// A slide has one tag list; it also carries the document's OPF_SLIDE_V1 record.
+const SLIDE_TAG = 'OPF_SLIDE_V1';
 const REL = 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/tags';
 const NS = 'http://schemas.openxmlformats.org/presentationml/2006/main';
 const enc = new TextEncoder(), dec = new TextDecoder('utf-8', {fatal: true});
 const parser = new XMLParser({ignoreAttributes: false, attributeNamePrefix: '', parseTagValue: false, trimValues: false});
 const array = value => value === undefined ? [] : Array.isArray(value) ? value : [value];
 const kinds = ['header', 'footer'], zones = ['left', 'center', 'right'];
-const fields = ['text', 'image', 'organization', 'section', 'slideNumber', 'date'];
+const fields = ['text', 'image', 'organization', 'socials', 'section', 'slideNumber', 'date'];
+const settings = ['slideNumberFormat', 'dateFormat'];
+const dateFormatForField = Object.fromEntries(Object.entries(NATIVE_DATE_FIELDS).map(([format, type]) => [type, format]));
+// Platform keys follow the Socials schema's propertyNames pattern exactly, so
+// every key a valid document can carry re-imports (and nothing else does).
+const platformId = new RegExp(schemas.presentation.$defs.Socials.propertyNames.pattern, 'u'), schemes = ['', 'https://'];
+// Socials lines show a profile URL without the https:// scheme; the manifest
+// keeps only each line's platform id and the stripped scheme, never its words.
+const socialLines = part => part.links.map(link => ({platform: link.platform,
+  scheme: link.href && !/^[a-z][a-z0-9+.-]*:/i.test(link.text) ? 'https://' : ''}));
 const object = value => value !== null && typeof value === 'object' && !Array.isArray(value);
 const key = part => `${part.kind}.${part.zone}.${part.field}`;
 const same = (a, b) => JSON.stringify(a) === JSON.stringify(b);
 const check = (condition, message) => { if (!condition) throw Error(message); };
 
-// This manifest contains topology, identities and inactive flags only. Current
-// native shapes supply all words, image bytes and alt text, even after edits.
-export function furnitureManifest(presentation, slide, layout, slideIndex) {
-  const definitions = {};
+// Change detection, not authentication: editable tags store no cached date words.
+function dateLineFingerprint(text) {
+  let a = 0xdeadbeef, b = 0x41c6ce57;
+  for (let index = 0; index < text.length; index++) {
+    a = Math.imul(a ^ text.charCodeAt(index), 2654435761);
+    b = Math.imul(b ^ text.charCodeAt(index), 1597334677);
+  }
+  return `${text.length}:${(a >>> 0).toString(16).padStart(8, '0')}${(b >>> 0).toString(16).padStart(8, '0')}`;
+}
+
+// Only the exporter may mark its own supported, whole-date field flattened by
+// an accepted soft wrap. Literal dates and unsupported patterns stay ordinary.
+export function staticDateFallback(part, field) {
+  const format = field.format ?? DEFAULT_DATE_FORMAT;
+  if (part.field !== 'date' || field.type !== 'date' || !NATIVE_DATE_FIELDS[format] ||
+      field.start !== 0 || field.end !== part.text.length || part.fit.lines.length < 2) return undefined;
+  const records = part.fit.sourceLines.map((line, index) => ({index, data: {
+    boundary: line.boundary, separator: part.text.slice(line.end, line.nextStart),
+  }}));
+  if (records.some((record, index) => record.data.boundary !== (index === records.length - 1 ? 'end' : 'soft'))) return undefined;
+  try {
+    if (sourceLineParagraphs(records, part.fit.lines.map(text => [{text}]))[0].text !== part.text) return undefined;
+  } catch { return undefined; }
+  return {v: 1, reason: 'wrapped-native-date', format, fingerprints: part.fit.lines.map(dateLineFingerprint)};
+}
+
+function unchangedStaticDate(marker, format, ordered, paragraphs) {
+  check(object(marker) && Object.keys(marker).sort().join(',') === 'fingerprints,format,reason,v' &&
+    marker.v === 1 && marker.reason === 'wrapped-native-date' && typeof marker.format === 'string' &&
+    Object.hasOwn(NATIVE_DATE_FIELDS, marker.format) && marker.format === (format.dateFormat ?? DEFAULT_DATE_FORMAT) &&
+    ordered.length > 1 && Array.isArray(marker.fingerprints) && marker.fingerprints.length === ordered.length,
+  'Invalid static date fallback evidence.');
+  check(ordered.every((record, index) => {
+    const current = paragraphs[record.index] ?? [];
+    return record.data.boundary === (index === ordered.length - 1 ? 'end' : 'soft') && record.data.separator === '' &&
+      typeof marker.fingerprints[index] === 'string' && /^\d+:[0-9a-f]{16}$/.test(marker.fingerprints[index]) &&
+      current.length === 1 && !current[0].bullet && dateLineFingerprint(current[0].text) === marker.fingerprints[index];
+  }), 'Current static date text or boundaries differ from the exported lines.');
+}
+
+// This manifest contains topology, identities, inactive flags and format
+// settings only. Current native shapes supply all words, image bytes and alt
+// text, even after edits; a recorded format is kept only while the current text
+// still matches it exactly.
+export function furnitureManifest(presentation, slide, layout, slideIndex, staticDates = new Map()) {
+  const definitions = {}, formats = {};
   for (const kind of kinds) {
     const local = slide.design?.[kind] !== undefined;
     const source = local ? slide.design[kind] : presentation.design?.[kind];
@@ -30,16 +85,20 @@ export function furnitureManifest(presentation, slide, layout, slideIndex) {
         const current = source[zone][field];
         value[zone][field] = field === 'image' ? 'native' : typeof current === 'string' ? 'literal' : current;
       }
+      const format = Object.fromEntries(settings.filter(setting => typeof source[zone][setting] === 'string').map(setting => [setting, source[zone][setting]]));
+      if (Object.keys(format).length) formats[`${kind}.${zone}`] = format;
     }
     definitions[kind] = {scope: local ? 'local' : 'global', value};
   }
   if (!Object.keys(definitions).length) return null;
   const organizations = array(presentation.organization);
   const organization = organizations.find(item => item.role === 'primary') ?? organizations[0];
-  return {v: 1, role: 'slide', group: String(slideIndex), definitions,
-    ...(layout.parts.some(part => part.field === 'organization') ? {organizationId: organization?.id} : {}),
-    parts: layout.parts.map(part => ({kind: part.kind, zone: part.zone, field: part.field,
-      type: part.type, count: part.type === 'image' ? 1 : part.fit.lines.length}))};
+  return {v: 1, role: 'slide', group: String(slideIndex), definitions, ...(Object.keys(formats).length ? {formats} : {}),
+    ...(layout.parts.some(part => part.field === 'organization' || part.field === 'socials') ? {organizationId: organization?.id} : {}),
+    parts: layout.parts.map((part, index) => ({kind: part.kind, zone: part.zone, field: part.field,
+      type: part.type, count: part.type === 'image' ? 1 : part.fit.lines.length,
+      ...(part.field === 'socials' ? {socials: socialLines(part)} : {}),
+      ...(staticDates.has(index) ? {staticDate: staticDates.get(index)} : {})}))};
 }
 
 export function attachFurnitureTags(entries, records, manifests) {
@@ -76,7 +135,7 @@ function readTags(container, relationships, entries) {
     } catch { unreadable = true; }
   }
   return {tags: tags.filter(tag => tag.name?.toUpperCase() === TAG),
-    ambiguous: unreadable || tags.filter(tag => /^OPF_/i.test(tag.name)).length !== 1};
+    ambiguous: unreadable || tags.filter(tag => /^OPF_/i.test(tag.name) && tag.name.toUpperCase() !== SLIDE_TAG).length !== 1};
 }
 
 function validateManifest(manifest) {
@@ -94,21 +153,33 @@ function validateManifest(manifest) {
       check(object(content) && Object.keys(content).every(field => fields.includes(field)), 'Invalid furniture fields.');
       for (const [field, flag] of Object.entries(content)) {
         check(field === 'image' ? flag === 'native' : field === 'text' ? flag === 'literal' :
-          field === 'date' ? flag === false || flag === 'literal' : typeof flag === 'boolean', 'Invalid furniture field intent.');
+          field === 'date' ? typeof flag === 'boolean' || flag === 'literal' : typeof flag === 'boolean', 'Invalid furniture field intent.');
         if (flag !== false) expected.set(`${kind}.${zone}.${field}`, field === 'image' ? 'image' : 'text');
       }
     }
   }
+  if (manifest.formats !== undefined) {
+    check(object(manifest.formats), 'Invalid furniture formats.');
+    for (const [slot, format] of Object.entries(manifest.formats)) {
+      const [kind, zone, extra] = slot.split('.');
+      check(extra === undefined && object(manifest.definitions[kind]?.value?.[zone]) && object(format) && Object.keys(format).length > 0 &&
+        Object.entries(format).every(([setting, value]) => settings.includes(setting) && typeof value === 'string'), 'Invalid furniture format.');
+    }
+  }
   check(manifest.parts.length === expected.size, 'Incomplete furniture topology.');
   for (const part of manifest.parts) {
     check(object(part) && expected.get(key(part)) === part.type, 'Ambiguous furniture part.');
     check(Number.isSafeInteger(part.count) && part.count >= 1 && part.count <= 10000 && (part.type !== 'image' || part.count === 1), 'Invalid furniture line count.');
+    if (part.field === 'socials') check(Array.isArray(part.socials) && part.socials.length >= 1 && part.socials.length <= 100
+      && part.socials.every(line => object(line) && platformId.test(line.platform) && schemes.includes(line.scheme))
+      && new Set(part.socials.map(line => line.platform)).size === part.socials.length, 'Invalid social profile lines.');
+    else check(part.socials === undefined, 'Unexpected social profile lines.');
     expected.delete(key(part));
   }
-  if (manifest.parts.some(part => part.field === 'organization')) check(typeof manifest.organizationId === 'string' && /^[a-zA-Z0-9_-]+$/.test(manifest.organizationId), 'Invalid organization identity.');
+  if (manifest.parts.some(part => part.field === 'organization' || part.field === 'socials')) check(typeof manifest.organizationId === 'string' && /^[a-zA-Z0-9_-]+$/.test(manifest.organizationId), 'Invalid organization identity.');
 }
 
-function readSlide(context, entries, slideIndex, report, taggedText) {
+function readSlide(context, entries, slideIndex, slideCount, report, taggedText) {
   const {root, shapes, paragraphs, pictures, relationships, readPicture} = context;
   const candidates = {};
   const records = [];
@@ -143,7 +214,7 @@ function readSlide(context, entries, slideIndex, 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: [], organizations: [], sections: []};
+      const candidate = {scope: definition.scope, value, text: [], pictures: [], organizations: [], socials: [], sections: []};
       for (const [partIndex, part] of manifest.parts.entries()) {
         if (part.kind !== kind) continue;
         const group = records.filter(record => record.data.part === partIndex);
@@ -161,10 +232,21 @@ function readSlide(context, entries, slideIndex, report, taggedText) {
             ordered[line] = record;
           }
           const text = sourceLineParagraphs(ordered, paragraphs)[0].text;
-          if (part.field === 'slideNumber') check(text === String(slideIndex + 1), 'Current slide number differs from its position; retain the visible number as ordinary text.');
+          const format = manifest.formats?.[`${kind}.${part.zone}`] ?? {};
+          if (part.field === 'slideNumber') {
+            // The live field renumbers in PowerPoint; any fixed text around it
+            // must still match the recorded format at this slide's position.
+            check(text === formatSlideNumber(format.slideNumberFormat ?? '{current}', slideIndex + 1, slideCount), 'Current slide number differs from its position; retain the visible number as ordinary text.');
+            if (format.slideNumberFormat !== undefined) value[part.zone].slideNumberFormat = format.slideNumberFormat;
+          }
           if (part.field === 'section') candidate.sections.push(text);
           if (part.field === 'organization') candidate.organizations.push({id: manifest.organizationId, name: text});
-          value[part.zone][part.field] = ['text', 'date'].includes(part.field) ? text : true;
+          if (part.field === 'socials') {
+            const lines = text.split('\n');
+            check(lines.length === part.socials.length && lines.every(line => line.trim()), 'Current social profile lines no longer match their platforms.');
+            candidate.socials.push({id: manifest.organizationId, socials: Object.fromEntries(part.socials.map((line, index) => [line.platform, line.scheme + lines[index]]))});
+          }
+          value[part.zone][part.field] = part.field === 'text' ? text : part.field === 'date' ? importedDate(definition.value[part.zone].date, format, text, ordered.flatMap(record => (paragraphs[record.index] ?? []).flatMap(paragraph => paragraph.fields ?? [])), value[part.zone], part.staticDate, ordered, paragraphs, message => report(slideIndex, `${kind}.${part.zone}.date: ${message}`)) : true;
           candidate.text.push(...ordered.map(record => record.index));
         }
       }
@@ -175,15 +257,40 @@ function readSlide(context, entries, slideIndex, report, taggedText) {
   return candidates;
 }
 
+// A current native date field wins. Full-mode static-wrap evidence can recover
+// generated OPF intent without turning the existing PPTX text into a live field. A fixed
+// date keeps its ISO value and pattern only when the current text round-trips.
+// Otherwise the current words import as a literal date.
+function importedDate(flag, format, text, nativeFields, zone, marker, ordered, paragraphs, report) {
+  if (flag === true) {
+    const pattern = nativeFields.length === 1 && nativeFields[0].text === text ? dateFormatForField[nativeFields[0].type] : undefined;
+    if (pattern) {
+      if (format.dateFormat !== undefined || pattern !== DEFAULT_DATE_FORMAT) zone.dateFormat = pattern;
+      return true;
+    }
+    if (marker !== undefined) try {
+      check(nativeFields.length === 0, 'A current native field no longer matches the static date evidence.');
+      unchangedStaticDate(marker, format, ordered, paragraphs);
+      if (format.dateFormat !== undefined) zone.dateFormat = format.dateFormat;
+      return true;
+    } catch (error) { report(`${error.message} Keep the current date as literal text.`); }
+    return text;
+  }
+  const iso = format.dateFormat === undefined ? null : parseDate(text, format.dateFormat);
+  if (iso) zone.dateFormat = format.dateFormat;
+  return iso ?? text;
+}
+
 // Reconcile metadata before consuming any shapes. Global inheritance is promoted
 // only when every slide has a valid definition/override and all inherited values
 // agree. A missing tag must never cause another slide's furniture to reappear.
 export function importFurniture(contexts, entries, onDiagnostic) {
   const report = (index, message) => onDiagnostic?.({code: 'invalid-furniture-provenance', path: `slides.${index}.design`, message: `${message} Ordinary import retains current native content; no old source words are restored.`});
   const taggedText = contexts.map(() => new Set());
-  const candidates = contexts.map((context, index) => readSlide(context, entries, index, report, taggedText[index]));
+  const candidates = contexts.map((context, index) => readSlide(context, entries, index, contexts.length, report, taggedText[index]));
   const organizations = candidates.flatMap(slide => Object.values(slide).flatMap(candidate => candidate.organizations));
-  if (organizations.some(item => !same(item, organizations[0]))) {
+  const organizationConflict = organizations.some(item => !same(item, organizations[0]));
+  if (organizationConflict) {
     for (const [index, slide] of candidates.entries()) for (const kind of kinds) if (slide[kind]?.organizations.length) {
       delete slide[kind]; report(index, `${kind}: Current organization metadata disagrees across repeated fields.`);
     }
@@ -194,6 +301,15 @@ export function importFurniture(contexts, entries, onDiagnostic) {
       delete slide[kind]; report(index, `${kind}: Current section metadata disagrees on this slide.`);
     }
   }
+  // Social profiles belong to the organization named by repeated furniture; without
+  // that name (or with disagreeing values) the lines stay ordinary current text.
+  const owner = candidates.flatMap(slide => Object.values(slide).flatMap(candidate => candidate.organizations))[0];
+  const socials = candidates.flatMap(slide => Object.values(slide).flatMap(candidate => candidate.socials));
+  if (socials.length && (!owner || socials.some(item => item.id !== owner.id || !same(item, socials[0])))) {
+    for (const [index, slide] of candidates.entries()) for (const kind of kinds) if (slide[kind]?.socials.length) {
+      delete slide[kind]; report(index, `${kind}: ${owner ? 'Current social profile metadata disagrees across repeated fields.' : 'Social profiles need a repeated organization name to rebuild organization metadata.'}`);
+    }
+  }
   const result = {design: {}, slides: candidates.map((slide, index) => {
     const values = Object.values(slide), sections = values.flatMap(candidate => candidate.sections);
     return {design: Object.fromEntries(Object.entries(slide).map(([kind, candidate]) => [kind, candidate.value])),
@@ -202,6 +318,10 @@ export function importFurniture(contexts, entries, onDiagnostic) {
   })};
   const validOrganizations = candidates.flatMap(slide => Object.values(slide).flatMap(candidate => candidate.organizations));
   if (validOrganizations.length) result.organization = validOrganizations[0];
+  const validSocials = candidates.flatMap(slide => Object.values(slide).flatMap(candidate => candidate.socials));
+  if (result.organization && validSocials.length) result.organization = {...result.organization, socials: validSocials[0].socials};
+  // Stored document metadata (FF-32) must not override disagreeing visible names.
+  if (organizationConflict) result.organizationConflict = true;
   for (const kind of kinds) {
     const inherited = candidates.map(slide => slide[kind]).filter(candidate => candidate?.scope === 'global');
     if (inherited.length && candidates.every(slide => slide[kind]) && inherited.every(candidate => same(candidate.value, inherited[0].value))) {

package/dist/image-geometry.js

@@ -12,7 +12,15 @@ export function rasterMetadata(bytes) {
   const text = (at, n) => String.fromCharCode(...bytes.subarray(at, at + n));
   const size = (width, height, mediaType) => Number.isInteger(width) && Number.isInteger(height) && width > 0 && height > 0 ? { width, height, mediaType } : null;
   if (bytes.length >= 33 && text(0, 8) === '\x89PNG\r\n\x1a\n' && view.getUint32(8) === 13 && text(12, 4) === 'IHDR') {
-    return size(view.getUint32(16), view.getUint32(20), "image/png");
+    const dimensions = size(view.getUint32(16), view.getUint32(20), "image/png");
+    // pHYs precedes IDAT. Only the metre unit defines a physical resolution.
+    for (let at = 33; dimensions && at + 12 <= bytes.length;) {
+      const length = view.getUint32(at), kind = text(at + 4, 4);
+      if (kind === 'IDAT' || kind === 'IEND' || at + 12 + length > bytes.length) break;
+      if (kind === 'pHYs' && length === 9 && bytes[at + 16] === 1) return { ...dimensions, ...resolution(view.getUint32(at + 8) * .0254, view.getUint32(at + 12) * .0254) };
+      at += 12 + length;
+    }
+    return dimensions;
   }
   if (bytes.length >= 13 && ['GIF87a', 'GIF89a'].includes(text(0, 6))) {
     return size(view.getUint16(6, true), view.getUint16(8, true), "image/gif");
@@ -39,7 +47,10 @@ export function rasterMetadata(bytes) {
     return null;
   }
   if (bytes.length >= 4 && bytes[0] === 0xff && bytes[1] === 0xd8) {
-    let dimensions = null, orientation = null;
+    let dimensions = null, orientation = null, jfif = null, exif = null;
+    // JFIF density (in inches or centimetres) takes precedence over EXIF
+    // X/YResolution; a JFIF aspect-ratio-only density (unit 0) defines no DPI.
+    const result = () => dimensions ? { ...dimensions, ...(jfif ?? exif), ...orientation } : null;
     // JPEG segment lengths include their two length bytes. Every iteration
     // advances within the input, including fill bytes and standalone markers.
     for (let at = 2; at < bytes.length;) {
@@ -47,7 +58,7 @@ export function rasterMetadata(bytes) {
       while (at < bytes.length && bytes[at] === 0xff) at++;
       if (at >= bytes.length) return null;
       const marker = bytes[at++];
-      if (marker === 0xda || marker === 0xd9) return dimensions ? { ...dimensions, ...orientation } : null;
+      if (marker === 0xda || marker === 0xd9) return result();
       if (marker === 0x01 || (marker >= 0xd0 && marker <= 0xd7)) continue;
       if (at + 2 > bytes.length) return null;
       const length = view.getUint16(at);
@@ -55,14 +66,55 @@ export function rasterMetadata(bytes) {
       if ([0xc0, 0xc1, 0xc2, 0xc3, 0xc5, 0xc6, 0xc7, 0xc9, 0xca, 0xcb, 0xcd, 0xce, 0xcf].includes(marker)) {
         dimensions = length >= 8 ? size(view.getUint16(at + 5), view.getUint16(at + 3), "image/jpeg") : null;
       }
-      if (marker === 0xe1 && text(at + 2, 6) === 'Exif\x00\x00') orientation ??= exifOrientation(bytes, at + 8, at + length);
+      if (marker === 0xe1 && text(at + 2, 6) === 'Exif\x00\x00') {
+        orientation ??= exifOrientation(bytes, at + 8, at + length);
+        exif ??= exifResolution(bytes, at + 8, at + length);
+      }
+      if (marker === 0xe0 && length >= 14 && text(at + 2, 5) === 'JFIF\x00' && (bytes[at + 9] === 1 || bytes[at + 9] === 2)) {
+        const unit = bytes[at + 9] === 1 ? 1 : 2.54;
+        jfif ??= resolution(view.getUint16(at + 10) * unit, view.getUint16(at + 12) * unit);
+      }
       at += length;
     }
-    return dimensions ? { ...dimensions, ...orientation } : null;
+    return result();
   }
   return null;
 }
 
+// Physical resolution in dots per inch, when both axes are positive.
+function resolution(x, y) {
+  return Number.isFinite(x) && Number.isFinite(y) && x > 0 && y > 0 ? { dpiX: x, dpiY: y } : null;
+}
+
+// IFD0 XResolution/YResolution (RATIONAL) with ResolutionUnit 2 (inch, the
+// default) or 3 (centimetre). Every value read stays within the APP1 segment.
+function exifResolution(bytes, start, end) {
+  if (start + 8 > end) return null;
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const littleEndian = bytes[start] === 0x49 && bytes[start + 1] === 0x49;
+  if (!littleEndian && !(bytes[start] === 0x4d && bytes[start + 1] === 0x4d)) return null;
+  if (view.getUint16(start + 2, littleEndian) !== 42) return null;
+  const directory = start + view.getUint32(start + 4, littleEndian);
+  if (directory < start + 8 || directory + 2 > end) return null;
+  const count = view.getUint16(directory, littleEndian);
+  if (directory + 2 + count * 12 > end) return null;
+  const values = {};
+  for (let i = 0; i < count; i++) {
+    const at = directory + 2 + i * 12, tag = view.getUint16(at, littleEndian), type = view.getUint16(at + 2, littleEndian);
+    if (view.getUint32(at + 4, littleEndian) !== 1) continue;
+    if ((tag === 0x11a || tag === 0x11b) && type === 5) {
+      const value = start + view.getUint32(at + 8, littleEndian);
+      if (value < start + 8 || value + 8 > end) continue;
+      const denominator = view.getUint32(value + 4, littleEndian);
+      if (denominator) values[tag] = view.getUint32(value, littleEndian) / denominator;
+    }
+    if (tag === 0x128 && type === 3) values.unit = view.getUint16(at + 8, littleEndian);
+  }
+  const unit = values.unit ?? 2;
+  if (unit !== 2 && unit !== 3) return null;
+  return resolution(values[0x11a] * (unit === 3 ? 2.54 : 1), values[0x11b] * (unit === 3 ? 2.54 : 1));
+}
+
 // Read only IFD0's inline SHORT orientation. All offsets and entry counts
 // stay within the APP1 segment; no linked IFDs or external values are followed.
 function exifOrientation(bytes, start, end) {
@@ -111,3 +163,23 @@ export function normalizeImageOrientation(bytes, metadata) {
   new DataView(output.buffer, output.byteOffset, output.byteLength).setUint16(metadata.orientationOffset, 1, metadata.littleEndian);
   return output;
 }
+
+// Keep the picture frame at the allocated box and express crop/fit through
+// a:srcRect. Crop trims the centered overflow (positive insets); fit pads the
+// centered image with negative insets. Frame-based masks, lines and effects
+// therefore apply to the same box as the SVG preview's clipped <image>.
+export function framePicture(image, box, mode) {
+  const scale = (mode === 'crop' ? Math.max : Math.min)(box.w / image.width, box.h / image.height);
+  const horizontal = Math.round((1 - box.w / (image.width * scale)) * 50000) || 0;
+  const vertical = Math.round((1 - box.h / (image.height * scale)) * 50000) || 0;
+  return { ...box, crop: horizontal || vertical ? { l: horizontal, t: vertical, r: horizontal, b: vertical } : null };
+}
+
+export function framedPictureTransform(metadata, box, mode) {
+  const orientation = metadata.orientation ?? 1;
+  const target = orientation >= 5
+    ? { x: box.x + (box.w - box.h) / 2, y: box.y + (box.h - box.w) / 2, w: box.h, h: box.w }
+    : box;
+  const rotation = [0, 0, 0, 180, 0, 90, 90, 90, 270][orientation];
+  return { ...framePicture(metadata, target, mode), rotation, flipH: orientation === 2 || orientation === 7, flipV: orientation === 4 || orientation === 5 };
+}