@bendyline/squisq 0.1.1

package/src/__tests__/markdownToDoc.test.ts

@@ -0,0 +1,374 @@
+import { describe, it, expect } from 'vitest';
+import { parseMarkdown, stringifyMarkdown } from '../markdown/index';
+import type { MarkdownText } from '../markdown/types';
+import { markdownToDoc, flattenBlocks, countBlocks, getBlockDepth } from '../doc/markdownToDoc';
+import { docToMarkdown } from '../doc/docToMarkdown';
+
+// Helper: strip positions from markdown nodes for cleaner assertions
+function stripPositions(obj: unknown): unknown {
+  if (obj === null || obj === undefined) return obj;
+  if (typeof obj !== 'object') return obj;
+  if (Array.isArray(obj)) return obj.map(stripPositions);
+  const result: Record<string, unknown> = {};
+  for (const [key, value] of Object.entries(obj as Record<string, unknown>)) {
+    if (key === 'position') continue;
+    result[key] = stripPositions(value);
+  }
+  return result;
+}
+
+describe('markdownToDoc', () => {
+  it('converts a simple heading + paragraph into a single block', () => {
+    const md = parseMarkdown('# Title\n\nHello world');
+    const doc = markdownToDoc(md);
+
+    expect(doc.blocks).toHaveLength(1);
+    expect(doc.blocks[0].id).toBe('title');
+    expect(doc.blocks[0].sourceHeading).toBeDefined();
+    expect(doc.blocks[0].sourceHeading!.depth).toBe(1);
+    expect(doc.blocks[0].contents).toHaveLength(1);
+    expect(doc.blocks[0].contents![0].type).toBe('paragraph');
+  });
+
+  it('creates preamble block for content before first heading', () => {
+    const md = parseMarkdown('Some intro text\n\n# First Heading\n\nBody');
+    const doc = markdownToDoc(md);
+
+    expect(doc.blocks).toHaveLength(2);
+    // Preamble block
+    expect(doc.blocks[0].id).toBe('preamble');
+    expect(doc.blocks[0].sourceHeading).toBeUndefined();
+    expect(doc.blocks[0].contents).toHaveLength(1);
+    expect(doc.blocks[0].contents![0].type).toBe('paragraph');
+    // Heading block
+    expect(doc.blocks[1].sourceHeading).toBeDefined();
+    expect(doc.blocks[1].contents).toHaveLength(1);
+  });
+
+  it('nests H2 under H1 as children', () => {
+    const md = parseMarkdown(
+      '# Chapter\n\nIntro\n\n## Section A\n\nContent A\n\n## Section B\n\nContent B',
+    );
+    const doc = markdownToDoc(md);
+
+    expect(doc.blocks).toHaveLength(1); // One root block (H1)
+    const root = doc.blocks[0];
+    expect(root.sourceHeading!.depth).toBe(1);
+    expect(root.contents).toHaveLength(1); // "Intro" paragraph
+
+    expect(root.children).toHaveLength(2);
+    expect(root.children![0].sourceHeading!.depth).toBe(2);
+    expect(root.children![0].contents).toHaveLength(1); // "Content A"
+    expect(root.children![1].sourceHeading!.depth).toBe(2);
+    expect(root.children![1].contents).toHaveLength(1); // "Content B"
+  });
+
+  it('handles same-level headings as siblings', () => {
+    const md = parseMarkdown('## A\n\nText A\n\n## B\n\nText B\n\n## C\n\nText C');
+    const doc = markdownToDoc(md);
+
+    expect(doc.blocks).toHaveLength(3);
+    expect(doc.blocks[0].id).toBe('a');
+    expect(doc.blocks[1].id).toBe('b');
+    expect(doc.blocks[2].id).toBe('c');
+  });
+
+  it('handles deep nesting H1→H2→H3→H4→H5→H6', () => {
+    const md = parseMarkdown(
+      '# L1\n\n## L2\n\n### L3\n\n#### L4\n\n##### L5\n\n###### L6\n\nDeep content',
+    );
+    const doc = markdownToDoc(md);
+
+    expect(doc.blocks).toHaveLength(1); // One root
+    let block = doc.blocks[0];
+    for (let depth = 1; depth <= 5; depth++) {
+      expect(block.sourceHeading!.depth).toBe(depth);
+      expect(block.children).toHaveLength(1);
+      block = block.children![0];
+    }
+    expect(block.sourceHeading!.depth).toBe(6);
+    expect(block.contents).toHaveLength(1);
+    expect(block.children).toBeUndefined();
+  });
+
+  it('handles mixed content between headings', () => {
+    const md = parseMarkdown(
+      '# Title\n\nParagraph\n\n- Item 1\n- Item 2\n\n```js\ncode\n```\n\n> Quote',
+    );
+    const doc = markdownToDoc(md);
+
+    expect(doc.blocks[0].contents).toHaveLength(4); // paragraph, list, code, blockquote
+    expect(doc.blocks[0].contents![0].type).toBe('paragraph');
+    expect(doc.blocks[0].contents![1].type).toBe('list');
+    expect(doc.blocks[0].contents![2].type).toBe('code');
+    expect(doc.blocks[0].contents![3].type).toBe('blockquote');
+  });
+
+  it('deduplicates IDs for duplicate headings', () => {
+    const md = parseMarkdown('# Intro\n\n# Intro\n\n# Intro');
+    const doc = markdownToDoc(md);
+
+    expect(doc.blocks).toHaveLength(3);
+    expect(doc.blocks[0].id).toBe('intro');
+    expect(doc.blocks[1].id).toBe('intro-2');
+    expect(doc.blocks[2].id).toBe('intro-3');
+  });
+
+  it('handles empty document', () => {
+    const md = parseMarkdown('');
+    const doc = markdownToDoc(md);
+
+    expect(doc.blocks).toHaveLength(0);
+    expect(doc.duration).toBe(0);
+  });
+
+  it('handles document with only content (no headings)', () => {
+    const md = parseMarkdown('Just some text\n\nAnd more text');
+    const doc = markdownToDoc(md);
+
+    expect(doc.blocks).toHaveLength(1);
+    expect(doc.blocks[0].id).toBe('preamble');
+    expect(doc.blocks[0].sourceHeading).toBeUndefined();
+    expect(doc.blocks[0].contents).toHaveLength(2);
+  });
+
+  it('sets default template on heading blocks', () => {
+    const md = parseMarkdown('# Hello');
+    const doc = markdownToDoc(md);
+    expect(doc.blocks[0].template).toBe('sectionHeader');
+  });
+
+  it('respects custom options', () => {
+    const md = parseMarkdown('# Test');
+    const doc = markdownToDoc(md, {
+      articleId: 'custom-article',
+      defaultTemplate: 'titleBlock',
+      defaultDuration: 10,
+    });
+
+    expect(doc.articleId).toBe('custom-article');
+    expect(doc.blocks[0].template).toBe('titleBlock');
+    expect(doc.blocks[0].duration).toBe(10);
+  });
+
+  it('respects custom ID generator', () => {
+    const md = parseMarkdown('# Hello\n\n## World');
+    const doc = markdownToDoc(md, {
+      generateId: (_heading, index) => `block-${index}`,
+    });
+
+    expect(doc.blocks[0].id).toBe('block-0');
+    expect(doc.blocks[0].children![0].id).toBe('block-1');
+  });
+
+  it('calculates timing sequentially across all blocks', () => {
+    const md = parseMarkdown('# A\n\n## A1\n\n## A2\n\n# B');
+    const doc = markdownToDoc(md, { defaultDuration: 5 });
+
+    const flat = flattenBlocks(doc.blocks);
+    expect(flat).toHaveLength(4);
+    expect(flat[0].startTime).toBe(0); // # A
+    expect(flat[1].startTime).toBe(5); // ## A1
+    expect(flat[2].startTime).toBe(10); // ## A2
+    expect(flat[3].startTime).toBe(15); // # B
+    expect(doc.duration).toBe(20);
+  });
+
+  it('handles heading depth going back up (H3 → H1)', () => {
+    const md = parseMarkdown('# Top\n\n### Deep\n\nDeep content\n\n# Back to top\n\nTop content');
+    const doc = markdownToDoc(md);
+
+    expect(doc.blocks).toHaveLength(2);
+    expect(doc.blocks[0].sourceHeading!.depth).toBe(1);
+    // H3 nests under H1 even though H2 was skipped
+    expect(doc.blocks[0].children).toHaveLength(1);
+    expect(doc.blocks[0].children![0].sourceHeading!.depth).toBe(3);
+    expect(doc.blocks[1].sourceHeading!.depth).toBe(1);
+    expect(doc.blocks[1].contents).toHaveLength(1);
+  });
+});
+
+describe('flattenBlocks', () => {
+  it('flattens nested blocks depth-first', () => {
+    const md = parseMarkdown('# A\n\n## A1\n\n### A1a\n\n## A2\n\n# B');
+    const doc = markdownToDoc(md);
+    const flat = flattenBlocks(doc.blocks);
+
+    expect(flat.map((b) => b.id)).toEqual(['a', 'a1', 'a1a', 'a2', 'b']);
+  });
+});
+
+describe('countBlocks', () => {
+  it('counts all blocks including nested children', () => {
+    const md = parseMarkdown('# A\n\n## A1\n\n### A1a\n\n## A2\n\n# B');
+    const doc = markdownToDoc(md);
+
+    expect(countBlocks(doc.blocks)).toBe(5);
+  });
+});
+
+describe('getBlockDepth', () => {
+  it('returns heading depth for heading blocks', () => {
+    const md = parseMarkdown('# Title');
+    const doc = markdownToDoc(md);
+    expect(getBlockDepth(doc.blocks[0])).toBe(1);
+  });
+
+  it('returns 0 for preamble blocks', () => {
+    const md = parseMarkdown('Just text');
+    const doc = markdownToDoc(md);
+    expect(getBlockDepth(doc.blocks[0])).toBe(0);
+  });
+});
+
+describe('docToMarkdown (round-trip)', () => {
+  it('converts a doc back to equivalent markdown', () => {
+    const input = '# Hello\n\nWorld\n\n## Details\n\nMore content\n';
+    const md = parseMarkdown(input);
+    const doc = markdownToDoc(md);
+    const roundTripped = docToMarkdown(doc);
+
+    // The resulting MarkdownDocument should have the same structure
+    expect(stripPositions(roundTripped)).toEqual(stripPositions(md));
+  });
+
+  it('round-trips through stringify', () => {
+    const input = '# Intro\n\nParagraph one.\n\n## Sub\n\nParagraph two.\n';
+    const md = parseMarkdown(input);
+    const doc = markdownToDoc(md);
+    const markdown2 = docToMarkdown(doc);
+    const output = stringifyMarkdown(markdown2);
+    // Parse again and compare ASTs
+    const md2 = parseMarkdown(output);
+    expect(stripPositions(md2)).toEqual(stripPositions(md));
+  });
+
+  it('round-trips preamble content', () => {
+    const input = 'Preamble text\n\n# Heading\n\nBody\n';
+    const md = parseMarkdown(input);
+    const doc = markdownToDoc(md);
+    const roundTripped = docToMarkdown(doc);
+    expect(stripPositions(roundTripped)).toEqual(stripPositions(md));
+  });
+
+  it('round-trips deeply nested headings', () => {
+    const input = '# L1\n\nT1\n\n## L2\n\nT2\n\n### L3\n\nT3\n\n#### L4\n\nT4\n';
+    const md = parseMarkdown(input);
+    const doc = markdownToDoc(md);
+    const roundTripped = docToMarkdown(doc);
+    expect(stripPositions(roundTripped)).toEqual(stripPositions(md));
+  });
+
+  it('round-trips complex mixed content', () => {
+    const input = `# Title
+
+Intro paragraph.
+
+- List item 1
+- List item 2
+
+## Code Section
+
+\`\`\`js
+const x = 1;
+\`\`\`
+
+## Quote Section
+
+> A blockquote
+
+---
+`;
+    const md = parseMarkdown(input);
+    const doc = markdownToDoc(md);
+    const roundTripped = docToMarkdown(doc);
+    expect(stripPositions(roundTripped)).toEqual(stripPositions(md));
+  });
+
+  it('handles empty doc → empty markdown', () => {
+    const md = parseMarkdown('');
+    const doc = markdownToDoc(md);
+    const roundTripped = docToMarkdown(doc);
+    expect(roundTripped.children).toEqual([]);
+  });
+});
+
+// ============================================
+// Template Annotation → Block mapping
+// ============================================
+
+describe('template annotation in markdownToDoc', () => {
+  it('sets block.template from heading annotation', () => {
+    const md = parseMarkdown('## Report {[chart]}\n\nSome data');
+    const doc = markdownToDoc(md);
+
+    expect(doc.blocks).toHaveLength(1);
+    expect(doc.blocks[0].template).toBe('chart');
+  });
+
+  it('sets block.templateOverrides from key=value params', () => {
+    const md = parseMarkdown('## Stats {[statHighlight colorScheme=blue size=large]}\n\nContent');
+    const doc = markdownToDoc(md);
+
+    expect(doc.blocks[0].template).toBe('statHighlight');
+    expect(doc.blocks[0].templateOverrides).toEqual({
+      colorScheme: 'blue',
+      size: 'large',
+    });
+  });
+
+  it('uses defaultTemplate when no annotation is present', () => {
+    const md = parseMarkdown('## Plain Heading\n\nBody');
+    const doc = markdownToDoc(md);
+
+    expect(doc.blocks[0].template).toBe('sectionHeader');
+    expect(doc.blocks[0].templateOverrides).toBeUndefined();
+  });
+
+  it('annotation stripping does not affect heading display text in sourceHeading', () => {
+    const md = parseMarkdown('## My Section {[chart]}\n\nBody');
+    const doc = markdownToDoc(md);
+    const heading = doc.blocks[0].sourceHeading!;
+
+    // The heading children should have the annotation stripped
+    expect(heading.templateAnnotation).toEqual({ template: 'chart' });
+    const textChild = heading.children.find((c) => c.type === 'text') as MarkdownText;
+    expect(textChild.value).toBe('My Section');
+  });
+
+  it('round-trips annotation through markdownToDoc → docToMarkdown → stringify', () => {
+    const input = '## Data {[chart colorScheme=blue]}\n\nContent here';
+    const md = parseMarkdown(input);
+    const doc = markdownToDoc(md);
+    const roundTripped = docToMarkdown(doc);
+    const output = stringifyMarkdown(roundTripped);
+
+    expect(output).toContain('{[chart colorScheme=blue]}');
+    expect(output).toContain('Data');
+  });
+
+  it('docToMarkdown injects annotation when block.template differs from default', () => {
+    // Create a doc programmatically with a non-default template
+    const md = parseMarkdown('## Section\n\nBody');
+    const doc = markdownToDoc(md);
+
+    // Programmatically set a custom template
+    doc.blocks[0].template = 'factCard';
+    doc.blocks[0].templateOverrides = { style: 'minimal' };
+
+    const roundTripped = docToMarkdown(doc);
+    const output = stringifyMarkdown(roundTripped);
+
+    expect(output).toContain('{[factCard style=minimal]}');
+  });
+
+  it('nested headings preserve their own annotations', () => {
+    const input = '# Chapter {[titleBlock]}\n\nIntro\n\n## Section {[chart]}\n\nData';
+    const md = parseMarkdown(input);
+    const doc = markdownToDoc(md);
+
+    expect(doc.blocks[0].template).toBe('titleBlock');
+    expect(doc.blocks[0].children).toHaveLength(1);
+    expect(doc.blocks[0].children![0].template).toBe('chart');
+  });
+});

package/src/__tests__/storage.test.ts

@@ -0,0 +1,60 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { MemoryStorageAdapter } from '../storage/MemoryStorageAdapter';
+
+describe('MemoryStorageAdapter', () => {
+  let storage: MemoryStorageAdapter;
+
+  beforeEach(() => {
+    storage = new MemoryStorageAdapter();
+  });
+
+  it('supports enumeration', () => {
+    expect(storage.supportsEnumeration).toBe(true);
+  });
+
+  it('get returns null for missing key', async () => {
+    expect(await storage.get('nonexistent')).toBeNull();
+  });
+
+  it('set and get round-trip', async () => {
+    await storage.set('key', { hello: 'world' });
+    expect(await storage.get('key')).toEqual({ hello: 'world' });
+  });
+
+  it('stores primitives', async () => {
+    await storage.set('str', 'hello');
+    await storage.set('num', 42);
+    await storage.set('bool', true);
+    expect(await storage.get('str')).toBe('hello');
+    expect(await storage.get('num')).toBe(42);
+    expect(await storage.get('bool')).toBe(true);
+  });
+
+  it('overwrites existing values', async () => {
+    await storage.set('key', 'first');
+    await storage.set('key', 'second');
+    expect(await storage.get('key')).toBe('second');
+  });
+
+  it('remove deletes a key', async () => {
+    await storage.set('key', 'value');
+    await storage.remove('key');
+    expect(await storage.get('key')).toBeNull();
+  });
+
+  it('clear removes all keys', async () => {
+    await storage.set('a', 1);
+    await storage.set('b', 2);
+    await storage.clear();
+    expect(await storage.get('a')).toBeNull();
+    expect(await storage.get('b')).toBeNull();
+    expect(await storage.keys()).toEqual([]);
+  });
+
+  it('keys returns all stored keys', async () => {
+    await storage.set('alpha', 1);
+    await storage.set('beta', 2);
+    const keys = await storage.keys();
+    expect(keys.sort()).toEqual(['alpha', 'beta']);
+  });
+});

package/src/__tests__/templates.test.ts

@@ -0,0 +1,247 @@
+import { describe, it, expect } from 'vitest';
+import {
+  expandTemplateBlock,
+  expandDocBlocks,
+  getAvailableTemplates,
+  hasTemplate,
+  templateRegistry,
+  createTemplateContext,
+  DEFAULT_THEME,
+  VIEWPORT_PRESETS,
+} from '../doc/templates/index';
+import type { TemplateBlock } from '../schemas/BlockTemplates';
+
+describe('templateRegistry', () => {
+  it('contains all expected templates', () => {
+    const expected = [
+      'titleBlock',
+      'sectionHeader',
+      'statHighlight',
+      'quoteBlock',
+      'factCard',
+      'twoColumn',
+      'dateEvent',
+      'imageWithCaption',
+      'mapBlock',
+      'fullBleedQuote',
+      'listBlock',
+      'photoGrid',
+      'definitionCard',
+      'comparisonBar',
+      'pullQuote',
+      'videoWithCaption',
+      'videoPullQuote',
+    ];
+    for (const name of expected) {
+      expect(templateRegistry).toHaveProperty(name);
+      const tpl = (templateRegistry as Record<string, unknown>)[name];
+      expect(typeof tpl).toBe('function');
+    }
+  });
+});
+
+describe('getAvailableTemplates', () => {
+  it('returns array of template names', () => {
+    const templates = getAvailableTemplates();
+    expect(templates).toContain('titleBlock');
+    expect(templates).toContain('sectionHeader');
+    expect(templates.length).toBeGreaterThanOrEqual(15);
+  });
+});
+
+describe('hasTemplate', () => {
+  it('returns true for existing templates', () => {
+    expect(hasTemplate('titleBlock')).toBe(true);
+    expect(hasTemplate('statHighlight')).toBe(true);
+  });
+
+  it('returns false for unknown templates', () => {
+    expect(hasTemplate('nonexistent')).toBe(false);
+  });
+});
+
+describe('expandTemplateBlock', () => {
+  it('expands titleSlide template into layers', () => {
+    const block: TemplateBlock = {
+      template: 'titleBlock',
+      id: 'title-1',
+      duration: 10,
+      audioSegment: 0,
+      title: 'Test Title',
+      subtitle: 'Test Subtitle',
+    };
+    const context = createTemplateContext(DEFAULT_THEME, 0, 5, VIEWPORT_PRESETS.landscape);
+    const result = expandTemplateBlock(block, context);
+
+    expect(result.id).toBe('title-1');
+    expect(result.duration).toBe(10);
+    expect(result.layers ?? []).toBeInstanceOf(Array);
+    expect((result.layers ?? []).length).toBeGreaterThan(0);
+  });
+
+  it('expands statHighlight template', () => {
+    const block: TemplateBlock = {
+      template: 'statHighlight',
+      id: 'stat-1',
+      duration: 8,
+      audioSegment: 0,
+      stat: '89%',
+      description: 'drop in salmon',
+    };
+    const context = createTemplateContext(DEFAULT_THEME, 0, 5, VIEWPORT_PRESETS.landscape);
+    const result = expandTemplateBlock(block, context);
+
+    expect((result.layers ?? []).length).toBeGreaterThan(0);
+    // Should have at least a shape background + text layers
+    const textLayers = (result.layers ?? []).filter((l) => l.type === 'text');
+    expect(textLayers.length).toBeGreaterThan(0);
+  });
+
+  it('returns empty layers for unknown template', () => {
+    const block = {
+      template: 'nonexistent',
+      id: 'unknown-1',
+      duration: 5,
+      audioSegment: 0,
+    } as unknown as TemplateBlock;
+    const context = createTemplateContext(DEFAULT_THEME, 0, 1, VIEWPORT_PRESETS.landscape);
+    const result = expandTemplateBlock(block, context);
+    expect(result.layers ?? []).toEqual([]);
+  });
+
+  it('each registered template returns valid layers', () => {
+    const templates = getAvailableTemplates();
+    const context = createTemplateContext(DEFAULT_THEME, 0, 10, VIEWPORT_PRESETS.landscape);
+
+    for (const name of templates) {
+      // `getAvailableTemplates()` returns string[]; cast when creating a TemplateBlock
+      const block = {
+        template: name as TemplateBlock['template'],
+        id: `test-${name}`,
+        duration: 10,
+        audioSegment: 0,
+        // Provide common props that templates might need
+        title: 'Test',
+        subtitle: 'Subtitle',
+        stat: '42',
+        description: 'Description',
+        detail: 'Detail',
+        quote: 'Quote text',
+        attribution: 'Author',
+        fact: 'A fact',
+        explanation: 'Explanation',
+        text: 'Some text',
+        date: '1776',
+        left: { label: 'Left', sublabel: 'Sub' },
+        right: { label: 'Right', sublabel: 'Sub' },
+        items: ['one', 'two', 'three'],
+        images: [
+          { src: 'test1.jpg', alt: 'Test 1' },
+          { src: 'test2.jpg', alt: 'Test 2' },
+        ],
+        imageSrc: 'test.jpg',
+        backgroundImage: { src: 'bg.jpg', alt: 'Background' },
+        backgroundVideo: { src: 'test.mp4', alt: 'Video', clipStart: 0, clipEnd: 5 },
+        videoSrc: 'test.mp4',
+        caption: 'Caption text',
+        term: 'Term',
+        definition: 'Definition',
+        leftLabel: 'A',
+        rightLabel: 'B',
+        leftValue: 50,
+        rightValue: 50,
+      } as unknown as TemplateBlock;
+      const result = expandTemplateBlock(block, context);
+      expect(result.id).toBe(`test-${name}`);
+      expect(result.layers ?? []).toBeInstanceOf(Array);
+      // Each template should produce at least 1 layer
+      expect((result.layers ?? []).length).toBeGreaterThanOrEqual(1);
+    }
+  });
+});
+
+describe('expandDocBlocks', () => {
+  it('expands array of template blocks with cumulative timing', () => {
+    const blocks: TemplateBlock[] = [
+      { template: 'titleBlock', id: 'slide-1', duration: 5, audioSegment: 0, title: 'Hello' },
+      {
+        template: 'factCard',
+        id: 'slide-2',
+        duration: 8,
+        audioSegment: 0,
+        fact: 'A fact',
+        explanation: 'Why',
+      },
+      {
+        template: 'statHighlight',
+        id: 'slide-3',
+        duration: 6,
+        audioSegment: 0,
+        stat: '99',
+        description: 'percent',
+      },
+    ];
+
+    const result = expandDocBlocks(blocks);
+    expect(result).toHaveLength(3);
+    expect(result[0].startTime).toBe(0);
+    expect(result[1].startTime).toBe(5);
+    expect(result[2].startTime).toBe(13);
+  });
+
+  it('expands with audio segment timing', () => {
+    const blocks: TemplateBlock[] = [
+      { template: 'sectionHeader', id: 'header-1', duration: 3, audioSegment: 0, title: 'Intro' },
+      {
+        template: 'factCard',
+        id: 'fact-1',
+        duration: 10,
+        audioSegment: 0,
+        fact: 'F',
+        explanation: 'E',
+      },
+    ];
+
+    const result = expandDocBlocks(blocks, {
+      audioSegments: [{ startTime: 0, duration: 30 }],
+    });
+
+    expect(result.length).toBeGreaterThan(0);
+    // First slide should start at 0
+    expect(result[0].startTime).toBe(0);
+  });
+
+  it('supports landscape and portrait viewports', () => {
+    const blocks: TemplateBlock[] = [
+      { template: 'titleBlock', id: 'title-1', duration: 5, audioSegment: 0, title: 'Test' },
+    ];
+
+    const landscape = expandDocBlocks(blocks, { viewport: VIEWPORT_PRESETS.landscape });
+    const portrait = expandDocBlocks(blocks, { viewport: VIEWPORT_PRESETS.portrait });
+
+    expect(landscape).toHaveLength(1);
+    expect(portrait).toHaveLength(1);
+    // Both should produce valid blocks
+    expect((landscape[0].layers ?? []).length).toBeGreaterThan(0);
+    expect((portrait[0].layers ?? []).length).toBeGreaterThan(0);
+  });
+});
+
+describe('DEFAULT_THEME', () => {
+  it('has required color properties', () => {
+    expect(DEFAULT_THEME.colors).toHaveProperty('primary');
+    expect(DEFAULT_THEME.colors).toHaveProperty('background');
+    expect(DEFAULT_THEME.colors).toHaveProperty('text');
+  });
+});
+
+describe('VIEWPORT_PRESETS', () => {
+  it('has landscape and portrait presets', () => {
+    expect(VIEWPORT_PRESETS).toHaveProperty('landscape');
+    expect(VIEWPORT_PRESETS).toHaveProperty('portrait');
+    expect(VIEWPORT_PRESETS.landscape.width).toBe(1920);
+    expect(VIEWPORT_PRESETS.landscape.height).toBe(1080);
+    expect(VIEWPORT_PRESETS.portrait.width).toBe(1080);
+    expect(VIEWPORT_PRESETS.portrait.height).toBe(1920);
+  });
+});