@bendyline/squisq-formats 1.3.1 → 1.4.1

package/src/__tests__/pptxExport.test.ts

@@ -0,0 +1,138 @@
+import { describe, expect, it } from 'vitest';
+import type { MarkdownBlockNode, MarkdownDocument } from '@bendyline/squisq/markdown';
+import type { Transition } from '@bendyline/squisq/schemas';
+import { TRANSITION_TYPES } from '@bendyline/squisq/schemas';
+import { markdownDocToPptx } from '../pptx/export';
+import { openPackage, getPartXml } from '../ooxml/reader';
+import { NS_PML, NS_PML_2010 } from '../ooxml/namespaces';
+
+function docWithSecondSlideTransition(transition: Transition): MarkdownDocument {
+  return {
+    type: 'document',
+    children: [
+      {
+        type: 'heading',
+        depth: 2,
+        children: [{ type: 'text', value: 'One' }],
+      },
+      {
+        type: 'paragraph',
+        children: [{ type: 'text', value: 'Intro' }],
+      },
+      {
+        type: 'heading',
+        depth: 2,
+        children: [{ type: 'text', value: 'Two' }],
+        attributes: {
+          params: {
+            transition: transition.type,
+            ...(transition.duration !== undefined
+              ? { transitionDuration: String(transition.duration) }
+              : {}),
+            ...(transition.direction ? { transitionDirection: transition.direction } : {}),
+          },
+          blockMeta: { transition },
+        },
+      },
+      {
+        type: 'paragraph',
+        children: [{ type: 'text', value: 'Body' }],
+      },
+    ],
+  };
+}
+
+function docWithAllTransitions(): MarkdownDocument {
+  const children: MarkdownBlockNode[] = [
+    {
+      type: 'heading',
+      depth: 2,
+      children: [{ type: 'text', value: 'Transition Gallery' }],
+    },
+    {
+      type: 'paragraph',
+      children: [{ type: 'text', value: 'Intro slide before transition checks.' }],
+    },
+  ];
+
+  for (const type of TRANSITION_TYPES) {
+    const transition: Transition = { type, duration: 0.8 };
+    children.push(
+      {
+        type: 'heading',
+        depth: 2,
+        children: [{ type: 'text', value: type }],
+        attributes: {
+          params: { transition: type, transitionDuration: '0.8' },
+          blockMeta: { transition },
+        },
+      },
+      {
+        type: 'paragraph',
+        children: [{ type: 'text', value: `Transition token: ${type}` }],
+      },
+    );
+  }
+
+  return { type: 'document', children };
+}
+
+describe('markdownDocToPptx transitions', () => {
+  it('writes valid transition XML for every shared transition token', async () => {
+    const pkg = await openPackage(await markdownDocToPptx(docWithAllTransitions()));
+
+    for (let i = 0; i < TRANSITION_TYPES.length; i++) {
+      const type = TRANSITION_TYPES[i];
+      const slide = await getPartXml(pkg, `ppt/slides/slide${i + 2}.xml`);
+      expect(slide, type).not.toBeNull();
+
+      const transitions = slide!.getElementsByTagNameNS(NS_PML, 'transition');
+      if (type === 'cut') {
+        expect(transitions, type).toHaveLength(0);
+        continue;
+      }
+
+      expect(transitions, type).toHaveLength(1);
+      expect(transitions[0].getAttribute('spd'), type).toBe('med');
+
+      const childElements = Array.from(transitions[0].childNodes).filter(
+        (node): node is Element => node.nodeType === 1,
+      );
+      expect(childElements, type).toHaveLength(1);
+      expect([NS_PML, NS_PML_2010], type).toContain(childElements[0].namespaceURI);
+
+      if (childElements[0].namespaceURI === NS_PML_2010) {
+        expect(slide!.documentElement.getAttribute('mc:Ignorable'), type).toContain('p14');
+      }
+    }
+  });
+
+  it('writes standard PresentationML transition XML', async () => {
+    const md = docWithSecondSlideTransition({
+      type: 'checkerboard',
+      duration: 1.3,
+      direction: 'vertical',
+    });
+
+    const pkg = await openPackage(await markdownDocToPptx(md));
+    const slide = await getPartXml(pkg, 'ppt/slides/slide2.xml');
+    const transition = slide!.getElementsByTagNameNS(NS_PML, 'transition')[0];
+    const checker = transition.getElementsByTagNameNS(NS_PML, 'checker')[0];
+
+    expect(transition.getAttribute('spd')).toBe('slow');
+    expect(checker.getAttribute('dir')).toBe('vert');
+  });
+
+  it('writes PowerPoint 2010 transition XML when needed', async () => {
+    const md = docWithSecondSlideTransition({ type: 'flash', duration: 0.4 });
+
+    const pkg = await openPackage(await markdownDocToPptx(md));
+    const slide = await getPartXml(pkg, 'ppt/slides/slide2.xml');
+    const transition = slide!.getElementsByTagNameNS(NS_PML, 'transition')[0];
+    const flash = transition.getElementsByTagNameNS(NS_PML_2010, 'flash')[0];
+
+    expect(transition.getAttribute('spd')).toBe('fast');
+    expect(flash).toBeDefined();
+    expect(slide!.documentElement.getAttribute('mc:Ignorable')).toBe('p14');
+  });
+});

package/src/__tests__/pptxImport.test.ts

@@ -0,0 +1,115 @@
+/**
+ * Tests for PPTX import: pptxToMarkdownDoc. Builds a minimal .pptx fixture with
+ * the shared OOXML writer, then imports it.
+ */
+
+import { describe, expect, it } from 'vitest';
+import type {
+  MarkdownDocument,
+  MarkdownHeading,
+  MarkdownList,
+  MarkdownParagraph,
+  MarkdownText,
+} from '@bendyline/squisq/markdown';
+import { NS_DRAWINGML, NS_PML, NS_R, REL_OFFICE_DOCUMENT, REL_SLIDE } from '../ooxml/namespaces';
+import { createPackage } from '../ooxml/writer';
+import { xmlDeclaration } from '../ooxml/xmlUtils';
+import { markdownDocToPptx } from '../pptx/export';
+import { pptxToContainer, pptxToMarkdownDoc } from '../pptx/import';
+
+/** Distinctive PNG-signature-prefixed payload so round-trip fidelity is checkable. */
+const IMAGE_BYTES = new Uint8Array([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 1, 2, 3, 4, 5]);
+
+async function buildTestPptx(): Promise<ArrayBuffer> {
+  const pkg = createPackage();
+
+  pkg.addPart(
+    'ppt/presentation.xml',
+    `${xmlDeclaration()}<p:presentation xmlns:p="${NS_PML}" xmlns:r="${NS_R}">` +
+      `<p:sldIdLst><p:sldId id="256" r:id="rId1"/></p:sldIdLst></p:presentation>`,
+    'application/xml',
+  );
+  pkg.addPart(
+    'ppt/slides/slide1.xml',
+    `${xmlDeclaration()}<p:sld xmlns:p="${NS_PML}" xmlns:a="${NS_DRAWINGML}"><p:cSld><p:spTree>` +
+      `<p:sp><p:nvSpPr><p:nvPr><p:ph type="title"/></p:nvPr></p:nvSpPr>` +
+      `<p:txBody><a:p><a:r><a:t>My Title</a:t></a:r></a:p></p:txBody></p:sp>` +
+      `<p:sp><p:txBody>` +
+      `<a:p><a:r><a:t>First bullet</a:t></a:r></a:p>` +
+      `<a:p><a:r><a:t>Second bullet</a:t></a:r></a:p>` +
+      `</p:txBody></p:sp>` +
+      `</p:spTree></p:cSld></p:sld>`,
+    'application/xml',
+  );
+
+  pkg.addRelationship('', {
+    id: 'rId1',
+    type: REL_OFFICE_DOCUMENT,
+    target: 'ppt/presentation.xml',
+  });
+  pkg.addRelationship('ppt/presentation.xml', {
+    id: 'rId1',
+    type: REL_SLIDE,
+    target: 'slides/slide1.xml',
+  });
+
+  return pkg.toArrayBuffer();
+}
+
+describe('pptxToMarkdownDoc', () => {
+  it('imports a slide as a heading + bullet list', async () => {
+    const doc = await pptxToMarkdownDoc(await buildTestPptx());
+    expect(doc.type).toBe('document');
+
+    const heading = doc.children[0] as MarkdownHeading;
+    expect(heading.type).toBe('heading');
+    expect(heading.depth).toBe(2);
+    expect((heading.children[0] as MarkdownText).value).toBe('My Title');
+
+    const list = doc.children[1] as MarkdownList;
+    expect(list.type).toBe('list');
+    expect(list.children).toHaveLength(2);
+    const firstItemPara = list.children[0]!.children[0] as MarkdownParagraph;
+    expect((firstItemPara.children[0] as MarkdownText).value).toBe('First bullet');
+  });
+});
+
+describe('pptxToContainer (embedded image import)', () => {
+  const deckWithImage: MarkdownDocument = {
+    type: 'document',
+    children: [
+      { type: 'heading', depth: 2, children: [{ type: 'text', value: 'Picture Slide' }] },
+      { type: 'paragraph', children: [{ type: 'image', url: 'photo.png', alt: 'A photo' }] },
+    ],
+  };
+
+  async function buildDeck(): Promise<ArrayBuffer> {
+    return markdownDocToPptx(deckWithImage, {
+      images: new Map([['photo.png', IMAGE_BYTES.buffer]]),
+    });
+  }
+
+  it('extracts embedded images into the container and references them', async () => {
+    const container = await pptxToContainer(await buildDeck());
+
+    // The extracted image exists at the docx-style images/imageN.ext path.
+    expect(await container.exists('images/image1.png')).toBe(true);
+
+    // The bytes survived the round-trip verbatim.
+    const bytes = await container.readFile('images/image1.png');
+    expect(bytes).not.toBeNull();
+    expect(new Uint8Array(bytes!)).toEqual(IMAGE_BYTES);
+
+    // The markdown references the extracted image (no dangling ref).
+    const markdown = await container.readDocument();
+    expect(markdown).toContain('images/image1.png');
+  });
+
+  it('does not emit dangling image refs without extractImages', async () => {
+    const doc = await pptxToMarkdownDoc(await buildDeck());
+    const hasImage = doc.children.some(
+      (b) => b.type === 'paragraph' && b.children.some((c) => c.type === 'image'),
+    );
+    expect(hasImage).toBe(false);
+  });
+});

package/src/__tests__/roundTripAssets.test.ts

@@ -0,0 +1,50 @@
+/**
+ * Asset-fidelity guard: an embedded image must survive a full export → import
+ * round-trip for every container-producing format. We author a markdown doc
+ * with an image, export it (supplying the image bytes), re-import via the
+ * format's `*ToContainer`, and assert the bytes + reference come back intact.
+ */
+
+import { describe, expect, it } from 'vitest';
+import type { MarkdownDocument } from '@bendyline/squisq/markdown';
+import { markdownDocToPptx } from '../pptx/export';
+import { pptxToContainer } from '../pptx/import';
+import { markdownDocToDocx } from '../docx/export';
+import { docxToContainer } from '../docx/import';
+
+/** PNG-signature-prefixed payload with a distinctive tail for byte comparison. */
+const IMAGE_BYTES = new Uint8Array([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 9, 8, 7, 6]);
+
+const doc: MarkdownDocument = {
+  type: 'document',
+  children: [
+    { type: 'heading', depth: 1, children: [{ type: 'text', value: 'Assets' }] },
+    { type: 'paragraph', children: [{ type: 'image', url: 'hero.png', alt: 'Hero' }] },
+  ],
+};
+
+describe('embedded image round-trips through container formats', () => {
+  it('survives markdown → pptx → pptxToContainer', async () => {
+    const pptx = await markdownDocToPptx(doc, {
+      images: new Map([['hero.png', IMAGE_BYTES.buffer]]),
+    });
+    const container = await pptxToContainer(pptx);
+
+    expect(await container.exists('images/image1.png')).toBe(true);
+    const bytes = await container.readFile('images/image1.png');
+    expect(new Uint8Array(bytes!)).toEqual(IMAGE_BYTES);
+    expect(await container.readDocument()).toContain('images/image1.png');
+  });
+
+  it('survives markdown → docx → docxToContainer', async () => {
+    const docx = await markdownDocToDocx(doc, {
+      images: new Map([['hero.png', { data: IMAGE_BYTES.buffer, contentType: 'image/png' }]]),
+    });
+    const container = await docxToContainer(docx);
+
+    expect(await container.exists('images/image1.png')).toBe(true);
+    const bytes = await container.readFile('images/image1.png');
+    expect(new Uint8Array(bytes!)).toEqual(IMAGE_BYTES);
+    expect(await container.readDocument()).toContain('images/image1.png');
+  });
+});

package/src/__tests__/roundTripMatrix.fixtures.ts

@@ -0,0 +1,86 @@
+import { parseMarkdown, type MarkdownDocument } from '@bendyline/squisq/markdown';
+
+export interface RoundTripFixture {
+  name: string;
+  markdown: string;
+  doc: MarkdownDocument;
+  keyPhrases: string[];
+  headingTexts: string[];
+}
+
+function makeFixture(
+  name: string,
+  markdown: string,
+  keyPhrases: string[],
+  headingTexts: string[],
+): RoundTripFixture {
+  return {
+    name,
+    markdown,
+    doc: parseMarkdown(markdown),
+    keyPhrases,
+    headingTexts,
+  };
+}
+
+export const ROUNDTRIP_FIXTURES = {
+  story: makeFixture(
+    'story',
+    `# River Journal
+
+The field team walked the north bank and recorded water conditions.
+
+## Morning Snapshot
+
+- Water level is steady.
+- Team status is ready.
+- Safety checks are complete.
+
+## Notes
+
+The crew published an update and linked the [full report](https://example.com/report).
+`,
+    ['river journal', 'north bank', 'water level', 'team status', 'full report'],
+    ['River Journal', 'Morning Snapshot', 'Notes'],
+  ),
+
+  mixed: makeFixture(
+    'mixed',
+    `# Ops Weekly
+
+This week we tracked **launch readiness**, *quality signals*, and risk burn-down.
+
+## Checklist
+
+1. Confirm deployment window.
+2. Validate rollback script.
+3. Notify stakeholders.
+
+## Outcome
+
+Launch readiness improved and support tickets declined.
+`,
+    [
+      'ops weekly',
+      'launch readiness',
+      'quality signals',
+      'rollback script',
+      'support tickets declined',
+    ],
+    ['Ops Weekly', 'Checklist', 'Outcome'],
+  ),
+
+  table: makeFixture(
+    'table',
+    `# Metrics
+
+| Metric | Value |
+| --- | --- |
+| Throughput | 120 req/s |
+| Error Rate | 0.2% |
+| P95 | 180ms |
+`,
+    ['metrics', 'throughput', '120 req/s', 'error rate', 'p95'],
+    ['Metrics'],
+  ),
+};

package/src/__tests__/roundTripMatrix.helpers.ts

@@ -0,0 +1,154 @@
+import { expect } from 'vitest';
+import type {
+  MarkdownDocument,
+  MarkdownNode,
+  MarkdownBlockNode,
+  MarkdownHeading,
+} from '@bendyline/squisq/markdown';
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null;
+}
+
+function collectText(node: unknown, out: string[]): void {
+  if (!isRecord(node)) return;
+
+  const maybeType = node.type;
+  if (typeof maybeType === 'string') {
+    if (maybeType === 'text' && typeof node.value === 'string') {
+      out.push(node.value);
+    }
+    if ((maybeType === 'code' || maybeType === 'inlineCode') && typeof node.value === 'string') {
+      out.push(node.value);
+    }
+    if (maybeType === 'link' && typeof node.url === 'string') {
+      out.push(node.url);
+    }
+    if (maybeType === 'image') {
+      if (typeof node.alt === 'string') out.push(node.alt);
+      if (typeof node.url === 'string') out.push(node.url);
+    }
+  }
+
+  const children = node.children;
+  if (Array.isArray(children)) {
+    for (const child of children) collectText(child, out);
+  }
+}
+
+function normalizeText(input: string): string {
+  return input
+    .toLowerCase()
+    .replace(/\r\n/g, '\n')
+    .replace(/[^a-z0-9%/.:\-\s]+/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+function compactText(input: string): string {
+  return normalizeText(input).replace(/\s+/g, '');
+}
+
+function extractDocumentText(doc: MarkdownDocument): string {
+  const out: string[] = [];
+  collectText(doc, out);
+  return normalizeText(out.join(' '));
+}
+
+function extractHeadingTexts(doc: MarkdownDocument): string[] {
+  return doc.children
+    .filter((block): block is MarkdownHeading => block.type === 'heading')
+    .map((heading) => {
+      const out: string[] = [];
+      collectText(heading, out);
+      return normalizeText(out.join(' '));
+    })
+    .filter(Boolean);
+}
+
+function containsNodeType(node: unknown, wantedType: string): boolean {
+  if (!isRecord(node)) return false;
+  if (node.type === wantedType) return true;
+  const children = node.children;
+  if (!Array.isArray(children)) return false;
+  return children.some((child) => containsNodeType(child, wantedType));
+}
+
+function retainRatio(source: string, roundTrip: string): number {
+  const sourceTokens = source.split(' ').filter((t) => t.length >= 4);
+  if (sourceTokens.length === 0) return 1;
+
+  const targetSet = new Set(roundTrip.split(' ').filter((t) => t.length >= 4));
+  let matched = 0;
+  for (const token of sourceTokens) {
+    if (targetSet.has(token)) matched++;
+  }
+  return matched / sourceTokens.length;
+}
+
+export interface HybridRoundTripAssertions {
+  source: MarkdownDocument;
+  roundTrip: MarkdownDocument;
+  keyPhrases: string[];
+  headingTexts?: string[];
+  requireHeadingOrder?: boolean;
+  requireListSurvival?: boolean;
+  requireTableSurvival?: boolean;
+  minRetainRatio?: number;
+}
+
+export function assertHybridRoundTrip(args: HybridRoundTripAssertions): void {
+  const sourceText = extractDocumentText(args.source);
+  const roundTripText = extractDocumentText(args.roundTrip);
+
+  expect(roundTripText.length).toBeGreaterThan(0);
+
+  const minRetainRatio = args.minRetainRatio ?? 0.5;
+  expect(retainRatio(sourceText, roundTripText)).toBeGreaterThanOrEqual(minRetainRatio);
+
+  for (const phrase of args.keyPhrases) {
+    const normalizedPhrase = normalizeText(phrase);
+    if (roundTripText.includes(normalizedPhrase)) continue;
+    expect(compactText(roundTripText)).toContain(compactText(normalizedPhrase));
+  }
+
+  if (args.requireHeadingOrder && args.headingTexts && args.headingTexts.length > 0) {
+    const normalizedExpected = args.headingTexts.map((h) => normalizeText(h));
+    const actualHeadings = extractHeadingTexts(args.roundTrip);
+
+    let cursor = -1;
+    for (const expectedHeading of normalizedExpected) {
+      const next = actualHeadings.findIndex(
+        (heading, index) => index > cursor && heading.includes(expectedHeading),
+      );
+      expect(next).toBeGreaterThan(cursor);
+      cursor = next;
+    }
+  }
+
+  if (args.requireListSurvival && containsNodeType(args.source, 'list')) {
+    expect(containsNodeType(args.roundTrip, 'list')).toBe(true);
+  }
+
+  if (args.requireTableSurvival && containsNodeType(args.source, 'table')) {
+    expect(containsNodeType(args.roundTrip, 'table')).toBe(true);
+  }
+}
+
+export function extractNormalizedText(doc: MarkdownDocument): string {
+  return extractDocumentText(doc);
+}
+
+export function docHasNodeType(doc: MarkdownDocument, wantedType: MarkdownNode['type']): boolean {
+  return containsNodeType(doc, wantedType);
+}
+
+export function firstHeadingText(doc: MarkdownDocument): string | null {
+  const firstHeading = doc.children.find(
+    (block): block is MarkdownBlockNode & { type: 'heading' } => block.type === 'heading',
+  );
+  if (!firstHeading) return null;
+  const out: string[] = [];
+  collectText(firstHeading, out);
+  return normalizeText(out.join(' '));
+}

package/src/__tests__/roundTripMatrix.test.ts

@@ -0,0 +1,142 @@
+import { describe, expect, it } from 'vitest';
+import JSZip from 'jszip';
+import { markdownToDoc } from '@bendyline/squisq/doc';
+
+import { markdownDocToDocx } from '../docx/export';
+import { docxToMarkdownDoc } from '../docx/import';
+import { markdownDocToPptx } from '../pptx/export';
+import { pptxToMarkdownDoc } from '../pptx/import';
+import { markdownDocToPdf } from '../pdf/export';
+import { pdfToMarkdownDoc } from '../pdf/import';
+import { markdownDocToCsv, csvToMarkdownDoc } from '../csv/index';
+import { markdownDocToEpub } from '../epub/export';
+import { docToHtml } from '../html/index';
+import { markdownDocToXlsx } from '../xlsx/index';
+import { xlsxToMarkdownDoc } from '../xlsx/import';
+import { assertHybridRoundTrip, extractNormalizedText } from './roundTripMatrix.helpers';
+import { ROUNDTRIP_FIXTURES } from './roundTripMatrix.fixtures';
+
+const MOCK_PLAYER_SCRIPT = 'var SquisqPlayer={mount:function(){}};';
+
+describe('format content-flow matrix', () => {
+  it('round-trips markdown through DOCX with hybrid equivalence', async () => {
+    const source = ROUNDTRIP_FIXTURES.story;
+    const docx = await markdownDocToDocx(source.doc);
+    const roundTrip = await docxToMarkdownDoc(docx);
+
+    assertHybridRoundTrip({
+      source: source.doc,
+      roundTrip,
+      keyPhrases: source.keyPhrases,
+      headingTexts: source.headingTexts,
+      requireHeadingOrder: true,
+      requireListSurvival: true,
+      minRetainRatio: 0.65,
+    });
+  });
+
+  it('round-trips markdown through PPTX with hybrid equivalence', async () => {
+    const source = ROUNDTRIP_FIXTURES.mixed;
+    const pptx = await markdownDocToPptx(source.doc);
+    const roundTrip = await pptxToMarkdownDoc(pptx);
+
+    assertHybridRoundTrip({
+      source: source.doc,
+      roundTrip,
+      keyPhrases: source.keyPhrases,
+      headingTexts: source.headingTexts,
+      requireHeadingOrder: true,
+      minRetainRatio: 0.5,
+    });
+  });
+
+  it('round-trips markdown through PDF with hybrid equivalence', async () => {
+    const source = ROUNDTRIP_FIXTURES.mixed;
+    const pdf = await markdownDocToPdf(source.doc, { title: 'Ops Weekly' });
+    const roundTrip = await pdfToMarkdownDoc(pdf, { bodyFontSize: 11 });
+
+    assertHybridRoundTrip({
+      source: source.doc,
+      roundTrip,
+      keyPhrases: ['ops weekly', 'launch readiness', 'rollback script', 'support tickets declined'],
+      minRetainRatio: 0.4,
+    });
+  });
+
+  it('round-trips markdown through CSV for table-centric content', async () => {
+    const source = ROUNDTRIP_FIXTURES.table;
+    const csv = markdownDocToCsv(source.doc);
+    const roundTrip = await csvToMarkdownDoc(csv);
+
+    assertHybridRoundTrip({
+      source: source.doc,
+      roundTrip,
+      keyPhrases: ['throughput', '120 req/s', 'error rate', 'p95'],
+      requireTableSurvival: true,
+      minRetainRatio: 0.7,
+    });
+  });
+
+  it('exports markdown to HTML as one-way smoke coverage', async () => {
+    const source = ROUNDTRIP_FIXTURES.story;
+    const doc = markdownToDoc(source.doc, { articleId: 'matrix-story' });
+    const html = docToHtml(doc, {
+      playerScript: MOCK_PLAYER_SCRIPT,
+      title: 'Matrix Story',
+    });
+
+    expect(html).toContain('<!DOCTYPE html>');
+    const normalizedHtml = html.toLowerCase();
+    expect(normalizedHtml).toContain('river journal');
+    expect(normalizedHtml).toContain('north bank');
+    expect(normalizedHtml).toContain('full report');
+  });
+
+  it('exports markdown to EPUB as one-way smoke coverage', async () => {
+    const source = ROUNDTRIP_FIXTURES.story;
+    const epub = await markdownDocToEpub(source.doc, {
+      title: 'River Journal',
+      author: 'Squisq Test',
+    });
+
+    const zip = await JSZip.loadAsync(epub);
+    expect(zip.file('OEBPS/content.opf')).toBeTruthy();
+
+    const chapter = await zip.file('OEBPS/chapters/chapter-001.xhtml')?.async('string');
+    expect(chapter).toBeTruthy();
+
+    const normalized = (chapter ?? '').toLowerCase();
+    expect(normalized).toContain('river journal');
+    expect(normalized).toContain('north bank');
+  });
+
+  it('keeps high-value text through all bidirectional formats', async () => {
+    const source = ROUNDTRIP_FIXTURES.story;
+
+    const docxRoundTrip = await docxToMarkdownDoc(await markdownDocToDocx(source.doc));
+    const pptxRoundTrip = await pptxToMarkdownDoc(await markdownDocToPptx(source.doc));
+    const pdfRoundTrip = await pdfToMarkdownDoc(await markdownDocToPdf(source.doc));
+    const csvRoundTrip = await csvToMarkdownDoc(markdownDocToCsv(ROUNDTRIP_FIXTURES.table.doc));
+
+    const docxText = extractNormalizedText(docxRoundTrip);
+    const pptxText = extractNormalizedText(pptxRoundTrip);
+    const pdfText = extractNormalizedText(pdfRoundTrip);
+    const csvText = extractNormalizedText(csvRoundTrip);
+
+    expect(docxText).toContain('river journal');
+    expect(pptxText).toContain('river journal');
+    expect(pdfText).toContain('river journal');
+    expect(csvText).toContain('throughput');
+  });
+
+  it('round-trips markdown through XLSX with table cell survival', async () => {
+    const source = ROUNDTRIP_FIXTURES.table;
+    const xlsx = await markdownDocToXlsx(source.doc);
+    const roundTrip = await xlsxToMarkdownDoc(xlsx);
+
+    const text = extractNormalizedText(roundTrip);
+    for (const phrase of source.keyPhrases) {
+      expect(text).toContain(phrase);
+    }
+  });
+});