@openpresentation/opf-pptx 0.3.0 → 0.5.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 return canonical `{value, style}` objects; `value` retains scalar text or supported rich runs. Covered merge positions are `null`. Explicit normal headers override OPF’s bold header default. Numeric/boolean/null source types cannot be reconstructed from native display text.
+- 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.
 
@@ -123,15 +125,15 @@ PptxGenJS is pinned to 4.0.1. Its unused `image-size` dependency remains flagged
 
 ### Native table fitting
 
-Core 0.5.0 accepts `TextRun[]` cells and headers. The 0.3.0 exporter preserves their resolved fonts, emphasis, color/alpha, hyperlinks, script positions and explicit line breaks as editable native runs. It measures rich content before export without inserting measured soft wraps. These changes are not in 0.2.1; version 0.3.0 requires core 0.5.0 and renderer 0.3.0. Native table import still flattens rich runs to strings, and native PowerPoint rendering remains unverified.
+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.
 
-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.
+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 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.
+`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.
 
@@ -156,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.
 
@@ -167,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.
 
@@ -190,3 +192,25 @@ Native dimensions retain full precision through import. Premature six-decimal in
 Background-only and empty slides now remain blank during PPTX import; the importer no longer inserts a synthetic “Slide N” title. Speaker notes remain separate from visible content. Native fixture verification covers this behavior using an actual Keynote-exported presentation.
 
 Version 0.2.0 requires Node 20.9 or later for native image decoding. Browser bundles continue using browser-safe entrypoints.
+
+
+## Conditional table text styles (since 0.5.0)
+
+The importer resolves referenced table styles through the archive's presentation relationship, including custom part paths, and accepts inline definitions. It applies whole-table, alternating row/column, edge and corner text styles using [Microsoft's DrawingML precedence](https://learn.microsoft.com/en-us/openspecs/office_standards/ms-oi29500/90de4085-5fbf-47a7-bc37-d59509481d0a). Direct list-level, paragraph and run properties override the inherited style. Supported character properties are bold/italic, explicit or major/minor-theme Latin fonts, and the existing RGB/system/theme color and alpha transforms. Font-reference placeholder colors resolve after style inheritance. The table-style list's insertion default does not silently restyle existing tables without a reference.
+
+Version 0.5.0 adds conditional table styles. Missing definitions (including built-in Office IDs whose definitions are absent from the archive) produce `unsupported-table-style`; no style data is fetched. Unsupported effects and table backgrounds produce `unsupported-table-cell-style`. Supported conditional solid fills, borders and their theme references use the same precedence as character styles. Native right-to-left geometry reports `unsupported-table-direction` and retains source cell order. Script-specific font selection, unsupported border geometry/color models and native PowerPoint raster parity remain separate work. Native re-export preserves effective character formatting but does not reconstruct the original style reference or redundant explicit normal flags.
+
+`test/table-styles.mjs` builds independent native XML fixtures covering band offsets, overlapping first/last flags, all four corners, theme and explicit fonts, placeholder alpha, inheritance/defaults, direct resets, absent/external definitions and repeated conversion. The checked-in `test/fixtures/table-styles/conditional.pptx` is project-authored test data, not a captured native-viewer reference. After `npm run build:browser-check`, serve this repository and open `/artifacts/native-table-styles/browser/index.html` for 11 browser import, preview-trace and re-export checks.
+
+
+## Styled and merged table cells (since 0.5.0)
+
+The importer returns canonical `{value, style}` cell objects. Values retain supported rich runs, and styles retain direct solid fills/alpha, individual borders, horizontal/vertical alignment and reference-pixel padding. Rectangular native merges use `rowSpan`/`colSpan` anchors with explicit `null` at covered grid positions. Numeric source types cannot be recovered from displayed native text.
+
+Import validates native continuation flags, bounds and covered text before applying merges. A malformed merge falls back to separate styled cells and reports `unsupported-table-merge`, retaining every source cell's text. If a valid merge crosses a flagged first row, the table keeps that row in its body with explicit formatting and reports `table-header-in-body`; OPF repeated headers cannot extend into body rows. Mixed/justified paragraph alignment, vertical text, unsupported fills/lines and 3D/diagonal effects remain explicit diagnostics. Unequal native column widths still need canonical representation.
+
+Conditional borders keep the whole-table outer frame separate from interior horizontal/vertical lines. Row/column bands, edges and corners inherit line properties before direct cell overrides. Archive-local line references resolve theme placeholder colors and alpha. Missing references report `unsupported-table-border` unless an invisible or complete direct line masks them. A merged anchor uses its full span to select outer edges; differing native continuation border segments report `unsupported-table-merge-border` and retain the anchor border. `test/table-border-styles.mjs` covers these cases with native XML fixtures and repeated conversion.
+
+Export consumes the same core geometry as SVG. It writes native merged cells and corrects PptxGenJS's padding-unit heuristic and missing dotted/transparent-border options in generated XML. Rich runs retain their own resolved opacity, including opaque overrides within a translucent cell. Tests inspect actual native XML and repeated conversions; native PowerPoint raster parity is not established.
+
+Version 0.5.0 requires core 0.7.0 and renderer 0.5.0 for coordinated previews. `npm run test:styled-table` runs export/import regressions. For local browser verification, set `OPF_CORE_ROOT` to the core repository and `OPF_RENDER_ROOT` to the coordinated renderer worktree when running `npm run build:browser-check`. Serve the repository and open `/artifacts/native-styled-table-import/browser/index.html`. Omit those variables to exercise installed package dependencies.

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, fitRichText, 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";
@@ -166,6 +167,7 @@ export async function toPptx(input, options = {}) {
   const context = resolvePresentationContext(presentation, {...options,textMeasurement:undefined});
   context.listMarkers = new Map();
   context.tableHeaders = new Map();
+  context.tableCells = new Map();
   context.imagePlacements = new Map();
   context.backgroundFills = new Map();
   context.imageFormat = options.imageFormat ?? "compatible";
@@ -282,6 +284,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 +407,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 : ''}`}), dimensions) : [];
+  for (const [index, frame] of frames.entries()) {
+    const item = importGraphicFrame(entries, frame, slidePath, relationships, tables[index]);
     if (item) items.push(item);
   }
 
@@ -446,7 +454,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 +466,7 @@ function importGraphicFrame(entries, frame, slidePath, relationships) {
       name,
       payload: {
         type: "table",
-        table: tableFromXml(table)
+        table: importedTable
       }
     };
   }
@@ -632,18 +640,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 +1106,23 @@ 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 rich = Array.isArray(row[columnIndex]);
-    const fit = rich
-      ? fitRichText(row[columnIndex], cellBox, 15 * scale, (context.composition?.minFontSize ?? 16) * scale, {style,textMeasurement:options.textMeasurement})
-      : 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 cellStyle = cell.style ?? {};
+    const baseColor = (cellStyle.color ?? (header ? '#FFFFFF' : '#' + context.colors.text)).replace(/^#/, '');
+    const baseFill = (cellStyle.fill ?? (header ? '#' + context.colors.accent : '#' + context.colors.surface)).replace(/^#/, '');
+    const alpha = value => value.length === 8 ? (1 - parseInt(value.slice(6), 16) / 255) * 100 : 0;
+    const text = stringifyText(cell.value), style = cell.textStyle;
     const fragments = rich ? fit.richLines.flatMap(line => line.fragments) : [];
-    const runs = rich ? row[columnIndex].flatMap((value, index) => {
+    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 rawColor = /^#(?:[0-9a-f]{3}|[0-9a-f]{6}|[0-9a-f]{8})$/i.test(run.color ?? '') ? run.color.slice(1) : baseColor;
       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,
@@ -1160,21 +1151,28 @@ function addTablePayload(slide, table, region, context, options, path) {
         italic: rich ? false : style.italic,
         lineSpacing: fit.lineHeight * 0.75,
         paraSpaceAfter: 0,
-        align: context.contentAlignment,
-        color: header ? "FFFFFF" : context.colors.text,
-        fill: { color: header ? context.colors.accent : context.colors.surface },
+        align: cellStyle.align ?? context.contentAlignment,
+        valign: cellStyle.verticalAlign ?? 'top',
+        ...(cell.colSpan > 1 ? {colspan:cell.colSpan} : {}),
+        ...(cell.rowSpan > 1 ? {rowspan:cell.rowSpan} : {}),
+        color: normalizeHex(baseColor),
+        // Rich runs carry resolved alpha. A translucent cell default would
+        // overwrite an explicit opaque run because PptxGenJS inherits falsy 0.
+        ...(cellStyle.color && !rich ? {transparency:alpha(baseColor)} : {}),
+        fill: { color: normalizeHex(baseFill), ...(cellStyle.fill ? {transparency:alpha(baseFill)} : {}) },
       },
     };
   }));
   const objectName = `OPF table ${context.tableHeaders.size + 1}`;
   context.tableHeaders.set(objectName, hasHeaders);
+  if (layout.rows.some(row => row.cells.some(cell => Object.keys(cell.style ?? {}).length))) context.tableCells.set(objectName, {layout, scale, defaultBorder:{color:"#"+context.colors.border,width:1/scale}});
   slide.addTable(rows, {
     objectName,
     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,
@@ -1643,7 +1641,56 @@ function normalizePartBytes(path, bytes, context, renameMaps, entries, imageMeta
       xml = xml.replace(/<p:graphicFrame>([\s\S]*?)<\/p:graphicFrame>/g, frame => {
         const name = frame.match(/name="(OPF table \d+)"/)?.[1];
         if (!context.tableHeaders.has(name)) return frame;
-        return frame.replace('<a:tblPr/>', `<a:tblPr firstRow="${context.tableHeaders.get(name) ? 1 : 0}"/>`);
+        frame = frame.replace('<a:tblPr/>', `<a:tblPr firstRow="${context.tableHeaders.get(name) ? 1 : 0}"/>`);
+        const table = context.tableCells.get(name);
+        if (!table) return frame;
+        const anchors = table.layout.rows.flatMap(row => row.cells);
+        const ownerAt = (row,column) => anchors.find(anchor => row >= anchor.row && row < anchor.row + anchor.rowSpan && column >= anchor.column && column < anchor.column + anchor.colSpan);
+        let rowIndex = 0;
+        return frame.replace(/<a:tr\b[^>]*>[\s\S]*?<\/a:tr>/g, rowXml => {
+          const currentRow = rowIndex++;
+          const cells = table.layout.rows[currentRow].cells;
+          let column = 0;
+          return rowXml.replace(/<a:tc\b[^>]*>[\s\S]*?<\/a:tc>/g, cellXml => {
+            const currentColumn = column++;
+            const cell = cells.find(cell => cell.column === currentColumn);
+            const owner = cell ?? ownerAt(currentRow,currentColumn);
+            if (!owner) return cellXml;
+            // PowerPoint reads each physical continuation's perimeter border.
+            // Anchor-only styling truncates dashes and restores hidden segments.
+            const perimeter = {left:currentColumn === owner.column, right:currentColumn === owner.column + owner.colSpan - 1,
+              top:currentRow === owner.row, bottom:currentRow === owner.row + owner.rowSpan - 1};
+            const style = cell ? {...cell.style} : {borders:Object.fromEntries(Object.keys(perimeter).map(edge => [edge,perimeter[edge] ? owner.style?.borders?.[edge] ?? table.defaultBorder : {color:'#000000',width:0}]))};
+            style.borders = {...style.borders};
+            // Native shared-edge precedence can let an implicit neighbor cover
+            // an explicit merge border. Give both physical sides that border.
+            for (const [edge,opposite,dr,dc] of [['left','right',0,-1],['right','left',0,1],['top','bottom',-1,0],['bottom','top',1,0]]) {
+              if (!perimeter[edge] || style.borders[edge] || owner.rowSpan > 1 || owner.colSpan > 1) continue;
+              const neighbor = ownerAt(currentRow+dr,currentColumn+dc);
+              if (neighbor?.style?.borders?.[opposite]) style.borders[edge] = neighbor.style.borders[opposite];
+            }
+            cellXml = cellXml.replace(/<a:tcPr\b([^>]*)\/>/, '<a:tcPr$1></a:tcPr>');
+            return cellXml.replace(/<a:tcPr\b([^>]*)>([\s\S]*?)<\/a:tcPr>/, (properties, attributes, contents) => {
+              if (style.padding) {
+                const padding = {top:8, right:10, bottom:4, left:10, ...style.padding};
+                for (const [edge, key] of [['top','marT'],['right','marR'],['bottom','marB'],['left','marL']]) {
+                  attributes = attributes.replace(new RegExp(` ${key}="[^"]*"`), '');
+                  attributes += ` ${key}="${Math.round(padding[edge] * table.scale * 9525)}"`;
+                }
+              }
+              for (const [edge, native] of [['left','lnL'],['right','lnR'],['top','lnT'],['bottom','lnB']]) {
+                const border = style.borders?.[edge];
+                if (!border) continue;
+                const fill = border.width === 0 ? '<a:noFill/>' : nativeBackgroundFill({type:'solid',color:border.color},{width:1,height:1});
+                const dash = {solid:'solid',dash:'dash',dot:'sysDot'}[border.dash ?? 'solid'];
+                const line = `<a:${native} w="${Math.round(border.width * table.scale * 9525)}" cap="flat" cmpd="sng" algn="ctr">${fill}<a:prstDash val="${dash}"/></a:${native}>`;
+                const existing = new RegExp(`<a:${native}\\b[^>]*>[\\s\\S]*?<\\/a:${native}>`);
+                contents = existing.test(contents) ? contents.replace(existing, line) : contents + line;
+              }
+              return `<a:tcPr${attributes}>${contents}</a:tcPr>`;
+            });
+          });
+        });
       });
       // Image data is already resolved and embedded by PptxGenJS. Read those
       // exact bytes instead of fetching or resolving the source a second time.

package/dist/table-border-import.js

@@ -0,0 +1,73 @@
+import {readBackgroundColor} from './background.js';
+
+const has=(value,key)=>Object.hasOwn(value??{},key);
+const fills=['a:solidFill','a:noFill','a:gradFill','a:blipFill','a:pattFill','a:grpFill'];
+
+export function mergeNativeLine(...levels){
+  const result={};
+  for(const level of levels){
+    if(!level)continue;
+    if(fills.some(key=>has(level,key)))for(const key of fills)delete result[key];
+    if(has(level,'a:prstDash')||has(level,'a:custDash')){delete result['a:prstDash'];delete result['a:custDash'];}
+    // A complete direct line or an invisible line masks an unavailable theme
+    // reference; partial overrides still need the missing inherited properties.
+    if(has(level,'a:noFill')||Number(level.w)===0||(has(level,'w')&&fills.some(key=>has(level,key))&&has(level,'a:prstDash')))delete result._opfUnresolvedTableLine;
+    Object.assign(result,level);
+  }
+  return result;
+}
+
+function nativeStyleLine(border,context){
+  if(border['a:ln'])return border['a:ln'];
+  const reference=border['a:lnRef'];
+  if(!reference)return undefined;
+  const unresolved={_opfUnresolvedTableLine:true};
+  if(!/^\d+$/.test(reference.idx??''))return unresolved;
+  const index=Number(reference.idx);
+  if(index===0)return undefined;
+  const lines=context.format?.['a:lnStyleLst']?.['a:ln'];
+  const selected=(Array.isArray(lines)?lines:lines?[lines]:[])[index-1];
+  if(!selected)return unresolved;
+  const line={...selected};
+  if(line['a:solidFill']){
+    const color=readBackgroundColor(line['a:solidFill'],{...context,placeholder:readBackgroundColor(reference,context)});
+    if(!color)return {...line,...unresolved};
+    line['a:solidFill']={'a:srgbClr':{val:color.hex.slice(1),'a:alpha':{val:String(Math.round(color.alpha*100000))}}};
+  }
+  return line;
+}
+
+export function nativeCellExtent(row,column,rowCount,columnCount,geometry={}){
+  const span=(value,remaining)=>{const n=Number(value??1);return Number.isSafeInteger(n)&&n>=1&&n<=remaining?n:1;};
+  return {top:row===0,left:column===0,bottom:row+span(geometry.rowSpan,rowCount-row)===rowCount,right:column+span(geometry.gridSpan,columnCount-column)===columnCount};
+}
+
+/** Keep named edge and interior properties distinct until inheritance finishes.
+ * wholeTbl edges belong to its outer frame; conditional explicit edges belong
+ * to the selected cell. Interior lines apply only away from the outer frame. */
+export function inheritNativeBorders(previous,decoration,name,extent,context){
+  const result={...previous},borders=decoration['a:tcBdr']??{};
+  for(const key of ['left','right','top','bottom','insideH','insideV','tl2br','tr2bl']){
+    const border=borders['a:'+key];
+    if(!border || name==='wholeTbl'&&has(extent,key)&&!extent[key])continue;
+    const line=nativeStyleLine(border,context);
+    if(line!==undefined)result[key]=mergeNativeLine(result[key],line);
+  }
+  return result;
+}
+
+export function nativeBorderProperties(borders,extent){
+  const result={};
+  for(const [edge,key,inside] of [['left','a:lnL','insideV'],['right','a:lnR','insideV'],['top','a:lnT','insideH'],['bottom','a:lnB','insideH']]){
+    const base=extent[edge]?undefined:borders[inside],line=borders[edge];
+    if(base||line)result[key]=mergeNativeLine(base,line);
+  }
+  for(const [edge,key] of [['tl2br','a:lnTlToBr'],['tr2bl','a:lnBlToTr']])if(borders[edge])result[key]=borders[edge];
+  return result;
+}
+
+export function mergeCellBorderOverrides(inherited,direct,merged){
+  const result={...merged};
+  for(const key of ['a:lnL','a:lnR','a:lnT','a:lnB','a:lnTlToBr','a:lnBlToTr'])if(inherited[key]&&direct[key])result[key]=mergeNativeLine(inherited[key],direct[key]);
+  return result;
+}

package/dist/table-cell-import.js

@@ -0,0 +1,138 @@
+import {drawingObject} from './background-import.js';
+import {readBackgroundColor} from './background.js';
+
+const has = (value, key) => Object.hasOwn(value ?? {}, key);
+const nodes = (tree, tag) => (tree ?? []).filter(node => has(node, tag));
+const child = (tree, tag) => nodes(tree, tag)[0]?.[tag];
+const truth = value => ['1','true','on'].includes(value);
+const text = value => Array.isArray(value) ? value.map(run => typeof run === 'string' ? run : run.text).join('') : value ?? '';
+const hex = color => color.hex + (color.alpha < 1 ? Math.round(color.alpha * 255).toString(16).padStart(2,'0').toUpperCase() : '');
+
+// Preserve ordered fill-style indexes: grouping XML tags would reorder mixed
+// solid/gradient/image entries. Resolve phClr against this reference only.
+export function nativeStyleFill(style, context) {
+  if (style['a:fill']) return style['a:fill'];
+  const reference=style['a:fillRef'];
+  if (!reference) return {};
+  const unresolved={_opfUnresolvedTableFill:true};
+  if (!/^\d+$/.test(reference.idx ?? '')) return unresolved;
+  const index=Number(reference.idx);
+  if (index===0 || index===1000) return {'a:noFill':{}};
+  const tree=context.formatPath && context.parsedPart(context.formatPath)?.tree;
+  const theme=child(tree,'a:theme'),elements=theme?child(theme,'a:themeElements'):child(tree,'a:themeOverride');
+  const format=child(elements,'a:fmtScheme');
+  const entries=child(format,index<1000?'a:fillStyleLst':'a:bgFillStyleLst')?.filter(node=>Object.keys(node).some(key=>key!=='#text'&&key!==':@'));
+  const entry=entries?.[index<1000?index-1:index-1001];
+  if (!entry) return unresolved;
+  const properties=drawingObject([entry]);
+  if (properties['a:solidFill']) {
+    const color=readBackgroundColor(properties['a:solidFill'],{...context,placeholder:readBackgroundColor(reference,context)});
+    if (!color) return unresolved;
+    return {'a:solidFill':{'a:srgbClr':{val:color.hex.slice(1),'a:alpha':{val:String(Math.round(color.alpha*100000))}}}};
+  }
+  return properties;
+}
+
+function solid(properties, context, report, kind) {
+  if (has(properties,'a:noFill')) return '#00000000';
+  if (properties['a:solidFill']) {
+    const color = readBackgroundColor(properties['a:solidFill'], context);
+    if (color) return hex(color);
+    report(`unsupported-table-${kind}`, 'The native solid color or its transforms could not be resolved.');
+  } else if (['a:gradFill','a:blipFill','a:pattFill','a:grpFill'].some(key => has(properties,key))) {
+    report(`unsupported-table-${kind}`, 'Only solid cell fills and border colors are represented by OPF table styles.');
+  }
+  return undefined;
+}
+
+export function nativeCellStyle(properties, body, context, scale, report) {
+  const style = {fill:'#00000000', align:'left', verticalAlign:'top', padding:{}, borders:{}};
+  const fill = solid(properties, context, report, 'cell-fill');
+  if (properties._opfUnresolvedTableFill) report('unsupported-table-cell-fill','The native fill style reference or placeholder color could not be resolved from this archive.');
+  if (fill !== undefined) style.fill = fill;
+  // DrawingML defaults are 0.1 inch horizontally and 0.05 inch vertically.
+  for (const [edge,key,fallback] of [['top','marT',45720],['right','marR',91440],['bottom','marB',45720],['left','marL',91440]]) {
+    const value = Number(properties[key] ?? fallback) / (9525 * scale);
+    if (Number.isFinite(value) && value >= 0 && value <= 200) style.padding[edge] = value;
+    else {style.padding[edge] = Math.min(200,fallback / (9525 * scale));report('unsupported-table-padding','The native cell margin is outside the canonical 0–200 reference-pixel range.');}
+  }
+  const vertical = {t:'top',ctr:'middle',b:'bottom'}[properties.anchor ?? 't'];
+  if (vertical) style.verticalAlign = vertical;
+  else report('unsupported-table-alignment','Distributed or justified vertical cell alignment is not represented.');
+  if (truth(properties.anchorCtr) || properties.vert && properties.vert !== 'horz') report('unsupported-table-alignment','Centered anchoring or vertical text direction is not represented.');
+  const listStyle = drawingObject(child(body,'a:lstStyle'));
+  const alignments = nodes(body,'a:p').map(paragraph => {
+    const p = drawingObject(paragraph['a:p'])['a:pPr'] ?? {};
+    return p.algn ?? listStyle[`a:lvl${Number(p.lvl ?? 0)+1}pPr`]?.algn ?? listStyle['a:defPPr']?.algn ?? 'l';
+  });
+  const alignment = {l:'left',ctr:'center',r:'right'}[alignments[0] ?? 'l'];
+  if (alignment) style.align = alignment;
+  if (!alignment || new Set(alignments).size > 1) report('unsupported-table-alignment','Mixed or justified paragraph alignment cannot be represented by one cell alignment.');
+  for (const [edge,key] of [['left','a:lnL'],['right','a:lnR'],['top','a:lnT'],['bottom','a:lnB']]) {
+    const line = properties[key];
+    style.borders[edge] = {color:'#00000000',width:0};
+    if (!line) continue;
+    if (has(line,'a:noFill') || line.w === '0') continue;
+    if (line._opfUnresolvedTableLine) report('unsupported-table-border','The native line style reference or placeholder color could not be resolved from this archive.');
+    const hasFill=['a:solidFill','a:noFill','a:gradFill','a:blipFill','a:pattFill','a:grpFill'].some(key=>has(line,key));
+    const color = solid(line,context,report,'border') ?? (!hasFill&&!line._opfUnresolvedTableLine?'#000000':undefined);
+    const width = Number(line.w ?? 12700) / (9525 * scale);
+    const dash = {solid:'solid',dash:'dash',sysDash:'dash',sysDot:'dot',dot:'dot'}[line['a:prstDash']?.val ?? 'solid'];
+    if (color !== undefined && Number.isFinite(width) && width >= 0 && width <= 32 && dash) style.borders[edge] = {color,width,...(dash === 'solid' ? {} : {dash})};
+    else report('unsupported-table-border','The native border color, width or dash pattern cannot be represented.');
+    if (line.cmpd && line.cmpd !== 'sng' || line.algn && line.algn !== 'ctr' || has(line,'a:custDash')) report('unsupported-table-border','Compound, inset or custom-dash border geometry is not represented.');
+  }
+  if (['a:lnTlToBr','a:lnBlToTr','a:cell3D'].some(key => has(properties,key))) report('unsupported-table-cell-effect','Diagonal cell borders and 3D cell effects are not represented.');
+  return style;
+}
+
+/** Accept a native dense merge only when every covered position is empty and
+ * carries the corresponding continuation flags. On malformed input, retain all
+ * source cells without merges rather than hiding text behind a guessed anchor. */
+export function nativeTableGrid(cells, columnCount, headers, report) {
+  const owners = cells.map(row => Array(row.length));
+  let malformed = false;
+  const bad = (r,c,message) => {malformed=true;report(`rows.${r}.${c}`,'unsupported-table-merge',message);};
+  const rows = cells.map(row => row.map(cell => ({value:cell.value,style:cell.style})));
+  for (let r=0;r<cells.length;r++) for (let c=0;c<cells[r].length;c++) {
+    const cell=cells[r][c], geometry=cell.geometry, owner=owners[r][c];
+    const horizontal=truth(geometry.hMerge),vertical=truth(geometry.vMerge);
+    if (owner) {
+      if (text(cell.value) !== '' || horizontal !== (c > owner.c) || vertical !== (r > owner.r)) bad(r,c,'Native merge continuations conflict with their anchor or contain text; all source cell text is retained.');
+      rows[r][c]=null;
+      continue;
+    }
+    const rowSpan=Number(geometry.rowSpan ?? 1),colSpan=Number(geometry.gridSpan ?? 1);
+    if (horizontal || vertical || !Number.isSafeInteger(rowSpan) || !Number.isSafeInteger(colSpan) || rowSpan<1 || colSpan<1 || r+rowSpan>cells.length || c+colSpan>columnCount) {
+      bad(r,c,'Native merge geometry is incomplete or outside the table grid; all source cell text is retained.');continue;
+    }
+    if (rowSpan>1) rows[r][c].rowSpan=rowSpan;
+    if (colSpan>1) rows[r][c].colSpan=colSpan;
+    if (rowSpan === 1 && colSpan === 1) continue;
+    for (let y=r;y<r+rowSpan;y++) for (let x=c;x<c+colSpan;x++) {
+      if (!cells[y]?.[x] || owners[y][x]) bad(r,c,'Native merge rectangles overlap or omit covered cells; all source cell text is retained.');
+      else owners[y][x]={r,c};
+    }
+  }
+  if (malformed) return {headers,rows:cells.map(row=>row.map(cell=>({value:cell.value,style:cell.style})))};
+  // A canonical merged cell has one border per full edge. Native continuation
+  // cells can specify different edge segments; retain the anchor and report
+  // the loss rather than silently claiming that segmented border is preserved.
+  for (let r=0;r<cells.length;r++) for (let c=0;c<cells[r].length;c++) {
+    const owner=owners[r][c];
+    if (!owner || owner.r===r && owner.c===c) continue;
+    const anchor=rows[owner.r][owner.c],cell=cells[r][c];
+    const perimeter={top:r===owner.r,left:c===owner.c,bottom:r===owner.r+(anchor.rowSpan??1)-1,right:c===owner.c+(anchor.colSpan??1)-1};
+    const differs=edge=>{
+      const a=anchor.style.borders[edge],b=cell.style.borders[edge];
+      if (a.width===0 && b.width===0) return false;
+      return a.width!==b.width || a.color!==b.color || (a.dash??'solid')!==(b.dash??'solid');
+    };
+    if ((cell.borderEdges??[]).some(edge=>perimeter[edge]&&differs(edge))) report(`rows.${r}.${c}`,'unsupported-table-merge-border','Native continuation cells specify differing border segments around a merged cell. The merge and anchor borders are retained; segmented borders are not represented.');
+  }
+  if (headers && rows[0]?.some(cell=>cell?.rowSpan>1)) {
+    headers=false;
+    report('','table-header-in-body','A native merge crosses the first row. It is retained in body rows with explicit formatting, because canonical repeated headers cannot span into body rows.');
+  }
+  return {headers,rows};
+}

package/dist/table-import.js

@@ -0,0 +1,212 @@
+import {drawingObject, readSlideTheme} from './background-import.js';
+import {readBackgroundColor} from './background.js';
+import {nativeCellStyle, nativeTableGrid, nativeStyleFill} from './table-cell-import.js';
+import {nativeCellExtent,inheritNativeBorders,nativeBorderProperties,mergeCellBorderOverrides} from './table-border-import.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 => ['1','true','on'].includes(value) ? true : ['0','false','off'].includes(value) ? 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 (properties['a:latin'] && !font) report('unsupported-table-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;
+    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','_opfUnresolvedTableFill'];
+  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, tableDefaults) {
+  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, tableDefaults, 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('');
+}
+
+// Table styles are archive data, resolved through the presentation relationship.
+// The list's def attribute is an insertion default, not an implicit style for
+// existing unstyled tables. Built-in IDs without archive definitions stay explicit
+// diagnostics; do not substitute a guessed theme or download style definitions.
+function tableStyle(props, archive, context, report) {
+  const inline = child(props, 'a:tableStyle');
+  if (inline) return drawingObject(inline);
+  const id = text(child(props, 'a:tableStyleId')).trim().toLowerCase();
+  if (!id) return undefined;
+  const relationship = [...archive.relationships('ppt/presentation.xml').values()]
+    .find(rel => rel.type.endsWith('/tableStyles') && rel.targetMode !== 'External' && archive.bytes(rel.path));
+  const list = relationship && child(context.parsedPart(relationship.path)?.tree, 'a:tblStyleLst');
+  const selected = nodes(list, 'a:tblStyle').find(node => node[':@']?.styleId?.trim().toLowerCase() === id);
+  if (selected) return drawingObject(selected['a:tblStyle']);
+  report('unsupported-table-style', 'The referenced native table style has no definition in this archive; direct text formatting is retained.');
+  return undefined;
+}
+
+const colorKinds = ['a:srgbClr','a:sysClr','a:schemeClr','a:scrgbClr','a:hslClr','a:prstClr'];
+function tableTextProperties(style, context) {
+  const result = {};
+  for (const key of ['b','i']) {
+    const value = boolean(style[key]);
+    if (value !== undefined) result[key] = value ? '1' : '0';
+  }
+  if (style['a:font']) {
+    result['a:latin'] = style['a:font']['a:latin'] ?? {};
+  } else if (style['a:fontRef']) {
+    const index = style['a:fontRef'].idx;
+    result['a:latin'] = {typeface:index === 'major' ? '+mj-lt' : index === 'minor' ? '+mn-lt' : ''};
+  }
+  const color = Object.fromEntries(colorKinds.filter(key => Object.hasOwn(style, key)).map(key => [key, style[key]]));
+  if (Object.keys(color).length) {
+    const placeholder = readBackgroundColor(style['a:fontRef'], context);
+    const resolved = readBackgroundColor(color, {...context, placeholder});
+    // Normalize style placeholder colors before merging direct paragraph/run fills.
+    result['a:solidFill'] = resolved ? {'a:srgbClr':{val:resolved.hex.slice(1), 'a:alpha':{val:String(Math.round(resolved.alpha * 100000))}}} : color;
+  }
+  return result;
+}
+
+function conditionalProperties(style, properties, row, column, rowCount, columnCount, context, report, geometry) {
+  if (!style) return {text:undefined,cell:{}};
+  const enabled = key => boolean(properties[key]) === true;
+  const firstRow = enabled('firstRow') && row === 0;
+  const lastRow = enabled('lastRow') && row === rowCount - 1;
+  const firstCol = enabled('firstCol') && column === 0;
+  const lastCol = enabled('lastCol') && column === columnCount - 1;
+  // DrawingML / MS-OI29500 2.1.1265 order (not WordprocessingML order).
+  const parts = ['wholeTbl'];
+  if (enabled('bandRow') && !firstRow && !lastRow) parts.push((row + Number(enabled('firstRow'))) % 2 ? 'band2H' : 'band1H');
+  if (enabled('bandCol') && !firstCol && !lastCol) parts.push((column + Number(enabled('firstCol'))) % 2 ? 'band2V' : 'band1V');
+  if (lastCol) parts.push('lastCol');
+  if (firstCol) parts.push('firstCol');
+  if (lastRow) parts.push('lastRow');
+  if (lastRow && lastCol) parts.push('seCell');
+  if (lastRow && firstCol) parts.push('swCell');
+  if (firstRow) parts.push('firstRow');
+  if (firstRow && lastCol) parts.push('neCell');
+  if (firstRow && firstCol) parts.push('nwCell');
+  const textStyle = {};
+  let cellStyle = {};
+  let borders = {};
+  const extent=nativeCellExtent(row,column,rowCount,columnCount,geometry);
+  for (const name of parts) {
+    const part = style['a:' + name];
+    if (!part) continue;
+    const decoration=part['a:tcStyle'] ?? {};
+    cellStyle=mergeProperties(cellStyle,nativeStyleFill(decoration,context));
+    borders=inheritNativeBorders(borders,decoration,name,extent,context);
+    if (Object.keys(decoration).some(key=>!['a:fill','a:fillRef','a:tcBdr'].includes(key))) report('unsupported-table-cell-style','The conditional cell style includes effects that are not represented; supported fills, borders and character styles are retained.');
+    const current = part['a:tcTxStyle'] ?? {};
+    // Resolve choices after inheritance so a later phClr can use an inherited
+    // fontRef, and an explicit font collection replaces a themed reference.
+    if (current['a:font'] || current['a:fontRef']) {delete textStyle['a:font'];delete textStyle['a:fontRef'];}
+    if (colorKinds.some(key => Object.hasOwn(current, key))) for (const key of colorKinds) delete textStyle[key];
+    for (const [key, value] of Object.entries(current)) {
+      if (['b','i'].includes(key) && value === 'def') continue;
+      textStyle[key] = value;
+    }
+  }
+  return {text:tableTextProperties(textStyle, context),cell:{...cellStyle,...nativeBorderProperties(borders,extent)}};
+}
+
+// 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, dimensions) {
+  const context = readSlideTheme(slidePath, archive);
+  const scale = Math.min(dimensions.widthInches,dimensions.heightInches) * 96 / 720;
+  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');
+    const style = tableStyle(props, archive, context, (code, message) => report(frameIndex, '', code, message));
+    if (style?.['a:tblBg']) report(frameIndex, '', 'unsupported-table-cell-style', 'The native table style background is not represented; supported character styles are retained.');
+    const properties = attrs(table, 'a:tblPr');
+    if (boolean(properties.rtl) === true) report(frameIndex, '', 'unsupported-table-direction', 'Right-to-left table geometry is not represented; cells retain native source order.');
+    const headers = boolean(properties.firstRow) === true;
+    const nativeRows = nodes(table, 'a:tr');
+    const columnCount = nodes(child(table, 'a:tblGrid'), 'a:gridCol').length;
+    const rows = nativeRows.map((row, rowIndex) => nodes(row['a:tr'], 'a:tc').map((cell, columnIndex) => {
+      const cellPath = `rows.${rowIndex}.${columnIndex}`;
+      const reported = new Set();
+      const emit = (code, message) => {if (!reported.has(code)) {reported.add(code);report(frameIndex, cellPath, code, message);}};
+      const geometry = cell[':@'] ?? {};
+      const defaults = conditionalProperties(style, properties, rowIndex, columnIndex, nativeRows.length, columnCount, context, emit, geometry);
+      const body = child(cell['a:tc'],'a:txBody');
+      const cellProperties = {...attrs(cell['a:tc'],'a:tcPr'),...drawingObject(child(cell['a:tc'],'a:tcPr'))};
+      const inherited=mergeProperties(defaults.cell,cellProperties);
+      return {
+        geometry,
+        value:cellText(body, context, relationships, emit, headers && rowIndex === 0, defaults.text),
+        style:nativeCellStyle(mergeCellBorderOverrides(defaults.cell,cellProperties,inherited),body,context,scale,emit),
+        borderEdges:[['left','a:lnL'],['right','a:lnR'],['top','a:lnT'],['bottom','a:lnB']]
+          .filter(([,key])=>Object.hasOwn(inherited,key)).map(([edge])=>edge),
+      };
+    }));
+    const grid = nativeTableGrid(rows,columnCount,headers,(cell,code,message)=>report(frameIndex,cell,code,message));
+    return grid.headers && grid.rows.length ? {columns:grid.rows[0], rows:grid.rows.slice(1)} : {rows:grid.rows};
+  });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openpresentation/opf-pptx",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "Pure local OPF to PPTX export and PPTX to OPF import tooling.",
   "license": "MIT",
   "type": "module",
@@ -35,21 +35,22 @@
   "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 && node --check test/rich-table.mjs",
-    "test": "npm run build && node test/dependency-boundary.mjs && npm run build:browser-check",
+    "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 && node --check test/table-styles.mjs && node --check test/table-styles-browser.js && node --check test/styled-table.mjs && node --check src/table-cell-import.js && node --check test/styled-table-import.mjs && node --check test/styled-table-import-browser.js && node --check src/table-border-import.js && node --check test/table-border-styles.mjs",
+    "test": "npm run build && node test/dependency-boundary.mjs && npm run build:browser-check && npm run test:styled-table",
     "validate": "node scripts/validate-package.mjs",
     "prepack": "npm run build",
-    "build:browser-check": "node scripts/build-browser-check.mjs"
+    "build:browser-check": "node scripts/build-browser-check.mjs",
+    "test:styled-table": "node test/styled-table.mjs && node test/styled-table-import.mjs"
   },
   "dependencies": {
-    "@openpresentation/opf": "^0.5.0",
+    "@openpresentation/opf": "^0.7.0",
     "fast-xml-parser": "^5.8.0",
     "fflate": "^0.8.3",
     "pptxgenjs": "4.0.1",
     "sharp": "0.35.4"
   },
   "peerDependencies": {
-    "@openpresentation/opf-render": "^0.3.0"
+    "@openpresentation/opf-render": "^0.5.0"
   },
   "peerDependenciesMeta": {
     "@openpresentation/opf-render": {
@@ -57,7 +58,7 @@
     }
   },
   "devDependencies": {
-    "@openpresentation/opf-render": "0.3.0",
+    "@openpresentation/opf-render": "0.5.0",
     "esbuild": "0.28.2"
   },
   "imports": {