@bendyline/squisq 2.1.0 → 2.2.0

package/src/__tests__/storage.test.ts

@@ -1,60 +0,0 @@
-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__/structuredData.test.ts

@@ -1,249 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { parseMarkdown } from '../markdown/parse.js';
-import { markdownToDoc } from '../doc/markdownToDoc.js';
-import { parseYamlSubset, replaceDataFence } from '../doc/structuredData.js';
-import type { MarkdownCodeBlock } from '../markdown/types.js';
-
-function toDoc(md: string) {
-  return markdownToDoc(parseMarkdown(md));
-}
-
-describe('parseYamlSubset', () => {
-  it('parses scalars with type coercion', () => {
-    expect(parseYamlSubset('title: Hello world\ncount: 3\nlive: true\nnothing: null')).toEqual({
-      title: 'Hello world',
-      count: 3,
-      live: true,
-      nothing: null,
-    });
-  });
-
-  it('parses inline arrays', () => {
-    expect(parseYamlSubset('headers: [Name, Age]')).toEqual({ headers: ['Name', 'Age'] });
-  });
-
-  it('parses block sequences of scalars and inline arrays', () => {
-    expect(
-      parseYamlSubset('rows:\n  - [Alice, 30]\n  - [Bob, 25]\nmarkers:\n  - "47.6,-122.3"'),
-    ).toEqual({
-      rows: [
-        ['Alice', 30],
-        ['Bob', 25],
-      ],
-      markers: ['47.6,-122.3'],
-    });
-  });
-
-  it('preserves quoted strings (commas, numbers stay strings)', () => {
-    expect(parseYamlSubset('label: "1,234"')).toEqual({ label: '1,234' });
-  });
-
-  it('skips comments and blank lines', () => {
-    expect(parseYamlSubset('# comment\n\nkey: value')).toEqual({ key: 'value' });
-  });
-
-  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/);
-  });
-});
-
-describe('data fences → block.templateData', () => {
-  it('parses a ```json data fence into templateData', () => {
-    const md = [
-      '## Numbers {[dataTable]}',
-      '',
-      '```json data',
-      '{ "headers": ["Q", "Revenue"], "rows": [["Q1", "1.2M"]] }',
-      '```',
-    ].join('\n');
-    const doc = toDoc(md);
-    expect(doc.blocks[0].templateData).toEqual({
-      headers: ['Q', 'Revenue'],
-      rows: [['Q1', '1.2M']],
-    });
-    expect(doc.diagnostics).toBeUndefined();
-  });
-
-  it('parses a ```yaml data fence into templateData', () => {
-    const md = [
-      '## Map {[map]}',
-      '',
-      '```yaml data',
-      'zoom: 12',
-      'markers:',
-      '  - "47.6,-122.3"',
-      '```',
-    ].join('\n');
-    const doc = toDoc(md);
-    expect(doc.blocks[0].templateData).toEqual({ zoom: 12, markers: ['47.6,-122.3'] });
-  });
-
-  it('ignores plain ```json fences without the data marker', () => {
-    const md = '## Code {[sectionHeader]}\n\n```json\n{ "just": "a sample" }\n```';
-    const doc = toDoc(md);
-    expect(doc.blocks[0].templateData).toBeUndefined();
-  });
-
-  it('records a diagnostic for unparseable fences and degrades gracefully', () => {
-    const md = '## Bad {[dataTable]}\n\n```json data\n{ not valid json\n```';
-    const doc = toDoc(md);
-    expect(doc.blocks[0].templateData).toBeUndefined();
-    expect(doc.diagnostics).toHaveLength(1);
-    expect(doc.diagnostics![0]).toMatchObject({ severity: 'error', code: 'data-fence-parse' });
-    expect(doc.diagnostics![0].line).toBe(3);
-  });
-});
-
-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');
-
-  it('supplies headers/rows/align from the first table in the body', () => {
-    const doc = toDoc(`## People {[dataTable]}\n\n${table}`);
-    expect(doc.blocks[0].templateData).toEqual({
-      headers: ['Name', 'Age'],
-      rows: [
-        ['Alice', '30'],
-        ['Bob', '25'],
-      ],
-      align: [null, 'right'],
-    });
-  });
-
-  it('does not extract tables for non-dataTable templates', () => {
-    const doc = toDoc(`## People {[sectionHeader]}\n\n${table}`);
-    expect(doc.blocks[0].templateData).toBeUndefined();
-  });
-
-  it('explicit fence data wins over the body table', () => {
-    const md = [
-      '## People {[dataTable]}',
-      '',
-      '```json data',
-      '{ "headers": ["X"], "rows": [["1"]] }',
-      '```',
-      '',
-      table,
-    ].join('\n');
-    const doc = toDoc(md);
-    expect(doc.blocks[0].templateData).toEqual({ headers: ['X'], rows: [['1']] });
-  });
-});
-
-describe('deterministic conversion', () => {
-  const md = '# Title\n\nSome body text.\n\n## Section {[quote]}\n\nA quote here.';
-
-  it('produces identical Docs for identical input', () => {
-    expect(toDoc(md)).toEqual(toDoc(md));
-  });
-
-  it('omits captions.generatedAt unless a timestamp is supplied', () => {
-    const doc = toDoc(md);
-    expect(doc.captions).toBeDefined();
-    expect(doc.captions!.generatedAt).toBeUndefined();
-
-    const stamped = markdownToDoc(parseMarkdown(md), {
-      captionsGeneratedAt: '2026-06-10T00:00:00.000Z',
-    });
-    expect(stamped.captions!.generatedAt).toBe('2026-06-10T00:00:00.000Z');
-  });
-});
-
-describe('conversion diagnostics', () => {
-  it('flags duplicate pinned ids', () => {
-    const doc = toDoc('## A {#dup}\n\n## B {#dup}');
-    expect(doc.diagnostics).toBeDefined();
-    expect(doc.diagnostics![0]).toMatchObject({ severity: 'error', code: 'duplicate-id' });
-  });
-
-  it('a pinned id reserves the slug so a later heading does not collide', () => {
-    const doc = toDoc('## Other name {#intro}\n\n## Intro');
-    const ids = doc.blocks.map((b) => b.id);
-    expect(ids[0]).toBe('intro');
-    expect(ids[1]).not.toBe('intro');
-    expect(doc.diagnostics).toBeUndefined();
-  });
-
-  it('flags connectsTo targets that do not resolve', () => {
-    const doc = toDoc('## A {#a connectsTo=ghost}\n\n## B {#b}');
-    expect(doc.diagnostics).toBeDefined();
-    expect(doc.diagnostics![0]).toMatchObject({
-      severity: 'warning',
-      code: 'unresolved-connection',
-      blockId: 'a',
-    });
-  });
-
-  it('resolved connections produce no diagnostics', () => {
-    const doc = toDoc('## A {#a connectsTo=b}\n\n## B {#b}');
-    expect(doc.diagnostics).toBeUndefined();
-  });
-});

package/src/__tests__/surface.test.ts

@@ -1,68 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import {
-  applySurface,
-  DARK_SURFACE,
-  DEFAULT_THEME,
-  LIGHT_SURFACE,
-  type SurfaceScheme,
-} from '../schemas/index.js';
-
-describe('SurfaceScheme', () => {
-  it('LIGHT_SURFACE and DARK_SURFACE expose the full field set', () => {
-    for (const s of [LIGHT_SURFACE, DARK_SURFACE]) {
-      expect(typeof s.id).toBe('string');
-      expect(typeof s.background).toBe('string');
-      expect(typeof s.backgroundLight).toBe('string');
-      expect(typeof s.text).toBe('string');
-      expect(typeof s.textMuted).toBe('string');
-    }
-  });
-});
-
-describe('applySurface', () => {
-  it('overlays surface fields onto a theme', () => {
-    const out = applySurface(DEFAULT_THEME, LIGHT_SURFACE);
-    expect(out.colors.background).toBe(LIGHT_SURFACE.background);
-    expect(out.colors.backgroundLight).toBe(LIGHT_SURFACE.backgroundLight);
-    expect(out.colors.text).toBe(LIGHT_SURFACE.text);
-    expect(out.colors.textMuted).toBe(LIGHT_SURFACE.textMuted);
-  });
-
-  it('leaves editorial colors (primary, highlight, warning) untouched', () => {
-    const out = applySurface(DEFAULT_THEME, DARK_SURFACE);
-    expect(out.colors.primary).toBe(DEFAULT_THEME.colors.primary);
-    expect(out.colors.secondary).toBe(DEFAULT_THEME.colors.secondary);
-    expect(out.colors.highlight).toBe(DEFAULT_THEME.colors.highlight);
-    expect(out.colors.warning).toBe(DEFAULT_THEME.colors.warning);
-  });
-
-  it('leaves typography, style, renderStyle, colorSchemes untouched', () => {
-    const out = applySurface(DEFAULT_THEME, LIGHT_SURFACE);
-    expect(out.typography).toBe(DEFAULT_THEME.typography);
-    expect(out.style).toBe(DEFAULT_THEME.style);
-    expect(out.renderStyle).toBe(DEFAULT_THEME.renderStyle);
-    expect(out.colorSchemes).toBe(DEFAULT_THEME.colorSchemes);
-  });
-
-  it('returns a new theme (does not mutate the base)', () => {
-    const frozenTheme = DEFAULT_THEME;
-    const originalBg = frozenTheme.colors.background;
-    const out = applySurface(frozenTheme, DARK_SURFACE);
-    expect(out).not.toBe(frozenTheme);
-    expect(out.colors).not.toBe(frozenTheme.colors);
-    expect(frozenTheme.colors.background).toBe(originalBg);
-  });
-
-  it('accepts custom SurfaceScheme objects', () => {
-    const custom: SurfaceScheme = {
-      id: 'parchment',
-      background: '#f4ecd8',
-      backgroundLight: '#e8dfc4',
-      text: '#2b2b2b',
-      textMuted: '#6b6b6b',
-    };
-    const out = applySurface(DEFAULT_THEME, custom);
-    expect(out.colors.background).toBe('#f4ecd8');
-    expect(out.colors.textMuted).toBe('#6b6b6b');
-  });
-});

package/src/__tests__/templateAnnotationParse.test.ts

@@ -1,173 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { parseMarkdown } from '../markdown/parse.js';
-import { stringifyMarkdown } from '../markdown/stringify.js';
-import { markdownToDoc } from '../doc/markdownToDoc.js';
-
-function getHeading(md: string) {
-  const doc = parseMarkdown(md);
-  const heading = doc.children[0];
-  if (heading.type !== 'heading') throw new Error('expected heading');
-  return heading;
-}
-
-describe('Template annotation in Heading parse path', () => {
-  it('extracts and round-trips an empty annotation without leaving literal heading text', () => {
-    const source = '## Getting Started {[]}';
-    const heading = getHeading(source);
-
-    expect(heading.templateAnnotation).toEqual({});
-    expect(heading.children).toHaveLength(1);
-    expect(heading.children[0]).toMatchObject({ type: 'text', value: 'Getting Started' });
-    expect(stringifyMarkdown(parseMarkdown(source)).trim()).toBe(source);
-  });
-
-  it('parseMarkdown extracts {[template]} from a heading', () => {
-    const md = '## Getting Started {[comparisonBar]}';
-    const doc = parseMarkdown(md);
-    const heading = doc.children[0];
-    expect(heading.type).toBe('heading');
-    if (heading.type !== 'heading') return;
-    expect(heading.templateAnnotation).toEqual({ template: 'comparisonBar' });
-  });
-
-  it('markdownToDoc preserves templateAnnotation on the resulting block', () => {
-    const md = '# Title\n\n## Getting Started {[comparisonBar]}\n\nBody.';
-    const parsed = parseMarkdown(md);
-    const doc = markdownToDoc(parsed, { articleId: 'test' });
-    // The h1 is the root; first child is the h2 with annotation
-    const h1 = doc.blocks[0];
-    expect(h1.sourceHeading?.depth).toBe(1);
-    const h2 = h1.children?.[0];
-    expect(h2?.sourceHeading?.depth).toBe(2);
-    expect(h2?.sourceHeading?.templateAnnotation).toEqual({ template: 'comparisonBar' });
-  });
-
-  it('tolerates accidentally-doubled trailing `]}` (user typo)', () => {
-    const md = '## Getting Started {[comparisonBar]}]}';
-    const doc = parseMarkdown(md);
-    const heading = doc.children[0];
-    if (heading.type !== 'heading') throw new Error('expected heading');
-    expect(heading.templateAnnotation).toEqual({ template: 'comparisonBar' });
-  });
-
-  it('still rejects non-trailing annotations (regex stays anchored)', () => {
-    const md = '## The {[chart]} section'; // word continues after — not an annotation
-    const doc = parseMarkdown(md);
-    const heading = doc.children[0];
-    if (heading.type !== 'heading') throw new Error('expected heading');
-    expect(heading.templateAnnotation).toBeUndefined();
-  });
-
-  it('keeps annotation-shaped text inside a code fence as literal code', () => {
-    const source = '```markdown\n## Example {[comparisonBar]}\n{[ ]}\n```';
-    const parsed = parseMarkdown(source);
-
-    expect(parsed.children).toHaveLength(1);
-    expect(parsed.children[0]).toMatchObject({
-      type: 'code',
-      lang: 'markdown',
-      value: '## Example {[comparisonBar]}\n{[ ]}',
-    });
-    expect(stringifyMarkdown(parsed).trim()).toBe(source);
-  });
-});
-
-describe('Quoted values in {[…]} annotations', () => {
-  it('parses double-quoted values with spaces (the documented syntax)', () => {
-    const h = getHeading(
-      '## Gallery {[imageWithCaption src="photo.jpg" caption="Beach at sunset"]}',
-    );
-    expect(h.templateAnnotation).toEqual({
-      template: 'imageWithCaption',
-      params: { src: 'photo.jpg', caption: 'Beach at sunset' },
-    });
-  });
-
-  it('parses single-quoted values with spaces', () => {
-    const h = getHeading("## X {[quote text='A long caption']}");
-    expect(h.templateAnnotation?.params).toEqual({ text: 'A long caption' });
-  });
-
-  it('parses a quoted value containing ]', () => {
-    const h = getHeading('## X {[quote text="a ] b"]}');
-    expect(h.templateAnnotation?.params).toEqual({ text: 'a ] b' });
-  });
-
-  it('parses a quoted value containing commas without splitting', () => {
-    const h = getHeading('## X {[quote text="hello, friend"]}');
-    expect(h.templateAnnotation?.params).toEqual({ text: 'hello, friend' });
-  });
-
-  it('treats an apostrophe inside an unquoted value as literal', () => {
-    const h = getHeading("## X {[quote attribution=O'Brien align=left]}");
-    expect(h.templateAnnotation?.params).toEqual({ attribution: "O'Brien", align: 'left' });
-  });
-
-  it('parses a double quote inside a single-quoted value', () => {
-    const h = getHeading('## X {[quote text=\'She said "hi"\']}');
-    expect(h.templateAnnotation?.params).toEqual({ text: 'She said "hi"' });
-  });
-
-  it('parses backslash-escaped emphasis characters inside quoted values', () => {
-    // Bare * would be parsed as markdown emphasis and fragment the heading
-    // text run; the documented escape hatch is to backslash it. remark
-    // resolves the escape before annotation extraction.
-    const h = getHeading('## X {[quote text="a \\*b\\* c"]}');
-    expect(h.templateAnnotation?.params).toEqual({ text: 'a *b* c' });
-  });
-
-  it('parses a template-less key=value annotation with a quoted value', () => {
-    const h = getHeading('## X {[audio="intro track.mp3"]}');
-    expect(h.templateAnnotation).toEqual({ params: { audio: 'intro track.mp3' } });
-  });
-});
-
-describe('Round-trip of quoted template params', () => {
-  function roundTrip(src: string): string {
-    return stringifyMarkdown(parseMarkdown(src)).trim();
-  }
-
-  it('spacey double-quoted values round-trip verbatim', () => {
-    const src = '## Gallery {[imageWithCaption src=photo.jpg caption="Beach at sunset"]}';
-    expect(roundTrip(src)).toBe(src);
-  });
-
-  it('single quotes canonicalize to double quotes', () => {
-    expect(roundTrip("## X {[quote text='A long caption']}")).toBe(
-      '## X {[quote text="A long caption"]}',
-    );
-  });
-
-  it('a value containing a double quote round-trips via single quotes', () => {
-    const src = '## X {[quote text=\'She said "hi"\']}';
-    expect(roundTrip(src)).toBe(src);
-  });
-
-  it('a quoted ] round-trips', () => {
-    const src = '## X {[quote text="a ] b"]}';
-    expect(roundTrip(src)).toBe(src);
-  });
-
-  it('emphasis characters survive a full stringify → parse cycle', () => {
-    // The emitted source keeps \* escaped (so the heading text run stays
-    // intact); reparsing resolves the escape back to the bare character.
-    const src = '## X {[quote text="a \\*b\\* c"]}';
-    const emitted = roundTrip(src);
-    expect(emitted).toBe(src);
-    const h = getHeading(emitted);
-    expect(h.templateAnnotation?.params).toEqual({ text: 'a *b* c' });
-  });
-
-  it('stringify quotes spacey values produced programmatically', () => {
-    const doc = parseMarkdown('## X {[quote]}');
-    const heading = doc.children[0];
-    if (heading.type !== 'heading') throw new Error('expected heading');
-    heading.templateAnnotation = {
-      template: 'quote',
-      params: { text: 'Beach at sunset', attribution: 'someone' },
-    };
-    expect(stringifyMarkdown(doc).trim()).toBe(
-      '## X {[quote text="Beach at sunset" attribution=someone]}',
-    );
-  });
-});

package/src/__tests__/templateInputs.test.ts

@@ -1,69 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { parseMarkdown } from '../markdown/parse.js';
-import { deriveTemplateInputs } from '../doc/templateInputs.js';
-
-function statInputs(heading: string, body: string): Record<string, unknown> | null {
-  return deriveTemplateInputs('statHighlight', heading, parseMarkdown(body).children);
-}
-
-describe('statHighlight template input derivation', () => {
-  it('uses a leading bold metric as the hero stat', () => {
-    expect(
-      statInputs('The Big Number', '**42%** of teams prefer visual blocks over raw slides.'),
-    ).toEqual({
-      stat: '42%',
-      description: 'of teams prefer visual blocks over raw slides.',
-    });
-  });
-
-  it('accepts an explicitly bold small integer', () => {
-    expect(statInputs('Answer Count', '**42** answers were submitted')).toEqual({
-      stat: '42',
-      description: 'answers were submitted',
-    });
-  });
-
-  it('promotes only the metric when the bold run contains a longer phrase', () => {
-    expect(statInputs('Revenue', '**Revenue grew 42%** year over year')).toEqual({
-      stat: '42%',
-      description: 'Revenue grew year over year',
-    });
-  });
-
-  it('drops an inline separator between the metric and description', () => {
-    expect(
-      statInputs('The Big Number', '**42%** — The percentage of developers who prefer it.'),
-    ).toEqual({
-      stat: '42%',
-      description: 'The percentage of developers who prefer it.',
-    });
-  });
-
-  it('preserves a stat-looking heading for existing documents', () => {
-    expect(statInputs('89%', 'of customers recommend it')).toEqual({
-      stat: '89%',
-      description: 'of customers recommend it',
-    });
-  });
-
-  it('extracts an unformatted body metric for automatic templates', () => {
-    expect(statInputs('Funding', '$2.3M raised')).toEqual({
-      stat: '$2.3M',
-      description: 'raised',
-    });
-  });
-
-  it('does not let a year in a structural heading eclipse the body metric', () => {
-    expect(statInputs('2024 Results', '42% of teams reached their goal')).toEqual({
-      stat: '42%',
-      description: 'of teams reached their goal',
-    });
-  });
-
-  it('retains the historical fallback when no metric can be found', () => {
-    expect(statInputs('A Result', 'Supporting context')).toEqual({
-      stat: 'A Result',
-      description: 'Supporting context',
-    });
-  });
-});

package/src/__tests__/templateMetadata.test.ts

@@ -1,32 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { templateRegistry, TEMPLATE_METADATA } from '../doc/templates/index';
-import { TEMPLATE_ALIASES } from '../doc/templates/templateNames';
-
-describe('TEMPLATE_METADATA', () => {
-  it('stays exactly 1:1 with templateRegistry (same ids)', () => {
-    const registryIds = Object.keys(templateRegistry).sort();
-    const metadataIds = Object.keys(TEMPLATE_METADATA).sort();
-    // If this fails, a template was added to the registry without metadata
-    // (or vice versa). Add the missing entry — the editor's TemplatePicker
-    // renders its gallery from TEMPLATE_METADATA, so a registry-only template
-    // would never appear in the picker.
-    expect(metadataIds).toEqual(registryIds);
-  });
-
-  it('every entry has a non-empty label and description', () => {
-    for (const [id, meta] of Object.entries(TEMPLATE_METADATA)) {
-      expect(meta.label, `label for "${id}"`).toBeTruthy();
-      expect(meta.description, `description for "${id}"`).toBeTruthy();
-    }
-  });
-});
-
-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);
-    }
-  });
-});