@beyondwork/docx-react-component 1.0.36 → 1.0.38

package/src/io/export/serialize-main-document.ts

@@ -23,6 +23,7 @@ import {
   serializeTablePropertiesXml,
   serializeTableRowPropertiesXml,
 } from "./table-properties-xml.ts";
+import { twip } from "./twip.ts";
 
 const HYPERLINK_RELATIONSHIP_TYPE =
   "http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink";
@@ -46,6 +47,15 @@ interface SerializationState {
   retainedRelationshipIds: Set<string>;
   media: MediaCatalog;
   preservation: PreservationStore;
+  /**
+   * A.7: per-body-context dedupe sets for w14:paraId / w14:textId.
+   * Every paragraph emitted into the same document part must carry a
+   * unique paraId (the schema constraint). Colliding ids are minted fresh.
+   */
+  usedParaIds: Set<string>;
+  usedTextIds: Set<string>;
+  /** Deterministic PRNG-less counter used when we mint fresh ids. */
+  mintedParaIdCounter: number;
 }
 
 interface InlineSerializationResult {
@@ -86,13 +96,10 @@ export function serializeMainDocument(
     ),
     media: options.media ?? { items: {} },
     preservation,
+    usedParaIds: new Set<string>(),
+    usedTextIds: new Set<string>(),
+    mintedParaIdCounter: 0,
   };
-  const documentOpen = `<w:document${serializeDocumentAttributes(options.documentAttributes, content)}>`;
-  const prefix = [
-    `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>`,
-    documentOpen,
-    `  <w:body>`,
-  ].join("\n");
   const suffix = `</w:body>\n</w:document>`;
   const bodyPieces: string[] = [];
   const paragraphBoundaries: RevisionParagraphBoundary[] = [];
@@ -117,11 +124,14 @@ export function serializeMainDocument(
         cursor,
         paragraphIndex,
       );
-      const paragraphOffset = prefix.length + bodyLength;
+      // Capture body-relative offsets; we apply the final prefix length after
+      // the body is fully serialized and we know which namespace aliases the
+      // document opening tag must declare (see mc:Ignorable scan below).
+      const bodyRelativeOffset = bodyLength;
       bodyPieces.push(serializedParagraph.xml);
       bodyLength += serializedParagraph.xml.length;
       paragraphBoundaries.push(
-        offsetParagraphBoundary(serializedParagraph.boundary, paragraphOffset),
+        offsetParagraphBoundary(serializedParagraph.boundary, bodyRelativeOffset),
       );
       cursor = serializedParagraph.nextCursor;
       previousWasParagraph = true;
@@ -194,12 +204,38 @@ export function serializeMainDocument(
   }
 
   const bodyXml = bodyPieces.join("");
-  const documentXml = `${prefix}${bodyXml || "<w:p><w:r><w:t></w:t></w:r></w:p>"}${sectionPropertiesXml}${suffix}`;
+  const bodyAndSectionXml = `${bodyXml || "<w:p><w:r><w:t></w:t></w:r></w:p>"}${sectionPropertiesXml}`;
+  const extensionAliases = collectExtensionAliases(bodyAndSectionXml, content);
+  const documentOpen = `<w:document${serializeDocumentAttributes(
+    options.documentAttributes,
+    content,
+    extensionAliases,
+  )}>`;
+  const prefix = [
+    `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>`,
+    documentOpen,
+    `  <w:body>`,
+  ].join("\n");
+  const documentXml = `${prefix}${bodyAndSectionXml}${suffix}`;
+  // A.9 dev guard — a NaN or -Infinity slipping into the serialized XML
+  // means an authoring path wrote a bad numeric without routing through
+  // twip() / requireTwip(). Fail early so the bug is caught at test time,
+  // not at validator-service time where the symptom is downstream.
+  assertNoNonFiniteNumbers(documentXml);
+  // A.4 dev guard — every emitted w:bookmarkStart id must be unique within
+  // a part. A collision means detectDuplicateBookmarkIds was not applied
+  // on the canonical document (or the caller wrote a custom path that
+  // bypassed it). Flag the first collision with a helpful console warning
+  // in non-production; production is a silent no-op.
+  assertUniqueBookmarkIdsOrWarn(documentXml);
+  const shiftedBoundaries = paragraphBoundaries.map((boundary) =>
+    offsetParagraphBoundary(boundary, prefix.length),
+  );
 
   return {
     documentXml,
     relationships: state.relationships,
-    paragraphBoundaries,
+    paragraphBoundaries: shiftedBoundaries,
   };
 }
 
@@ -218,7 +254,7 @@ function serializeTableNode(
   const gridXml =
     table.gridColumns.length > 0
       ? `<w:tblGrid>${table.gridColumns
-          .map((width) => `<w:gridCol w:w="${width}"/>`)
+          .map((width) => `<w:gridCol w:w="${twip(width)}"/>`)
           .join("")}</w:tblGrid>`
       : "";
   const rowsXml = table.rows
@@ -335,7 +371,9 @@ function buildSdtPropertiesXml(block: SdtNode): string {
   if (block.properties.checkbox) {
     const cb = block.properties.checkbox;
     const cbParts: string[] = [];
-    cbParts.push(`<w14:checked w14:val="${cb.checked ? "1" : "0"}"/>`);
+    // ST_OnOff (A.3): w14:val is typed as ST_OnOff; emit "true"/"false"
+    // instead of "1"/"0" to satisfy DocumentFormat.OpenXml validation.
+    cbParts.push(`<w14:checked w14:val="${cb.checked ? "true" : "false"}"/>`);
     if (cb.checkedChar) cbParts.push(`<w14:checkedState w14:val="${escapeAttribute(cb.checkedChar)}"/>`);
     if (cb.uncheckedChar) cbParts.push(`<w14:uncheckedState w14:val="${escapeAttribute(cb.uncheckedChar)}"/>`);
     children.push(`<w14:checkbox>${cbParts.join("")}</w14:checkbox>`);
@@ -372,7 +410,7 @@ function serializeTableCellParagraph(
   paragraph: ParagraphNode,
   state: SerializationState,
 ): string {
-  let xml = "<w:p>";
+  let xml = buildParagraphOpenTag(paragraph, state);
   const paragraphPropertiesXml = buildParagraphPropertiesXml(paragraph);
   if (paragraphPropertiesXml.length > 0) {
     xml += paragraphPropertiesXml;
@@ -383,6 +421,80 @@ function serializeTableCellParagraph(
   return xml;
 }
 
+/**
+ * A.7: build the paragraph opening tag. When the canonical paragraph
+ * carries a preserved `wordExtensionIds`, re-emit `w14:paraId` /
+ * `w14:textId` and register them in the per-document dedupe set.
+ * If the incoming paraId collides with a previously-emitted one,
+ * mint a fresh 8-hex uppercase id (deterministic via a state counter).
+ * Paragraphs without an id are left unchanged — A.1 + A.7 only force
+ * the namespace to declare when at least one paragraph actually carries
+ * the attribute.
+ */
+function buildParagraphOpenTag(
+  paragraph: ParagraphNode,
+  state: SerializationState,
+): string {
+  const preserved = paragraph.wordExtensionIds;
+  if (!preserved || (!preserved.paraId && !preserved.textId)) {
+    return "<w:p>";
+  }
+  const attrs: string[] = [];
+  if (preserved.paraId) {
+    const paraId = ensureUniqueExtensionId(
+      preserved.paraId,
+      state.usedParaIds,
+      state,
+    );
+    state.usedParaIds.add(paraId);
+    attrs.push(` w14:paraId="${paraId}"`);
+  }
+  if (preserved.textId) {
+    const textId = ensureUniqueExtensionId(
+      preserved.textId,
+      state.usedTextIds,
+      state,
+    );
+    state.usedTextIds.add(textId);
+    attrs.push(` w14:textId="${textId}"`);
+  }
+  return `<w:p${attrs.join("")}>`;
+}
+
+function ensureUniqueExtensionId(
+  candidate: string,
+  used: Set<string>,
+  state: SerializationState,
+): string {
+  const normalized = normalizeExtensionId(candidate);
+  if (normalized && !used.has(normalized)) {
+    return normalized;
+  }
+  return mintExtensionId(state);
+}
+
+function normalizeExtensionId(raw: string): string {
+  // ECMA-376 expects 8 uppercase hex chars. Be generous on import (Word has
+  // been known to emit 7-char ids) but re-canonicalise on export.
+  const hex = raw.trim().replace(/[^0-9A-Fa-f]/gu, "").toUpperCase();
+  if (hex.length === 8) return hex;
+  if (hex.length === 0) return "";
+  if (hex.length < 8) return hex.padStart(8, "0");
+  return hex.slice(0, 8);
+}
+
+function mintExtensionId(state: SerializationState): string {
+  // Deterministic — keeps snapshot tests stable. The seed is the counter
+  // shifted into the upper nibble so collisions with the canonical
+  // monotonic id space used by authoring tools stay rare.
+  state.mintedParaIdCounter += 1;
+  const hex = ((0xC0DE0000 + state.mintedParaIdCounter) >>> 0)
+    .toString(16)
+    .toUpperCase()
+    .padStart(8, "0");
+  return hex;
+}
+
 function serializeTableInlineNode(
   node: InlineNode,
   state: SerializationState,
@@ -501,26 +613,31 @@ function buildParagraphPropertiesXml(paragraph: ParagraphNode): string {
   if (paragraph.spacing) {
     const s = paragraph.spacing;
     const attrs: string[] = [];
-    if (s.before !== undefined) attrs.push(`w:before="${s.before}"`);
-    if (s.after !== undefined) attrs.push(`w:after="${s.after}"`);
-    if (s.line !== undefined) attrs.push(`w:line="${s.line}"`);
+    if (s.before !== undefined) attrs.push(`w:before="${twip(s.before)}"`);
+    if (s.after !== undefined) attrs.push(`w:after="${twip(s.after)}"`);
+    if (s.line !== undefined) attrs.push(`w:line="${twip(s.line)}"`);
     if (s.lineRule !== undefined) attrs.push(`w:lineRule="${s.lineRule}"`);
     if (attrs.length > 0) children.push(`<w:spacing ${attrs.join(" ")}/>`);
   }
-  if (paragraph.contextualSpacing !== undefined) {
-    children.push(
-      paragraph.contextualSpacing
-        ? "<w:contextualSpacing/>"
-        : `<w:contextualSpacing w:val="0"/>`,
-    );
+  // ST_OnOff element (A.3):
+  // - true  → <w:contextualSpacing/>.
+  // - false → <w:contextualSpacing w:val="false"/> (explicit override —
+  //            paragraph-level false overrides a potentially-true style
+  //            default; canonical false is preserved byte-for-byte with
+  //            "false" not "0" per A.3).
+  // - undefined → omit.
+  if (paragraph.contextualSpacing === true) {
+    children.push("<w:contextualSpacing/>");
+  } else if (paragraph.contextualSpacing === false) {
+    children.push(`<w:contextualSpacing w:val="false"/>`);
   }
   if (paragraph.indentation) {
     const ind = paragraph.indentation;
     const attrs: string[] = [];
-    if (ind.left !== undefined) attrs.push(`w:left="${ind.left}"`);
-    if (ind.right !== undefined) attrs.push(`w:right="${ind.right}"`);
-    if (ind.firstLine !== undefined) attrs.push(`w:firstLine="${ind.firstLine}"`);
-    if (ind.hanging !== undefined) attrs.push(`w:hanging="${ind.hanging}"`);
+    if (ind.left !== undefined) attrs.push(`w:left="${twip(ind.left)}"`);
+    if (ind.right !== undefined) attrs.push(`w:right="${twip(ind.right)}"`);
+    if (ind.firstLine !== undefined) attrs.push(`w:firstLine="${twip(ind.firstLine)}"`);
+    if (ind.hanging !== undefined) attrs.push(`w:hanging="${twip(ind.hanging)}"`);
     if (attrs.length > 0) children.push(`<w:ind ${attrs.join(" ")}/>`);
   }
   if (paragraph.alignment) {
@@ -550,7 +667,7 @@ function buildParagraphPropertiesXml(paragraph: ParagraphNode): string {
   if (paragraph.tabStops && paragraph.tabStops.length > 0) {
     const tabsXml = paragraph.tabStops.map((tab) => {
       const leaderAttr = tab.leader ? ` w:leader="${tab.leader}"` : "";
-      return `<w:tab w:val="${tab.align}" w:pos="${tab.position}"${leaderAttr}/>`;
+      return `<w:tab w:val="${tab.align}" w:pos="${twip(tab.position)}"${leaderAttr}/>`;
     }).join("");
     children.push(`<w:tabs>${tabsXml}</w:tabs>`);
   }
@@ -590,8 +707,8 @@ function serializeBorder(name: string, border: BorderSpec | undefined): string {
   }
   const attrs: string[] = [];
   if (border.value) attrs.push(`w:val="${escapeAttribute(border.value)}"`);
-  if (border.size !== undefined) attrs.push(`w:sz="${border.size}"`);
-  if (border.space !== undefined) attrs.push(`w:space="${border.space}"`);
+  if (border.size !== undefined) attrs.push(`w:sz="${twip(border.size)}"`);
+  if (border.space !== undefined) attrs.push(`w:space="${twip(border.space)}"`);
   if (border.color) attrs.push(`w:color="${escapeAttribute(border.color)}"`);
   return attrs.length > 0 ? `<w:${name} ${attrs.join(" ")}/>` : "";
 }
@@ -603,7 +720,14 @@ function serializeParagraphShading(shading: ParagraphNode["shading"]): string {
   const attrs: string[] = [];
   if (shading.val) attrs.push(`w:val="${escapeAttribute(shading.val)}"`);
   if (shading.color) attrs.push(`w:color="${escapeAttribute(shading.color)}"`);
-  if (shading.fill) attrs.push(`w:fill="${escapeAttribute(shading.fill)}"`);
+  // A.9: w:shd w:val="clear" must always carry w:fill. Emit w:fill="auto"
+  // when the canonical model has no explicit fill; otherwise the SDK
+  // flags the shading as incomplete.
+  if (shading.fill !== undefined) {
+    attrs.push(`w:fill="${escapeAttribute(shading.fill)}"`);
+  } else if (shading.val === "clear") {
+    attrs.push(`w:fill="auto"`);
+  }
   return attrs.length > 0 ? `<w:shd ${attrs.join(" ")}/>` : "";
 }
 
@@ -617,7 +741,7 @@ function serializeParagraph(
   cursor: number,
   paragraphIndex: number,
 ): ParagraphSerializationResult {
-  let xml = "<w:p>";
+  let xml = buildParagraphOpenTag(paragraph, state);
   const boundaries = new Map<number, number>();
   const paragraphStart = 0;
   const paragraphStartTagEnd = xml.length;
@@ -1139,20 +1263,169 @@ function offsetParagraphBoundary(
   };
 }
 
+function assertUniqueBookmarkIdsOrWarn(documentXml: string): void {
+  const proc = (globalThis as unknown as {
+    process?: { env?: Record<string, string | undefined> };
+  }).process;
+  if (proc?.env?.NODE_ENV === "production") {
+    return;
+  }
+  const seen = new Set<string>();
+  const pattern = /<w:bookmarkStart\b[^>]*\bw:id="([^"]+)"/gu;
+  let match: RegExpExecArray | null;
+  while ((match = pattern.exec(documentXml)) !== null) {
+    const id = match[1] ?? "";
+    if (seen.has(id)) {
+      console.warn(
+        `[serialize-main-document] duplicate w:bookmarkStart w:id="${id}" — call detectDuplicateBookmarkIds() during import and re-key in-place before export (§2 A.4 guard).`,
+      );
+      return;
+    }
+    seen.add(id);
+  }
+}
+
+function assertNoNonFiniteNumbers(documentXml: string): void {
+  // Match `="NaN"` / `="Infinity"` / `="-Infinity"` inside any attribute value.
+  const pattern = /="(NaN|-?Infinity)"/u;
+  const match = pattern.exec(documentXml);
+  if (match) {
+    const around = documentXml.slice(
+      Math.max(0, (match.index ?? 0) - 60),
+      Math.min(documentXml.length, (match.index ?? 0) + 120),
+    );
+    throw new Error(
+      `serializeMainDocument: non-finite numeric (${match[1]}) leaked into the serialized XML near: ${around}`,
+    );
+  }
+}
+
+const EXTENSION_NAMESPACE_URIS: Readonly<Record<string, string>> = {
+  w14: "http://schemas.microsoft.com/office/word/2010/wordml",
+  w15: "http://schemas.microsoft.com/office/word/2012/wordml",
+  w16: "http://schemas.microsoft.com/office/word/2018/wordml",
+  w16cex: "http://schemas.microsoft.com/office/word/2018/wordml/cex",
+  w16cid: "http://schemas.microsoft.com/office/word/2016/wordml/cid",
+  w16se: "http://schemas.microsoft.com/office/word/2015/wordml/symex",
+  w16sdtdh: "http://schemas.microsoft.com/office/word/2020/wordml/sdtdatahash",
+  w16sdtfl: "http://schemas.microsoft.com/office/word/2024/wordml/sdtformatlock",
+  w16du: "http://schemas.microsoft.com/office/word/2023/wordml/word16du",
+  wp14: "http://schemas.microsoft.com/office/word/2010/wordprocessingDrawing",
+};
+
+const MC_IGNORABLE_PRIORITY: readonly string[] = [
+  "w14",
+  "w15",
+  "w16se",
+  "w16cid",
+  "w16",
+  "w16cex",
+  "w16sdtdh",
+  "w16sdtfl",
+  "w16du",
+  "wp14",
+];
+
+const NON_EXTENSION_PREFIXES = new Set([
+  "w",
+  "r",
+  "mc",
+  "xml",
+  "xsi",
+  "xmlns",
+  "v",
+  "o",
+  "pic",
+  "a",
+  "a14",
+  "ve",
+  "m",
+]);
+
+function collectExtensionAliases(
+  bodyAndSectionXml: string,
+  content?: DocumentRootNode,
+): readonly string[] {
+  const discovered = new Set<string>();
+  // Walk element / attribute prefixes. `<w14:paraId`, ` w14:paraId=`, etc.
+  const prefixPattern = /(?:<|\s)([A-Za-z][A-Za-z0-9]*):[A-Za-z]/gu;
+  let match: RegExpExecArray | null;
+  while ((match = prefixPattern.exec(bodyAndSectionXml)) !== null) {
+    const alias = match[1] ?? "";
+    if (!alias || NON_EXTENSION_PREFIXES.has(alias)) continue;
+    if (alias in EXTENSION_NAMESPACE_URIS) {
+      discovered.add(alias);
+    }
+  }
+  // Legacy textFill/sdt-checkbox signals emit w14 even when attribute text is absent
+  // from the assembled body (defensive; safe to add when scanning missed it).
+  if (content && documentNeedsW14Namespace(content)) {
+    discovered.add("w14");
+  }
+  return MC_IGNORABLE_PRIORITY.filter((alias) => discovered.has(alias));
+}
+
 function serializeDocumentAttributes(
   attributes: Record<string, string> | undefined,
   content?: DocumentRootNode,
+  extensionAliases: readonly string[] = [],
 ): string {
-  const merged = {
+  const extensionXmlns: Record<string, string> = {};
+  for (const alias of extensionAliases) {
+    const uri = EXTENSION_NAMESPACE_URIS[alias];
+    if (uri) extensionXmlns[`xmlns:${alias}`] = uri;
+  }
+
+  const merged: Record<string, string> = {
     "xmlns:r": "http://schemas.openxmlformats.org/officeDocument/2006/relationships",
     "xmlns:w": "http://schemas.openxmlformats.org/wordprocessingml/2006/main",
-    ...(content && documentNeedsW14Namespace(content)
-      ? { "xmlns:w14": "http://schemas.microsoft.com/office/word/2010/wordml" }
-      : {}),
+    ...extensionXmlns,
     ...(attributes ?? {}),
   };
 
-  return Object.entries(merged)
+  // mc:Ignorable declares extension-namespace aliases that downstream readers
+  // may skip without dropping the document. Only emit when aliases are in play.
+  if (extensionAliases.length > 0) {
+    merged["xmlns:mc"] =
+      merged["xmlns:mc"] ??
+      "http://schemas.openxmlformats.org/markup-compatibility/2006";
+    merged["mc:Ignorable"] = extensionAliases.join(" ");
+  }
+
+  return renderDeterministicRootAttributes(merged);
+}
+
+/**
+ * A.8: emit root attributes in a stable order so identical canonical
+ * inputs produce byte-identical XML (fixture-stable diffs, deterministic
+ * caching). Order:
+ *   1. xmlns:* declarations, alphabetised by local name.
+ *   2. mc:Ignorable (only emitted when extensionAliases was non-empty).
+ *   3. Remaining attributes, alphabetised.
+ */
+export function renderDeterministicRootAttributes(
+  attrs: Record<string, string>,
+): string {
+  const xmlnsEntries: Array<[string, string]> = [];
+  const ignorableEntries: Array<[string, string]> = [];
+  const otherEntries: Array<[string, string]> = [];
+  for (const [name, value] of Object.entries(attrs)) {
+    if (name === "mc:Ignorable") {
+      ignorableEntries.push([name, value]);
+    } else if (name.startsWith("xmlns:") || name === "xmlns") {
+      xmlnsEntries.push([name, value]);
+    } else {
+      otherEntries.push([name, value]);
+    }
+  }
+  xmlnsEntries.sort((a, b) => a[0].localeCompare(b[0]));
+  otherEntries.sort((a, b) => a[0].localeCompare(b[0]));
+  const ordered: Array<[string, string]> = [
+    ...xmlnsEntries,
+    ...ignorableEntries,
+    ...otherEntries,
+  ];
+  return ordered
     .map(([name, value]) => ` ${name}="${escapeAttribute(value)}"`)
     .join("");
 }
@@ -1181,7 +1454,7 @@ export function serializeSectionPropertiesXml(props: SectionProperties): string
 
   // Page size
   if (props.pageSize) {
-    let pgSz = `<w:pgSz w:w="${props.pageSize.width}" w:h="${props.pageSize.height}"`;
+    let pgSz = `<w:pgSz w:w="${twip(props.pageSize.width)}" w:h="${twip(props.pageSize.height)}"`;
     if (props.pageSize.orientation) {
       pgSz += ` w:orient="${props.pageSize.orientation}"`;
     }
@@ -1191,10 +1464,12 @@ export function serializeSectionPropertiesXml(props: SectionProperties): string
 
   // Page margins
   if (props.pageMargins) {
-    let pgMar = `<w:pgMar w:top="${props.pageMargins.top}" w:right="${props.pageMargins.right}" w:bottom="${props.pageMargins.bottom}" w:left="${props.pageMargins.left}"`;
-    if (props.pageMargins.header !== undefined) pgMar += ` w:header="${props.pageMargins.header}"`;
-    if (props.pageMargins.footer !== undefined) pgMar += ` w:footer="${props.pageMargins.footer}"`;
-    if (props.pageMargins.gutter !== undefined) pgMar += ` w:gutter="${props.pageMargins.gutter}"`;
+    let pgMar = `<w:pgMar w:top="${twip(props.pageMargins.top)}" w:right="${twip(
+      props.pageMargins.right,
+    )}" w:bottom="${twip(props.pageMargins.bottom)}" w:left="${twip(props.pageMargins.left)}"`;
+    if (props.pageMargins.header !== undefined) pgMar += ` w:header="${twip(props.pageMargins.header)}"`;
+    if (props.pageMargins.footer !== undefined) pgMar += ` w:footer="${twip(props.pageMargins.footer)}"`;
+    if (props.pageMargins.gutter !== undefined) pgMar += ` w:gutter="${twip(props.pageMargins.gutter)}"`;
     pgMar += "/>";
     children.push(pgMar);
   }
@@ -1202,15 +1477,18 @@ export function serializeSectionPropertiesXml(props: SectionProperties): string
   // Columns
   if (props.columns) {
     let cols = "<w:cols";
-    if (props.columns.count !== undefined) cols += ` w:num="${props.columns.count}"`;
-    if (props.columns.space !== undefined) cols += ` w:space="${props.columns.space}"`;
-    if (props.columns.equalWidth !== undefined) cols += ` w:equalWidth="${props.columns.equalWidth ? "1" : "0"}"`;
+    if (props.columns.count !== undefined) cols += ` w:num="${twip(props.columns.count)}"`;
+    if (props.columns.space !== undefined) cols += ` w:space="${twip(props.columns.space)}"`;
+    if (props.columns.equalWidth !== undefined) {
+      // ST_OnOff (A.3): emit "true"/"false", never "1"/"0".
+      cols += ` w:equalWidth="${props.columns.equalWidth ? "true" : "false"}"`;
+    }
     if (props.columns.separator) cols += ` w:sep="1"`;
     if (props.columns.columns && props.columns.columns.length > 0) {
       cols += ">";
       for (const col of props.columns.columns) {
-        let colXml = `<w:col w:w="${col.width}"`;
-        if (col.space !== undefined) colXml += ` w:space="${col.space}"`;
+        let colXml = `<w:col w:w="${twip(col.width)}"`;
+        if (col.space !== undefined) colXml += ` w:space="${twip(col.space)}"`;
         colXml += "/>";
         cols += colXml;
       }
@@ -1225,7 +1503,7 @@ export function serializeSectionPropertiesXml(props: SectionProperties): string
   if (props.pageNumbering) {
     let pgNum = "<w:pgNumType";
     if (props.pageNumbering.format) pgNum += ` w:fmt="${escapeAttribute(props.pageNumbering.format)}"`;
-    if (props.pageNumbering.start !== undefined) pgNum += ` w:start="${props.pageNumbering.start}"`;
+    if (props.pageNumbering.start !== undefined) pgNum += ` w:start="${twip(props.pageNumbering.start)}"`;
     if (props.pageNumbering.chapStyle) pgNum += ` w:chapStyle="${escapeAttribute(props.pageNumbering.chapStyle)}"`;
     if (props.pageNumbering.chapSep) pgNum += ` w:chapSep="${escapeAttribute(props.pageNumbering.chapSep)}"`;
     pgNum += "/>";
@@ -1235,13 +1513,13 @@ export function serializeSectionPropertiesXml(props: SectionProperties): string
   if (props.lineNumbering) {
     let lineNumbering = "<w:lnNumType";
     if (props.lineNumbering.countBy !== undefined) {
-      lineNumbering += ` w:countBy="${props.lineNumbering.countBy}"`;
+      lineNumbering += ` w:countBy="${twip(props.lineNumbering.countBy)}"`;
     }
     if (props.lineNumbering.start !== undefined) {
-      lineNumbering += ` w:start="${props.lineNumbering.start}"`;
+      lineNumbering += ` w:start="${twip(props.lineNumbering.start)}"`;
     }
     if (props.lineNumbering.distance !== undefined) {
-      lineNumbering += ` w:distance="${props.lineNumbering.distance}"`;
+      lineNumbering += ` w:distance="${twip(props.lineNumbering.distance)}"`;
     }
     if (props.lineNumbering.restart) {
       lineNumbering += ` w:restart="${escapeAttribute(props.lineNumbering.restart)}"`;