@bendyline/squisq-formats 2.0.1 → 2.2.0

package/src/__tests__/exportThemeReconciliation.test.ts

@@ -1,87 +0,0 @@
-/**
- * Export theme reconciliation.
- *
- * Every export format must honor the theme the document selects in its
- * frontmatter (`squisq-theme`) — including an inline custom theme stored in
- * `squisq-custom-themes` — without an explicit `themeId` option. This guards
- * the fix that made PDF/EPUB read the frontmatter theme like PPTX/DOCX/HTML,
- * and that custom themes resolve doc-scoped in exports (no global register).
- */
-
-import { describe, it, expect } from 'vitest';
-import JSZip from 'jszip';
-import { compileTheme } from '@bendyline/squisq/schemas';
-import { writeCustomThemesToFrontmatter } from '@bendyline/squisq/doc';
-import { parseMarkdown } from '@bendyline/squisq/markdown';
-import { markdownDocToPptx } from '../pptx/export';
-import { markdownDocToDocx } from '../docx/export';
-import { markdownDocToPdf } from '../pdf/export';
-import { markdownDocToEpub } from '../epub/export';
-import { markdownDocToPlainHtml } from '../html/plainHtml';
-
-const brand = compileTheme({
-  id: 'custom-brand',
-  name: 'Brand',
-  seedColors: { primary: '#ff0088', background: '#123456', text: '#abcdef' },
-});
-
-const withTheme = parseMarkdown(`---
-title: Audit
-squisq-theme: custom-brand
-squisq-custom-themes: ${writeCustomThemesToFrontmatter([brand])}
----
-
-# Heading One
-
-Body with a [link](https://example.com).
-`);
-
-const noTheme = parseMarkdown('# Heading One\n\nBody.\n');
-
-/** Concatenate the text of every XML/CSS/HTML entry in a ZIP export. */
-async function zipText(buf: ArrayBuffer): Promise<string> {
-  const zip = await JSZip.loadAsync(buf);
-  let text = '';
-  for (const name of Object.keys(zip.files)) {
-    if (/\.(xml|css|html|xhtml|rels)$/i.test(name)) {
-      text += await zip.files[name].async('string');
-    }
-  }
-  return text.toLowerCase();
-}
-
-describe('export theme reconciliation (frontmatter-only custom theme)', () => {
-  it('HTML applies the frontmatter custom theme colors', () => {
-    const html = markdownDocToPlainHtml(withTheme, {}).toLowerCase();
-    expect(html).toContain('123456'); // background
-    expect(html).toContain('abcdef'); // text
-  });
-
-  it('PPTX applies the frontmatter custom theme colors', async () => {
-    const text = await zipText(await markdownDocToPptx(withTheme, {}));
-    expect(text).toContain('123456');
-  });
-
-  it('DOCX applies the frontmatter custom theme colors', async () => {
-    const text = await zipText(await markdownDocToDocx(withTheme, {}));
-    expect(text).toContain('123456');
-  });
-
-  it('EPUB applies the frontmatter custom theme colors (frontmatter fallback)', async () => {
-    const text = await zipText(await markdownDocToEpub(withTheme, {}));
-    expect(text).toContain('123456');
-  });
-
-  it('PDF themes from frontmatter — themed output differs from un-themed', async () => {
-    const themed = new Uint8Array(await markdownDocToPdf(withTheme, {}));
-    const plain = new Uint8Array(await markdownDocToPdf(noTheme, {}));
-    const differs = themed.length !== plain.length || !themed.every((b, i) => b === plain[i]);
-    expect(differs).toBe(true);
-  });
-
-  it('an explicit themeId option still overrides the frontmatter theme', async () => {
-    const bare = await zipText(await markdownDocToPptx(withTheme, { themeId: 'standard' }));
-    // The custom background must NOT appear when the caller forces 'standard'.
-    expect(bare).not.toContain('123456');
-  });
-});

package/src/__tests__/formatRegistry.test.ts

@@ -1,174 +0,0 @@
-/**
- * Tests for the format registry: createRegistry / defaultRegistry, capability
- * consistency across every built-in, and the structured error codes.
- */
-
-import { describe, it, expect } from 'vitest';
-import { parseMarkdown } from '@bendyline/squisq/markdown';
-import { markdownToDoc } from '@bendyline/squisq/doc';
-import { MemoryContentContainer } from '@bendyline/squisq/storage';
-import {
-  createRegistry,
-  defaultRegistry,
-  defaultFormats,
-  ConversionError,
-  BUILTIN_FORMAT_IDS,
-} from '../registry/index';
-import type { FormatDefinition, NormalizedInput } from '../registry/index';
-
-const SAMPLE_MD = `# Title
-
-Some intro text.
-
-| Name | Value |
-| --- | --- |
-| A | 1 |
-| B | 2 |
-`;
-
-async function makeInput(baseName = 'sample'): Promise<NormalizedInput> {
-  const markdownDoc = parseMarkdown(SAMPLE_MD);
-  const doc = markdownToDoc(markdownDoc);
-  const container = new MemoryContentContainer();
-  await container.writeDocument(SAMPLE_MD);
-  return { doc, markdownDoc, container, baseName };
-}
-
-const stubDef = (id: string, extensions: string[]): FormatDefinition => ({
-  id,
-  label: id.toUpperCase(),
-  mimeType: 'application/octet-stream',
-  extensions,
-});
-
-// ── Registry mechanics ──────────────────────────────────────────────
-
-describe('createRegistry', () => {
-  it('registers and gets definitions by id', () => {
-    const reg = createRegistry();
-    reg.register(stubDef('foo', ['.foo']));
-    expect(reg.get('foo')?.id).toBe('foo');
-    expect(reg.get('missing')).toBeUndefined();
-  });
-
-  it('resolves byExtension, normalizing leading dot + case', () => {
-    const reg = createRegistry();
-    reg.register(stubDef('foo', ['.foo', '.f']));
-    expect(reg.byExtension('foo')?.id).toBe('foo');
-    expect(reg.byExtension('.FOO')?.id).toBe('foo');
-    expect(reg.byExtension('f')?.id).toBe('foo');
-    expect(reg.byExtension('nope')).toBeUndefined();
-  });
-
-  it('is last-write-wins by id', () => {
-    const reg = createRegistry();
-    reg.register(stubDef('foo', ['.foo']));
-    reg.register({ ...stubDef('foo', ['.foo']), label: 'SECOND' });
-    expect(reg.get('foo')?.label).toBe('SECOND');
-    expect(reg.list().filter((d) => d.id === 'foo')).toHaveLength(1);
-  });
-
-  it('lists all registered definitions', () => {
-    const reg = createRegistry();
-    reg.register(stubDef('a', ['.a']));
-    reg.register(stubDef('b', ['.b']));
-    expect(
-      reg
-        .list()
-        .map((d) => d.id)
-        .sort(),
-    ).toEqual(['a', 'b']);
-  });
-});
-
-describe('defaultRegistry', () => {
-  it('registers all built-in formats', () => {
-    const reg = defaultRegistry();
-    for (const id of BUILTIN_FORMAT_IDS) {
-      expect(reg.get(id), `built-in "${id}" should be registered`).toBeDefined();
-    }
-    expect(reg.list()).toHaveLength(BUILTIN_FORMAT_IDS.length);
-  });
-
-  it('defaultFormats matches BUILTIN_FORMAT_IDS exactly', () => {
-    const ids = defaultFormats()
-      .map((d) => d.id)
-      .sort();
-    expect(ids).toEqual([...BUILTIN_FORMAT_IDS].sort());
-  });
-});
-
-// ── Capability consistency ──────────────────────────────────────────
-
-describe('built-in capability consistency', () => {
-  const formats = defaultFormats();
-
-  for (const def of formats) {
-    if (!def.exportDoc) continue;
-    it(`${def.id}: exportDoc produces bytes (or a tolerated not-implemented error)`, async () => {
-      const input = await makeInput();
-      // HTML formats need a player script; provide a trivial stub.
-      const options = { resolvePlayerScript: async () => '/* stub */' };
-      try {
-        const result = await def.exportDoc!(input, options);
-        // Use ArrayBuffer.isView rather than `instanceof Uint8Array`: under the
-        // jsdom test env, bytes built from node's TextEncoder/Uint8Array live in
-        // a different realm than the test file's Uint8Array global.
-        expect(ArrayBuffer.isView(result.bytes)).toBe(true);
-        expect(result.bytes.byteLength).toBeGreaterThan(0);
-        expect(typeof result.mimeType).toBe('string');
-        expect(Array.isArray(result.warnings)).toBe(true);
-      } catch (err: unknown) {
-        // xlsx export is being implemented concurrently and may still throw
-        // 'not yet implemented'. Tolerate that specific case only.
-        const message = err instanceof Error ? err.message : String(err);
-        expect(def.id, `unexpected export failure for "${def.id}": ${message}`).toBe('xlsx');
-        expect(message).toMatch(/not yet implemented/i);
-      }
-    });
-  }
-
-  it('csv export warns when the document has multiple tables', async () => {
-    const multiTable = parseMarkdown(
-      `| A | B |\n| - | - |\n| 1 | 2 |\n\n| C | D |\n| - | - |\n| 3 | 4 |\n`,
-    );
-    const container = new MemoryContentContainer();
-    const input: NormalizedInput = {
-      doc: markdownToDoc(multiTable),
-      markdownDoc: multiTable,
-      container,
-      baseName: 'tables',
-    };
-    const csv = defaultFormats().find((d) => d.id === 'csv')!;
-    const result = await csv.exportDoc!(input, {});
-    expect(result.warnings.length).toBeGreaterThan(0);
-    expect(result.warnings[0]).toMatch(/table/i);
-  });
-});
-
-// ── Error codes ─────────────────────────────────────────────────────
-
-describe('error codes', () => {
-  it('ConversionError carries a stable code + optional fields', () => {
-    const err = new ConversionError('invalid-input', 'boom', {
-      format: 'docx',
-      hint: 'try again',
-      cause: new Error('root'),
-    });
-    expect(err).toBeInstanceOf(Error);
-    expect(err.name).toBe('ConversionError');
-    expect(err.code).toBe('invalid-input');
-    expect(err.format).toBe('docx');
-    expect(err.hint).toBe('try again');
-    expect((err as Error & { cause?: unknown }).cause).toBeInstanceOf(Error);
-  });
-
-  it('html export without a player script → missing-dependency', async () => {
-    const input = await makeInput();
-    const html = defaultFormats().find((d) => d.id === 'html')!;
-    await expect(html.exportDoc!(input, {})).rejects.toMatchObject({
-      name: 'ConversionError',
-      code: 'missing-dependency',
-    });
-  });
-});

package/src/__tests__/html.test.ts

@@ -1,435 +0,0 @@
-/**
- * Tests for HTML export: docToHtml, docToHtmlZip, image utilities.
- *
- * Verifies that generated HTML contains the expected structure,
- * embedded script, and image handling. ZIP exports are also validated.
- */
-
-import { describe, it, expect } from 'vitest';
-import JSZip from 'jszip';
-import type { Doc, Block, ImageLayer } from '@bendyline/squisq/schemas';
-import { compileTheme, createThemeRegistry } from '@bendyline/squisq/schemas';
-import { docToHtml, docToHtmlZip, collectImagePaths } from '../html/index';
-import { inferMimeType, arrayBufferToBase64DataUrl, extractFilename } from '../html/imageUtils';
-
-// ============================================
-// Helpers
-// ============================================
-
-const MOCK_PLAYER_SCRIPT = 'var SquisqPlayer={mount:function(){}};';
-
-/** Helper to read a Blob as Uint8Array (works in jsdom where blob.arrayBuffer() may not exist) */
-async function blobToUint8Array(blob: Blob): Promise<Uint8Array> {
-  return new Promise((resolve, reject) => {
-    const reader = new FileReader();
-    reader.onload = () => resolve(new Uint8Array(reader.result as ArrayBuffer));
-    reader.onerror = () => reject(reader.error);
-    reader.readAsArrayBuffer(blob);
-  });
-}
-
-function makeDoc(overrides: Partial<Doc> = {}): Doc {
-  return {
-    articleId: 'test-doc',
-    duration: 10,
-    blocks: [],
-    audio: {
-      segments: [{ src: 'intro.mp3', name: 'intro', duration: 10, startTime: 0 }],
-    },
-    ...overrides,
-  };
-}
-
-function makeImageBlock(imageSrc: string): Block {
-  const layer: ImageLayer = {
-    id: 'img-1',
-    type: 'image',
-    position: { x: 0, y: 0, width: '100%', height: '100%' },
-    content: { src: imageSrc, alt: 'test image' },
-  };
-  return {
-    id: 'block-1',
-    startTime: 0,
-    duration: 5,
-    audioSegment: 0,
-    layers: [layer],
-  };
-}
-
-function makeImageBuffer(): ArrayBuffer {
-  // Minimal 1x1 PNG
-  const bytes = new Uint8Array([
-    0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
-    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x08, 0x02, 0x00, 0x00, 0x00, 0x90, 0x77, 0x53,
-    0xde, 0x00, 0x00, 0x00, 0x0c, 0x49, 0x44, 0x41, 0x54, 0x08, 0xd7, 0x63, 0xf8, 0xcf, 0xc0, 0x00,
-    0x00, 0x00, 0x02, 0x00, 0x01, 0xe2, 0x21, 0xbc, 0x33, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e,
-    0x44, 0xae, 0x42, 0x60, 0x82,
-  ]);
-  return bytes.buffer;
-}
-
-// ============================================
-// Image Utilities
-// ============================================
-
-describe('inferMimeType', () => {
-  it('returns correct MIME types for common extensions', () => {
-    expect(inferMimeType('photo.jpg')).toBe('image/jpeg');
-    expect(inferMimeType('photo.jpeg')).toBe('image/jpeg');
-    expect(inferMimeType('logo.png')).toBe('image/png');
-    expect(inferMimeType('anim.gif')).toBe('image/gif');
-    expect(inferMimeType('hero.webp')).toBe('image/webp');
-    expect(inferMimeType('icon.svg')).toBe('image/svg+xml');
-    expect(inferMimeType('track.mp3')).toBe('audio/mpeg');
-  });
-
-  it('returns octet-stream for unknown extensions', () => {
-    expect(inferMimeType('data.xyz')).toBe('application/octet-stream');
-    expect(inferMimeType('noext')).toBe('application/octet-stream');
-  });
-});
-
-describe('arrayBufferToBase64DataUrl', () => {
-  it('produces a valid data URI', () => {
-    const buffer = new TextEncoder().encode('hello').buffer;
-    const result = arrayBufferToBase64DataUrl(buffer, 'text/plain');
-    expect(result).toMatch(/^data:text\/plain;base64,/);
-    expect(result).toBe('data:text/plain;base64,aGVsbG8=');
-  });
-
-  it('encodes large buffers correctly across chunk boundaries', () => {
-    const bytes = Uint8Array.from({ length: 100_003 }, (_, index) => index % 251);
-    const result = arrayBufferToBase64DataUrl(bytes.buffer, 'application/octet-stream');
-    const decoded = Uint8Array.from(atob(result.split(',')[1]), (character) =>
-      character.charCodeAt(0),
-    );
-
-    expect(decoded).toEqual(bytes);
-  });
-});
-
-describe('extractFilename', () => {
-  it('extracts filename from path', () => {
-    expect(extractFilename('images/hero.jpg')).toBe('hero.jpg');
-    expect(extractFilename('hero.jpg')).toBe('hero.jpg');
-    expect(extractFilename('a/b/c/deep.png')).toBe('deep.png');
-  });
-
-  it('strips query and hash', () => {
-    expect(extractFilename('photo.jpg?v=2')).toBe('photo.jpg');
-    expect(extractFilename('photo.jpg#anchor')).toBe('photo.jpg');
-  });
-});
-
-// ============================================
-// Image Path Collection
-// ============================================
-
-describe('collectImagePaths', () => {
-  it('collects image layer src from blocks', () => {
-    const doc = makeDoc({ blocks: [makeImageBlock('hero.jpg')] });
-    const paths = collectImagePaths(doc);
-    expect(paths.has('hero.jpg')).toBe(true);
-  });
-
-  it('ignores absolute URLs', () => {
-    const doc = makeDoc({ blocks: [makeImageBlock('https://example.com/photo.jpg')] });
-    const paths = collectImagePaths(doc);
-    expect(paths.size).toBe(0);
-  });
-
-  it('ignores data URIs', () => {
-    const doc = makeDoc({ blocks: [makeImageBlock('data:image/png;base64,abc')] });
-    const paths = collectImagePaths(doc);
-    expect(paths.size).toBe(0);
-  });
-
-  it('collects startBlock heroSrc', () => {
-    const doc = makeDoc({ startBlock: { heroSrc: 'cover.jpg', title: 'Test' } });
-    const paths = collectImagePaths(doc);
-    expect(paths.has('cover.jpg')).toBe(true);
-  });
-
-  it('collects markdown image refs from block contents', () => {
-    const doc = makeDoc({
-      blocks: [
-        {
-          id: 'b1',
-          startTime: 0,
-          duration: 5,
-          audioSegment: 0,
-          contents: [
-            {
-              type: 'paragraph',
-              children: [{ type: 'image', url: 'body.jpg', alt: '' }],
-            },
-          ] as unknown as Block['contents'],
-        },
-      ],
-    });
-    const paths = collectImagePaths(doc);
-    expect(paths.has('body.jpg')).toBe(true);
-  });
-
-  it('collects raw HTML <img> refs from block contents (WYSIWYG resize case)', () => {
-    // When the WYSIWYG editor serializes a resized image, it emits a raw
-    // `<img src width>` tag because markdown shorthand has no width syntax.
-    // The parser produces an htmlBlock node with htmlChildren rather than
-    // an image node — earlier this was invisible to the export pipeline.
-    const doc = makeDoc({
-      blocks: [
-        {
-          id: 'b1',
-          startTime: 0,
-          duration: 5,
-          audioSegment: 0,
-          contents: [
-            {
-              type: 'htmlBlock',
-              rawHtml: '<img alt="resized" src="resized.jpg" width="194">',
-              htmlChildren: [
-                {
-                  type: 'htmlElement',
-                  tagName: 'img',
-                  attributes: { src: 'resized.jpg', alt: 'resized', width: '194' },
-                  children: [],
-                  selfClosing: true,
-                },
-              ],
-            },
-          ] as unknown as Block['contents'],
-        },
-      ],
-    });
-    const paths = collectImagePaths(doc);
-    expect(paths.has('resized.jpg')).toBe(true);
-  });
-});
-
-// ============================================
-// Single HTML Export
-// ============================================
-
-describe('docToHtml', () => {
-  it('produces a complete HTML document', () => {
-    const doc = makeDoc();
-    const html = docToHtml(doc, { playerScript: MOCK_PLAYER_SCRIPT });
-
-    expect(html).toContain('<!DOCTYPE html>');
-    expect(html).toContain('<html');
-    expect(html).toContain('</html>');
-    expect(html).toContain('<meta charset="UTF-8">');
-    expect(html).toContain('<div id="squisq-root">');
-  });
-
-  it('embeds the player script inline', () => {
-    const doc = makeDoc();
-    const html = docToHtml(doc, { playerScript: MOCK_PLAYER_SCRIPT });
-
-    expect(html).toContain(MOCK_PLAYER_SCRIPT);
-  });
-
-  it('embeds the doc JSON', () => {
-    const doc = makeDoc();
-    const html = docToHtml(doc, { playerScript: MOCK_PLAYER_SCRIPT });
-
-    expect(html).toContain('test-doc');
-  });
-
-  it('embeds an explicitly registered theme selected by the document', () => {
-    const external = compileTheme({
-      id: 'tenant-brand',
-      name: 'External Tenant Brand',
-      seedColors: { primary: '#6633cc' },
-    });
-    const html = docToHtml(makeDoc({ themeId: external.id }), {
-      playerScript: MOCK_PLAYER_SCRIPT,
-      themeRegistry: createThemeRegistry([external]),
-    });
-
-    expect(html).toContain('External Tenant Brand');
-    expect(html).toContain('\\"themeId\\":\\"tenant-brand\\"');
-  });
-
-  it('keeps a document-scoped theme ahead of the explicit registry', () => {
-    const inline = compileTheme({
-      id: 'tenant-brand',
-      name: 'Inline Tenant Brand',
-      seedColors: { primary: '#112233' },
-    });
-    const external = compileTheme({
-      id: 'tenant-brand',
-      name: 'External Tenant Brand',
-      seedColors: { primary: '#6633cc' },
-    });
-    const html = docToHtml(makeDoc({ themeId: inline.id, customThemes: [inline] }), {
-      playerScript: MOCK_PLAYER_SCRIPT,
-      themeRegistry: createThemeRegistry([external]),
-    });
-
-    expect(html).toContain('Inline Tenant Brand');
-    expect(html).not.toContain('External Tenant Brand');
-  });
-
-  it('calls SquisqPlayer.mount', () => {
-    const doc = makeDoc();
-    const html = docToHtml(doc, { playerScript: MOCK_PLAYER_SCRIPT });
-
-    expect(html).toContain('SquisqPlayer.mount');
-  });
-
-  it('sets the page title', () => {
-    const doc = makeDoc();
-    const html = docToHtml(doc, {
-      playerScript: MOCK_PLAYER_SCRIPT,
-      title: 'My Amazing Doc',
-    });
-
-    expect(html).toContain('<title>My Amazing Doc</title>');
-  });
-
-  it('uses slideshow mode by default', () => {
-    const doc = makeDoc();
-    const html = docToHtml(doc, { playerScript: MOCK_PLAYER_SCRIPT });
-
-    expect(html).toContain('"slideshow"');
-  });
-
-  it('supports static mode', () => {
-    const doc = makeDoc();
-    const html = docToHtml(doc, { playerScript: MOCK_PLAYER_SCRIPT, mode: 'static' });
-
-    expect(html).toContain('"static"');
-  });
-
-  it('inlines images as base64 data URIs', () => {
-    const doc = makeDoc({ blocks: [makeImageBlock('hero.png')] });
-    const images = new Map([['hero.png', makeImageBuffer()]]);
-    const html = docToHtml(doc, { playerScript: MOCK_PLAYER_SCRIPT, images });
-
-    expect(html).toContain('data:image/png;base64,');
-  });
-
-  it('escapes script-breaking content in title', () => {
-    const doc = makeDoc();
-    const html = docToHtml(doc, {
-      playerScript: MOCK_PLAYER_SCRIPT,
-      title: '<script>alert("xss")</script>',
-    });
-
-    // Title should be escaped
-    expect(html).not.toContain('<script>alert');
-    expect(html).toContain('&lt;script&gt;');
-  });
-});
-
-// ============================================
-// ZIP Archive Export
-// ============================================
-
-describe('docToHtmlZip', () => {
-  it('produces a valid ZIP blob', async () => {
-    const doc = makeDoc();
-    const blob = await docToHtmlZip(doc, { playerScript: MOCK_PLAYER_SCRIPT });
-
-    expect(blob).toBeInstanceOf(Blob);
-    expect(blob.size).toBeGreaterThan(0);
-  });
-
-  it('contains index.html and squisq-player.js', async () => {
-    const doc = makeDoc();
-    const blob = await docToHtmlZip(doc, { playerScript: MOCK_PLAYER_SCRIPT });
-
-    const zip = await JSZip.loadAsync(await blobToUint8Array(blob));
-    expect(zip.file('index.html')).not.toBeNull();
-    expect(zip.file('squisq-player.js')).not.toBeNull();
-  });
-
-  it('references player script via src attribute', async () => {
-    const doc = makeDoc();
-    const blob = await docToHtmlZip(doc, { playerScript: MOCK_PLAYER_SCRIPT });
-
-    const zip = await JSZip.loadAsync(await blobToUint8Array(blob));
-    const html = await zip.file('index.html')!.async('text');
-    expect(html).toContain('src="squisq-player.js"');
-    // Should NOT contain the inline script
-    expect(html).not.toContain(MOCK_PLAYER_SCRIPT);
-  });
-
-  it('embeds a caller-owned theme selected by the document', async () => {
-    const external = compileTheme({
-      id: 'tenant-zip-brand',
-      name: 'Tenant ZIP Brand',
-      seedColors: { primary: '#224466' },
-    });
-    const blob = await docToHtmlZip(makeDoc({ themeId: external.id }), {
-      playerScript: MOCK_PLAYER_SCRIPT,
-      themeRegistry: createThemeRegistry([external]),
-    });
-
-    const zip = await JSZip.loadAsync(await blobToUint8Array(blob));
-    const html = await zip.file('index.html')!.async('text');
-    expect(html).toContain('Tenant ZIP Brand');
-  });
-
-  it('preserves the original image path inside the zip', async () => {
-    // Direct `<img src="folder/file.png">` references in the rendered HTML
-    // resolve only if the zip mirrors the doc's path layout — flattening
-    // to `images/<basename>` would 404 in the static renderer (which does
-    // not rewrite paths through imagePathMap).
-    const doc = makeDoc({ blocks: [makeImageBlock('mikehome_files/hero.png')] });
-    const images = new Map([['mikehome_files/hero.png', makeImageBuffer()]]);
-    const blob = await docToHtmlZip(doc, { playerScript: MOCK_PLAYER_SCRIPT, images });
-
-    const zip = await JSZip.loadAsync(await blobToUint8Array(blob));
-    expect(zip.file('mikehome_files/hero.png')).not.toBeNull();
-    expect(zip.file('images/hero.png')).toBeNull();
-  });
-
-  it('strips leading slashes and rejects parent-traversal paths', async () => {
-    const doc = makeDoc();
-    const buffer = makeImageBuffer();
-    const images = new Map([
-      ['/leading/slash.png', buffer],
-      ['../escape.png', buffer],
-      ['nested/../sneaky.png', buffer],
-      ['ok/path.png', buffer],
-    ]);
-    const blob = await docToHtmlZip(doc, { playerScript: MOCK_PLAYER_SCRIPT, images });
-
-    const zip = await JSZip.loadAsync(await blobToUint8Array(blob));
-    expect(zip.file('leading/slash.png')).not.toBeNull();
-    expect(zip.file('ok/path.png')).not.toBeNull();
-    expect(zip.file('../escape.png')).toBeNull();
-    expect(zip.file('nested/../sneaky.png')).toBeNull();
-  });
-
-  it('includes audio in audio/ folder when provided', async () => {
-    const audioData = new Uint8Array([0x49, 0x44, 0x33, 0x00]).buffer;
-    const doc = makeDoc();
-    const audio = new Map([['intro.mp3', audioData]]);
-    const blob = await docToHtmlZip(doc, { playerScript: MOCK_PLAYER_SCRIPT, audio });
-
-    const zip = await JSZip.loadAsync(await blobToUint8Array(blob));
-    expect(zip.file('audio/intro.mp3')).not.toBeNull();
-  });
-
-  it('HTML references doc JSON inline', async () => {
-    const doc = makeDoc();
-    const blob = await docToHtmlZip(doc, { playerScript: MOCK_PLAYER_SCRIPT });
-
-    const zip = await JSZip.loadAsync(await blobToUint8Array(blob));
-    const html = await zip.file('index.html')!.async('text');
-    expect(html).toContain('test-doc');
-    expect(html).toContain('SquisqPlayer.mount');
-  });
-
-  it('player.js contains the provided script', async () => {
-    const doc = makeDoc();
-    const blob = await docToHtmlZip(doc, { playerScript: MOCK_PLAYER_SCRIPT });
-
-    const zip = await JSZip.loadAsync(await blobToUint8Array(blob));
-    const js = await zip.file('squisq-player.js')!.async('text');
-    expect(js).toBe(MOCK_PLAYER_SCRIPT);
-  });
-});