@bendyline/squisq-formats 1.4.2 → 2.0.1

package/src/__tests__/inferTheme.test.ts

@@ -0,0 +1,135 @@
+/**
+ * Tests for `inferThemeFromFile`: format sniffing, per-format extraction
+ * (incl. dark-deck clrMap inversion), theme compilation, and error paths.
+ */
+
+import { describe, expect, it } from 'vitest';
+import { ConversionError } from '../registry/errors';
+import { inferThemeFromFile } from '../infer/index';
+import {
+  buildThemeXml,
+  buildThemedDocx,
+  buildThemedPptx,
+  buildThemedXlsx,
+} from './pptxInferFixtures';
+
+describe('inferThemeFromFile — PPTX', () => {
+  it('maps a light deck onto seeds, palette, schemes, and fonts', async () => {
+    const data = await buildThemedPptx();
+    const result = await inferThemeFromFile(data);
+
+    expect(result.extraction.sourceFormat).toBe('pptx');
+    expect(result.extraction.colorMap).toEqual({ bg1: 'lt1', tx1: 'dk1' });
+
+    const { theme } = result;
+    expect(theme.seedColors).toMatchObject({
+      primary: '#4472c4',
+      secondary: '#ed7d31',
+      accent: '#a5a5a5',
+      background: '#fdfdf8',
+      text: '#1a1a2e',
+    });
+    expect(theme.colors.background).toBe('#fdfdf8');
+    expect(theme.colors.text).toBe('#1a1a2e');
+    // Companion slot (lt2) becomes backgroundLight; hlink becomes highlight.
+    expect(theme.colors.backgroundLight).toBe('#efefe4');
+    expect(theme.colors.highlight).toBe('#0563c1');
+    // Six accents → six color schemes keyed by slot.
+    expect(Object.keys(theme.colorSchemes)).toEqual([
+      'accent1',
+      'accent2',
+      'accent3',
+      'accent4',
+      'accent5',
+      'accent6',
+    ]);
+    // Fonts: curated stack match + custom preservation.
+    expect(theme.typography.titleFont).toEqual({ stackId: 'playfair' });
+    expect(theme.typography.bodyFont).toEqual({
+      custom: { name: 'Aptos', fallback: 'sans-serif' },
+    });
+    // Compiled + validated, named from the theme part, re-editable via seeds.
+    expect(theme.name).toBe('Fixture Theme');
+    expect(theme.id).toBe('custom-fixture-theme');
+  });
+
+  it('inverts background/text for a dark deck (clrMap bg1="dk1")', async () => {
+    const data = await buildThemedPptx({
+      clrMapAttrs: 'bg1="dk1" tx1="lt1" bg2="dk2" tx2="lt2"',
+    });
+    const result = await inferThemeFromFile(data);
+    expect(result.theme.seedColors?.background).toBe('#1a1a2e');
+    expect(result.theme.seedColors?.text).toBe('#fdfdf8');
+    // Dark companion slot backs backgroundLight.
+    expect(result.theme.colors.backgroundLight).toBe('#30304a');
+  });
+
+  it('respects a nameHint over the file theme name', async () => {
+    const result = await inferThemeFromFile(await buildThemedPptx(), { nameHint: 'Q3 Deck' });
+    expect(result.theme.name).toBe('Q3 Deck');
+    expect(result.theme.id).toBe('custom-q3-deck');
+  });
+
+  it('throws invalid-input when the file has no theme part', async () => {
+    const data = await buildThemedPptx({ themeXml: null });
+    await expect(inferThemeFromFile(data)).rejects.toMatchObject({
+      name: 'ConversionError',
+      code: 'invalid-input',
+    });
+  });
+});
+
+describe('inferThemeFromFile — DOCX / XLSX', () => {
+  it('extracts from a DOCX theme part', async () => {
+    const result = await inferThemeFromFile(await buildThemedDocx());
+    expect(result.extraction.sourceFormat).toBe('docx');
+    expect(result.theme.seedColors?.primary).toBe('#4472c4');
+    expect(result.theme.colors.background).toBe('#fdfdf8');
+  });
+
+  it('extracts from an XLSX theme part', async () => {
+    const result = await inferThemeFromFile(await buildThemedXlsx());
+    expect(result.extraction.sourceFormat).toBe('xlsx');
+    expect(result.theme.seedColors?.primary).toBe('#4472c4');
+  });
+
+  it('ignores inferLayouts for non-PPTX sources with a warning', async () => {
+    const result = await inferThemeFromFile(await buildThemedDocx(), { inferLayouts: true });
+    expect(result.layouts).toBeUndefined();
+    expect(result.warnings.some((w) => w.includes('PowerPoint'))).toBe(true);
+  });
+});
+
+describe('inferThemeFromFile — rejection paths', () => {
+  it('rejects PDF bytes with unsupported-input', async () => {
+    const pdf = new TextEncoder().encode('%PDF-1.4 fake').buffer as ArrayBuffer;
+    await expect(inferThemeFromFile(pdf)).rejects.toMatchObject({
+      code: 'unsupported-input',
+    });
+  });
+
+  it('rejects non-zip bytes with invalid-input', async () => {
+    const junk = new TextEncoder().encode('definitely not a zip').buffer as ArrayBuffer;
+    const err = await inferThemeFromFile(junk).catch((e: unknown) => e);
+    expect(err).toBeInstanceOf(ConversionError);
+    expect((err as ConversionError).code).toBe('invalid-input');
+  });
+});
+
+describe('inferThemeFromFile — degraded themes', () => {
+  it('drops near-background accents from the scheme list with a warning', async () => {
+    // accent2 equals the background color — should be dropped from schemes.
+    const themeXml = buildThemeXml({ accents: ['4472c4', 'fdfdf8', 'a5a5a5'] });
+    const result = await inferThemeFromFile(await buildThemedPptx({ themeXml }));
+    expect(Object.keys(result.theme.colorSchemes)).toEqual(['accent1', 'accent3']);
+    expect(result.warnings.some((w) => w.includes('accent2'))).toBe(true);
+  });
+
+  it('keeps fonts inherited when the theme has no fontScheme', async () => {
+    const themeXml = buildThemeXml({ omitFontScheme: true });
+    const result = await inferThemeFromFile(await buildThemedPptx({ themeXml }));
+    // STARTER defaults survive.
+    expect(result.theme.typography.titleFont).toEqual({ stackId: 'system-serif' });
+    expect(result.warnings.some((w) => w.includes('fontScheme'))).toBe(true);
+  });
+});

package/src/__tests__/lossyWarnings.test.ts

@@ -8,8 +8,49 @@
 
 import { describe, it, expect, afterEach, vi } from 'vitest';
 import { MemoryContentContainer } from '@bendyline/squisq/storage';
+import type { MarkdownDocument } from '@bendyline/squisq/markdown';
 import { convert, defaultRegistry } from '../registry/index';
 
+// ── shared Markdown exporter capability profiles ───────────────────
+
+describe('Markdown exporters warn about unsupported AST extensions', () => {
+  const extendedMarkdown: MarkdownDocument = {
+    type: 'document',
+    children: [
+      {
+        type: 'paragraph',
+        children: [
+          { type: 'text', value: 'Assigned to ' },
+          {
+            type: 'mention',
+            targetKind: 'user',
+            targetId: '42',
+            displayName: 'Ada',
+          },
+        ],
+      },
+      {
+        type: 'containerDirective',
+        name: 'note',
+        children: [{ type: 'paragraph', children: [{ type: 'text', value: 'Important' }] }],
+      },
+    ],
+  };
+
+  it('surfaces the omitted node types through ConversionResult', async () => {
+    const result = await convert({ kind: 'markdown', markdown: extendedMarkdown }, 'docx');
+    const warning = result.warnings.find((item) => /unsupported Markdown node/i.test(item));
+
+    expect(warning).toMatch(/mention \(1\)/);
+    expect(warning).toMatch(/containerDirective \(1\)/);
+  });
+
+  it('does not warn for the supported Markdown subset', async () => {
+    const result = await convert({ kind: 'markdown', markdown: '# Title\n\nBody.' }, 'docx');
+    expect(result.warnings.some((item) => /unsupported Markdown node/i.test(item))).toBe(false);
+  });
+});
+
 // ── xlsx: tables-only fidelity ──────────────────────────────────────
 
 describe('xlsx export warns about omitted non-table content', () => {

package/src/__tests__/ooxml.test.ts

@@ -2,7 +2,7 @@
  * Tests for the shared OOXML layer: xmlUtils, writer, reader round-trips.
  */
 
-import { describe, it, expect } from 'vitest';
+import { afterEach, describe, it, expect, vi } from 'vitest';
 import {
   escapeXml,
   xmlElement,
@@ -15,6 +15,10 @@ import { createPackage } from '../ooxml/writer';
 import { openPackage, getPartXml, getCoreProperties, getPartRelationships } from '../ooxml/reader';
 import { REL_OFFICE_DOCUMENT } from '../ooxml/namespaces';
 
+afterEach(() => {
+  vi.unstubAllGlobals();
+});
+
 // ============================================
 // XML Utilities
 // ============================================
@@ -97,6 +101,62 @@ describe('xmlDeclaration', () => {
 // ============================================
 
 describe('createPackage / openPackage round-trip', () => {
+  it('rejects unsafe authored part paths', () => {
+    const pkg = createPackage();
+    expect(() => pkg.addPart('../outside.xml', '<doc/>', 'application/xml')).toThrow(
+      /path is unsafe/i,
+    );
+    expect(() =>
+      pkg.addRelationship('..\\outside.xml', {
+        id: 'rId1',
+        type: REL_OFFICE_DOCUMENT,
+        target: 'word/document.xml',
+      }),
+    ).toThrow(/path is unsafe/i);
+  });
+
+  it('parses packages when the browser DOMParser global is unavailable', async () => {
+    const pkg = createPackage();
+    pkg.addPart('word/document.xml', '<doc><value>node</value></doc>', 'application/xml');
+    const buffer = await pkg.toArrayBuffer();
+
+    vi.stubGlobal('DOMParser', undefined);
+    const opened = await openPackage(buffer);
+    const doc = await getPartXml(opened, 'word/document.xml');
+    expect(doc?.getElementsByTagName('value')[0]?.textContent).toBe('node');
+  });
+
+  it('ignores an incomplete ambient DOMParser when running in Node', async () => {
+    const pkg = createPackage();
+    pkg.addPart('word/document.xml', '<doc><value>node</value></doc>', 'application/xml');
+    const buffer = await pkg.toArrayBuffer();
+
+    class IncompleteDomParser {
+      parseFromString(): never {
+        throw new Error('ambient parser must not be used in Node');
+      }
+    }
+
+    vi.stubGlobal('DOMParser', IncompleteDomParser);
+    const opened = await openPackage(buffer);
+    const doc = await getPartXml(opened, 'word/document.xml');
+    expect(doc?.getElementsByTagName('value')[0]?.textContent).toBe('node');
+  });
+
+  it('applies archive resource limits before parsing OOXML parts', async () => {
+    const pkg = createPackage();
+    pkg.addPart('word/document.xml', '<doc/>', 'application/xml');
+    const buffer = await pkg.toArrayBuffer();
+
+    await expect(openPackage(buffer, { maxEntries: 1 })).rejects.toMatchObject({
+      code: 'too-many-entries',
+      actual: 3,
+    });
+    await expect(openPackage(buffer, { maxUncompressedBytes: 1 })).rejects.toThrow(
+      /uncompressed content exceeds 1 byte limit/,
+    );
+  });
+
   it('creates a valid ZIP with content types and parts', async () => {
     const pkg = createPackage();
     pkg.addPart(
@@ -116,7 +176,7 @@ describe('createPackage / openPackage round-trip', () => {
 
     // Read it back
     const opened = await openPackage(arrayBuffer);
-    expect(opened.zip).toBeDefined();
+    expect(opened).not.toHaveProperty('zip');
     expect(opened.contentTypes.overrides.has('word/document.xml')).toBe(true);
     expect(opened.rootRelationships.length).toBeGreaterThanOrEqual(1);
     expect(opened.rootRelationships[0].type).toBe(REL_OFFICE_DOCUMENT);
@@ -156,6 +216,20 @@ describe('createPackage / openPackage round-trip', () => {
     expect(props.description).toBe('Test description with <special> & chars');
   });
 
+  it('serializes repeatedly without accumulating generated relationships', async () => {
+    const pkg = createPackage();
+    pkg.addPart('word/document.xml', '<doc/>', 'application/xml');
+    pkg.setCoreProperties({ title: 'Stable' });
+
+    await pkg.toArrayBuffer();
+    const second = await pkg.toArrayBuffer();
+    const opened = await openPackage(second);
+    const coreRelationships = opened.rootRelationships.filter((rel) =>
+      rel.type.endsWith('/metadata/core-properties'),
+    );
+    expect(coreRelationships).toHaveLength(1);
+  });
+
   it('round-trips part relationships', async () => {
     const pkg = createPackage();
     pkg.addPart('word/document.xml', '<doc/>', 'application/xml');

package/src/__tests__/ooxmlCancellation.test.ts

@@ -0,0 +1,113 @@
+import { describe, expect, it } from 'vitest';
+import { inferThemeFromFile } from '../infer/index';
+import { getPartXml, openPackage } from '../ooxml/reader';
+import { inspectPptxLayouts } from '../pptx/layouts';
+import { prepareZipInput } from '../shared/zipEntryCount';
+import { buildThemedPptx } from './pptxInferFixtures';
+
+function blockingBlob(onRead: () => void): Blob {
+  const blob = {
+    size: 128,
+    slice: () => blob,
+    arrayBuffer: () => {
+      onRead();
+      return new Promise<ArrayBuffer>(() => undefined);
+    },
+  };
+  return blob as unknown as Blob;
+}
+
+describe('OOXML cancellation', () => {
+  it('preserves the exact reason while theme inference reads Blob input', async () => {
+    let markStarted: (() => void) | undefined;
+    const started = new Promise<void>((resolve) => {
+      markStarted = resolve;
+    });
+    const controller = new AbortController();
+    const reason = new Error('stop inference');
+    const pending = inferThemeFromFile(
+      blockingBlob(() => markStarted?.()),
+      {
+        signal: controller.signal,
+      },
+    );
+
+    await started;
+    controller.abort(reason);
+
+    await expect(pending).rejects.toBe(reason);
+  });
+
+  it('preserves the exact reason while layout inspection opens Blob input', async () => {
+    let markStarted: (() => void) | undefined;
+    const started = new Promise<void>((resolve) => {
+      markStarted = resolve;
+    });
+    const controller = new AbortController();
+    const reason = new Error('stop layout inspection');
+    const pending = inspectPptxLayouts(
+      blockingBlob(() => markStarted?.()),
+      {
+        signal: controller.signal,
+      },
+    );
+
+    await started;
+    controller.abort(reason);
+
+    await expect(pending).rejects.toBe(reason);
+  });
+
+  it('propagates package cancellation through later OOXML part traversal', async () => {
+    const controller = new AbortController();
+    const pkg = await openPackage(await buildThemedPptx(), { signal: controller.signal });
+    const reason = new Error('stop OOXML traversal');
+    controller.abort(reason);
+
+    await expect(getPartXml(pkg, 'ppt/presentation.xml')).rejects.toBe(reason);
+  });
+
+  it('handles a synchronously re-entrant FileReader abort exactly once', async () => {
+    const previous = globalThis.FileReader;
+    let abortCalls = 0;
+    class ReentrantFileReader {
+      result: ArrayBuffer | null = null;
+      error: DOMException | null = null;
+      onload: ((event: ProgressEvent<FileReader>) => void) | null = null;
+      onerror: ((event: ProgressEvent<FileReader>) => void) | null = null;
+      onabort: ((event: ProgressEvent<FileReader>) => void) | null = null;
+      readAsArrayBuffer(): void {
+        // Remain pending until the caller aborts.
+      }
+
+      abort(): void {
+        abortCalls += 1;
+        this.onabort?.({} as ProgressEvent<FileReader>);
+      }
+    }
+    Object.defineProperty(globalThis, 'FileReader', {
+      configurable: true,
+      writable: true,
+      value: ReentrantFileReader,
+    });
+
+    const blobLike = { size: 1, slice: () => blobLike } as unknown as Blob;
+    const controller = new AbortController();
+    const reason = new Error('stop FileReader');
+    try {
+      const pending = prepareZipInput(blobLike, controller.signal);
+      controller.abort(reason);
+      await expect(pending).rejects.toBe(reason);
+      expect(abortCalls).toBe(1);
+    } finally {
+      if (previous === undefined) Reflect.deleteProperty(globalThis, 'FileReader');
+      else {
+        Object.defineProperty(globalThis, 'FileReader', {
+          configurable: true,
+          writable: true,
+          value: previous,
+        });
+      }
+    }
+  });
+});

package/src/__tests__/ooxmlThemeReader.test.ts

@@ -0,0 +1,92 @@
+/**
+ * Tests for the shared OOXML theme reader: clrScheme slot resolution
+ * (srgbClr / sysClr / fallbacks) and fontScheme parsing.
+ */
+
+import { describe, expect, it } from 'vitest';
+import { NS_DRAWINGML } from '../ooxml/namespaces';
+import { parseThemeXml } from '../ooxml/themeReader';
+import { buildThemeXml } from './pptxInferFixtures';
+
+function parse(xml: string): Document {
+  return new DOMParser().parseFromString(xml, 'application/xml');
+}
+
+describe('parseThemeXml', () => {
+  it('reads srgbClr slots, theme name, and latin fonts', () => {
+    const theme = parseThemeXml(parse(buildThemeXml({ name: 'Ion' })));
+    expect(theme.name).toBe('Ion');
+    expect(theme.colors).toMatchObject({
+      dk1: '#1a1a2e',
+      lt1: '#fdfdf8',
+      dk2: '#30304a',
+      lt2: '#efefe4',
+      accent1: '#4472c4',
+      accent6: '#70ad47',
+      hlink: '#0563c1',
+    });
+    expect(theme.fonts).toEqual({ majorLatin: 'Playfair Display', minorLatin: 'Aptos' });
+  });
+
+  it('prefers sysClr lastClr when present', () => {
+    const xml = buildThemeXml({
+      dk1: '<a:sysClr val="windowText" lastClr="0B0B0B"/>',
+      lt1: '<a:sysClr val="window" lastClr="FAFAFA"/>',
+    });
+    const theme = parseThemeXml(parse(xml));
+    expect(theme.colors?.dk1).toBe('#0b0b0b');
+    expect(theme.colors?.lt1).toBe('#fafafa');
+  });
+
+  it('resolves windowText/window sysClr without lastClr', () => {
+    const xml = buildThemeXml({
+      dk1: '<a:sysClr val="windowText"/>',
+      lt1: '<a:sysClr val="window"/>',
+    });
+    const theme = parseThemeXml(parse(xml));
+    expect(theme.colors?.dk1).toBe('#000000');
+    expect(theme.colors?.lt1).toBe('#ffffff');
+  });
+
+  it('falls back with a warning for unknown sysClr values', () => {
+    const xml = buildThemeXml({ dk1: '<a:sysClr val="btnFace"/>' });
+    const theme = parseThemeXml(parse(xml));
+    expect(theme.colors?.dk1).toBe('#000000');
+    expect(theme.warnings.some((w) => w.includes('dk1'))).toBe(true);
+  });
+
+  it('drops unresolvable accent slots with warnings', () => {
+    // accent list of 2 → accent3..6 slots missing entirely.
+    const xml = buildThemeXml({ accents: ['112233', '445566'] });
+    const theme = parseThemeXml(parse(xml));
+    expect(theme.colors?.accent1).toBe('#112233');
+    expect(theme.colors?.accent2).toBe('#445566');
+    expect(theme.colors?.accent3).toBeUndefined();
+    expect(theme.warnings.some((w) => w.includes('accent3'))).toBe(true);
+  });
+
+  it('handles a missing fontScheme', () => {
+    const theme = parseThemeXml(parse(buildThemeXml({ omitFontScheme: true })));
+    expect(theme.fonts).toBeUndefined();
+    expect(theme.warnings.some((w) => w.includes('fontScheme'))).toBe(true);
+  });
+
+  it('treats an empty typeface as absent', () => {
+    const xml =
+      `<a:theme xmlns:a="${NS_DRAWINGML}" name="T"><a:themeElements>` +
+      `<a:fontScheme name="T">` +
+      `<a:majorFont><a:latin typeface=""/></a:majorFont>` +
+      `<a:minorFont><a:latin typeface="Georgia"/></a:minorFont>` +
+      `</a:fontScheme></a:themeElements></a:theme>`;
+    const theme = parseThemeXml(parse(xml));
+    expect(theme.fonts).toEqual({ minorLatin: 'Georgia' });
+    expect(theme.warnings.some((w) => w.includes('majorFont'))).toBe(true);
+  });
+
+  it('reports a theme with no clrScheme', () => {
+    const xml = `<a:theme xmlns:a="${NS_DRAWINGML}" name="Empty"><a:themeElements/></a:theme>`;
+    const theme = parseThemeXml(parse(xml));
+    expect(theme.colors).toBeUndefined();
+    expect(theme.warnings.some((w) => w.includes('clrScheme'))).toBe(true);
+  });
+});

package/src/__tests__/plainHtml.test.ts

@@ -4,7 +4,7 @@
 
 import { describe, it, expect } from 'vitest';
 import { parseMarkdown } from '@bendyline/squisq/markdown';
-import { resolveTheme } from '@bendyline/squisq/schemas';
+import { compileTheme, createThemeRegistry, resolveTheme } from '@bendyline/squisq/schemas';
 import { markdownDocToPlainHtml } from '../html/plainHtml';
 
 function render(md: string, options?: Parameters<typeof markdownDocToPlainHtml>[1]): string {
@@ -26,6 +26,20 @@ describe('markdownDocToPlainHtml', () => {
     expect(html).toContain('<title>A &lt;script&gt; &amp; more</title>');
   });
 
+  it('resolves custom themes only through an explicit caller-owned registry', () => {
+    const custom = compileTheme({
+      id: 'tenant-theme',
+      name: 'Tenant Theme',
+      seedColors: { primary: '#123456' },
+    });
+    const registry = createThemeRegistry([custom]);
+    const withoutRegistry = render('# Title', { themeId: 'tenant-theme' });
+    const withRegistry = render('# Title', { themeId: 'tenant-theme', themeRegistry: registry });
+
+    expect(withoutRegistry).not.toContain('--plain-primary: #123456');
+    expect(withRegistry).toContain('--plain-primary: #123456');
+  });
+
   it('renders headings at the correct depth', () => {
     const html = render('# One\n\n## Two\n\n### Three\n\n#### Four\n\n##### Five\n\n###### Six');
     expect(html).toContain('<h1>One</h1>');

package/src/__tests__/plainHtmlBundle.test.ts

@@ -10,6 +10,7 @@
 
 import { describe, it, expect } from 'vitest';
 import JSZip from 'jszip';
+import { compileTheme, createThemeRegistry } from '@bendyline/squisq/schemas';
 import { markdownDocsToPlainHtmlBundle } from '../html/plainHtmlBundle';
 
 /** Helper to read a Blob as Uint8Array (works in jsdom). */
@@ -58,6 +59,23 @@ describe('markdownDocsToPlainHtmlBundle', () => {
     expect(html).toContain('<h1>Home</h1>');
   });
 
+  it('resolves a caller-owned theme without process-global registration', async () => {
+    const theme = compileTheme({
+      id: 'tenant-brand',
+      name: 'Tenant Brand',
+      seedColors: { primary: '#123456' },
+    });
+    const c = makeContainer({ 'home.md': '# Home' });
+    const blob = await markdownDocsToPlainHtmlBundle({
+      entryPath: 'home.md',
+      themeId: theme.id,
+      themeRegistry: createThemeRegistry([theme]),
+      ...c,
+    });
+
+    expect(await readZipPath(blob, 'home.html')).toContain('--plain-primary: #123456');
+  });
+
   it('follows a linear chain home.md → resume.md and bundles both', async () => {
     const c = makeContainer({
       'home.md': '# Home\n\nMy [resume](resume.md) is here.',

package/src/__tests__/pptxImport.test.ts

@@ -11,6 +11,7 @@ import type {
   MarkdownParagraph,
   MarkdownText,
 } from '@bendyline/squisq/markdown';
+import { readCustomThemesFromFrontmatter } from '@bendyline/squisq/doc';
 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';
@@ -113,3 +114,32 @@ describe('pptxToContainer (embedded image import)', () => {
     expect(hasImage).toBe(false);
   });
 });
+
+describe('theme inference defaults (ON)', () => {
+  const simpleDoc: MarkdownDocument = {
+    type: 'document',
+    children: [{ type: 'heading', depth: 2, children: [{ type: 'text', value: 'Hello' }] }],
+  };
+
+  it('carries the deck theme in frontmatter on an export → import round trip', async () => {
+    const deck = await markdownDocToPptx(simpleDoc, {});
+    const imported = await pptxToMarkdownDoc(deck);
+    // The exporter writes the stock Office theme part; import infers it.
+    expect(imported.frontmatter?.['squisq-theme']).toBe('custom-office-theme');
+    const themes = readCustomThemesFromFrontmatter(imported.frontmatter);
+    expect(themes).toHaveLength(1);
+    expect(themes![0]!.seedColors?.primary).toBe('#4472c4');
+    expect(themes![0]!.seedColors?.background).toBe('#ffffff');
+  });
+
+  it('produces the legacy frontmatter-free import when inference is disabled', async () => {
+    const deck = await markdownDocToPptx(simpleDoc, {});
+    const imported = await pptxToMarkdownDoc(deck, { inferTheme: false, inferLayouts: false });
+    expect(imported.frontmatter).toBeUndefined();
+  });
+
+  it('imports decks without theme parts cleanly (no frontmatter, no failure)', async () => {
+    const doc = await pptxToMarkdownDoc(await buildTestPptx());
+    expect(doc.frontmatter).toBeUndefined();
+  });
+});