@bendyline/squisq-formats 1.3.1 → 1.4.1

package/src/__tests__/sharedContainer.test.ts

@@ -0,0 +1,41 @@
+/**
+ * Tests for the shared container-assembly tail (`shared/container.ts`) that the
+ * docx / pptx / pdf `*ToContainer` importers now delegate to.
+ */
+
+import { describe, it, expect } from 'vitest';
+import { buildContainer } from '../shared/container';
+
+const BYTES_A = new Uint8Array([1, 2, 3, 4]);
+const BYTES_B = new Uint8Array([9, 8, 7]);
+
+describe('buildContainer', () => {
+  it('writes the markdown document and every image with its mime type', async () => {
+    const container = await buildContainer(
+      '# Hello\n\n![](images/a.png)',
+      new Map([
+        ['images/a.png', { data: BYTES_A.buffer, mimeType: 'image/png' }],
+        ['images/b.jpg', { data: BYTES_B.buffer, mimeType: 'image/jpeg' }],
+      ]),
+    );
+
+    expect(await container.readDocument()).toContain('Hello');
+    expect(await container.exists('images/a.png')).toBe(true);
+    expect(await container.exists('images/b.jpg')).toBe(true);
+    expect(new Uint8Array((await container.readFile('images/a.png'))!)).toEqual(BYTES_A);
+    expect(new Uint8Array((await container.readFile('images/b.jpg'))!)).toEqual(BYTES_B);
+  });
+
+  it('accepts any iterable of [path, {data, mimeType}] (e.g. mapped array)', async () => {
+    const images = [{ path: 'images/x.png', data: BYTES_A.buffer }].map(
+      (i) => [i.path, { data: i.data, mimeType: 'image/png' }] as const,
+    );
+    const container = await buildContainer('# Doc', images);
+    expect(await container.exists('images/x.png')).toBe(true);
+  });
+
+  it('produces a valid empty container with no images', async () => {
+    const container = await buildContainer('', []);
+    expect(await container.readDocument()).toBe('');
+  });
+});

package/src/__tests__/sharedImages.test.ts

@@ -0,0 +1,61 @@
+/**
+ * Tests for the consolidated ext→MIME map (`shared/images.ts`) and the html
+ * `inferMimeType` wrapper that now delegates to it. This map is the union of
+ * the three previously-drifting copies (docx/pptx importers + html export).
+ */
+
+import { describe, it, expect } from 'vitest';
+import { extToMime } from '../shared/images';
+import { inferMimeType } from '../html/imageUtils';
+
+describe('extToMime', () => {
+  it('is dot-tolerant and case-insensitive', () => {
+    expect(extToMime('png')).toBe('image/png');
+    expect(extToMime('.png')).toBe('image/png');
+    expect(extToMime('.PNG')).toBe('image/png');
+    expect(extToMime('PNG')).toBe('image/png');
+  });
+
+  it('resolves .avif to image/avif (the correct answer where the old maps disagreed)', () => {
+    // html's map had avif→image/avif; the docx/pptx maps omitted it entirely
+    // (would have fallen back to octet-stream). The union picks image/avif.
+    expect(extToMime('avif')).toBe('image/avif');
+    expect(extToMime('.avif')).toBe('image/avif');
+  });
+
+  it('covers the union of all three previous maps', () => {
+    // Raster/vector (all three had most of these)
+    expect(extToMime('jpg')).toBe('image/jpeg');
+    expect(extToMime('jpeg')).toBe('image/jpeg');
+    expect(extToMime('gif')).toBe('image/gif');
+    expect(extToMime('webp')).toBe('image/webp');
+    expect(extToMime('bmp')).toBe('image/bmp');
+    expect(extToMime('svg')).toBe('image/svg+xml');
+    // Only docx/pptx had these
+    expect(extToMime('tiff')).toBe('image/tiff');
+    expect(extToMime('tif')).toBe('image/tiff');
+    expect(extToMime('emf')).toBe('image/emf');
+    expect(extToMime('wmf')).toBe('image/wmf');
+    // Only html had these
+    expect(extToMime('ico')).toBe('image/x-icon');
+    expect(extToMime('mp3')).toBe('audio/mpeg');
+    expect(extToMime('wav')).toBe('audio/wav');
+    expect(extToMime('ogg')).toBe('audio/ogg');
+    expect(extToMime('mp4')).toBe('video/mp4');
+    expect(extToMime('webm')).toBe('video/webm');
+  });
+
+  it('returns application/octet-stream for unknown / empty extensions', () => {
+    expect(extToMime('xyz')).toBe('application/octet-stream');
+    expect(extToMime('')).toBe('application/octet-stream');
+  });
+});
+
+describe('inferMimeType (html wrapper)', () => {
+  it('delegates to extToMime, keying off the filename extension', () => {
+    expect(inferMimeType('images/hero.PNG')).toBe('image/png');
+    expect(inferMimeType('photo.avif')).toBe('image/avif');
+    expect(inferMimeType('clip.webm')).toBe('video/webm');
+    expect(inferMimeType('noextension')).toBe('application/octet-stream');
+  });
+});

package/src/__tests__/xlsxExport.test.ts

@@ -0,0 +1,164 @@
+import { describe, expect, it } from 'vitest';
+import JSZip from 'jszip';
+import { parseMarkdown, type MarkdownDocument } from '@bendyline/squisq/markdown';
+import { markdownToDoc } from '@bendyline/squisq/doc';
+
+import { markdownDocToXlsx, docToXlsx } from '../xlsx/export';
+import { xlsxToMarkdownDoc } from '../xlsx/import';
+
+/** Read the workbook.xml + all worksheet XML out of an exported .xlsx buffer. */
+async function unzip(buffer: ArrayBuffer): Promise<{
+  workbook: string;
+  sheets: string[];
+  paths: string[];
+}> {
+  const zip = await JSZip.loadAsync(buffer);
+  const paths = Object.keys(zip.files).sort();
+  const workbook = (await zip.file('xl/workbook.xml')?.async('string')) ?? '';
+  const sheetPaths = paths.filter((p) => /^xl\/worksheets\/sheet\d+\.xml$/.test(p));
+  const sheets = await Promise.all(sheetPaths.map((p) => zip.file(p)!.async('string')));
+  return { workbook, sheets, paths };
+}
+
+/** Extract sheet names (in order) from a workbook.xml string. */
+function sheetNames(workbook: string): string[] {
+  return [...workbook.matchAll(/<sheet\s+name="([^"]*)"/g)].map((m) => m[1]!);
+}
+
+/** Build a single-heading + single-table document without touching the parser. */
+function docWithHeading(headingText: string): MarkdownDocument {
+  return {
+    type: 'document',
+    children: [
+      { type: 'heading', depth: 1, children: [{ type: 'text', value: headingText }] },
+      {
+        type: 'table',
+        children: [
+          {
+            type: 'tableRow',
+            children: [
+              { type: 'tableCell', isHeader: true, children: [{ type: 'text', value: 'A' }] },
+            ],
+          },
+          {
+            type: 'tableRow',
+            children: [{ type: 'tableCell', children: [{ type: 'text', value: 'x' }] }],
+          },
+        ],
+      },
+    ],
+  };
+}
+
+describe('markdownDocToXlsx', () => {
+  it('produces a structurally valid package (content types + rels + workbook)', async () => {
+    const md = parseMarkdown('# Data\n\n| A | B |\n| - | - |\n| 1 | 2 |\n');
+    const buffer = await markdownDocToXlsx(md);
+    const { paths } = await unzip(buffer);
+
+    expect(paths).toContain('[Content_Types].xml');
+    expect(paths).toContain('_rels/.rels');
+    expect(paths).toContain('xl/workbook.xml');
+    expect(paths).toContain('xl/_rels/workbook.xml.rels');
+    expect(paths).toContain('xl/worksheets/sheet1.xml');
+    expect(paths).toContain('xl/styles.xml');
+  });
+
+  it('names each sheet from the nearest preceding heading', async () => {
+    const md = parseMarkdown('# Sales\n\n| A |\n| - |\n| x |\n');
+    const { workbook } = await unzip(await markdownDocToXlsx(md));
+    expect(sheetNames(workbook)).toEqual(['Sales']);
+  });
+
+  it('sanitizes invalid Excel characters and caps names at 31 chars', async () => {
+    const { workbook } = await unzip(await markdownDocToXlsx(docWithHeading('a:b/c\\d[e]f?g*h')));
+    expect(sheetNames(workbook)).toEqual(['abcdefgh']);
+
+    const { workbook: wb2 } = await unzip(await markdownDocToXlsx(docWithHeading('X'.repeat(50))));
+    expect(sheetNames(wb2)[0]!.length).toBe(31);
+  });
+
+  it('de-duplicates repeated sheet names (Name, Name2, Name3, …)', async () => {
+    const md = parseMarkdown(
+      '# Report\n\n| A |\n| - |\n| 1 |\n\n# Report\n\n| B |\n| - |\n| 2 |\n\n# Report\n\n| C |\n| - |\n| 3 |\n',
+    );
+    const { workbook } = await unzip(await markdownDocToXlsx(md));
+    expect(sheetNames(workbook)).toEqual(['Report', 'Report2', 'Report3']);
+  });
+
+  it('falls back to Sheet1, Sheet2 when a table has no preceding heading', async () => {
+    const md = parseMarkdown('| A |\n| - |\n| 1 |\n\n| B |\n| - |\n| 2 |\n');
+    const { workbook } = await unzip(await markdownDocToXlsx(md));
+    expect(sheetNames(workbook)).toEqual(['Sheet1', 'Sheet2']);
+  });
+
+  it('emits plain numbers as numeric cells and everything else as inline strings', async () => {
+    const md = parseMarkdown(
+      '# T\n\n| Label | N |\n| - | - |\n| Alpha | 42 |\n| Neg | -3.5 |\n| Mixed | 120 req/s |\n',
+    );
+    const { sheets } = await unzip(await markdownDocToXlsx(md));
+    const xml = sheets[0]!;
+
+    // Numeric cells: <v>…</v> without t="inlineStr"
+    expect(xml).toContain('<v>42</v>');
+    expect(xml).toContain('<v>-3.5</v>');
+    // String cells: inlineStr
+    expect(xml).toContain('t="inlineStr"');
+    expect(xml).toContain('>Alpha<');
+    expect(xml).toContain('>120 req/s<');
+    // "120 req/s" must NOT be numeric
+    expect(xml).not.toContain('<v>120 req/s</v>');
+  });
+
+  it('maps multiple tables to multiple worksheets', async () => {
+    const md = parseMarkdown('# First\n\n| A |\n| - |\n| 1 |\n\n# Second\n\n| B |\n| - |\n| 2 |\n');
+    const { sheets, workbook } = await unzip(await markdownDocToXlsx(md));
+    expect(sheets.length).toBe(2);
+    expect(sheetNames(workbook)).toEqual(['First', 'Second']);
+  });
+
+  it('produces a valid empty file (single sheet) when there are no tables', async () => {
+    const md = parseMarkdown('# Just prose\n\nNo tables here at all.\n');
+    const buffer = await markdownDocToXlsx(md);
+    const { sheets, workbook } = await unzip(buffer);
+    expect(sheets.length).toBe(1);
+    expect(sheetNames(workbook)).toEqual(['Sheet1']);
+
+    // Still round-trips without throwing.
+    const roundTrip = await xlsxToMarkdownDoc(buffer);
+    expect(roundTrip.type).toBe('document');
+  });
+
+  it('honors a custom sheetNamePrefix for auto-named sheets', async () => {
+    const md = parseMarkdown('| A |\n| - |\n| 1 |\n');
+    const { workbook } = await unzip(await markdownDocToXlsx(md, { sheetNamePrefix: 'Tab' }));
+    expect(sheetNames(workbook)).toEqual(['Tab1']);
+  });
+
+  it('survives a full round-trip (cell text preserved through import)', async () => {
+    const md = parseMarkdown(
+      '# Metrics\n\n| Metric | Value |\n| - | - |\n| Throughput | 120 |\n| Errors | 0.2% |\n',
+    );
+    const roundTrip = await xlsxToMarkdownDoc(await markdownDocToXlsx(md));
+    const table = roundTrip.children.find((n) => n.type === 'table');
+    expect(table).toBeDefined();
+
+    const flat = JSON.stringify(roundTrip);
+    for (const cell of ['Metric', 'Value', 'Throughput', '120', 'Errors', '0.2%']) {
+      expect(flat).toContain(cell);
+    }
+  });
+
+  it('docToXlsx converts a Doc via the markdown table model', async () => {
+    const doc = markdownToDoc(parseMarkdown('# Report\n\n| K | V |\n| - | - |\n| Users | 99 |\n'));
+    const buffer = await docToXlsx(doc);
+    const { sheets, workbook } = await unzip(buffer);
+    expect(sheets.length).toBeGreaterThanOrEqual(1);
+    expect(sheetNames(workbook).length).toBeGreaterThanOrEqual(1);
+
+    const roundTrip = await xlsxToMarkdownDoc(buffer);
+    const flat = JSON.stringify(roundTrip);
+    expect(flat).toContain('Users');
+    expect(flat).toContain('99');
+  });
+});

package/src/__tests__/xlsxImport.test.ts

@@ -0,0 +1,80 @@
+/**
+ * Tests for XLSX import: xlsxToMarkdownDoc. Builds a minimal .xlsx fixture
+ * with the shared OOXML writer (dogfooding), then imports it.
+ */
+
+import { describe, expect, it } from 'vitest';
+import type { MarkdownHeading, MarkdownTable, MarkdownText } from '@bendyline/squisq/markdown';
+import { NS_R, NS_SML, REL_OFFICE_DOCUMENT } from '../ooxml/namespaces';
+import { createPackage } from '../ooxml/writer';
+import { xmlDeclaration } from '../ooxml/xmlUtils';
+import { xlsxToMarkdownDoc } from '../xlsx/import';
+
+const REL_WORKSHEET =
+  'http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet';
+const REL_SHARED_STRINGS =
+  'http://schemas.openxmlformats.org/officeDocument/2006/relationships/sharedStrings';
+
+async function buildTestXlsx(): Promise<ArrayBuffer> {
+  const pkg = createPackage();
+
+  pkg.addPart(
+    'xl/workbook.xml',
+    `${xmlDeclaration()}<workbook xmlns="${NS_SML}" xmlns:r="${NS_R}">` +
+      `<sheets><sheet name="Data" sheetId="1" r:id="rId1"/></sheets></workbook>`,
+    'application/xml',
+  );
+  pkg.addPart(
+    'xl/sharedStrings.xml',
+    `${xmlDeclaration()}<sst xmlns="${NS_SML}">` +
+      `<si><t>Name</t></si><si><t>Age</t></si><si><t>Alice</t></si></sst>`,
+    'application/xml',
+  );
+  pkg.addPart(
+    'xl/worksheets/sheet1.xml',
+    `${xmlDeclaration()}<worksheet xmlns="${NS_SML}"><sheetData>` +
+      `<row r="1"><c r="A1" t="s"><v>0</v></c><c r="B1" t="s"><v>1</v></c></row>` +
+      `<row r="2"><c r="A2" t="s"><v>2</v></c><c r="B2"><v>30</v></c></row>` +
+      `</sheetData></worksheet>`,
+    'application/xml',
+  );
+
+  pkg.addRelationship('', { id: 'rId1', type: REL_OFFICE_DOCUMENT, target: 'xl/workbook.xml' });
+  pkg.addRelationship('xl/workbook.xml', {
+    id: 'rId1',
+    type: REL_WORKSHEET,
+    target: 'worksheets/sheet1.xml',
+  });
+  pkg.addRelationship('xl/workbook.xml', {
+    id: 'rId2',
+    type: REL_SHARED_STRINGS,
+    target: 'sharedStrings.xml',
+  });
+
+  return pkg.toArrayBuffer();
+}
+
+describe('xlsxToMarkdownDoc', () => {
+  it('imports a sheet as a heading + table, resolving shared strings', async () => {
+    const doc = await xlsxToMarkdownDoc(await buildTestXlsx());
+    expect(doc.type).toBe('document');
+
+    const heading = doc.children[0] as MarkdownHeading;
+    expect(heading.type).toBe('heading');
+    expect((heading.children[0] as MarkdownText).value).toBe('Data');
+
+    const table = doc.children[1] as MarkdownTable;
+    expect(table.type).toBe('table');
+    expect(table.children).toHaveLength(2);
+    const headerCell = table.children[0]!.children[0]!;
+    expect(headerCell.isHeader).toBe(true);
+    expect((headerCell.children[0] as MarkdownText).value).toBe('Name');
+    expect((table.children[1]!.children[0]!.children[0] as MarkdownText).value).toBe('Alice');
+    expect((table.children[1]!.children[1]!.children[0] as MarkdownText).value).toBe('30');
+  });
+
+  it('selects a single sheet by name without a heading', async () => {
+    const doc = await xlsxToMarkdownDoc(await buildTestXlsx(), { sheet: 'Data' });
+    expect(doc.children[0]!.type).toBe('table');
+  });
+});

package/src/csv/index.ts

@@ -0,0 +1,188 @@
+/**
+ * @bendyline/squisq-formats CSV Module
+ *
+ * Bridges CSV ↔ the squisq markdown table model. CSV isn't OOXML, so this
+ * module is self-contained (no jszip / DOMParser): a small RFC-4180 parser on
+ * the import side and a serializer on the export side. The first row is treated
+ * as the table header by default.
+ *
+ * @example
+ * ```ts
+ * import { csvToMarkdownDoc, markdownDocToCsv } from '@bendyline/squisq-formats/csv';
+ * ```
+ */
+
+import { markdownToDoc } from '@bendyline/squisq/doc';
+import type {
+  MarkdownDocument,
+  MarkdownTable,
+  MarkdownTableCell,
+  MarkdownTableRow,
+} from '@bendyline/squisq/markdown';
+import type { Doc } from '@bendyline/squisq/schemas';
+
+export interface CsvImportOptions {
+  /** Field delimiter. Default `,`. */
+  delimiter?: string;
+  /** Treat the first row as a header row. Default true. */
+  hasHeader?: boolean;
+}
+
+export interface CsvExportOptions {
+  /** Field delimiter. Default `,`. */
+  delimiter?: string;
+  /**
+   * Zero-based index of the table to export when the document contains more
+   * than one. Default 0 (the first table). An explicitly provided index that
+   * doesn't match a table in the document is an error.
+   */
+  tableIndex?: number;
+}
+
+async function toText(data: ArrayBuffer | Blob | string): Promise<string> {
+  if (typeof data === 'string') return data;
+  if (typeof Blob !== 'undefined' && data instanceof Blob) return data.text();
+  return new TextDecoder().decode(new Uint8Array(data as ArrayBuffer));
+}
+
+/** Parse CSV text into a grid of string cells (RFC 4180: quotes, escaped quotes). */
+export function parseCsv(text: string, delimiter = ','): string[][] {
+  const rows: string[][] = [];
+  let row: string[] = [];
+  let field = '';
+  let inQuotes = false;
+  let sawAny = false;
+  const pushField = () => {
+    row.push(field);
+    field = '';
+  };
+  const pushRow = () => {
+    pushField();
+    rows.push(row);
+    row = [];
+  };
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i]!;
+    if (inQuotes) {
+      if (ch === '"') {
+        if (text[i + 1] === '"') {
+          field += '"';
+          i++;
+        } else {
+          inQuotes = false;
+        }
+      } else {
+        field += ch;
+      }
+      continue;
+    }
+    if (ch === '"') {
+      inQuotes = true;
+      sawAny = true;
+      continue;
+    }
+    if (ch === delimiter) {
+      sawAny = true;
+      pushField();
+      continue;
+    }
+    if (ch === '\n' || ch === '\r') {
+      if (ch === '\r' && text[i + 1] === '\n') i++;
+      pushRow();
+      sawAny = false;
+      continue;
+    }
+    sawAny = true;
+    field += ch;
+  }
+  // Flush a trailing field/row only if the last line wasn't terminated.
+  if (field !== '' || row.length > 0 || sawAny) pushRow();
+  return rows;
+}
+
+function rowsToTable(rows: string[][], hasHeader: boolean): MarkdownTable {
+  const maxCols = rows.reduce((m, r) => Math.max(m, r.length), 1);
+  const mdRows: MarkdownTableRow[] = rows.map((cells, rowIdx) => {
+    const children: MarkdownTableCell[] = [];
+    for (let c = 0; c < maxCols; c++) {
+      const value = cells[c] ?? '';
+      children.push({
+        type: 'tableCell',
+        ...(hasHeader && rowIdx === 0 ? { isHeader: true } : {}),
+        children: value ? [{ type: 'text', value }] : [],
+      });
+    }
+    return { type: 'tableRow', children };
+  });
+  return { type: 'table', children: mdRows };
+}
+
+/** Convert CSV to a MarkdownDocument containing a single table. */
+export async function csvToMarkdownDoc(
+  data: ArrayBuffer | Blob | string,
+  options: CsvImportOptions = {},
+): Promise<MarkdownDocument> {
+  const text = await toText(data);
+  const rows = parseCsv(text, options.delimiter ?? ',');
+  const hasHeader = options.hasHeader ?? true;
+  const children = rows.length > 0 ? [rowsToTable(rows, hasHeader)] : [];
+  return { type: 'document', children };
+}
+
+/** Convert CSV to a squisq Doc. */
+export async function csvToDoc(
+  data: ArrayBuffer | Blob | string,
+  options: CsvImportOptions = {},
+): Promise<Doc> {
+  return markdownToDoc(await csvToMarkdownDoc(data, options));
+}
+
+function escapeCsvField(value: string, delimiter: string): string {
+  if (value.includes('"') || value.includes(delimiter) || /[\r\n]/.test(value)) {
+    return `"${value.replace(/"/g, '""')}"`;
+  }
+  return value;
+}
+
+function cellText(cell: MarkdownTableCell): string {
+  // Flatten inline children to plain text (CSV has no formatting).
+  const walk = (nodes: unknown[]): string =>
+    nodes
+      .map((n) => {
+        const node = n as { type?: string; value?: string; children?: unknown[] };
+        if (node.value !== undefined) return node.value;
+        if (Array.isArray(node.children)) return walk(node.children);
+        return '';
+      })
+      .join('');
+  return walk(cell.children);
+}
+
+/**
+ * Serialize one table in a MarkdownDocument to CSV text.
+ *
+ * By default the first table is exported. Documents with multiple tables can
+ * select another via `options.tableIndex` (zero-based). An explicit
+ * `tableIndex` that is out of range throws; the implicit first-table default
+ * on a table-less document returns an empty string (back-compat).
+ */
+export function markdownDocToCsv(doc: MarkdownDocument, options: CsvExportOptions = {}): string {
+  const delimiter = options.delimiter ?? ',';
+  const tables = doc.children.filter((n): n is MarkdownTable => n.type === 'table');
+  const index = options.tableIndex ?? 0;
+  if (
+    options.tableIndex !== undefined &&
+    (!Number.isInteger(index) || index < 0 || index >= tables.length)
+  ) {
+    throw new Error(
+      `CSV export: tableIndex ${index} is out of range — the document contains ${tables.length} table(s).`,
+    );
+  }
+  const table = tables[index];
+  if (!table) return '';
+  return table.children
+    .map((row) =>
+      row.children.map((cell) => escapeCsvField(cellText(cell), delimiter)).join(delimiter),
+    )
+    .join('\r\n');
+}

package/src/docx/export.ts

@@ -18,8 +18,8 @@
  */
 
 import type { Doc, Theme } from '@bendyline/squisq/schemas';
-import { resolveTheme, resolveFontFamily } from '@bendyline/squisq/schemas';
-import { docToMarkdown } from '@bendyline/squisq/doc';
+import { resolveFontFamily } from '@bendyline/squisq/schemas';
+import { docToMarkdown, resolveThemeForDoc } from '@bendyline/squisq/doc';
 import type {
   MarkdownDocument,
   MarkdownBlockNode,
@@ -44,6 +44,12 @@ import { readFrontmatterThemeId } from '@bendyline/squisq/markdown';
 
 import { createPackage } from '../ooxml/writer.js';
 import { xmlDeclaration, escapeXml } from '../ooxml/xmlUtils.js';
+import { stripHtmlTags } from '../shared/text.js';
+import {
+  inlineNodesToRuns,
+  inlineNodeToRuns,
+  type InlineRunHandlers,
+} from '../shared/inlineRuns.js';
 import {
   NS_WML,
   NS_R,
@@ -126,7 +132,7 @@ export async function markdownDocToDocx(
     options.themeId !== undefined
       ? options
       : { ...options, themeId: readFrontmatterThemeId(doc.frontmatter) };
-  const ctx = new ExportContext(resolvedOptions);
+  const ctx = new ExportContext(resolvedOptions, doc);
   const bodyXml = convertBlocks(doc.children, ctx);
   return buildDocxPackage(bodyXml, ctx, resolvedOptions);
 }
@@ -206,7 +212,7 @@ class ExportContext {
 
   private nextDocPrId = 1;
 
-  constructor(options: DocxExportOptions) {
+  constructor(options: DocxExportOptions, doc?: MarkdownDocument) {
     let themeFont: string | undefined;
     let themeTitleFont: string | undefined;
     let themeHeadingColor: string | undefined;
@@ -215,7 +221,7 @@ class ExportContext {
     let themeBackgroundColor: string | undefined;
 
     if (options.themeId) {
-      const theme: Theme = resolveTheme(options.themeId);
+      const theme: Theme = resolveThemeForDoc(doc, options.themeId);
       // Theme fonts arrive as CSS stacks (e.g. `"Oswald", Impact,
       // "Arial Black", sans-serif`). Word's `w:ascii` attribute is a
       // single font name — passing the whole stack is treated as a
@@ -631,46 +637,30 @@ interface InlineFormat {
   color?: string;
 }
 
+/**
+ * DOCX leaf handlers for the shared run-based inline walker. The traversal
+ * (format threading) lives in `shared/inlineRuns.ts`; these emit WordprocessingML.
+ */
+function docxRunHandlers(ctx: ExportContext): InlineRunHandlers {
+  return {
+    run: (text, format) => makeRun(text, format),
+    link: (node, format) => convertLink(node, ctx, format),
+    image: (node) => convertImage(node, ctx),
+    lineBreak: () => `<w:r><w:br/></w:r>`,
+    footnoteRef: (node) => convertFootnoteRef(node, ctx),
+  };
+}
+
 function convertInlines(
   nodes: MarkdownInlineNode[],
   ctx: ExportContext,
   format: InlineFormat = {},
 ): string {
-  const parts: string[] = [];
-  for (const node of nodes) {
-    parts.push(convertInline(node, ctx, format));
-  }
-  return parts.join('');
+  return inlineNodesToRuns(nodes, docxRunHandlers(ctx), format);
 }
 
 function convertInline(node: MarkdownInlineNode, ctx: ExportContext, format: InlineFormat): string {
-  switch (node.type) {
-    case 'text':
-      return makeRun(node.value, format);
-    case 'strong':
-      return convertInlines(node.children, ctx, { ...format, bold: true });
-    case 'emphasis':
-      return convertInlines(node.children, ctx, { ...format, italic: true });
-    case 'delete':
-      return convertInlines(node.children, ctx, { ...format, strike: true });
-    case 'inlineCode':
-      return makeRun(node.value, { ...format, code: true });
-    case 'link':
-      return convertLink(node, ctx, format);
-    case 'image':
-      return convertImage(node, ctx);
-    case 'break':
-      return `<w:r><w:br/></w:r>`;
-    case 'htmlInline':
-      return makeRun(stripHtmlTags(node.rawHtml), format);
-    case 'inlineMath':
-      return makeRun(node.value, { ...format, code: true });
-    case 'footnoteReference':
-      return convertFootnoteRef(node, ctx);
-    default:
-      // linkReference, imageReference, textDirective — skip or emit plain
-      return '';
-  }
+  return inlineNodeToRuns(node, docxRunHandlers(ctx), format);
 }
 
 function makeRun(text: string, format: InlineFormat): string {
@@ -1273,10 +1263,3 @@ function buildFootnotesXml(ctx: ExportContext): string {
 // ============================================
 // Helpers
 // ============================================
-
-/**
- * Strip HTML tags from a string, keeping only text content.
- */
-function stripHtmlTags(html: string): string {
-  return html.replace(/<[^>]*>/g, '');
-}