mixdog 1.0.4 → 1.0.6

package/src/runtime/office/core/office-finalize/review-stage.mjs

@@ -20,6 +20,11 @@ const AUTHORED_ADVISORY_SOURCES = new Set([
 // with its chart laid over the figures it was drawn from.
 const VISIBLE_DEFECT_CODES = new Set(['drawing_covers_cells', 'drawing_overlap']);
 
+/** A Word document or workbook written to a brief (design.brief): reviewed with the deck's scored critique. */
+export function briefedDocument(session) {
+  return ['docx', 'xlsx'].includes(session?.format) && session?.authoredBrief?.present === true;
+}
+
 export function blocksFinalize(issue, { failOn, authored }) {
   if (
     VISIBLE_DEFECT_CODES.has(String(issue?.code || '')) &&
@@ -79,11 +84,19 @@ export async function reviewForFinalize(session, args, cwd, { timedStep, failOn,
   // only pixels this call produced are new evidence worth sending again.
   const reviewImages = reviewed?.preview?.reused !== true && Array.isArray(reviewed?._images) ? reviewed._images : [];
   const review = reviewed ? { ...reviewed } : null;
-  const pptx = session.format === 'pptx' ? applyPptxAcceptance(session, args, review) : null;
-  const documentVisualReview = applyDocumentAcceptance(session, args, review);
+  // A PDF of designed pages (authoring/pdf-author-action.mjs) is reviewed as the deck it was measured as, and so is a
+  // Word document or workbook written to a brief: five scores, a note, and checks from the brief per page.
+  const scored = session.authoredFrame === true || briefedDocument(session);
+  const deck = session.format === 'pptx' || scored;
+  const pptx = deck ? applyPptxAcceptance(session, args, review) : null;
+  const documentVisualReview = scored ? null : applyDocumentAcceptance(session, args, review);
   if (review) delete review._images;
   const issuesAfter = review?.issuesAfter || [];
   const blockingIssues = issuesAfter.filter((issue) => blocksFinalize(issue, { failOn, authored }));
+  // Its measured audit ran on the deck at author time; an error it found holds the file as it would the deck.
+  if (session.authoredFrame === true) {
+    blockingIssues.push(...(session.frameAudit?.top || []).filter((issue) => issue.severity === 'error'));
+  }
   if (review && authored) {
     review.advisoryIssues = issuesAfter.filter(
       (issue) => !blockingIssues.includes(issue) && ['error', 'warning'].includes(String(issue?.severity || ''))

package/src/runtime/office/core/office-qa/design-review-stage.mjs

@@ -4,6 +4,7 @@
 import { inferPptxSlideRoles, reviewOfficeDesign } from '../../quality/design-review.mjs';
 import { issue } from '../../quality/assurance-issue.mjs';
 import { reviewSnapshot } from '../office-actions-inspect.mjs';
+import { documentBriefIssues } from '../../quality/document-brief.mjs';
 
 function unavailableDesignReview(session, error) {
   return {
@@ -64,6 +65,14 @@ export async function reviewQaDesign(session, args) {
   } catch (error) {
     designReview = unavailableDesignReview(session, error);
   }
+  // A PDF of designed pages was read against its brief on the working deck at author time (the plan
+  // count, the facts' locators); those readings join the PDF's own review.
+  if (session.authoredFrame === true && Array.isArray(session.frameDesignIssues) && session.frameDesignIssues.length) {
+    designReview = { ...designReview, issues: [...(designReview.issues || []), ...session.frameDesignIssues] };
+  }
+  // A Word document or workbook written to a brief: its figures against the facts line, its facts against the sources.
+  const briefIssues = documentBriefIssues(session.format, currentSnapshot?.document, session.authoredBrief);
+  if (briefIssues.length) designReview = { ...designReview, issues: [...(designReview.issues || []), ...briefIssues] };
   return {
     designReview,
     currentSnapshot,

package/src/runtime/office/core/office-session-dispatch.mjs

@@ -9,6 +9,7 @@ import { describeOfficeCapabilities } from '../capabilities.mjs';
 import { applyBatch, closeSession, finalize, issues, qa, render, save, validate } from './office-actions.mjs';
 import { getOfficeElement, queryOfficeDocument } from './office-actions-read.mjs';
 import { snapshot } from './office-sessions.mjs';
+import { noteBatchAgainstHtml } from '../authoring/html-source-drift.mjs';
 import {
   assertTransactionUnchanged,
   beginTransaction,
@@ -41,6 +42,8 @@ async function batchAction(session, args, cwd, signal) {
     __cwd: cwd,
     ...(args.finalize === true ? { save: true } : {}),
   });
+  const drift = noteBatchAgainstHtml(session, batch);
+  if (drift) batch.htmlSource = drift;
   if (args.finalize !== true) return batch;
   return {
     ...(await finalize(

package/src/runtime/office/core/office-sessionless-actions.mjs

@@ -9,7 +9,7 @@
  * returns null so the caller falls through to the session-bound dispatch.
  */
 import { mkdir } from 'node:fs/promises';
-import { dirname } from 'node:path';
+import { dirname, extname } from 'node:path';
 import { detectMicrosoftOffice } from '../com/com-adapter.mjs';
 import { pdfOcrReadiness } from '../pdf/pdf-analysis.mjs';
 import { describeOfficeCapabilities } from '../capabilities.mjs';
@@ -18,6 +18,8 @@ import { unicodeFontPath } from '../pdf/pdf-fonts.mjs';
 import { inspectOfficeDesignLibrary } from '../design/library/design-library.mjs';
 import { openCreateOrAttachOffice } from './office-actions-open.mjs';
 import { authorPptx } from '../authoring/pptx-author-action.mjs';
+import { authorPdf } from '../authoring/pdf-author-action.mjs';
+import { authorHtmlDocument } from '../authoring/html-document-author.mjs';
 import {
   FILE_KIND_TO_FORMAT,
   documentFormat,
@@ -97,7 +99,10 @@ async function describeWithoutSession(args, cwd) {
 }
 
 async function authorAction(args, cwd, dataDir, signal, startedAt) {
-  const authored = await authorPptx(args, { cwd, dataDir, signal });
+  const extension = extname(String(args.path || args.output || '')).toLowerCase();
+  const author =
+    { '.pdf': authorPdf, '.docx': authorHtmlDocument, '.xlsx': authorHtmlDocument }[extension] || authorPptx;
+  const authored = await author(args, { cwd, dataDir, signal });
   const images = Array.isArray(authored?._images) ? authored._images : [];
   delete authored._images;
   const session = authored.session ? sessions.get(authored.session) : null;

package/src/runtime/office/core/office-sessions.mjs

@@ -145,7 +145,7 @@ function portableCreateDesignState() {
 // old file is closed first, never left registered beside the new one (PDF) or
 // handed back in place of the document the caller asked to write. A session on
 // a document the user has open is theirs, so the overwrite is refused instead.
-async function releaseOverwrittenSession(target, overwrite) {
+export async function releaseOverwrittenSession(target, overwrite) {
   if (overwrite !== true) return;
   const existing = officeSessionForDocument(target);
   if (!existing) return;
@@ -452,6 +452,22 @@ async function createPdfSession(creation, args, cwd) {
   });
 }
 
+// A PDF the author action printed from HTML (authoring/pdf-author-action.mjs)
+// is already on disk; its session is registered as a created PDF's is, so it
+// goes through the same render, review, and finalize.
+export async function registerHtmlPdfSession(args, dataDir, target, { targetExisted, receipt }) {
+  const designContext = await resolveOfficeDesignContext({ args, dataDir, target, format: 'pdf', created: true });
+  return registerCreatedSession(
+    { target, fileKind: documentFileKind(target), format: 'pdf', dataDir, targetExisted, designContext },
+    {
+      mode: 'portable',
+      backend: 'mixdog-pdf',
+      designState: portableCreateDesignState(),
+      extra: { createReceipt: receipt, ownership: 'owned', visible: false },
+    }
+  );
+}
+
 async function createTabularSession(creation) {
   await mkdir(dirname(creation.target), { recursive: true });
   await createTabular(creation.target);
@@ -571,7 +587,8 @@ function authoredDesignContext(resolved) {
 export async function createAuthoredSession(args, _cwd, dataDir, target) {
   const fileKind = documentFileKind(target);
   const format = documentFormat(target);
-  if (format !== 'pptx') throw new Error('author currently supports PowerPoint targets only');
+  if (!['pptx', 'docx', 'xlsx'].includes(format))
+    throw new Error('author writes PowerPoint, Word, Excel, and PDF targets only');
   const requestedMode = validatePptxAuthorMode(args.mode);
   const selected = await selectMode(requestedMode, format, target);
   const designContext = authoredDesignContext(

package/src/runtime/office/pdf/pdf-writer.mjs

@@ -1151,7 +1151,7 @@ function drawPageFooters(document, properties, { font, margin, numbering }) {
   });
 }
 
-function applyDocumentProperties(document, properties) {
+export function applyDocumentProperties(document, properties) {
   if (properties.title != null) document.setTitle(String(properties.title));
   if (properties.author != null) document.setAuthor(String(properties.author));
   if (properties.subject != null) document.setSubject(String(properties.subject));

package/src/runtime/office/portable/docx-formatting.mjs

@@ -69,6 +69,27 @@ export function patchParagraphFormat(xml, properties, numbering = null) {
   return patchWordFormat(xml, 'p', 'pPr', paragraphFormatXml(properties, numbering));
 }
 
+// A style definition's children run name … qFormat, then pPr, rPr, then the table parts; an absent pPr or rPr is
+// opened in its place first, so the patch lands inside the schema's order rather than ahead of the style's name.
+function openStyleProperties(styleXml, tag) {
+  if (new RegExp(`<w:${tag}(?:\\s[^>]*)?(?:/>|>)`).test(styleXml)) {
+    return styleXml.replace(new RegExp(`<w:${tag}(?:\\s[^>]*)?/>`), `<w:${tag}></w:${tag}>`);
+  }
+  const before = tag === 'pPr' ? /<w:(?:rPr|tblPr|trPr|tcPr|tblStylePr)\b/ : /<w:(?:tblPr|trPr|tcPr|tblStylePr)\b/;
+  const at = before.exec(styleXml)?.index ?? styleXml.lastIndexOf('</w:style>');
+  return `${styleXml.slice(0, at)}<w:${tag}></w:${tag}>${styleXml.slice(at)}`;
+}
+
+/** A style's paragraph and run formatting patched with the supplied properties only (define_styles). */
+export function patchWordStyle(styleXml, properties) {
+  let next = styleXml;
+  const paragraph = paragraphFormatXml(properties);
+  if (paragraph) next = patchWordFormat(openStyleProperties(next, 'pPr'), 'style', 'pPr', paragraph);
+  const run = wordRunProperties(properties);
+  if (run) next = patchWordFormat(openStyleProperties(next, 'rPr'), 'style', 'rPr', run);
+  return next;
+}
+
 /** Search the first body phrase, across text runs, without touching headers or footers.
  *  Only matching characters change; fields, drawings and breaks are search barriers. */
 export function formatFirstBodyPhrase(documentXml, find, properties) {

package/src/runtime/office/portable/ooxml-validator.mjs

@@ -3,6 +3,7 @@ import { createHash, randomUUID } from 'node:crypto';
 import { access, chmod, mkdir, rename, rm, stat, writeFile } from 'node:fs/promises';
 import { gunzipSync } from 'node:zlib';
 import { join } from 'node:path';
+import { withFileLock } from '../../shared/file-lock.mjs';
 
 const VERSION = '0.3.0';
 const MAX_ARCHIVE_BYTES = 160 * 1024 * 1024;
@@ -167,7 +168,10 @@ export async function ensureOoxmlValidator({ dataDir, download = true, signal =
       reason: `OOXML schema validation is unavailable on ${process.platform}-${process.arch}.`,
     };
   }
-  const paths = cachePaths(dataDir, entry);
+  // Test runners share immutable tools, never session files or user data.
+  // Normal app calls retain their existing data-directory cache.
+  const sharedCache = process.env.MIXDOG_TEST_OOXML_CACHE_DIR;
+  const paths = cachePaths(sharedCache || dataDir, entry);
   if (await usableBinary(paths.binary)) {
     return { available: true, cached: true, downloaded: false, path: paths.binary, version: VERSION };
   }
@@ -181,6 +185,23 @@ export async function ensureOoxmlValidator({ dataDir, download = true, signal =
     };
   }
   await mkdir(paths.root, { recursive: true });
+  if (sharedCache) {
+    return withFileLock(
+      join(paths.root, '.install.lock'),
+      async () => {
+        signal?.throwIfAborted();
+        if (await usableBinary(paths.binary)) {
+          return { available: true, cached: true, downloaded: false, path: paths.binary, version: VERSION };
+        }
+        return installValidator(paths, entry, signal);
+      },
+      { timeoutMs: 120_000 }
+    );
+  }
+  return installValidator(paths, entry, signal);
+}
+
+async function installValidator(paths, entry, signal) {
   const temporary = join(paths.root, `.${entry.binary}.${randomUUID()}.tmp`);
   try {
     const archive = await fetchArchive(packageUrl(entry.name), { signal });

package/src/runtime/office/portable/portable-chart.mjs

@@ -194,14 +194,18 @@ function categoryAxis({
   reversed = horizontal,
   size = CHART_TEXT.sheet.body,
   low = false,
+  numberFormat = '',
 } = {}) {
+  // Dated categories (a month column formatted m"월") read in their cells' format on a text axis: auto would turn
+  // them into a date scale, and without the linked format Excel labelled the months with their serials (46174).
   return (
     `<c:catAx><c:axId val="${CATEGORY_AXIS_ID}"/>` +
     `<c:scaling><c:orientation val="${reversed ? 'maxMin' : 'minMax'}"/></c:scaling><c:delete val="${hidden ? 1 : 0}"/><c:axPos val="${horizontal ? 'l' : 'b'}"/>` +
+    (numberFormat ? `<c:numFmt formatCode="${xmlEncode(numberFormat)}" sourceLinked="1"/>` : '') +
     `<c:majorTickMark val="none"/><c:minorTickMark val="none"/><c:tickLblPos val="${low ? 'low' : 'nextTo'}"/>` +
     '<c:spPr><a:ln w="9525"><a:solidFill><a:srgbClr val="C7CBD1"/></a:solidFill></a:ln></c:spPr>' +
     axisText(size) +
-    `<c:crossAx val="${VALUE_AXIS_ID}"/><c:crosses val="autoZero"/><c:auto val="1"/>` +
+    `<c:crossAx val="${VALUE_AXIS_ID}"/><c:crosses val="autoZero"/><c:auto val="${numberFormat ? 0 : 1}"/>` +
     '<c:lblAlgn val="ctr"/><c:lblOffset val="100"/><c:noMultiLvlLbl val="0"/></c:catAx>'
   );
 }
@@ -288,6 +292,9 @@ export function chartXml({
   font = '',
   // CHART_TEXT.sheet or CHART_TEXT.slide.
   text = CHART_TEXT.sheet,
+  // Dated categories: their serials and the cells' date format, written as a number reference Excel reads in that
+  // format; the labels in `categories` are the cache's text otherwise.
+  categoryDates = null,
 } = {}) {
   const family = resolveChartFamily(chartType);
   if (!family) {
@@ -334,7 +341,7 @@ export function chartXml({
           size: text.label,
           pointColors: pointColorsFor(family, entry, rows),
         }) +
-        `<c:cat>${stringReference(categoryFormula, rows)}</c:cat>` +
+        `<c:cat>${categoryDates ? numberReference(categoryFormula, categoryDates.values, categoryDates.format) : stringReference(categoryFormula, rows)}</c:cat>` +
         `<c:val>${numberReference(valueFormula, entry.values, entry.numberFormat || valueNumberFormat)}</c:val>` +
         (family.element === 'lineChart' ? '<c:smooth val="0"/>' : '') +
         '</c:ser>'
@@ -386,6 +393,7 @@ export function chartXml({
           reversed,
           size: text.body,
           low: negative,
+          numberFormat: categoryDates?.format || '',
         })}${valueAxis({
           size: text.body,
           horizontal: family.direction === 'bar',

package/src/runtime/office/portable/portable-docx-edits.mjs

@@ -808,6 +808,12 @@ export async function setDocxHeaderFooter(zip, op) {
   };
 }
 
+// A separator says the number stands against the total ("3 / 12"): asked for with separator:' / ' and no
+// includeTotal, the footer printed "3" alone. includeTotal:false still keeps the number alone.
+export function pageNumbersIncludeTotal(op) {
+  return op.includeTotal === true || (op.includeTotal !== false && Boolean(String(op.separator ?? '').trim()));
+}
+
 // Same vocabulary as set_header_footer: kind names the story (the footer
 // unless the caller asks for the header), variant names the page.
 export async function addDocxPageNumbers(zip, op) {
@@ -821,11 +827,11 @@ export async function addDocxPageNumbers(zip, op) {
   // larger in the portable file than the same footer written through Word.
   const size = '<w:rPr><w:sz w:val="18"/><w:szCs w:val="18"/></w:rPr>';
   const prefix = op.prefix ? `<w:r>${size}<w:t xml:space="preserve">${xmlEncode(op.prefix)} </w:t></w:r>` : '';
-  const separator =
-    op.includeTotal === true
-      ? `<w:r>${size}<w:t xml:space="preserve"> ${xmlEncode(op.separator || '/')} </w:t></w:r>` +
-        `<w:fldSimple w:instr=" NUMPAGES "><w:r>${size}<w:t>1</w:t></w:r></w:fldSimple>`
-      : '';
+  const includeTotal = pageNumbersIncludeTotal(op);
+  const separator = includeTotal
+    ? `<w:r>${size}<w:t xml:space="preserve"> ${xmlEncode(String(op.separator || '/').trim() || '/')} </w:t></w:r>` +
+      `<w:fldSimple w:instr=" NUMPAGES "><w:r>${size}<w:t>1</w:t></w:r></w:fldSimple>`
+    : '';
   const numbering =
     `<w:p><w:pPr><w:jc w:val="${alignment}"/><w:rPr><w:sz w:val="18"/><w:szCs w:val="18"/></w:rPr></w:pPr>${prefix}` +
     `<w:fldSimple w:instr=" PAGE "><w:r>${size}<w:t>1</w:t></w:r></w:fldSimple>` +
@@ -857,7 +863,7 @@ export async function addDocxPageNumbers(zip, op) {
     changed: true,
     part: written.part,
     header,
-    includeTotal: op.includeTotal === true,
+    includeTotal,
     ...(written.replaced ? { replaced: true } : {}),
     ...(keptStory ? { keptExistingContent: true } : {}),
   };

package/src/runtime/office/portable/portable-docx-operations.mjs

@@ -34,7 +34,8 @@ import {
 } from './portable-docx-xml.mjs';
 import { docxRevisionTree, flattenDocxRevisions } from './docx-revisions.mjs';
 import { settleDocxStory } from './docx-runs.mjs';
-import { patchParagraphFormat } from './docx-formatting.mjs';
+import { patchParagraphFormat, patchWordStyle } from './docx-formatting.mjs';
+import { documentStyleId } from './portable-docx-styles.mjs';
 import { anchorPhraseInParagraph, trackedParagraphReplace, trackedParagraphRewrite } from './docx-tracked-edits.mjs';
 
 // Word rebuilds a TOC field when the reader updates it; until then the cached
@@ -386,6 +387,79 @@ export async function setDocxDocumentFont(zip, op) {
   return { op: op.op, changed: true, ...font };
 }
 
+// The fields one style takes in define_styles: its face, size, weight, ink, and its paragraph's flow.
+export const DOCX_STYLE_FIELDS = Object.freeze([
+  'name',
+  'nameEastAsia',
+  'size',
+  'bold',
+  'italic',
+  'color',
+  'alignment',
+  'spacingBefore',
+  'spacingAfter',
+  'lineSpacing',
+  'lineSpacingRule',
+  'keepWithNext',
+  'keepTogether',
+]);
+
+/** The fields of every style asked for, checked before anything is written; one message lists every fault. */
+export function docxStyleDefinitions(op) {
+  const styles = op.styles;
+  if (!styles || typeof styles !== 'object' || Array.isArray(styles) || !Object.keys(styles).length) {
+    throw new Error(
+      `define_styles needs styles: { "<style name>": { ${DOCX_STYLE_FIELDS.join(', ')} } }, e.g. { "Heading 1": { size: 15, bold: true } }`
+    );
+  }
+  const faults = [];
+  for (const [style, fields] of Object.entries(styles)) {
+    if (!fields || typeof fields !== 'object' || Array.isArray(fields)) {
+      faults.push(`${style}: needs an object of fields`);
+      continue;
+    }
+    const unknown = Object.keys(fields).filter((field) => !DOCX_STYLE_FIELDS.includes(field));
+    if (unknown.length) faults.push(`${style}: unknown fields ${unknown.join(', ')}`);
+  }
+  if (faults.length) throw new Error(`define_styles: ${faults.join('; ')}. Fields: ${DOCX_STYLE_FIELDS.join(', ')}.`);
+  return Object.entries(styles);
+}
+
+/** Word's own styles defined once — the title, headings, body, caption a report is set in — so every paragraph that
+ *  names the style takes them, and a paragraph the reader adds in Word under that style matches the rest. Set
+ *  paragraph by paragraph instead, a heading added later came out in Word's blue Calibri. */
+export async function defineDocxStyles(zip, op) {
+  const definitions = docxStyleDefinitions(op);
+  const defined = [];
+  const notFound = [];
+  for (const [requested, fields] of definitions) {
+    const resolved = await documentStyleId(zip, requested);
+    if (!resolved.found) {
+      notFound.push(requested);
+      continue;
+    }
+    const styles = await zipText(zip, 'word/styles.xml');
+    const id = resolved.id.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const pattern = new RegExp(`<w:style\\b(?=[^>]*\\bw:styleId="${id}")[^>]*>[\\s\\S]*?<\\/w:style>`);
+    const style = pattern.exec(styles)?.[0];
+    if (!style) {
+      notFound.push(requested);
+      continue;
+    }
+    zip.file(
+      'word/styles.xml',
+      styles.replace(style, () => patchWordStyle(style, fields))
+    );
+    defined.push(requested);
+  }
+  return {
+    op: op.op,
+    changed: defined.length > 0,
+    styles: defined,
+    ...(notFound.length ? { styleNotFound: notFound } : {}),
+  };
+}
+
 /** Page size, orientation, margins and text columns of one section, keeping what was not asked for. */
 function pageRequest(properties) {
   const orientation = String(properties.orientation || '').toLowerCase();

package/src/runtime/office/portable/portable-docx-xml.mjs

@@ -251,7 +251,15 @@ export function naturalTableColumnWidths(values, properties = {}, available = 0)
   const headers = tableHeaderRows(properties, rows.length);
   const gutters = isLayoutTable(properties) ? [] : gutterColumns(properties);
   const measure = (text, rowIndex, column) =>
-    measureTextWidth(text, { ...font, bold: headerBold && rowIndex < headers }) * 1.05 +
+    measureTextWidth(text, {
+      ...font,
+      fontSize:
+        Number(tableRowStyle(properties, rowIndex)?.fontSize) > 0
+          ? Number(tableRowStyle(properties, rowIndex).fontSize)
+          : font.fontSize,
+      bold: rowBold(properties, rowIndex, rows.length, headerBold && rowIndex < headers),
+    }) *
+      1.05 +
     CELL_PADDING_POINTS +
     (gutters[column] ? GUTTER_POINTS : 0);
   return naturalColumnWidths(rows, measure, available);
@@ -284,6 +292,36 @@ function tableHeaderBold(properties, rows) {
   return rows > 1 && properties?.headerBold !== false && properties?.repeatHeader !== false;
 }
 
+// One row's own type (rowStyles[row]: fontSize, color, bold): a stat strip sets its figures at 22 pt and the labels
+// under them at 9 pt in one table, where a single fontSize set the labels at 22 pt too.
+function tableRowStyle(properties, row) {
+  const style = Array.isArray(properties?.rowStyles) ? properties.rowStyles[row] : null;
+  return style && typeof style === 'object' ? style : null;
+}
+
+// The last row is the total when totalRow is set: bold over a rule, so it reads as the sum of the rows above it and
+// not as one more of them.
+const isTotalRow = (properties, row, rows) => properties?.totalRow === true && rows > 1 && row === rows - 1;
+export const TOTAL_ROW_RULE = Object.freeze({ size: 8, color: '374151' });
+
+// A row's weight: its own rowStyles bold when given, else the header's or the total's.
+function rowBold(properties, row, rows, header) {
+  const own = tableRowStyle(properties, row)?.bold;
+  if (typeof own === 'boolean') return own;
+  return header || isTotalRow(properties, row, rows);
+}
+
+// A row's type properties: the table's, with its own rowStyles size and ink over them.
+function rowTypeProperties(properties, row) {
+  const style = tableRowStyle(properties, row);
+  if (!style) return properties;
+  return {
+    ...properties,
+    ...(Number(style.fontSize) > 0 ? { fontSize: Number(style.fontSize) } : {}),
+    ...(style.color ? { color: style.color } : {}),
+  };
+}
+
 const flushCellMargins = (first, last) => {
   if (!first && !last) return '';
   const left = first ? '<w:left w:w="0" w:type="dxa"/>' : '';
@@ -305,12 +343,15 @@ export function wordTableXml(operation, { available = 0 } = {}) {
     [];
   const heights = operation.properties?.rowHeights || [];
   const justifications = (operation.properties?.columnAlignments || []).map(wordJustification);
-  const runProperties = wordTableRunProperties(operation.properties);
   // The header row is set apart by weight, on both backends, unless the caller
   // says otherwise; a header a reader cannot tell from the data is not one.
   const headerBold = tableHeaderBold(operation.properties, rows);
-  const headerRunProperties = headerBold ? wordTableRunProperties(operation.properties, { bold: true }) : runProperties;
   const headers = tableHeaderRows(operation.properties, rows);
+  const rowRunProperties = (row) =>
+    wordTableRunProperties(rowTypeProperties(operation.properties, row), {
+      bold: rowBold(operation.properties, row, rows, headerBold && row < headers),
+    });
+  const totalBorder = `<w:tcBorders><w:top w:val="single" w:sz="${TOTAL_ROW_RULE.size}" w:space="0" w:color="${TOTAL_ROW_RULE.color}"/></w:tcBorders>`;
   const gutters = layout ? [] : gutterColumns(operation.properties);
   // A page break never strands a table's edge: the header travels with the first two rows and the last two rows
   // travel together (widow and orphan control, row by row) — a three-row table used to leave its last row alone at
@@ -319,7 +360,8 @@ export function wordTableXml(operation, { available = 0 } = {}) {
   // caption): gluing every row instead carried a 25-row table whole to the next page and left half a page blank.
   const keptRow = (row) =>
     row < rows - 1 ? rows <= 6 || row <= headers || row === rows - 2 : Boolean(operation.properties?.keepWithNext);
-  const paragraphProperties = (row) => wordTableParagraphProperties(operation.properties, { keepNext: keptRow(row) });
+  const paragraphProperties = (row) =>
+    wordTableParagraphProperties(rowTypeProperties(operation.properties, row), { keepNext: keptRow(row) });
   const grid = Array.from(
     { length: columns },
     (_, column) => `<w:gridCol${widths[column] ? ` w:w="${pointsToTwips(widths[column])}"` : ''}/>`
@@ -347,14 +389,15 @@ export function wordTableXml(operation, { available = 0 } = {}) {
           .join('');
         // Schema order inside pPr: style and spacing before justification.
         const cellParagraphProperties = `${paragraphProperties(row)}${justifications[column] ? `<w:jc w:val="${justifications[column]}"/>` : ''}`;
-        const cellRunProperties = row < headers ? headerRunProperties : runProperties;
+        const cellRunProperties = rowRunProperties(row);
         // A row reads from its top: a label beside a two-line note starts on the note's first line, where the
         // bottom edge put it on the last. The header row sits on its rule (its bottom edge), so a header that wraps
         // stands on the same line as the ones beside it. The exact line pitch keeps a Latin-only figure and a Hangul
         // label on one baseline either way; set_table_cell_style verticalAlignment overrides per cell.
         const margins = layout ? flushCellMargins(column === 0, column === columns - 1) : gutterMargin(gutters[column]);
         const edge = row < headers && headerBold ? 'bottom' : 'top';
-        return `<w:tc><w:tcPr>${width}${margins}<w:vAlign w:val="${edge}"/></w:tcPr><w:p>${cellParagraphProperties ? `<w:pPr>${cellParagraphProperties}</w:pPr>` : ''}<w:r>${cellRunProperties ? `<w:rPr>${cellRunProperties}</w:rPr>` : ''}${runs}</w:r></w:p></w:tc>`;
+        const rule = isTotalRow(operation.properties, row, rows) ? totalBorder : '';
+        return `<w:tc><w:tcPr>${width}${rule}${margins}<w:vAlign w:val="${edge}"/></w:tcPr><w:p>${cellParagraphProperties ? `<w:pPr>${cellParagraphProperties}</w:pPr>` : ''}<w:r>${cellRunProperties ? `<w:rPr>${cellRunProperties}</w:rPr>` : ''}${runs}</w:r></w:p></w:tc>`;
       }
     ).join('')}</w:tr>`;
   }).join('');

package/src/runtime/office/portable/portable-docx.mjs

@@ -28,6 +28,7 @@ import {
 } from './portable-docx-edits.mjs';
 import {
   addDocxNote,
+  defineDocxStyles,
   editDocxParagraph,
   fillDocxContentControl,
   fitDocxTable,
@@ -60,6 +61,7 @@ const DOCUMENT_EDITS = {
   add_image: addDocxImage,
   set_page: setDocxPage,
   set_document_font: setDocxDocumentFont,
+  define_styles: defineDocxStyles,
   insert_table_row: editDocxTableRowsOrColumns,
   delete_table_row: editDocxTableRowsOrColumns,
   insert_table_column: editDocxTableRowsOrColumns,

package/src/runtime/office/portable/portable-snapshot-docx.mjs

@@ -128,6 +128,8 @@ function tableRecord(block, tableIndex) {
       path: `/body/tbl[${tableIndex}]/row[${rowIndex + 1}]/cell[${cellIndex + 1}]`,
       index: cellIndex + 1,
       text: blockText(cell.xml, 'w:t'),
+      // The cell's own type, as the review reads a paragraph's: a stat strip's label set at the figure's 22 pt.
+      ...statedRunFont(cell.xml),
       ...cellMarkup(cell.xml),
     })),
   }));

package/src/runtime/office/portable/portable-validation.mjs

@@ -621,7 +621,7 @@ async function sheetAuditIssues(zip) {
 }
 
 /** What the slides measure: fit, contrast, tracking, spacing, balance, structure, charts. */
-async function presentationMetricIssues(zip) {
+async function presentationMetricIssues(zip, options = {}) {
   const issues = [];
   const inspected = await inspectPptxTextBoxes(zip);
   for (const fit of reviewTextBoxFit(inspected.boxes, {
@@ -654,7 +654,10 @@ async function presentationMetricIssues(zip) {
   // neighbours share, a margin breach, a collision. A defect is cheapest to
   // answer in the turn that wrote it, not one call later. Contrast stays with
   // the metrics pass above, which measures it against the resolved surface.
-  for (const finding of reviewOfficeStructure({ format: 'pptx', document: await snapshotPptx(zip) })) {
+  // A PDF's designed sheets (printSheet) are held to the print type floors, not a screen's.
+  const document = await snapshotPptx(zip);
+  if (options.printSheet) document.printSheet = true;
+  for (const finding of reviewOfficeStructure({ format: 'pptx', document })) {
     if (finding.code === 'low_contrast') continue;
     issues.push(finding);
   }
@@ -1060,7 +1063,7 @@ export async function issuesPortableOoxml(path, format, options = {}) {
   issues.push(...(await placeholderIssues(zip, format)));
   issues.push(...(await imagePlacementIssues(zip, format)));
   if (format === 'xlsx') issues.push(...(await sheetAuditIssues(zip)));
-  if (format === 'pptx') issues.push(...(await presentationMetricIssues(zip)));
+  if (format === 'pptx') issues.push(...(await presentationMetricIssues(zip, options)));
   issues.push(...packageProvenanceIssues(validation));
   if (format === 'docx') issues.push(...(await documentContentIssues(zip, validation)));
   else if (format === 'xlsx') issues.push(...(await workbookContentIssues(zip, options)));