@bendyline/squisq 1.5.0 → 1.5.2

package/src/__tests__/markdownToDoc.test.ts

@@ -250,6 +250,31 @@ describe('docToMarkdown (round-trip)', () => {
     expect(stripPositions(md2)).toEqual(stripPositions(md));
   });
 
+  it('round-trips inline coerced template params, keeping overrides raw', () => {
+    const input = '# Downtown {[map center="47.6,-122.3" zoom=9 mapStyle="road"]}\n\nSome text.\n';
+    const md = parseMarkdown(input);
+    const doc = markdownToDoc(md, { generateCoverBlock: false });
+
+    // The overrides must stay RAW strings — coercion only ever touches the
+    // ephemeral render input, never the stored block, so round-trips are lossless.
+    expect(doc.blocks[0].templateOverrides).toEqual({
+      center: '47.6,-122.3',
+      zoom: '9',
+      mapStyle: 'road',
+    });
+
+    // Byte-stable: one full cycle reaches a fixed point that a second cycle
+    // reproduces exactly.
+    const once = stringifyMarkdown(docToMarkdown(doc));
+    const twice = stringifyMarkdown(
+      docToMarkdown(markdownToDoc(parseMarkdown(once), { generateCoverBlock: false })),
+    );
+    expect(twice).toBe(once);
+    // And the annotation with its raw values survives serialization.
+    expect(once).toContain('center=47.6,-122.3');
+    expect(once).toContain('zoom=9');
+  });
+
   it('round-trips preamble content', () => {
     const input = 'Preamble text\n\n# Heading\n\nBody\n';
     const md = parseMarkdown(input);
@@ -369,14 +394,62 @@ describe('template annotation in markdownToDoc', () => {
     expect(output).toContain('{[factCard style=minimal]}');
   });
 
-  it('docToMarkdown injects transition attributes from block metadata', () => {
+  it('docToMarkdown injects transition params into the squiggly annotation', () => {
     const md = parseMarkdown('## Section\n\nBody');
     const doc = markdownToDoc(md);
     doc.blocks[0].transition = { type: 'wipe', duration: 0.8, direction: 'left' };
 
     const output = stringifyMarkdown(docToMarkdown(doc));
 
-    expect(output).toContain('{transition=wipe transitionDuration=0.8 transitionDirection=left}');
+    expect(output).toContain('{[transition=wipe transitionDuration=0.8 transitionDirection=left]}');
+    expect(output).not.toContain('{transition=wipe');
+  });
+
+  it('a programmatic transition survives the string round trip', () => {
+    const doc = markdownToDoc(parseMarkdown('## Section\n\nBody'));
+    doc.blocks[0].transition = { type: 'wipe', duration: 0.8, direction: 'left' };
+
+    const reparsed = markdownToDoc(parseMarkdown(stringifyMarkdown(docToMarkdown(doc))));
+
+    expect(reparsed.blocks[0].transition).toEqual({
+      type: 'wipe',
+      duration: 0.8,
+      direction: 'left',
+    });
+  });
+
+  it('a programmatic transition survives the in-memory round trip (no stringify)', () => {
+    // markdownToDoc reads heading.attributes.blockMeta directly — it never
+    // re-coerces params — so docToMarkdown must keep blockMeta in sync with
+    // the params it writes for stringifyMarkdown.
+    const doc = markdownToDoc(parseMarkdown('## Section\n\nBody'));
+    doc.blocks[0].transition = { type: 'wipe', duration: 0.8, direction: 'left' };
+
+    const reconverted = markdownToDoc(docToMarkdown(doc));
+
+    expect(reconverted.blocks[0].transition).toEqual({
+      type: 'wipe',
+      duration: 0.8,
+      direction: 'left',
+    });
+  });
+
+  it('an updated transition replaces a previously authored one in both round trips', () => {
+    // The heading already carries a parsed transition (params + blockMeta);
+    // a programmatic change must win over the stale blockMeta.
+    const doc = markdownToDoc(parseMarkdown('## Section {transition=fade}\n\nBody'));
+    expect(doc.blocks[0].transition).toEqual({ type: 'fade' });
+    doc.blocks[0].transition = { type: 'wipe', direction: 'left' };
+
+    const inMemory = markdownToDoc(docToMarkdown(doc));
+    expect(inMemory.blocks[0].transition).toEqual({ type: 'wipe', direction: 'left' });
+
+    const output = stringifyMarkdown(docToMarkdown(doc));
+    expect(output).toContain('transition=wipe');
+    expect(output).toContain('{[transition=wipe transitionDirection=left]}');
+    expect(output).not.toContain('{transition=wipe');
+    const reparsed = markdownToDoc(parseMarkdown(output));
+    expect(reparsed.blocks[0].transition).toEqual({ type: 'wipe', direction: 'left' });
   });
 
   it('nested headings preserve their own annotations', () => {
@@ -784,3 +857,101 @@ describe('auto template picking (autoTemplates, default on)', () => {
     expect(roundTripped).not.toContain('{[quote');
   });
 });
+
+describe('standalone annotation blocks (S2)', () => {
+  const toDoc = (md: string, options?: Parameters<typeof markdownToDoc>[1]) =>
+    markdownToDoc(parseMarkdown(md), { articleId: 't', generateCoverBlock: false, ...options });
+
+  it('turns a standalone {[template]} paragraph into a heading-less block', () => {
+    const doc = toDoc('# Intro\n\nlead para\n\n{[quote]}\n\nquoted body\n');
+    // Containing block keeps only the leading content.
+    const intro = doc.blocks[0];
+    expect(intro.title).toBe('Intro');
+    expect(intro.contents?.map((n) => n.type)).toEqual(['paragraph']);
+    // The produced block is a sibling right after the containing block.
+    const q = doc.blocks[1];
+    expect(q.template).toBe('quote');
+    expect(q.standaloneAnnotation).toBe(true);
+    expect(q.sourceHeading).toBeUndefined();
+    expect(q.sourceAnnotation).toEqual({ template: 'quote' });
+    expect(q.contents?.map((n) => n.type)).toEqual(['paragraph']);
+  });
+
+  it('attaches trailing contents up to the next annotation; params → overrides + title', () => {
+    const doc = toDoc(
+      '# H\n\n{[statHighlight title="Q1 Revenue" colorScheme=blue]}\n\nbig number\n\n{[quote]}\n\nq\n',
+    );
+    const stat = doc.blocks[1];
+    expect(stat.template).toBe('statHighlight');
+    expect(stat.title).toBe('Q1 Revenue');
+    expect(stat.templateOverrides).toEqual({ title: 'Q1 Revenue', colorScheme: 'blue' });
+    expect(stat.contents?.length).toBe(1); // "big number", ended by the next annotation
+    const quote = doc.blocks[2];
+    expect(quote.template).toBe('quote');
+    expect(quote.contents?.length).toBe(1); // "q"
+  });
+
+  it('produces adjacent blocks for consecutive annotations (no content between)', () => {
+    const doc = toDoc('# H\n\n{[quote]}\n\n{[factCard]}\n\ntail\n');
+    expect(doc.blocks[1].template).toBe('quote');
+    expect(doc.blocks[1].contents ?? []).toHaveLength(0);
+    expect(doc.blocks[2].template).toBe('factCard');
+    expect(doc.blocks[2].contents?.length).toBe(1); // "tail"
+  });
+
+  it('handles an annotation as the last node (no trailing contents)', () => {
+    const doc = toDoc('# H\n\nbody\n\n{[quote]}\n');
+    expect(doc.blocks[1].template).toBe('quote');
+    expect(doc.blocks[1].contents ?? []).toHaveLength(0);
+  });
+
+  it('generates unique slug ids that dedupe against headings', () => {
+    const doc = toDoc('# Quote\n\n{[quote title=Quote]}\n\nbody\n');
+    expect(doc.blocks[0].id).toBe('quote');
+    expect(doc.blocks[1].id).toBe('quote-2');
+  });
+
+  it('lifts an annotation out of the preamble (before the first heading)', () => {
+    const doc = toDoc('intro\n\n{[quote]}\n\nquoted\n\n# Heading\n\nrest\n');
+    // preamble keeps "intro", quote block next, then the heading block.
+    expect(doc.blocks[0].sourceHeading).toBeUndefined();
+    expect(doc.blocks[0].contents?.length).toBe(1);
+    expect(doc.blocks[1].template).toBe('quote');
+    expect(doc.blocks[2].title).toBe('Heading');
+  });
+
+  it('drops a preamble that was entirely a standalone annotation', () => {
+    const doc = toDoc('{[quote]}\n\nquoted\n\n# Heading\n');
+    expect(doc.blocks[0].template).toBe('quote');
+    expect(doc.blocks[0].standaloneAnnotation).toBe(true);
+    expect(doc.blocks[1].title).toBe('Heading');
+  });
+
+  it('honors a pinned duration on a standalone annotation', () => {
+    const doc = toDoc('# H\n\n{[quote duration=9]}\n\nbody\n');
+    expect(doc.blocks[1].duration).toBe(9);
+  });
+
+  it('does not treat annotations nested inside a list as blocks', () => {
+    const doc = toDoc('# H\n\n- {[quote]}\n');
+    // Only the heading block — the list annotation stays in contents.
+    expect(doc.blocks).toHaveLength(1);
+    expect(doc.blocks[0].contents?.[0].type).toBe('list');
+  });
+
+  it('round-trips a standalone annotation block byte-for-byte', () => {
+    const md = '# Intro\n\nlead\n\n{[quote]}\n\nquoted body\n';
+    const doc = toDoc(md);
+    const out = stringifyMarkdown(docToMarkdown(doc));
+    expect(out).toBe(md);
+    // And re-parsing is stable.
+    const doc2 = toDoc(out);
+    expect(stringifyMarkdown(docToMarkdown(doc2))).toBe(md);
+  });
+
+  it('round-trips params (quoting) byte-for-byte', () => {
+    const md = '# H\n\n{[statHighlight title="Q1 Revenue" colorScheme=blue]}\n\nbody\n';
+    const out = stringifyMarkdown(docToMarkdown(toDoc(md)));
+    expect(out).toBe(md);
+  });
+});

package/src/__tests__/mediaAnnotations.test.ts

@@ -44,6 +44,14 @@ describe('markdownToDoc media annotations', () => {
     });
   });
 
+  it('accepts startTime as an alias of startAt (startAt wins when both given)', () => {
+    const alias = toDoc('# B {duration=20}\n\n{[audio src=a.mp3 startTime=5]}\n');
+    expect(alias.blocks[0].media![0].startAt).toBe(5);
+
+    const both = toDoc('# B {duration=20}\n\n{[audio src=a.mp3 startAt=3 startTime=5]}\n');
+    expect(both.blocks[0].media![0].startAt).toBe(3);
+  });
+
   it('media annotation text does not inflate block duration', () => {
     // No explicit duration; body is only the annotation → default (5s), not reading-time of the annotation text.
     const doc = toDoc('# B\n\n{[audio src=a.mp3]}\n');
@@ -62,3 +70,22 @@ describe('markdownToDoc media annotations', () => {
     expect(block.absoluteStart).toBe(35); // block Two at 30 + startAt 5
   });
 });
+
+describe('media annotations vs standalone template blocks', () => {
+  it('extracts media annotations as clips, not standalone blocks (media names win)', () => {
+    const doc = toDoc('# One\n\nIntro.\n\n{[audio src=narration.mp3]}\n\n{[video src=clip.mp4]}\n');
+    const block = doc.blocks[0];
+    expect(block.media?.map((m) => m.kind)).toEqual(['audio', 'video']);
+    // No sibling standalone blocks were produced for the media names.
+    expect(doc.blocks).toHaveLength(1);
+    expect(doc.blocks.some((b) => b.standaloneAnnotation)).toBe(false);
+  });
+
+  it('mixes a media clip and a standalone template block in one section', () => {
+    const doc = toDoc('# One\n\n{[audio src=n.mp3]}\n\n{[quote]}\n\nquoted\n');
+    expect(doc.blocks[0].media?.map((m) => m.kind)).toEqual(['audio']);
+    const q = doc.blocks[1];
+    expect(q.template).toBe('quote');
+    expect(q.standaloneAnnotation).toBe(true);
+  });
+});

package/src/__tests__/shapeGeometry.test.ts

@@ -4,8 +4,11 @@ import {
   markerPath,
   connectorPath,
   clipEndpoints,
+  nearestSnapPoint,
   lineStyleDasharray,
   PATH_SHAPE_KINDS,
+  snapEndpoints,
+  snapPoints,
 } from '../doc/utils/shapeGeometry.js';
 
 describe('shapePath', () => {
@@ -79,6 +82,40 @@ describe('clipEndpoints', () => {
   });
 });
 
+describe('snapEndpoints', () => {
+  const a = { cx: 50, cy: 50, rx: 30, ry: 20 };
+  const b = { cx: 180, cy: 50, rx: 30, ry: 20 };
+
+  it('exposes side and corner ports around a box', () => {
+    expect(snapPoints(a).map((p) => p.port)).toEqual([
+      'top',
+      'right',
+      'bottom',
+      'left',
+      'top-left',
+      'top-right',
+      'bottom-right',
+      'bottom-left',
+    ]);
+  });
+
+  it('snaps horizontal connections to side ports', () => {
+    const r = snapEndpoints(a, b);
+    expect(r.start).toMatchObject({ port: 'right', x: 80, y: 50 });
+    expect(r.end).toMatchObject({ port: 'left', x: 150, y: 50 });
+  });
+
+  it('snaps diagonal connections to nearest corner ports', () => {
+    const r = snapEndpoints(a, { cx: 180, cy: 140, rx: 30, ry: 20 });
+    expect(r.start).toMatchObject({ port: 'bottom-right', x: 80, y: 70 });
+    expect(r.end).toMatchObject({ port: 'top-left', x: 150, y: 120 });
+  });
+
+  it('finds the nearest port toward a free pointer', () => {
+    expect(nearestSnapPoint(a, { x: 100, y: 10 }).port).toBe('top-right');
+  });
+});
+
 describe('lineStyleDasharray', () => {
   it('maps line styles to dash patterns', () => {
     expect(lineStyleDasharray('dashed')).toBe('8 6');

package/src/__tests__/structuredData.test.ts

@@ -1,7 +1,8 @@
 import { describe, it, expect } from 'vitest';
 import { parseMarkdown } from '../markdown/parse.js';
 import { markdownToDoc } from '../doc/markdownToDoc.js';
-import { parseYamlSubset } from '../doc/structuredData.js';
+import { parseYamlSubset, replaceDataFence } from '../doc/structuredData.js';
+import type { MarkdownCodeBlock } from '../markdown/types.js';
 
 function toDoc(md: string) {
   return markdownToDoc(parseMarkdown(md));
@@ -41,8 +42,21 @@ describe('parseYamlSubset', () => {
     expect(parseYamlSubset('# comment\n\nkey: value')).toEqual({ key: 'value' });
   });
 
-  it('rejects nested mappings with a line-anchored error', () => {
-    expect(() => parseYamlSubset('outer:\n  inner: 1')).toThrow(/line 2/);
+  it('parses one level of nested mapping', () => {
+    expect(parseYamlSubset('center:\n  lat: 47.6\n  lng: -122.3\nzoom: 12')).toEqual({
+      center: { lat: 47.6, lng: -122.3 },
+      zoom: 12,
+    });
+  });
+
+  it('rejects nesting deeper than one level with a line-anchored error', () => {
+    expect(() => parseYamlSubset('a:\n  b:\n    c: 1')).toThrow(/line 2/);
+    expect(() => parseYamlSubset('a:\n  b: 1\n    c: 2')).toThrow(/line 3/);
+  });
+
+  it('rejects mixing list items and mapping keys under one key', () => {
+    expect(() => parseYamlSubset('a:\n  - x\n  b: 1')).toThrow(/mix/);
+    expect(() => parseYamlSubset('a:\n  b: 1\n  - x')).toThrow(/mix/);
   });
 });
 
@@ -93,6 +107,62 @@ describe('data fences → block.templateData', () => {
   });
 });
 
+describe('replaceDataFence', () => {
+  it('replaces the first data fence content, keeping lang and meta', () => {
+    const doc = toDoc(
+      '## Numbers {[dataTable]}\n\nIntro.\n\n```json data\n{ "headers": ["Q"] }\n```',
+    );
+    const contents = doc.blocks[0].contents!;
+
+    const next = replaceDataFence(contents, { headers: ['Q', 'Revenue'] });
+
+    const fence = next.find((n): n is MarkdownCodeBlock => n.type === 'code')!;
+    expect(fence.lang).toBe('json');
+    expect(fence.meta).toBe('data');
+    expect(JSON.parse(fence.value)).toEqual({ headers: ['Q', 'Revenue'] });
+    // Pretty-printed, not single-line.
+    expect(fence.value).toContain('\n');
+    // Same length, other nodes untouched.
+    expect(next).toHaveLength(contents.length);
+    expect(next[0]).toBe(contents[0]);
+  });
+
+  it('does not mutate the input array or the original fence node', () => {
+    const doc = toDoc('## Numbers {[dataTable]}\n\n```json data\n{ "a": 1 }\n```');
+    const contents = doc.blocks[0].contents!;
+    const originalFence = contents.find((n): n is MarkdownCodeBlock => n.type === 'code')!;
+
+    replaceDataFence(contents, { a: 2 });
+
+    expect(originalFence.value).toBe('{ "a": 1 }');
+  });
+
+  it('appends a new ```json data fence when none exists', () => {
+    const doc = toDoc('## Numbers {[dataTable]}\n\nJust text.');
+    const contents = doc.blocks[0].contents!;
+
+    const next = replaceDataFence(contents, { rows: [['Q1', '1.2M']] });
+
+    expect(next).toHaveLength(contents.length + 1);
+    const fence = next[next.length - 1] as MarkdownCodeBlock;
+    expect(fence).toMatchObject({ type: 'code', lang: 'json', meta: 'data' });
+    expect(JSON.parse(fence.value)).toEqual({ rows: [['Q1', '1.2M']] });
+  });
+
+  it('treats plain code fences (no data marker) as non-fences and appends', () => {
+    const doc = toDoc('## Code {[sectionHeader]}\n\n```json\n{ "just": "a sample" }\n```');
+    const contents = doc.blocks[0].contents!;
+
+    const next = replaceDataFence(contents, { a: 1 });
+
+    // The sample fence is untouched; a data fence is appended after it.
+    const sample = next.find((n): n is MarkdownCodeBlock => n.type === 'code' && !n.meta)!;
+    expect(sample.value).toBe('{ "just": "a sample" }');
+    expect(next).toHaveLength(contents.length + 1);
+    expect((next[next.length - 1] as MarkdownCodeBlock).meta).toBe('data');
+  });
+});
+
 describe('dataTable eats GFM tables', () => {
   const table = ['| Name | Age |', '| --- | ---: |', '| Alice | 30 |', '| Bob | 25 |'].join('\n');
 

package/src/__tests__/templateMetadata.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest';
-import { templateRegistry, TEMPLATE_METADATA } from '../doc/templates/index';
+import { templateRegistry, TEMPLATE_METADATA, TEMPLATE_ALIASES } from '../doc/templates/index';
 
 describe('TEMPLATE_METADATA', () => {
   it('stays exactly 1:1 with templateRegistry (same ids)', () => {
@@ -19,3 +19,13 @@ describe('TEMPLATE_METADATA', () => {
     }
   });
 });
+
+describe('TEMPLATE_ALIASES', () => {
+  it('every alias target resolves to a real registry entry', () => {
+    // A typo'd alias target would otherwise fall through resolveTemplateName's
+    // `?? name` fallback and silently resolve to a non-existent template.
+    for (const [alias, target] of Object.entries(TEMPLATE_ALIASES)) {
+      expect(target in templateRegistry, `alias "${alias}" → "${target}"`).toBe(true);
+    }
+  });
+});

package/src/__tests__/templates.test.ts

@@ -10,6 +10,10 @@ import {
   VIEWPORT_PRESETS,
 } from '../doc/templates/index';
 import type { TemplateBlock } from '../schemas/BlockTemplates';
+import type { TextLayer } from '../schemas/Doc';
+import { getLayers } from '../doc/getLayers';
+import { markdownToDoc } from '../doc/markdownToDoc';
+import { parseMarkdown } from '../markdown/parse';
 
 describe('templateRegistry', () => {
   it('contains all expected templates', () => {
@@ -244,6 +248,75 @@ describe('expandTemplateBlock', () => {
       expect((result.layers ?? []).length).toBeGreaterThanOrEqual(1);
     }
   });
+
+  it('keeps photoGrid media captions compact without placeholder alt labels', () => {
+    const block: TemplateBlock = {
+      template: 'photoGrid',
+      id: 'photo-grid-captions',
+      duration: 10,
+      audioSegment: 0,
+      images: [
+        { src: 'one.jpg', alt: 'A long archival caption for the first image' },
+        { src: 'two.jpg', alt: 'A long archival caption for the second image' },
+        { src: 'three.jpg', alt: 'A long archival caption for the third image' },
+      ],
+      caption:
+        'A long Wikimedia description with source notes, place names, dates, and details that should remain compact.',
+    };
+
+    const context = createTemplateContext(DEFAULT_THEME, 0, 10, VIEWPORT_PRESETS.landscape);
+    const result = expandTemplateBlock(block, context);
+    const layers = result.layers ?? [];
+    const captionLayer = layers.find(
+      (layer): layer is TextLayer => layer.type === 'text' && layer.id === 'caption',
+    );
+
+    expect(layers.some((layer) => layer.id.startsWith('grid-alt-'))).toBe(false);
+    expect(captionLayer).toBeDefined();
+    expect(captionLayer!.content.style.maxLines).toBe(1);
+    expect(captionLayer!.position.width).toBe('78%');
+  });
+
+  it('clamps full-bleed media captions above playback controls', () => {
+    const imageBlock: TemplateBlock = {
+      template: 'imageWithCaption',
+      id: 'image-caption',
+      duration: 10,
+      audioSegment: 0,
+      imageSrc: 'image.jpg',
+      imageAlt: 'Image',
+      caption:
+        'A long Wikimedia description with source notes, place names, dates, and details that should remain compact.',
+    };
+    const videoBlock: TemplateBlock = {
+      template: 'videoWithCaption',
+      id: 'video-caption',
+      duration: 10,
+      audioSegment: 0,
+      videoSrc: 'video.mp4',
+      videoAlt: 'Video',
+      clipStart: 0,
+      clipEnd: 10,
+      caption: imageBlock.caption,
+    };
+
+    const context = createTemplateContext(DEFAULT_THEME, 0, 10, VIEWPORT_PRESETS.landscape);
+    const imageCaption = (expandTemplateBlock(imageBlock, context).layers ?? []).find(
+      (layer): layer is TextLayer => layer.type === 'text' && layer.id === 'caption',
+    );
+    const videoCaption = (expandTemplateBlock(videoBlock, context).layers ?? []).find(
+      (layer): layer is TextLayer => layer.type === 'text' && layer.id === 'caption',
+    );
+
+    expect(imageCaption).toBeDefined();
+    expect(videoCaption).toBeDefined();
+    expect(imageCaption!.content.style.maxLines).toBe(2);
+    expect(videoCaption!.content.style.maxLines).toBe(2);
+    expect(imageCaption!.position.y).toBe('74%');
+    expect(videoCaption!.position.y).toBe('74%');
+    expect(imageCaption!.position.width).toBe('78%');
+    expect(videoCaption!.position.width).toBe('78%');
+  });
 });
 
 describe('expandDocBlocks', () => {
@@ -460,6 +533,45 @@ describe('DEFAULT_THEME', () => {
   });
 });
 
+describe('inline-param coercion → getLayers', () => {
+  function firstBlock(md: string) {
+    return markdownToDoc(parseMarkdown(md), { generateCoverBlock: false }).blocks[0];
+  }
+
+  it('renders a map from pure-inline {[map center=… zoom=…]} annotation', () => {
+    const block = firstBlock('# Downtown {[map center="47.6,-122.3" zoom=9 mapStyle="road"]}\n');
+    // Raw overrides stay strings for lossless round-trip.
+    expect(block.templateOverrides).toEqual({
+      center: '47.6,-122.3',
+      zoom: '9',
+      mapStyle: 'road',
+    });
+
+    const layers = getLayers(block, {});
+    const mapLayer = layers.find((l) => l.type === 'map');
+    expect(mapLayer).toBeDefined();
+    // Coerced center/zoom flow into the map layer's content — not empty strings.
+    const content = mapLayer!.content as { center: { lat: number; lng: number }; zoom: number };
+    expect(content.center).toEqual({ lat: 47.6, lng: -122.3 });
+    expect(content.zoom).toBe(9);
+  });
+
+  it('renders a twoColumn from pure-inline labeled-pair annotation', () => {
+    const block = firstBlock('# Coffee {[twoColumn left="Espresso|Bold" right="Filter|Smooth"]}\n');
+    const layers = getLayers(block, {});
+    // Guard requires both labels — a non-empty layer set proves coercion worked.
+    expect(layers.length).toBeGreaterThan(0);
+    const texts = layers
+      .filter((l) => l.type === 'text')
+      .map((l) => (l.content as { text: string }).text);
+    expect(texts).toContain('Espresso');
+    expect(texts).toContain('Filter');
+    // The sublabels from the "|" split render too.
+    expect(texts).toContain('Bold');
+    expect(texts).toContain('Smooth');
+  });
+});
+
 describe('VIEWPORT_PRESETS', () => {
   it('has landscape and portrait presets', () => {
     expect(VIEWPORT_PRESETS).toHaveProperty('landscape');