@bendyline/squisq-formats 2.1.0 → 2.2.0

package/src/__tests__/roundTripMatrix.fixtures.ts

@@ -1,86 +0,0 @@
-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

@@ -1,154 +0,0 @@
-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

@@ -1,142 +0,0 @@
-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);
-    }
-  });
-});

package/src/__tests__/sharedContainer.test.ts

@@ -1,41 +0,0 @@
-/**
- * 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

@@ -1,61 +0,0 @@
-/**
- * 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

@@ -1,164 +0,0 @@
-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');
-  });
-});