@openpresentation/opf-pptx 0.2.1 → 0.4.0

package/README.md

@@ -67,7 +67,9 @@ The first importer is mechanical and schema-compatible:
 - Remaining text boxes map to `blocks[]` as text or list payloads, sorted by OOXML position.
 - PowerPoint tables map to OPF table blocks, embedded images map to data URI image blocks, and cached chart series map to basic OPF chart blocks.
 - 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.
-- Imported table values are display strings: numeric/boolean/null types, rich cell formatting, whitespace and merged-cell semantics are not losslessly reconstructed.
+- Native table text preserves run/field/break order, significant whitespace, and blank paragraphs. Cells with supported formatting become canonical `TextRun[]`; unstyled body cells stay strings. Explicit normal headers override OPF’s bold header default. Numeric/boolean/null source types cannot be reconstructed from native display text.
+- Imported runs retain bold, italic, underline, strike, point sizes, Latin font families, solid colors/alpha, external hyperlink URLs, and superscript/subscript direction. List-level and paragraph defaults apply before run overrides; supported theme fonts/colors resolve from the archive. Field values become their cached text, and underline/strike variants and baseline magnitudes reduce to OPF booleans.
+- Conditional table styles, merged-cell geometry, cell fills/borders/alignment, unsupported text fills/colors, and internal hyperlink actions are not fully reconstructed. `onDiagnostic` reports unsupported table style references, merges, fonts/colors/fills and links with native frame/cell paths. Table paths use the native graphic-frame and row indexes, including a header row. The shared core 0.6.0 layout sizes rows from their content and reports `text-overflow` when text cannot fit at the minimum size. These checks establish native XML conversion, not visual parity with PowerPoint.
 - Unknown non-text shapes and unsupported graphic frames become editable text fallback blocks instead of failing the import.
 
 There is no AI classification pass in the OSS runtime. Hosts can run optional cleanup or semantic remapping after `fromPptx` returns.
@@ -109,11 +111,11 @@ Required first-publish setup:
 
 This repo does not require an npm automation token when Trusted Publishing is configured.
 
-## Shared dynamic composition (local development)
+## Shared dynamic composition
 
 The current checkout uses `@openpresentation/opf/composition` for portable geometry. Slides can select `auto`, `row`, `column`, or `grid`, set weighted tracks, and request path-specific overflow diagnostics. See the sibling OPF repo's `docs/dynamic-composition.md` for the complete contract.
 
-Version 0.1.0 requires published `@openpresentation/opf@^0.4.0`. The optional renderer peer requires `@openpresentation/opf-render@^0.1.0`. Clean registry installs support the new composition APIs without sibling checkouts. For coordinated source development, build OPF and run `node scripts/link-ecosystem.mjs` there; `pnpm test:ecosystem` verifies shared geometry and import/export behavior.
+Version 0.4.0 requires published `@openpresentation/opf@^0.6.0`. The optional renderer peer requires `@openpresentation/opf-render@^0.4.0`. Clean registry installs support the new composition APIs without sibling checkouts. For coordinated source development, build OPF and run `node scripts/link-ecosystem.mjs` there; `pnpm test:ecosystem` verifies shared geometry and import/export behavior.
 
 For crowded drafts, run `paginatePresentation` from `@openpresentation/opf/pagination` first, then pass its returned presentation to both preview and `toPptx`. Native table row sizing now follows shared reference geometry; the exporter does not add hidden table continuation slides.
 
@@ -121,15 +123,17 @@ Pass the same `textMeasurement` provider used by preview and pagination to `toPp
 
 PptxGenJS is pinned to 4.0.1. Its unused `image-size` dependency remains flagged by npm audit; tested OPF operations run with that parser blocked. See [dependency reachability and regression coverage](DEPENDENCY-NOTES.md).
 
-### Native table fitting (unreleased)
+### Native table fitting
 
-The development exporter measures every cell with the same `textMeasurement` provider, font roles and effective nested `minFontSize` used by the SVG preview. Native table cells retain the original strings and values as text, with matching fitted sizes, line spacing, alignment, margins and row/column geometry. Uneven rows receive empty cells for missing columns. Theme border colors now use the same slot as the preview.
+Version 0.4.0 imports and exports supported rich table cells and headers as editable runs, retaining resolved fonts, emphasis, color/alpha, hyperlinks, script positions and explicit line breaks. Import reads native XML, including paragraph defaults and significant whitespace; unstyled body cells remain strings. Shared core 0.6.0 layout grows rows for multiline content and fits text consistently with renderer 0.4.0 without inserting measured soft wraps. Native PowerPoint rendering remains unverified.
 
-`npm test` compares exported OOXML against the published SVG renderer across 168 cells, including 24 cases that require shrinking, Roboto and Calibri-to-Carlito substitution, two canvas sizes, headers and all three alignments. PowerPoint still performs its own natural wrapping and needs the resolved fonts installed. These document-property checks do not establish native raster parity or lossless typed-cell import.
+The exporter measures every cell with the same `textMeasurement` provider, font roles and effective nested `minFontSize` used by the SVG preview. Native table cells retain the original strings and values as text, with matching fitted sizes, line spacing, alignment, margins and row/column geometry. Uneven rows receive empty cells for missing columns. Theme border colors now use the same slot as the preview.
+
+`npm test` compares exported OOXML against the published SVG renderer across 168 cells, including 24 cases that require taller rows, Roboto and Calibri-to-Carlito substitution, two canvas sizes, headers and all three alignments. PowerPoint still performs its own natural wrapping and needs the resolved fonts installed. These document-property checks do not establish native raster parity or lossless typed-cell import.
 
 A local macOS Quick Look check opened both Roboto and system-Arial specimens. Quick Look substituted a serif font for uninstalled Roboto; the Arial specimen used a sans-serif face but still differed in table wrapping and row proportions. This is evidence of remaining viewer differences, not a passing PowerPoint raster comparison.
 
-## Image geometry (unreleased)
+## Image geometry
 
 Native image exports now follow the browser's `design.imageFill`: `fit` (the default) centers an image without changing its aspect ratio, and `crop` fills the allocated box with a centered native crop. Slide settings override presentation settings. Geometry is calculated from the exact bytes embedded after asset resolution, so host resolvers are called once. PNG, JPEG, GIF and WebP dimension headers are supported; unsupported or unreadable dimensions produce a path-specific error rather than a distorted picture. Supply supported raster bytes through `imageResolver` for other formats.
 
@@ -154,7 +158,7 @@ Node conversion lazily loads the pinned open-source Sharp dependency and require
 `npm test` includes the Node pixel-reference cases and verifies browser bundling. To run the browser pixel checks, run `npm run build:browser-check`, serve this repository locally, and open `/artifacts/webp-fallback/browser/index.html`. The page reports 13 checks covering embedded PNG pixels, alpha, EXIF, the first animation frame, fit/crop, resolver calls and DOM canvas fallback. These are browser export checks, separate from the recorded Keynote viewing evidence.
 
 
-## Native background fills (unreleased)
+## Native background fills
 
 Fixed solid and linear-gradient backgrounds now export as native slide fills, keeping the background editable without rasterizing slide content. Deck defaults, inline theme overrides and per-slide overrides are resolved before export. Solid opacity, gradient stop colors/positions and combined color/background alpha are preserved. Empty and single-stop gradients follow the SVG preview's transparent/solid behavior; descending stop positions clamp to the preceding stop.
 
@@ -165,7 +169,7 @@ Import reads supported native RGB solid/linear fills directly; it uses no hidden
 Node 20/24 tests and the 126-deck / 805-slide structural corpus pass. This proves serialization and the mathematical mapping, not native viewer pixels. Keynote 14.4 recognizes the editable native gradients. Twelve captured native PNGs now support 18 comparisons, including a Keynote-generated PPTX import: opaque differences are at most 4/255 per channel (mean below 0.38), and transparent portrait alpha differs by at most 1/255. The checked-in references run in ordinary Node tests without Keynote. Quick Look still renders these specimens as a flat average color, so its thumbnails are not evidence of their native appearance. Microsoft PowerPoint remains unavailable and unverified. Pattern/image backgrounds, theme-aware native fills, and other design decorations remain separate fidelity work.
 
 
-## JPEG orientation on import (unreleased)
+## JPEG orientation on import
 
 `fromPptx` now preserves native quarter-turns and mirroring for JPEG pictures by writing the combined orientation into EXIF metadata. Existing embedded EXIF orientation is applied before the native transform. This requires no pixel decoder, recompression, upload or new dependency. The original PPTX remains unchanged, and alternative text survives. The eight orientations produced by this exporter restore the exact source JPEG bytes through repeated fit-mode export/import cycles.
 

package/dist/background-import.js

@@ -1,18 +1,18 @@
 import {XMLParser} from 'fast-xml-parser';
 import {readNativeBackground, readBackgroundColor, colorTransforms} from './background.js';
 
-const orderedParser = new XMLParser({ignoreAttributes: false, attributeNamePrefix: '', preserveOrder: true, parseAttributeValue: false, parseTagValue: false});
+const orderedParser = new XMLParser({ignoreAttributes: false, attributeNamePrefix: '', preserveOrder: true, parseAttributeValue: false, parseTagValue: false, trimValues: false});
 const defaultMapping = {bg1:'lt1',tx1:'dk1',bg2:'lt2',tx2:'dk2'};
 const children = (nodes, name) => nodes?.find(node => Object.hasOwn(node, name))?.[name];
-function object(nodes) {
+export function drawingObject(nodes) {
   const result = Object.create(null);
   for (const node of nodes ?? []) for (const [name, value] of Object.entries(node)) {
     if (name === ':@' || name === '#text') continue;
-    const child = {...(node[':@'] ?? {}), ...object(value)};
+    const child = {...(node[':@'] ?? {}), ...drawingObject(value)};
     if (['a:srgbClr', 'a:sysClr', 'a:schemeClr'].includes(name)) {
       child[colorTransforms] = (value ?? []).flatMap(item => Object.keys(item)
         .filter(key => key !== ':@' && key !== '#text')
-        .map(key => [key, {...(item[':@'] ?? {}), ...object(item[key])}]));
+        .map(key => [key, {...(item[':@'] ?? {}), ...drawingObject(item[key])}]));
     }
     if (Object.hasOwn(result, name)) result[name] = Array.isArray(result[name]) ? [...result[name], child] : [result[name], child];
     else result[name] = child;
@@ -27,13 +27,13 @@ function parsed(bytes, parse) {
   if (!bytes) return undefined;
   if (!parsedParts.has(bytes)) {
     const tree = parse();
-    parsedParts.set(bytes, {tree, value: object(tree)});
+    parsedParts.set(bytes, {tree, value: drawingObject(tree)});
   }
   return parsedParts.get(bytes);
 }
 
 // Resolve only relationships inside the input archive; never fetch theme URLs.
-export function importBackground(slidePath, dimensions, {part, relationships, bytes}, report) {
+export function readSlideTheme(slidePath, {part, relationships, bytes}) {
   const parsedPart = path => parsed(bytes(path), () => part(path, orderedParser));
   const value = path => parsedPart(path)?.value;
   const related = (path, type) => [...relationships(path).values()].find(rel => rel.type.endsWith('/' + type) && bytes(rel.path))?.path;
@@ -49,7 +49,7 @@ export function importBackground(slidePath, dimensions, {part, relationships, by
     if (override?.['a:overrideClrMapping']) mapping = {...defaultMapping, ...override['a:overrideClrMapping']};
     else if (override && Object.hasOwn(override, 'a:masterClrMapping')) mapping = masterMapping;
   }
-  let colors, format, formatPath;
+  let colors, fonts, format, formatPath;
   for (const {path} of [...chain].reverse()) {
     for (const type of ['theme', 'themeOverride']) {
       const themePath = related(path, type);
@@ -57,9 +57,15 @@ export function importBackground(slidePath, dimensions, {part, relationships, by
       const doc = value(themePath);
       const elements = type === 'theme' ? doc?.['a:theme']?.['a:themeElements'] : doc?.['a:themeOverride'];
       if (elements?.['a:clrScheme']) colors = elements['a:clrScheme'];
+      if (elements?.['a:fontScheme']) fonts = elements['a:fontScheme'];
       if (elements?.['a:fmtScheme']) {format = elements['a:fmtScheme'];formatPath = themePath;}
     }
   }
+  return {chain, colors, mapping, fonts, format, formatPath, parsedPart};
+}
+
+export function importBackground(slidePath, dimensions, archive, report) {
+  const {chain, colors, mapping, format, formatPath, parsedPart} = readSlideTheme(slidePath, archive);
   const background = chain.map(item => item.root?.['p:cSld']?.['p:bg']).find(value => value !== undefined);
   if (!background) return undefined;
   const unsupported = () => {
@@ -84,5 +90,5 @@ export function importBackground(slidePath, dimensions, {part, relationships, by
   const style = styles?.[index < 1000 ? index - 1 : index - 1001];
   if (!style) return unsupported();
   context.placeholder = readBackgroundColor(reference, context);
-  return readNativeBackground(object([style]), dimensions, report, context);
+  return readNativeBackground(drawingObject([style]), dimensions, report, context);
 }

package/dist/index.d.ts

@@ -48,7 +48,7 @@ export interface ToPptxOptions {
 }
 
 export interface FromPptxOptions {
-  /** Reports native gradient or picture crop/transform details that OPF import cannot preserve. Picture paths identify the native picture index. */
+  /** Reports native background, picture and table details that OPF import cannot preserve. Table paths identify the native graphic-frame and row/cell indexes (including headers). */
   onDiagnostic?: (diagnostic: {code: string; path: string; message: string}) => void;
   fallbackName?: string;
   schema?: string;

package/dist/index.js

@@ -1,9 +1,10 @@
+import {importTableFrames} from './table-import.js';
 import {importImageOrientation} from './image-import.js';
 import {nativeBackgroundFill} from './background.js';
 import {importBackground} from './background-import.js';
 import { webpToPng } from '#image-fallback';
 import { rasterMetadata, pictureTransform, normalizeImageOrientation } from './image-geometry.js';
-import { composeSlide, fitText, textWidthMeasurer, resolveCanvasDimensions, resolveFontFamilies, resolveTextStyle } from "@openpresentation/opf/composition";
+import { layoutTable, composeSlide, fitText, fitRichText, textWidthMeasurer, resolveCanvasDimensions, resolveFontFamilies, resolveTextStyle } from "@openpresentation/opf/composition";
 import PptxGenJS from "pptxgenjs";
 import { unzipSync, zipSync } from "fflate";
 import { XMLParser } from "fast-xml-parser";
@@ -282,6 +283,7 @@ function parseRelationships(entries, sourcePartPath) {
       id: relationship.Id,
       type: relationship.Type ?? "",
       target: relationship.Target ?? "",
+      targetMode: relationship.TargetMode ?? "Internal",
       path: resolveRelationshipTarget(sourcePartPath, relationship.Target ?? "")
     });
   }
@@ -404,8 +406,13 @@ function collectSlideItems(entries, slideRoot, slidePath, relationships, dimensi
     if (item) items.push(item);
   }
 
-  for (const frame of asArray(tree?.["p:graphicFrame"])) {
-    const item = importGraphicFrame(entries, frame, slidePath, relationships);
+  const frames = asArray(tree?.["p:graphicFrame"]);
+  const tables = frames.some(frame => frame['a:graphic']?.['a:graphicData']?.['a:tbl'])
+    ? importTableFrames(slidePath, {
+      part: (path, parser) => parseRequiredXml(entries, path, parser), relationships: path => parseRelationships(entries, path), bytes: path => entries[path]
+    }, relationships, (frame, cell, code, message) => options.onDiagnostic?.({code, message, path: `slides.${slideIndex}.tables.${frame}${cell ? '.' + cell : ''}`})) : [];
+  for (const [index, frame] of frames.entries()) {
+    const item = importGraphicFrame(entries, frame, slidePath, relationships, tables[index]);
     if (item) items.push(item);
   }
 
@@ -446,7 +453,7 @@ function importShape(shape, dimensions) {
   };
 }
 
-function importGraphicFrame(entries, frame, slidePath, relationships) {
+function importGraphicFrame(entries, frame, slidePath, relationships, importedTable) {
   const bounds = shapeBounds(frame["p:xfrm"]);
   const name = scalarText(frame["p:nvGraphicFramePr"]?.["p:cNvPr"]?.name).trim();
   const graphicData = frame["a:graphic"]?.["a:graphicData"];
@@ -458,7 +465,7 @@ function importGraphicFrame(entries, frame, slidePath, relationships) {
       name,
       payload: {
         type: "table",
-        table: tableFromXml(table)
+        table: importedTable
       }
     };
   }
@@ -632,18 +639,6 @@ function payloadFromSlideItem(item) {
   return null;
 }
 
-function tableFromXml(table) {
-  const rows = asArray(table["a:tr"])
-    .map((row) => asArray(row?.["a:tc"]).map((cell) => textFromTextBody(cell?.["a:txBody"])));
-  // DrawingML's firstRow flag applies header-row formatting. Without that
-  // signal, retain all rows as data instead of guessing from their contents.
-  const firstRow = table["a:tblPr"]?.firstRow;
-  const hasHeaders = firstRow === "1" || firstRow === "true";
-  return hasHeaders && rows.length
-    ? { columns: rows[0], rows: rows.slice(1) }
-    : { rows };
-}
-
 function chartFromRelationship(entries, slidePath, relationships, relId) {
   const relationship = relationships.get(relId);
   if (!relationship?.path || !entries[relationship.path]) return null;
@@ -1110,28 +1105,45 @@ function addTablePayload(slide, table, region, context, options, path) {
     return;
   }
 
-  const columnCount = Math.max(1, ...sourceRows.map(row => row.length));
-  const rowHeight = Math.min(54 * scale / 96, region.h / sourceRows.length);
-  const cellBox = {
-    x: 0, y: 0,
-    width: Math.max(scale, region.w * 96 / columnCount - 20 * scale),
-    height: Math.max(scale, rowHeight * 96 - 12 * scale),
-  };
-  const rows = sourceRows.map((row, rowIndex) => Array.from({ length: columnCount }, (_, columnIndex) => {
-    const header = hasHeaders && rowIndex === 0;
-    const cellPath = header ? `${path}.columns.${columnIndex}` : `${path}.rows.${rowIndex - Number(hasHeaders)}.${columnIndex}`;
-    const text = stringifyText(row[columnIndex]);
-    const style = resolveTextStyle({ fontFamily: context.fonts.body, fontWeight: header ? 700 : 400, italic: false, path: cellPath }, options.textMeasurement);
-    const fit = fitText(text, cellBox, 15 * scale, (context.composition?.minFontSize ?? 16) * scale, textWidthMeasurer(style, options.textMeasurement));
+  const layout = layoutTable(table, {x:region.x*96,y:region.y*96,width:region.w*96,height:region.h*96}, {
+    scale, minFontSize:context.composition?.minFontSize, fontFamily:context.fonts.body, textMeasurement:options.textMeasurement, path
+  });
+  const columnCount = layout.columnCount;
+  const rows = layout.rows.map(row => row.cells.map(cell => {
+    const {header,rich,fit} = cell;
+    const text = stringifyText(cell.value), style = cell.textStyle;
+    const fragments = rich ? fit.richLines.flatMap(line => line.fragments) : [];
+    const runs = rich ? cell.value.flatMap((value, index) => {
+      const run = typeof value === 'string' ? {text:value} : value;
+      const fragment = fragments.find(item => item.runIndex === index);
+      const runStyle = fragment?.style ?? resolveTextStyle({...style,fontFamily:run.fontFamily ?? style.fontFamily,fontWeight:run.bold === undefined ? style.fontWeight : run.bold ? 700 : 400,italic:run.italic ?? style.italic}, options.textMeasurement);
+      const rawColor = /^#(?:[0-9a-f]{3}|[0-9a-f]{6}|[0-9a-f]{8})$/i.test(run.color ?? '') ? run.color.slice(1) : header ? 'FFFFFF' : context.colors.text;
+      const color = normalizeHex(rawColor), transparency = rawColor.length === 8 ? (1 - parseInt(rawColor.slice(6), 16) / 255) * 100 : 0;
+      const runOptions = {
+        fontFace:runStyle.fontFamily,fontSize:fragment ? fragment.fontSize * .75 : fit.fontSize * .75,
+        bold:runStyle.fontWeight >= 600,italic:runStyle.italic,
+        underline:run.underline ? {color} : undefined,strike:run.strikethrough ? 'sngStrike' : undefined,
+        color,transparency,baseline:fragment?.baselineShift ? -fragment.baselineShift / fragment.fontSize * 2000 : undefined,
+        hyperlink:run.link && /^(https?:|mailto:)/i.test(run.link) ? {url:run.link} : undefined,
+      };
+      // PptxGenJS marks every part of a newline-containing run as a paragraph
+      // break, including its final part. Split explicitly so the next styled
+      // run stays on that final line, and preserve empty/trailing lines.
+      const parts = run.text.split(/\r*\n/);
+      return parts.map((text, part) => ({text,options:{...runOptions,breakLine:part < parts.length - 1}}));
+    }) : null;
     return {
       // Keep native wrapping and the original cell value: inserting measured
       // soft wraps into the text would change a later import or copy operation.
-      text,
+      text: rich ? runs : text,
       options: {
         fontFace: style.fontFamily,
         fontSize: fit.fontSize * 0.75,
-        bold: style.fontWeight >= 600,
-        italic: style.italic,
+        // PptxGenJS fills falsy run options from cell defaults. Rich runs
+        // carry their resolved weight, so a bold header default must not turn
+        // an explicit bold:false run back on.
+        bold: rich ? false : style.fontWeight >= 600,
+        italic: rich ? false : style.italic,
         lineSpacing: fit.lineHeight * 0.75,
         paraSpaceAfter: 0,
         align: context.contentAlignment,
@@ -1147,8 +1159,8 @@ function addTablePayload(slide, table, region, context, options, path) {
     x: region.x,
     y: region.y,
     w: region.w,
-    h: rowHeight * rows.length,
-    rowH: rowHeight,
+    h: layout.height / 96,
+    rowH: layout.rows.map(row => row.box.height / 96),
     colW: Array(columnCount).fill(region.w / columnCount),
     autoPage: false,
     fontFace: context.fonts.body,

package/dist/table-import.js

@@ -0,0 +1,108 @@
+import {drawingObject, readSlideTheme} from './background-import.js';
+import {readBackgroundColor} from './background.js';
+
+const nodes = (tree, tag) => (tree ?? []).filter(node => Object.hasOwn(node, tag));
+const child = (tree, tag) => nodes(tree, tag)[0]?.[tag];
+const attrs = (tree, tag) => nodes(tree, tag)[0]?.[':@'] ?? {};
+const text = tree => (tree ?? []).map(node => node['#text'] ?? '').join('');
+const boolean = value => value === '1' || value === 'true' ? true : value === '0' || value === 'false' ? false : undefined;
+
+function runStyle(properties, context, relationships, report) {
+  const result = {};
+  for (const [native, opf] of [['b','bold'], ['i','italic']]) {
+    const value = boolean(properties[native]);
+    if (value !== undefined) result[opf] = value;
+  }
+  for (const [native, opf] of [['u','underline'], ['strike','strikethrough']]) {
+    if (properties[native] !== undefined) result[opf] = properties[native] !== 'none' && properties[native] !== 'noStrike';
+  }
+  const size = Number(properties.sz);
+  if (Number.isFinite(size) && size > 0) result.fontSize = size / 100;
+  const baseline = Number(properties.baseline);
+  if (Number.isFinite(baseline)) {
+    result.superscript = baseline > 0;
+    result.subscript = baseline < 0;
+  }
+  const font = properties['a:latin']?.typeface;
+  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;
+    if (family) result.fontFamily = family;
+    else report('unsupported-table-font', 'The theme font reference could not be resolved from this archive.');
+  }
+  if (properties['a:solidFill']) {
+    const color = readBackgroundColor(properties['a:solidFill'], context);
+    if (color) result.color = color.hex + (color.alpha < 1 ? Math.round(color.alpha * 255).toString(16).padStart(2, '0').toUpperCase() : '');
+    else report('unsupported-table-text-color', 'The native text color or its transforms could not be resolved.');
+  } else if (properties['a:noFill']) {
+    result.color = '#00000000';
+  }
+  if (['a:gradFill','a:blipFill','a:pattFill','a:grpFill'].some(key => properties[key])) report('unsupported-table-text-fill', 'Only solid native text fills are represented by OPF runs.');
+  const hyperlink = properties['a:hlinkClick'];
+  if (hyperlink) {
+    const relationship = relationships.get(hyperlink['r:id']);
+    if (relationship?.type.endsWith('/hyperlink') && relationship.targetMode === 'External' && relationship.target && !hyperlink.action) result.link = relationship.target;
+    else report('unsupported-table-link', 'The native hyperlink action or relationship cannot be represented as a URL.');
+  }
+  return result;
+}
+
+// Merge at the native property level before conversion: an explicit normal run
+// overrides a bold paragraph default, and a new fill replaces the inherited fill.
+function mergeProperties(...levels) {
+  const result = {};
+  const fills = ['a:solidFill','a:noFill','a:gradFill','a:blipFill','a:pattFill','a:grpFill'];
+  for (const level of levels) {
+    if (!level) continue;
+    if (fills.some(key => Object.hasOwn(level, key))) for (const key of fills) delete result[key];
+    Object.assign(result, level);
+  }
+  return result;
+}
+
+function cellText(body, context, relationships, report, header) {
+  const listStyle = drawingObject(child(body, 'a:lstStyle'));
+  const paragraphs = nodes(body, 'a:p');
+  const runs = [];
+  const append = (value, style = {}) => {
+    if (!value) return;
+    runs.push(Object.keys(style).length ? {text:value, ...style} : value);
+  };
+  paragraphs.forEach((paragraph, index) => {
+    const content = paragraph['a:p'];
+    if (index) append('\n');
+    const pPr = drawingObject(content)['a:pPr'] ?? {};
+    const level = Number(pPr.lvl ?? 0) + 1;
+    const defaults = mergeProperties(header ? {b:'0'} : undefined, listStyle['a:defPPr']?.['a:defRPr'], listStyle[`a:lvl${level}pPr`]?.['a:defRPr'], pPr['a:defRPr']);
+    for (const node of content) {
+      const tag = ['a:r', 'a:fld', 'a:br'].find(tag => Object.hasOwn(node, tag));
+      if (!tag) continue;
+      const properties = mergeProperties(defaults, drawingObject(node[tag])['a:rPr']);
+      append(tag === 'a:br' ? '\n' : text(child(node[tag], 'a:t')), runStyle(properties, context, relationships, report));
+    }
+  });
+  return runs.some(run => typeof run !== 'string') ? runs : runs.join('');
+}
+
+// Use the same direct graphic-frame ordering as the slide collector. The ordered
+// reader retains interleaved runs, fields, breaks, empty paragraphs and spaces.
+export function importTableFrames(slidePath, archive, relationships, report) {
+  const context = readSlideTheme(slidePath, archive);
+  const root = child(context.parsedPart(slidePath)?.tree, 'p:sld');
+  const tree = child(child(root, 'p:cSld'), 'p:spTree');
+  return nodes(tree, 'p:graphicFrame').map((frame, frameIndex) => {
+    const table = child(child(child(frame['p:graphicFrame'], 'a:graphic'), 'a:graphicData'), 'a:tbl');
+    if (!table) return undefined;
+    const props = child(table, 'a:tblPr');
+    if (child(props, 'a:tableStyleId') || child(props, 'a:tableStyle')) report(frameIndex, '', 'unsupported-table-style', 'Conditional native table styles are not applied; direct cell and paragraph text formatting is retained.');
+    const headers = boolean(attrs(table, 'a:tblPr').firstRow) === true;
+    const rows = nodes(table, 'a:tr').map((row, rowIndex) => nodes(row['a:tr'], 'a:tc').map((cell, columnIndex) => {
+      const cellPath = `rows.${rowIndex}.${columnIndex}`;
+      const emit = (code, message) => report(frameIndex, cellPath, code, message);
+      const geometry = cell[':@'] ?? {};
+      if (['gridSpan','rowSpan'].some(key => Number(geometry[key] ?? 1) > 1) || ['hMerge','vMerge'].some(key => boolean(geometry[key]) === true)) emit('unsupported-table-merge', 'Merged-cell geometry is not represented; the native cell text is retained.');
+      return cellText(child(cell['a:tc'], 'a:txBody'), context, relationships, emit, headers && rowIndex === 0);
+    }));
+    return headers && rows.length ? {columns:rows[0], rows:rows.slice(1)} : {rows};
+  });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openpresentation/opf-pptx",
-  "version": "0.2.1",
+  "version": "0.4.0",
   "description": "Pure local OPF to PPTX export and PPTX to OPF import tooling.",
   "license": "MIT",
   "type": "module",
@@ -35,21 +35,21 @@
   "sideEffects": false,
   "scripts": {
     "build": "node scripts/build.mjs",
-    "typecheck": "node --check src/index.js && node --check scripts/build.mjs && node --check scripts/validate-package.mjs && node --check test/smoke.mjs && node --check src/image-geometry.js && node --check test/image-fit.mjs && node --check test/image-orientation.mjs && node --check test/table-layout.mjs && node --check test/table-import.mjs && node --check test/object-ids.mjs && node --check test/export-corpus.mjs && node --check test/image-media-type.mjs && node --check src/image-fallback-node.js && node --check src/image-fallback-browser.js && node --check test/webp-fallback.mjs && node --check scripts/build-browser-check.mjs && node --check test/webp-fallback-browser.js && node --check test/image-fallback-boundary.mjs && node --check src/background.js && node --check test/background.mjs && node --check src/image-import.js && node --check test/image-import.mjs && node --check test/native-background.mjs && node --check src/background-import.js && node --check test/background-inheritance.mjs",
+    "typecheck": "node --check src/index.js && node --check scripts/build.mjs && node --check scripts/validate-package.mjs && node --check test/smoke.mjs && node --check src/image-geometry.js && node --check test/image-fit.mjs && node --check test/image-orientation.mjs && node --check test/table-layout.mjs && node --check test/table-import.mjs && node --check test/object-ids.mjs && node --check test/export-corpus.mjs && node --check test/image-media-type.mjs && node --check src/image-fallback-node.js && node --check src/image-fallback-browser.js && node --check test/webp-fallback.mjs && node --check scripts/build-browser-check.mjs && node --check test/webp-fallback-browser.js && node --check test/image-fallback-boundary.mjs && node --check src/background.js && node --check test/background.mjs && node --check src/image-import.js && node --check test/image-import.mjs && node --check test/native-background.mjs && node --check src/background-import.js && node --check test/background-inheritance.mjs && node --check test/rich-table.mjs && node --check src/table-import.js && node --check test/rich-table-import.mjs && node --check test/rich-table-import-browser.js && node --check test/table-row-sizing.mjs",
     "test": "npm run build && node test/dependency-boundary.mjs && npm run build:browser-check",
     "validate": "node scripts/validate-package.mjs",
     "prepack": "npm run build",
     "build:browser-check": "node scripts/build-browser-check.mjs"
   },
   "dependencies": {
-    "@openpresentation/opf": "^0.4.1",
+    "@openpresentation/opf": "^0.6.0",
     "fast-xml-parser": "^5.8.0",
     "fflate": "^0.8.3",
     "pptxgenjs": "4.0.1",
     "sharp": "0.35.4"
   },
   "peerDependencies": {
-    "@openpresentation/opf-render": "^0.2.0"
+    "@openpresentation/opf-render": "^0.4.0"
   },
   "peerDependenciesMeta": {
     "@openpresentation/opf-render": {
@@ -57,7 +57,7 @@
     }
   },
   "devDependencies": {
-    "@openpresentation/opf-render": "0.2.0",
+    "@openpresentation/opf-render": "0.4.0",
     "esbuild": "0.28.2"
   },
   "imports": {