@bendyline/squisq 2.1.0 → 2.2.0

package/src/__tests__/matchFontFamily.test.ts

@@ -1,114 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { matchFontFamily, guessFontFallback } from '../schemas/fontStacks.js';
-import { accentToColorScheme } from '../schemas/themeCompile.js';
-import { deriveScale, isHex } from '../schemas/colorUtils.js';
-
-describe('matchFontFamily', () => {
-  it('matches curated stacks by label', () => {
-    expect(matchFontFamily('Playfair Display')).toEqual({ stackId: 'playfair' });
-    expect(matchFontFamily('JetBrains Mono')).toEqual({ stackId: 'jetbrains-mono' });
-    expect(matchFontFamily('IBM Plex Sans')).toEqual({ stackId: 'ibm-plex-sans' });
-    expect(matchFontFamily('Inter')).toEqual({ stackId: 'inter' });
-  });
-
-  it('matches case-insensitively and ignores surrounding quotes/whitespace', () => {
-    expect(matchFontFamily('  playfair display  ')).toEqual({ stackId: 'playfair' });
-    expect(matchFontFamily('"Merriweather"')).toEqual({ stackId: 'merriweather' });
-    expect(matchFontFamily("'LORA'")).toEqual({ stackId: 'lora' });
-  });
-
-  it('matches explicit aliases and Google family names', () => {
-    expect(matchFontFamily('Playfair')).toEqual({ stackId: 'playfair' });
-    expect(matchFontFamily('Source Serif Pro')).toEqual({ stackId: 'source-serif' });
-    expect(matchFontFamily('Source Serif 4')).toEqual({ stackId: 'source-serif' });
-    expect(matchFontFamily('Crimson Pro')).toEqual({ stackId: 'crimson' });
-    expect(matchFontFamily('Cormorant')).toEqual({ stackId: 'cormorant' });
-  });
-
-  it('maps web-safe faces onto the system stacks that already anchor them', () => {
-    expect(matchFontFamily('Georgia')).toEqual({ stackId: 'system-serif' });
-    expect(matchFontFamily('Times New Roman')).toEqual({ stackId: 'system-serif' });
-    expect(matchFontFamily('Consolas')).toEqual({ stackId: 'system-mono' });
-    expect(matchFontFamily('Courier New')).toEqual({ stackId: 'system-mono' });
-    expect(matchFontFamily('Segoe UI')).toEqual({ stackId: 'system-sans' });
-  });
-
-  it('preserves unknown faces as custom fonts with a heuristic fallback', () => {
-    expect(matchFontFamily('Calibri')).toEqual({
-      custom: { name: 'Calibri', fallback: 'sans-serif' },
-    });
-    expect(matchFontFamily('Calibri Light')).toEqual({
-      custom: { name: 'Calibri Light', fallback: 'sans-serif' },
-    });
-    expect(matchFontFamily('Cambria')).toEqual({
-      custom: { name: 'Cambria', fallback: 'serif' },
-    });
-    expect(matchFontFamily('Aptos')).toEqual({
-      custom: { name: 'Aptos', fallback: 'sans-serif' },
-    });
-  });
-
-  it('keeps original casing but strips quotes on custom names', () => {
-    expect(matchFontFamily('"Neue Haas Grotesk"')).toEqual({
-      custom: { name: 'Neue Haas Grotesk', fallback: 'sans-serif' },
-    });
-  });
-
-  it('resolves empty/blank names to system-sans', () => {
-    expect(matchFontFamily('')).toEqual({ stackId: 'system-sans' });
-    expect(matchFontFamily('   ')).toEqual({ stackId: 'system-sans' });
-  });
-});
-
-describe('guessFontFallback', () => {
-  it('detects monospace faces', () => {
-    expect(guessFontFallback('Cascadia Code')).toBe('monospace');
-    expect(guessFontFallback('Roboto Mono')).toBe('monospace');
-    expect(guessFontFallback('Courier Prime')).toBe('monospace');
-  });
-
-  it('detects serif faces by keyword and by known serif names', () => {
-    expect(guessFontFallback('Adobe Caslon Pro')).toBe('serif');
-    expect(guessFontFallback('Bodoni Moda')).toBe('serif');
-    expect(guessFontFallback('Palatino Linotype')).toBe('serif');
-    expect(guessFontFallback('Awesome Serif')).toBe('serif');
-  });
-
-  it('does not treat sans-serif names as serif', () => {
-    expect(guessFontFallback('PT Sans Serif Whatever')).toBe('sans-serif');
-    expect(guessFontFallback('Open Sans')).toBe('sans-serif');
-  });
-
-  it('defaults to sans-serif and never guesses system-ui', () => {
-    expect(guessFontFallback('Neue Haas Grotesk')).toBe('sans-serif');
-    expect(guessFontFallback('Futura')).toBe('sans-serif');
-  });
-});
-
-describe('accentToColorScheme', () => {
-  it('derives the same scheme the editor previously derived inline', () => {
-    // Parity with the original editor-react schemeFromAccent implementation.
-    const accent = '#63b3ed';
-    const scale = deriveScale(accent, 0.3);
-    expect(accentToColorScheme(accent)).toEqual({
-      bg: scale.darker2,
-      text: scale.lighter2,
-      accent: scale.base,
-    });
-  });
-
-  it('returns valid hex colors for every slot', () => {
-    const scheme = accentToColorScheme('#c05621');
-    expect(isHex(scheme.bg)).toBe(true);
-    expect(isHex(scheme.text)).toBe(true);
-    expect(isHex(scheme.accent)).toBe(true);
-  });
-
-  it('falls back to a neutral scheme on invalid input', () => {
-    expect(accentToColorScheme('not-a-color')).toEqual({
-      bg: '#1a202c',
-      text: '#e2e8f0',
-      accent: '#63b3ed',
-    });
-  });
-});

package/src/__tests__/materializeBlockLayers.test.ts

@@ -1,167 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { DEFAULT_THEME, expandDocBlocks } from '../doc/templates/index.js';
-import { materializeBlockLayers } from '../doc/materializeBlockLayers.js';
-import type { CustomTemplateDefinition } from '../schemas/CustomTemplates.js';
-import type { Block, Layer, TextLayer } from '../schemas/Doc.js';
-import type { TemplateBlock } from '../schemas/BlockTemplates.js';
-
-const titleBlock: TemplateBlock = {
-  template: 'title',
-  id: 'title-1',
-  duration: 5,
-  audioSegment: 0,
-  title: 'A canonical materializer',
-};
-
-describe('materializeBlockLayers', () => {
-  it('returns owned layers and metadata for built-in and authored blocks', () => {
-    const templated = materializeBlockLayers(titleBlock, { persistentLayers: false });
-    expect(templated.source).toBe('template');
-    expect(templated.diagnostic).toBeUndefined();
-    expect(templated.layers.length).toBeGreaterThan(0);
-
-    const authoredLayer: Layer = {
-      id: 'authored',
-      type: 'shape',
-      content: { shape: 'rect', fill: '#123456' },
-      position: { x: 0, y: 0, width: 10, height: 10 },
-    };
-    const authored: Block = {
-      id: 'raw',
-      startTime: 0,
-      duration: 5,
-      audioSegment: 0,
-      layers: [authoredLayer],
-    };
-    const materialized = materializeBlockLayers(authored, { persistentLayers: false });
-    expect(materialized.source).toBe('authored');
-    expect(materialized.layers).toEqual([authoredLayer]);
-    expect(materialized.layers[0]).not.toBe(authoredLayer);
-  });
-
-  it('materializes Mermaid fences for empty and templated blocks', () => {
-    const contents = [
-      {
-        type: 'code' as const,
-        lang: 'mermaid',
-        value: 'flowchart LR\n  start --> next',
-      },
-    ];
-    const empty: Block = {
-      id: 'rich-empty',
-      startTime: 0,
-      duration: 5,
-      audioSegment: 0,
-      contents,
-    };
-    const richOnly = materializeBlockLayers(empty, { persistentLayers: false });
-    expect(richOnly.source).toBe('rich-content');
-    expect(richOnly.layers).toHaveLength(1);
-    expect(richOnly.layers[0]).toMatchObject({
-      type: 'mermaid',
-      content: { source: 'flowchart LR\n  start --> next' },
-    });
-
-    const templated = materializeBlockLayers(
-      { ...titleBlock, contents } as unknown as TemplateBlock,
-      { persistentLayers: false },
-    );
-    expect(templated.source).toBe('template');
-    expect(templated.layers.some((layer) => layer.type === 'text')).toBe(true);
-    expect(templated.layers.some((layer) => layer.type === 'mermaid')).toBe(true);
-  });
-
-  it('resolves document-scoped custom templates in the on-demand API', () => {
-    const customTemplate: CustomTemplateDefinition = {
-      name: 'hero',
-      label: 'Hero',
-      viewport: { width: 1920, height: 1080 },
-      layers: [
-        {
-          id: 'hero-title',
-          type: 'text',
-          position: { x: '5%', y: '10%', width: '90%' },
-          content: { text: '{title}', style: { fontSize: 64, color: '#000000' } },
-        },
-      ],
-    };
-    const block = {
-      ...titleBlock,
-      template: 'hero',
-      title: 'Doc-scoped',
-    } as unknown as TemplateBlock;
-
-    const result = materializeBlockLayers(block, {
-      customTemplates: [customTemplate],
-      persistentLayers: false,
-    });
-
-    expect(result.source).toBe('template');
-    expect((result.layers[0] as TextLayer).content.text).toBe('Doc-scoped');
-  });
-
-  it('returns structured diagnostics and a visible fallback without logging', () => {
-    const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
-    const error = vi.spyOn(console, 'error').mockImplementation(() => {});
-    const unknown = { ...titleBlock, template: 'not-registered' } as unknown as TemplateBlock;
-
-    const result = materializeBlockLayers(unknown, { persistentLayers: false });
-
-    expect(result.source).toBe('fallback');
-    expect(result.diagnostic).toEqual({
-      code: 'unknown-template',
-      template: 'not-registered',
-      message: 'Unknown template "not-registered"',
-    });
-    expect(result.layers.some((layer) => layer.id === 'fallback-notice')).toBe(true);
-    expect(warn).not.toHaveBeenCalled();
-    expect(error).not.toHaveBeenCalled();
-    warn.mockRestore();
-    error.mockRestore();
-  });
-
-  it('supports an explicit empty failure policy', () => {
-    const unknown = { ...titleBlock, template: 'not-registered' } as unknown as TemplateBlock;
-    const result = materializeBlockLayers(unknown, {
-      failureMode: 'empty',
-      persistentLayers: false,
-    });
-
-    expect(result.source).toBe('empty');
-    expect(result.layers).toEqual([]);
-    expect(result.diagnostic?.code).toBe('unknown-template');
-  });
-
-  it('inherits theme persistent layers by default and has an explicit opt-out', () => {
-    const theme = {
-      ...DEFAULT_THEME,
-      persistentLayers: {
-        bottomLayers: [
-          {
-            template: 'solidBackground' as const,
-            config: { type: 'solidBackground' as const, color: '#123456' },
-          },
-        ],
-      },
-    };
-
-    const inherited = materializeBlockLayers(titleBlock, { theme });
-    const disabled = materializeBlockLayers(titleBlock, { theme, persistentLayers: false });
-
-    expect(inherited.layers[0]?.id).toContain('solid');
-    expect(disabled.layers[0]?.id).not.toContain('solid');
-  });
-
-  it('is the only materialization path used by timed expansion', () => {
-    const diagnostics: string[] = [];
-    const unknown = { ...titleBlock, template: 'not-registered' } as unknown as TemplateBlock;
-    const direct = materializeBlockLayers(unknown, { persistentLayers: false });
-    const [scheduled] = expandDocBlocks([unknown], {
-      persistentLayers: false,
-      onDiagnostic: (diagnostic) => diagnostics.push(diagnostic.code),
-    });
-
-    expect(scheduled.layers).toEqual(direct.layers);
-    expect(diagnostics).toEqual(['unknown-template']);
-  });
-});

package/src/__tests__/materializePageSections.test.ts

@@ -1,404 +0,0 @@
-import { describe, it, expect, vi, afterEach } from 'vitest';
-import type { Block, Doc } from '../schemas/Doc.js';
-import type { Theme } from '../schemas/Theme.js';
-import { PAGE_SECTION_KINDS } from '../schemas/PageStyle.js';
-import { THEMES, DEFAULT_THEME } from '../schemas/themeLibrary.js';
-import { createTheme } from '../schemas/Theme.js';
-import { templateRegistry } from '../doc/templates/registry.js';
-import { TEMPLATE_ALIASES } from '../doc/templates/templateNames.js';
-import { sectionExtractors } from '../doc/page/sectionExtractors.js';
-import {
-  materializePageSection,
-  materializePageSections,
-  resolvePageStyle,
-} from '../doc/page/materializePageSection.js';
-import { parseMarkdown } from '../markdown/parse.js';
-import { markdownToDoc } from '../doc/markdownToDoc.js';
-import { buildPageCss, buildPageCssVars, PAGE_BASE_CSS } from '../doc/pageCss.js';
-import { resolveTransformStyle } from '../transform/registry.js';
-
-afterEach(() => {
-  vi.restoreAllMocks();
-});
-
-function templateBlock(template: string, extra: Record<string, unknown> = {}): Block {
-  return {
-    id: `test-${template}`,
-    startTime: 0,
-    duration: 1,
-    audioSegment: 0,
-    template,
-    ...extra,
-  } as unknown as Block;
-}
-
-function docOf(blocks: Block[], extra: Partial<Doc> = {}): Doc {
-  return { blocks, duration: 10, ...extra } as Doc;
-}
-
-describe('section extractor coverage', () => {
-  it('covers every registered template id', () => {
-    for (const id of Object.keys(templateRegistry)) {
-      expect(sectionExtractors[id], `template "${id}" has no section extractor`).toBeDefined();
-    }
-  });
-
-  it('maps every registry template (and alias) to a valid section kind', () => {
-    const names = [...Object.keys(templateRegistry), ...Object.keys(TEMPLATE_ALIASES)];
-    for (const name of names) {
-      const { section, source } = materializePageSection(templateBlock(name));
-      expect(source, name).toBe('template');
-      expect(PAGE_SECTION_KINDS, `${name} → ${section.kind}`).toContain(section.kind);
-    }
-  });
-
-  it('extracts typed slots for representative templates', () => {
-    const stat = materializePageSection(
-      templateBlock('statHighlight', { stat: '42%', description: 'more speed', detail: 'ctx' }),
-    ).section;
-    expect(stat.kind).toBe('stat-band');
-    expect(stat.slots.items?.[0]).toMatchObject({ value: '42%', title: 'more speed' });
-
-    const quote = materializePageSection(
-      templateBlock('quote', { quote: 'Words matter.', attribution: 'Someone' }),
-    ).section;
-    expect(quote.kind).toBe('quote-band');
-    expect(quote.slots.body?.text).toBe('Words matter.');
-    expect(quote.slots.attribution).toBe('Someone');
-
-    const feature = materializePageSection(
-      templateBlock('rightFeature', { imageSrc: 'a.png', title: 'T', body: 'B' }),
-    ).section;
-    expect(feature.kind).toBe('feature-split');
-    expect(feature.variant).toBe('media-right');
-    expect(feature.slots.media).toMatchObject({ type: 'image', src: 'a.png' });
-
-    const table = materializePageSection(
-      templateBlock('dataTable', { headers: ['A'], rows: [['1']] }),
-    ).section;
-    expect(table.kind).toBe('table-section');
-    expect(table.slots.table).toMatchObject({ headers: ['A'], rows: [['1']] });
-
-    const diagram = materializePageSection(templateBlock('diagram', { nodes: [] })).section;
-    expect(diagram.kind).toBe('canvas-embed');
-    expect(diagram.slots.media).toMatchObject({ type: 'canvas', spatial: 'diagram' });
-
-    const video = materializePageSection(
-      templateBlock('videoWithCaption', {
-        videoSrc: 'v.mp4',
-        videoAlt: 'clip',
-        clipStart: 0,
-        clipEnd: 3,
-      }),
-    ).section;
-    expect(video.kind).toBe('media-figure');
-    expect(video.slots.media).toMatchObject({ type: 'video', src: 'v.mp4' });
-  });
-
-  it('pullQuote with a background image becomes a media-backed quote band', () => {
-    const { section } = materializePageSection(
-      templateBlock('pullQuote', {
-        text: 'Big words',
-        backgroundImage: { src: 'bg.jpg', alt: 'bg' },
-      }),
-    );
-    expect(section.kind).toBe('quote-band');
-    expect(section.background).toBe('media');
-    expect(section.slots.media).toMatchObject({ type: 'image', src: 'bg.jpg' });
-  });
-});
-
-describe('non-template paths', () => {
-  it('unknown template falls back to a visible diagnostic callout without console.warn', () => {
-    const warnSpy = vi.spyOn(console, 'warn');
-    const { section, source, diagnostic } = materializePageSection(templateBlock('zzz-nope'));
-    expect(source).toBe('fallback');
-    expect(section.kind).toBe('callout');
-    expect(section.variant).toBe('diagnostic');
-    expect(section.slots.meta).toContain('Unknown template');
-    expect(diagnostic).toMatchObject({ code: 'unknown-template', template: 'zzz-nope' });
-    expect(warnSpy).not.toHaveBeenCalled();
-  });
-
-  it('custom templates become custom canvas embeds at their authored aspect', () => {
-    const { section, source } = materializePageSection(templateBlock('my-custom'), {
-      customTemplates: [
-        {
-          name: 'my-custom',
-          label: 'My Custom',
-          viewport: { width: 1080, height: 1080 },
-          layers: [],
-        } as never,
-      ],
-    });
-    expect(source).toBe('custom-template');
-    expect(section.kind).toBe('canvas-embed');
-    expect(section.slots.media).toMatchObject({
-      type: 'canvas',
-      spatial: 'custom',
-      aspect: { width: 1080, height: 1080 },
-    });
-  });
-
-  it('authored layer blocks become authored canvas embeds', () => {
-    const block = {
-      id: 'raw',
-      startTime: 0,
-      duration: 1,
-      audioSegment: 0,
-      layers: [{ id: 'l1', type: 'text', content: { text: 'hi' } }],
-    } as unknown as Block;
-    const { section, source } = materializePageSection(block);
-    expect(source).toBe('authored');
-    expect(section.kind).toBe('canvas-embed');
-    expect(section.slots.media).toMatchObject({ type: 'canvas', spatial: 'authored' });
-  });
-
-  it('plain heading blocks become prose sections with markdown body', () => {
-    const doc = markdownToDoc(parseMarkdown('# Hello\n\nSome *rich* text.'));
-    const sections = materializePageSections(doc);
-    const prose = sections.find((entry) => entry.section.kind === 'prose');
-    expect(prose).toBeDefined();
-    expect(prose!.section.slots.title).toBe('Hello');
-    expect(prose!.section.slots.headingLevel).toBe(1);
-    expect(prose!.section.slots.body?.markdown?.length).toBeGreaterThan(0);
-    expect(prose!.section.slots.body?.text).toContain('Some');
-  });
-
-  it('auto-templated blocks map to their typed section', () => {
-    const doc = markdownToDoc(parseMarkdown('# Journey\n\n> The only way out is through.'));
-    const sections = materializePageSections(doc);
-    const auto = sections.find((entry) => entry.section.template === 'quote');
-    expect(auto).toBeDefined();
-    expect(auto!.section.kind).toBe('quote-band');
-    expect(auto!.section.slots.body?.text).toContain('only way out');
-  });
-
-  it('preserves Mermaid and unconsumed media alongside typed page templates', () => {
-    const doc = markdownToDoc(
-      parseMarkdown(
-        '# Rich {[factCard]}\n\nNarrative copy.\n\n```mermaid\nflowchart LR\n  a --> b\n```',
-      ),
-    );
-    const [entry] = materializePageSections(doc);
-    expect(entry.section.kind).toBe('callout');
-    expect(entry.section.slots.body?.text).not.toContain('flowchart LR');
-    expect(entry.section.slots.richContent?.markdown).toEqual([
-      expect.objectContaining({ type: 'code', lang: 'mermaid' }),
-    ]);
-
-    const imageBlock = templateBlock('quote', {
-      quote: 'Keep the picture too.',
-      contents: parseMarkdown('![Architecture](architecture.png)').children,
-    });
-    const imageSection = materializePageSection(imageBlock).section;
-    expect(imageSection.slots.richContent?.markdown).toEqual([
-      expect.objectContaining({ type: 'paragraph' }),
-    ]);
-  });
-});
-
-describe('doc-level art direction', () => {
-  it('synthesizes a cover hero when requested', () => {
-    const doc = docOf([templateBlock('quote', { quote: 'q' })], {
-      startBlock: { title: 'Cover Title', subtitle: 'Sub', heroSrc: 'hero.jpg' },
-    });
-    const sections = materializePageSections(doc, { cover: doc.startBlock });
-    expect(sections[0].section.kind).toBe('hero');
-    expect(sections[0].section.source).toBe('cover');
-    expect(sections[0].section.slots.title).toBe('Cover Title');
-    expect(sections[0].section.background).toBe('media');
-    expect(sections[0].section.emphasis).toBe('lead');
-
-    const withoutCover = materializePageSections(doc);
-    expect(withoutCover[0].section.kind).not.toBe('hero');
-  });
-
-  it('dedupes the cover against an authored title block (authored hero wins)', () => {
-    const doc = docOf([templateBlock('title', { title: 'Same Title', subtitle: 'Authored sub' })], {
-      startBlock: { title: 'Same Title', heroSrc: 'hero.jpg', heroAlt: 'hero' },
-    });
-    const sections = materializePageSections(doc, { cover: doc.startBlock });
-    const heroes = sections.filter((entry) => entry.section.kind === 'hero');
-    expect(heroes).toHaveLength(1);
-    expect(heroes[0].section.source).toBe('template');
-    // The cover's hero image grafts onto the authored hero when it has none.
-    expect(heroes[0].section.slots.media).toMatchObject({ type: 'image', src: 'hero.jpg' });
-    expect(heroes[0].section.background).toBe('media');
-  });
-
-  it('dedupes the cover against a mirrored leading prose H1', () => {
-    const doc = markdownToDoc(parseMarkdown('# My Doc\n\nIntro paragraph.\n\nSecond paragraph.'));
-    expect(doc.startBlock?.title).toBe('My Doc');
-    const sections = materializePageSections(doc, { cover: doc.startBlock });
-    expect(sections[0].section.kind).toBe('hero');
-    expect(sections[0].section.slots.subtitle).toBe('Intro paragraph.');
-    // The H1's own section keeps only the non-mirrored body.
-    const prose = sections.find((entry) => entry.section.kind === 'prose')!;
-    expect(prose.section.slots.title).toBeUndefined();
-    expect(prose.section.slots.body?.text).toBe('Second paragraph.');
-  });
-
-  it('applies the alternate background rhythm across non-prose sections', () => {
-    const theme = THEMES.standard; // backgroundRhythm: alternate
-    const doc = docOf([
-      templateBlock('quote', { quote: 'a' }),
-      templateBlock('quote', { quote: 'b' }),
-      templateBlock('quote', { quote: 'c' }),
-    ]);
-    const sections = materializePageSections(doc, { theme });
-    expect(sections.map((entry) => entry.section.background)).toEqual([
-      'base',
-      'alternate',
-      'base',
-    ]);
-  });
-
-  it('rotates accent schemes with cycle strategy and lets block colorScheme win', () => {
-    const theme = THEMES.standard; // accentRotation: cycle
-    const schemeNames = Object.keys(theme.colorSchemes);
-    const doc = docOf([
-      templateBlock('sectionHeader', { title: 'one' }),
-      templateBlock('sectionHeader', { title: 'two' }),
-      templateBlock('sectionHeader', { title: 'pinned', colorScheme: 'teal' }),
-    ]);
-    const sections = materializePageSections(doc, { theme });
-    expect(sections[0].section.accent).toMatchObject({
-      schemeName: schemeNames[0],
-      role: 'rotation',
-    });
-    expect(sections[1].section.accent).toMatchObject({
-      schemeName: schemeNames[1],
-      role: 'rotation',
-    });
-    expect(sections[2].section.accent).toMatchObject({ schemeName: 'teal', role: 'block' });
-  });
-
-  it('primary-only strategy skips rotation', () => {
-    const theme = THEMES.documentary;
-    const doc = docOf([templateBlock('sectionHeader', { title: 'one' })]);
-    const sections = materializePageSections(doc, { theme });
-    expect(sections[0].section.accent.role).toBe('primary');
-    expect(sections[0].section.accent.schemeName).toBeUndefined();
-  });
-
-  it('applies theme section overrides (documentary quote-band → editorial variant)', () => {
-    const sections = materializePageSections(docOf([templateBlock('quote', { quote: 'q' })]), {
-      theme: THEMES.documentary,
-    });
-    expect(sections[0].section.variant).toBe('editorial');
-  });
-
-  it('applies per-template hints (tech-dark diagram → terminal frame)', () => {
-    const sections = materializePageSections(docOf([templateBlock('diagram', {})]), {
-      theme: THEMES['tech-dark'],
-    });
-    expect(sections[0].section.hints).toMatchObject({ frame: 'terminal' });
-  });
-
-  it('numbers hero/banner eyebrows under numbered and mono-tag treatments', () => {
-    const doc = docOf([
-      templateBlock('sectionHeader', { title: 'one' }),
-      templateBlock('quote', { quote: 'interlude' }),
-      templateBlock('sectionHeader', { title: 'two' }),
-    ]);
-    const sections = materializePageSections(doc, { theme: THEMES.documentary });
-    expect(sections[0].section.slots.eyebrow).toBe('01');
-    expect(sections[1].section.slots.eyebrow).toBeUndefined();
-    expect(sections[2].section.slots.eyebrow).toBe('02');
-
-    const clean = materializePageSections(doc, { theme: THEMES.standard });
-    expect(clean[0].section.slots.eyebrow).toBeUndefined();
-  });
-
-  it('container template children are consumed; other children recurse with depth', () => {
-    const container = templateBlock('diagram', {
-      children: [
-        {
-          id: 'child-consumed',
-          startTime: 0,
-          duration: 1,
-          audioSegment: 0,
-          template: 'sectionHeader',
-        },
-      ],
-    });
-    const parent = {
-      ...templateBlock('sectionHeader', { title: 'parent' }),
-      children: [
-        {
-          id: 'child-kept',
-          startTime: 0,
-          duration: 1,
-          audioSegment: 0,
-          sourceHeading: {
-            type: 'heading',
-            depth: 2,
-            children: [{ type: 'text', value: 'Child' }],
-          },
-        } as unknown as Block,
-      ],
-    } as Block;
-    const sections = materializePageSections(docOf([container, parent]));
-    const ids = sections.map((entry) => entry.section.blockId);
-    expect(ids).not.toContain('child-consumed');
-    expect(ids).toContain('child-kept');
-    const child = sections.find((entry) => entry.section.blockId === 'child-kept')!;
-    expect(child.section.depth).toBe(1);
-  });
-
-  it('transform page hints overlay spacing and front-load emphasis', () => {
-    const hints = resolveTransformStyle('documentary').page;
-    expect(hints).toMatchObject({ spacing: 'generous', emphasisCurve: 'front-loaded' });
-
-    const style = resolvePageStyle(THEMES.standard, { spacing: 'compact' });
-    expect(style.tokens.sectionSpacing).toBe('compact');
-    expect(THEMES.standard.pageStyle!.tokens.sectionSpacing).toBe('comfortable');
-
-    const doc = docOf([
-      templateBlock('quote', { quote: 'a' }),
-      templateBlock('quote', { quote: 'b' }),
-      templateBlock('quote', { quote: 'c' }),
-    ]);
-    const sections = materializePageSections(doc, {
-      transformPage: { emphasisCurve: 'front-loaded' },
-    });
-    expect(sections[0].section.emphasis).toBe('strong');
-    expect(sections[1].section.emphasis).toBe('strong');
-    expect(sections[2].section.emphasis).toBe('standard');
-  });
-
-  it('indexes sections pre-order with totals', () => {
-    const doc = docOf([
-      templateBlock('quote', { quote: 'a' }),
-      templateBlock('quote', { quote: 'b' }),
-    ]);
-    const sections = materializePageSections(doc);
-    expect(sections.map((entry) => entry.section.index)).toEqual([0, 1]);
-    expect(sections.every((entry) => entry.section.totalSections === 2)).toBe(true);
-  });
-});
-
-describe('page CSS', () => {
-  it('builds theme vars covering colors, fonts, and token dimensions', () => {
-    const vars = buildPageCssVars(THEMES.magazine);
-    expect(vars['--squisq-page-bg']).toBe(THEMES.magazine.colors.background);
-    expect(vars['--squisq-page-wide-max']).toBe('1240px');
-    expect(vars['--squisq-page-title-font']).toContain('DM Serif');
-  });
-
-  it('buildPageCss embeds the vars and the structural sheet', () => {
-    const css = buildPageCss(DEFAULT_THEME);
-    expect(css).toContain('.squisq-page {');
-    expect(css).toContain('--squisq-page-bg:');
-    expect(css).toContain(PAGE_BASE_CSS.slice(0, 60).trim());
-  });
-
-  it('resolvePageStyle derives a style for themes without pageStyle', () => {
-    const theme = createTheme(DEFAULT_THEME, { id: 'legacy' });
-    delete (theme as unknown as Record<string, unknown>).pageStyle;
-    const style = resolvePageStyle(theme as Theme);
-    expect(style.family).toBe('clean');
-    expect(style.tokens.contentMaxWidth).toBeGreaterThan(0);
-  });
-});