@bendyline/squisq 2.0.1 → 2.2.0

package/src/__tests__/customThemesFrontmatter.test.ts

@@ -1,146 +0,0 @@
-/**
- * Custom themes round-trip through frontmatter.
- *
- * The theme analog of customTemplatesFrontmatter.test.ts: verifies that a
- * Theme stored in markdown frontmatter under `squisq-custom-themes` is
- * faithfully reconstructed by `markdownToDoc` and serialized back by
- * `docToMarkdown` without loss, and that the reader is tolerant of malformed
- * entries.
- */
-
-import { describe, it, expect } from 'vitest';
-import { markdownToDoc } from '../doc/markdownToDoc';
-import { docToMarkdown } from '../doc/docToMarkdown';
-import {
-  readCustomThemesFromFrontmatter,
-  writeCustomThemesToFrontmatter,
-  FRONTMATTER_CUSTOM_THEMES_KEY,
-} from '../doc/customThemesFrontmatter';
-import { parseMarkdown } from '../markdown/parse';
-import { compileTheme } from '../schemas/themeCompile';
-import type { Doc } from '../schemas/Doc.js';
-import type { Theme } from '../schemas/Theme.js';
-
-const brand: Theme = compileTheme({
-  id: 'my-brand',
-  name: 'My Brand',
-  seedColors: { primary: '#3182ce', secondary: '#805ad5' },
-});
-
-describe('writeCustomThemesToFrontmatter → readCustomThemesFromFrontmatter', () => {
-  it('round-trips a single theme through the compact JSON wire format', () => {
-    const payload = writeCustomThemesToFrontmatter([brand]);
-    expect(typeof payload).toBe('string');
-    expect(payload!.startsWith('{"my-brand":')).toBe(true);
-    const out = readCustomThemesFromFrontmatter({ [FRONTMATTER_CUSTOM_THEMES_KEY]: payload });
-    expect(out).toHaveLength(1);
-    expect(out![0]).toEqual(brand);
-  });
-
-  it('default output is compact (single line) and byte-unchanged', () => {
-    const payload = writeCustomThemesToFrontmatter([brand])!;
-    expect(payload).not.toContain('\n');
-    expect(writeCustomThemesToFrontmatter([brand], { pretty: false })).toBe(payload);
-  });
-
-  it('pretty:true emits multi-line JSON that still reads back', () => {
-    const payload = writeCustomThemesToFrontmatter([brand], { pretty: true })!;
-    expect(payload).toContain('\n');
-    const out = readCustomThemesFromFrontmatter({ [FRONTMATTER_CUSTOM_THEMES_KEY]: payload });
-    expect(out).toHaveLength(1);
-    expect(out![0]).toEqual(brand);
-  });
-
-  it('a hand-written block-scalar frontmatter parses back into the theme', () => {
-    const payload = writeCustomThemesToFrontmatter([brand], { pretty: true })!;
-    const body = payload
-      .split('\n')
-      .map((l) => `  ${l}`)
-      .join('\n');
-    const md = `---\n${FRONTMATTER_CUSTOM_THEMES_KEY}: |-\n${body}\n---\n\n# Hi\n`;
-    const parsed = parseMarkdown(md);
-    const out = readCustomThemesFromFrontmatter(parsed.frontmatter);
-    expect(out).toHaveLength(1);
-    expect(out![0]).toEqual(brand);
-  });
-
-  it('round-trips multiple themes keyed by id', () => {
-    const second = compileTheme({
-      id: 'second',
-      name: 'Second',
-      seedColors: { primary: '#e53e3e' },
-    });
-    const payload = writeCustomThemesToFrontmatter([brand, second]);
-    const out = readCustomThemesFromFrontmatter({ [FRONTMATTER_CUSTOM_THEMES_KEY]: payload });
-    expect(out!.map((t) => t.id).sort()).toEqual(['my-brand', 'second']);
-  });
-
-  it('also accepts an already-decoded object map (forward-compatible)', () => {
-    const out = readCustomThemesFromFrontmatter({
-      [FRONTMATTER_CUSTOM_THEMES_KEY]: { 'my-brand': brand },
-    });
-    expect(out).toHaveLength(1);
-    expect(out![0].id).toBe('my-brand');
-  });
-
-  it('drops invalid themes rather than failing the whole load', () => {
-    const payload = JSON.stringify({ 'my-brand': brand, junk: { id: 'junk' } });
-    const out = readCustomThemesFromFrontmatter({ [FRONTMATTER_CUSTOM_THEMES_KEY]: payload });
-    expect(out).toHaveLength(1);
-    expect(out![0].id).toBe('my-brand');
-  });
-
-  it('returns undefined when the key is absent or unparseable', () => {
-    expect(readCustomThemesFromFrontmatter({})).toBeUndefined();
-    expect(readCustomThemesFromFrontmatter(undefined)).toBeUndefined();
-    expect(
-      readCustomThemesFromFrontmatter({ [FRONTMATTER_CUSTOM_THEMES_KEY]: 'not json' }),
-    ).toBeUndefined();
-  });
-});
-
-describe('Doc.customThemes round-trip via markdownToDoc + docToMarkdown', () => {
-  it('survives a markdownToDoc → docToMarkdown cycle and keeps the selection', () => {
-    const encoded = writeCustomThemesToFrontmatter([brand])!;
-    // Compact JSON is stored unquoted — it round-trips verbatim through the
-    // line-based frontmatter parser, exactly like custom templates.
-    const sourceMd = `---
-title: My Doc
-squisq-theme: my-brand
-squisq-custom-themes: ${encoded}
----
-
-# Welcome
-
-A small editor for big ideas.
-`;
-    const doc = markdownToDoc(parseMarkdown(sourceMd));
-    expect(doc.themeId).toBe('my-brand');
-    expect(doc.customThemes).toHaveLength(1);
-    expect(doc.customThemes![0]).toEqual(brand);
-
-    const mdOut = docToMarkdown(doc);
-    const payload = mdOut.frontmatter![FRONTMATTER_CUSTOM_THEMES_KEY];
-    expect(typeof payload).toBe('string');
-    const reread = readCustomThemesFromFrontmatter({ [FRONTMATTER_CUSTOM_THEMES_KEY]: payload });
-    expect(reread).toEqual(doc.customThemes);
-    // The active selection is preserved untouched.
-    expect(mdOut.frontmatter!['squisq-theme']).toBe('my-brand');
-  });
-
-  it('drops the frontmatter key when the doc has no custom themes anymore', () => {
-    const doc: Doc = {
-      articleId: 'd',
-      duration: 0,
-      blocks: [],
-      audio: { segments: [] },
-      frontmatter: {
-        title: 'Doc',
-        [FRONTMATTER_CUSTOM_THEMES_KEY]: 'stale-blob',
-      },
-    };
-    const md = docToMarkdown(doc);
-    expect(md.frontmatter).not.toHaveProperty(FRONTMATTER_CUSTOM_THEMES_KEY);
-    expect(md.frontmatter!.title).toBe('Doc');
-  });
-});

package/src/__tests__/dataTable.test.ts

@@ -1,145 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import type { MaterializeBlockLayersOptions } from '../doc/materializeBlockLayers.js';
-import { materializeLayers } from './materializeTestUtils.js';
-import { DEFAULT_THEME } from '../schemas/themeLibrary.js';
-import { VIEWPORT_PRESETS } from '../schemas/Viewport.js';
-import type { TemplateBlock } from '../schemas/BlockTemplates.js';
-import type { TableLayer } from '../schemas/Doc.js';
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-function makeDataTableBlock(overrides: Record<string, unknown> = {}): TemplateBlock {
-  return {
-    template: 'dataTable',
-    id: 'dt-1',
-    duration: 5,
-    audioSegment: 0,
-    headers: ['Name', 'Value'],
-    rows: [
-      ['Alpha', '100'],
-      ['Beta', '200'],
-    ],
-    ...overrides,
-  } as TemplateBlock;
-}
-
-const defaultContext: MaterializeBlockLayersOptions = {
-  theme: DEFAULT_THEME,
-  viewport: VIEWPORT_PRESETS.landscape,
-  blockIndex: 0,
-  totalBlocks: 5,
-};
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-describe('dataTable template', () => {
-  it('produces layers including a table layer', () => {
-    const layers = materializeLayers(makeDataTableBlock(), defaultContext);
-    expect(layers.length).toBeGreaterThan(0);
-
-    const tableLayer = layers.find((l) => l.type === 'table');
-    expect(tableLayer).toBeDefined();
-  });
-
-  it('table layer contains the correct headers', () => {
-    const layers = materializeLayers(makeDataTableBlock(), defaultContext);
-    const tableLayer = layers.find((l) => l.type === 'table') as TableLayer;
-
-    expect(tableLayer.content.headers).toEqual(['Name', 'Value']);
-  });
-
-  it('table layer contains the correct rows', () => {
-    const layers = materializeLayers(makeDataTableBlock(), defaultContext);
-    const tableLayer = layers.find((l) => l.type === 'table') as TableLayer;
-
-    expect(tableLayer.content.rows).toEqual([
-      ['Alpha', '100'],
-      ['Beta', '200'],
-    ]);
-  });
-
-  it('includes a title text layer when title is provided', () => {
-    const layers = materializeLayers(makeDataTableBlock({ title: 'My Table' }), defaultContext);
-    const textLayers = layers.filter((l) => l.type === 'text');
-
-    expect(textLayers.length).toBeGreaterThanOrEqual(1);
-    const titleLayer = textLayers.find((l) => l.type === 'text' && l.content.text === 'My Table');
-    expect(titleLayer).toBeDefined();
-  });
-
-  it('omits title layer when no title is given', () => {
-    const layers = materializeLayers(makeDataTableBlock({ title: undefined }), defaultContext);
-    const textLayers = layers.filter((l) => l.type === 'text');
-
-    // Should have no text layers (only bg + table)
-    expect(textLayers.length).toBe(0);
-  });
-
-  it('includes a background layer', () => {
-    const layers = materializeLayers(makeDataTableBlock(), defaultContext);
-    // Background is the first layer (shape with gradient fill)
-    expect(['shape', 'image']).toContain(layers[0].type);
-  });
-
-  it('passes column alignment to the table layer', () => {
-    const layers = materializeLayers(
-      makeDataTableBlock({ align: ['left', 'right'] }),
-      defaultContext,
-    );
-    const tableLayer = layers.find((l) => l.type === 'table') as TableLayer;
-
-    expect(tableLayer.content.align).toEqual(['left', 'right']);
-  });
-
-  it('applies theme colors to table styling', () => {
-    const layers = materializeLayers(makeDataTableBlock(), defaultContext);
-    const tableLayer = layers.find((l) => l.type === 'table') as TableLayer;
-    const style = tableLayer.content.style;
-
-    // Style fields should be populated strings/numbers
-    expect(style.headerBackground).toBeTruthy();
-    expect(style.headerColor).toBeTruthy();
-    expect(style.cellColor).toBeTruthy();
-    expect(style.borderColor).toBeTruthy();
-    expect(typeof style.fontSize).toBe('number');
-    expect(style.fontSize).toBeGreaterThan(0);
-  });
-
-  it('adjusts table position when title is present vs absent', () => {
-    const withTitle = materializeLayers(makeDataTableBlock({ title: 'Title' }), defaultContext);
-    const withoutTitle = materializeLayers(
-      makeDataTableBlock({ title: undefined }),
-      defaultContext,
-    );
-
-    const tableWithTitle = withTitle.find((l) => l.type === 'table') as TableLayer;
-    const tableWithoutTitle = withoutTitle.find((l) => l.type === 'table') as TableLayer;
-
-    // Table should be positioned lower when a title is present
-    expect(tableWithTitle.position.y).not.toBe(tableWithoutTitle.position.y);
-  });
-
-  it('works with portrait viewport', () => {
-    const portraitContext: MaterializeBlockLayersOptions = {
-      ...defaultContext,
-      viewport: VIEWPORT_PRESETS.portrait,
-    };
-    const layers = materializeLayers(makeDataTableBlock(), portraitContext);
-    expect(layers.length).toBeGreaterThan(0);
-    const tableLayer = layers.find((l) => l.type === 'table');
-    expect(tableLayer).toBeDefined();
-  });
-
-  it('handles empty rows gracefully', () => {
-    const layers = materializeLayers(
-      makeDataTableBlock({ headers: ['A', 'B'], rows: [] }),
-      defaultContext,
-    );
-    const tableLayer = layers.find((l) => l.type === 'table') as TableLayer;
-    expect(tableLayer.content.rows).toEqual([]);
-  });
-});

package/src/__tests__/diagramBlock.test.ts

@@ -1,122 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { diagramBlock } from '../doc/templates/diagramBlock.js';
-import { createTemplateContext } from '../schemas/BlockTemplates.js';
-import { DEFAULT_THEME } from '../schemas/themeLibrary.js';
-import { VIEWPORT_PRESETS } from '../schemas/Viewport.js';
-import type { Block, Layer, ShapeLayer, PathLayer, TextLayer } from '../schemas/Doc.js';
-import type { DiagramBlockInput } from '../schemas/BlockTemplates.js';
-
-function makeBlock(overrides: Partial<Block> & { id: string }): Block {
-  return {
-    startTime: 0,
-    duration: 0,
-    audioSegment: 0,
-    ...overrides,
-  } as Block;
-}
-
-function makeInput(overrides: Partial<DiagramBlockInput> = {}): DiagramBlockInput {
-  return {
-    template: 'diagram',
-    id: 'family-tree',
-    duration: 0,
-    audioSegment: 0,
-    ...overrides,
-  };
-}
-
-describe('diagramBlock template', () => {
-  it('emits node card + label layers for each child', () => {
-    const ctx = createTemplateContext(DEFAULT_THEME, 0, 1, VIEWPORT_PRESETS.landscape);
-    ctx.children = [
-      makeBlock({ id: 'a', title: 'Alpha', x: 100, y: 100 }),
-      makeBlock({ id: 'b', title: 'Beta', x: 400, y: 100 }),
-    ];
-    const layers = diagramBlock(makeInput(), ctx);
-    const cards = layers.filter((l) => l.type === 'shape') as ShapeLayer[];
-    const texts = layers.filter((l) => l.type === 'text') as TextLayer[];
-    expect(cards.length).toBe(2);
-    expect(texts.length).toBe(2);
-    expect(texts[0].content.text).toBe('Alpha');
-    expect(texts[1].content.text).toBe('Beta');
-  });
-
-  it('emits a path layer with arrow for each connectsTo entry', () => {
-    const ctx = createTemplateContext(DEFAULT_THEME, 0, 1, VIEWPORT_PRESETS.landscape);
-    ctx.children = [
-      makeBlock({ id: 'a', x: 100, y: 100, connectsTo: [{ target: 'b' }] }),
-      makeBlock({ id: 'b', x: 400, y: 100 }),
-    ];
-    const layers = diagramBlock(makeInput(), ctx);
-    const paths = layers.filter((l) => l.type === 'path') as PathLayer[];
-    expect(paths.length).toBe(1);
-    expect(paths[0].content.endMarker).toBe('arrow');
-    expect(paths[0].content.d.startsWith('M ')).toBe(true);
-  });
-
-  it('emits a typed edge label when connection has a type', () => {
-    const ctx = createTemplateContext(DEFAULT_THEME, 0, 1, VIEWPORT_PRESETS.landscape);
-    ctx.children = [
-      makeBlock({ id: 'a', x: 100, y: 100, connectsTo: [{ target: 'b', type: 'requires' }] }),
-      makeBlock({ id: 'b', x: 400, y: 100 }),
-    ];
-    const layers = diagramBlock(makeInput(), ctx);
-    const labels = layers.filter(
-      (l): l is TextLayer => l.type === 'text' && l.id.startsWith('edge-label-'),
-    );
-    expect(labels.length).toBe(1);
-    expect(labels[0].content.text).toBe('requires');
-  });
-
-  it('returns a single hint text layer when there are no children', () => {
-    const ctx = createTemplateContext(DEFAULT_THEME, 0, 1, VIEWPORT_PRESETS.landscape);
-    ctx.children = [];
-    const layers = diagramBlock(makeInput({ title: 'Empty' }), ctx);
-    expect(layers.length).toBe(1);
-    expect(layers[0].type).toBe('text');
-  });
-
-  it('emits a title layer when input.title is set', () => {
-    const ctx = createTemplateContext(DEFAULT_THEME, 0, 1, VIEWPORT_PRESETS.landscape);
-    ctx.children = [makeBlock({ id: 'a', title: 'A', x: 100, y: 100 })];
-    const layers = diagramBlock(makeInput({ title: 'My Diagram' }), ctx);
-    const titleLayer = layers.find((l): l is TextLayer => l.id === 'diagram-title');
-    expect(titleLayer).toBeDefined();
-    expect(titleLayer?.content.text).toBe('My Diagram');
-  });
-
-  it('handles children without explicit positions via auto-layout', () => {
-    const ctx = createTemplateContext(DEFAULT_THEME, 0, 1, VIEWPORT_PRESETS.landscape);
-    ctx.children = [
-      makeBlock({ id: 'a', title: 'A' }),
-      makeBlock({ id: 'b', title: 'B' }),
-      makeBlock({ id: 'c', title: 'C' }),
-    ];
-    const layers = diagramBlock(makeInput(), ctx);
-    const cards = layers.filter((l) => l.type === 'shape');
-    expect(cards.length).toBe(3);
-  });
-});
-
-describe('diagramBlock integration with materializeBlockLayers', () => {
-  it('renders through the full template registry', async () => {
-    const { materializeBlockLayers } = await import('../doc/materializeBlockLayers.js');
-    const parentBlock: Block = {
-      id: 'family',
-      startTime: 0,
-      duration: 0,
-      audioSegment: 0,
-      template: 'diagram',
-      title: 'Family Tree',
-      children: [
-        makeBlock({ id: 'a', title: 'A', x: 100, y: 100 }),
-        makeBlock({ id: 'b', title: 'B', x: 400, y: 100, connectsTo: [{ target: 'a' }] }),
-      ],
-    };
-    const layers = materializeBlockLayers(parentBlock, { persistentLayers: false }).layers;
-    // Should contain at least one shape (node card) and one path (edge).
-    const types = new Set(layers.map((l: Layer) => l.type));
-    expect(types.has('shape')).toBe(true);
-    expect(types.has('path')).toBe(true);
-  });
-});

package/src/__tests__/diagramLayout.test.ts

@@ -1,134 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { computeDiagramLayout } from '../doc/templates/diagramLayout.js';
-import type { Block } from '../schemas/Doc.js';
-
-function makeBlock(overrides: Partial<Block> & { id: string }): Block {
-  return {
-    startTime: 0,
-    duration: 0,
-    audioSegment: 0,
-    ...overrides,
-  } as Block;
-}
-
-describe('computeDiagramLayout', () => {
-  it('keeps explicit x/y positions intact', () => {
-    const layout = computeDiagramLayout([
-      makeBlock({ id: 'a', x: 100, y: 200 }),
-      makeBlock({ id: 'b', x: 400, y: 300 }),
-    ]);
-    expect(layout.nodes).toHaveLength(2);
-    expect(layout.nodes[0]).toMatchObject({ id: 'a', x: 100, y: 200, pinned: true });
-    expect(layout.nodes[1]).toMatchObject({ id: 'b', x: 400, y: 300, pinned: true });
-  });
-
-  it('auto-positions children missing x or y in a grid below pinned nodes', () => {
-    const layout = computeDiagramLayout([
-      makeBlock({ id: 'pinned', x: 200, y: 100 }),
-      makeBlock({ id: 'a' }),
-      makeBlock({ id: 'b' }),
-      makeBlock({ id: 'c' }),
-      makeBlock({ id: 'd' }),
-    ]);
-    expect(layout.nodes.find((n) => n.id === 'pinned')?.pinned).toBe(true);
-    const auto = layout.nodes.filter((n) => n.id !== 'pinned');
-    for (const node of auto) {
-      expect(node.pinned).toBe(false);
-      // Should sit below the pinned node's y.
-      expect(node.y).toBeGreaterThan(100);
-    }
-  });
-
-  it('places fully-unpositioned children starting at the default origin', () => {
-    const layout = computeDiagramLayout([
-      makeBlock({ id: 'a', title: 'A' }),
-      makeBlock({ id: 'b', title: 'B' }),
-    ]);
-    expect(layout.nodes[0].pinned).toBe(false);
-    expect(layout.nodes[1].pinned).toBe(false);
-    expect(layout.nodes[0].x).toBeGreaterThanOrEqual(0);
-    expect(layout.nodes[0].y).toBeGreaterThanOrEqual(0);
-  });
-
-  it('extracts edges from connectsTo, including connection types', () => {
-    const layout = computeDiagramLayout([
-      makeBlock({
-        id: 'a',
-        x: 0,
-        y: 0,
-        connectsTo: [{ target: 'b', type: 'flow' }, { target: 'c' }],
-      }),
-      makeBlock({ id: 'b', x: 100, y: 0 }),
-      makeBlock({ id: 'c', x: 200, y: 0 }),
-    ]);
-    expect(layout.edges).toHaveLength(2);
-    expect(layout.edges[0]).toMatchObject({ source: 'a', target: 'b', type: 'flow' });
-    expect(layout.edges[1]).toMatchObject({ source: 'a', target: 'c' });
-    expect(layout.edges[1].type).toBeUndefined();
-  });
-
-  it('drops edges with unknown targets and reports a warning', () => {
-    const layout = computeDiagramLayout([
-      makeBlock({
-        id: 'a',
-        x: 0,
-        y: 0,
-        connectsTo: [{ target: 'ghost' }, { target: 'b' }],
-      }),
-      makeBlock({ id: 'b', x: 100, y: 0 }),
-    ]);
-    expect(layout.edges).toHaveLength(1);
-    expect(layout.edges[0].target).toBe('b');
-    expect(layout.warnings.length).toBe(1);
-    expect(layout.warnings[0]).toContain('ghost');
-  });
-
-  it('dedupes edges with identical source/target/type', () => {
-    const layout = computeDiagramLayout([
-      makeBlock({
-        id: 'a',
-        x: 0,
-        y: 0,
-        connectsTo: [
-          { target: 'b', type: 'flow' },
-          { target: 'b', type: 'flow' },
-        ],
-      }),
-      makeBlock({ id: 'b', x: 100, y: 0 }),
-    ]);
-    expect(layout.edges).toHaveLength(1);
-  });
-
-  it('distinguishes edges with different types', () => {
-    const layout = computeDiagramLayout([
-      makeBlock({
-        id: 'a',
-        x: 0,
-        y: 0,
-        connectsTo: [
-          { target: 'b', type: 'flow' },
-          { target: 'b', type: 'requires' },
-        ],
-      }),
-      makeBlock({ id: 'b', x: 100, y: 0 }),
-    ]);
-    expect(layout.edges).toHaveLength(2);
-  });
-
-  it('returns an empty layout for no children', () => {
-    const layout = computeDiagramLayout([]);
-    expect(layout.nodes).toEqual([]);
-    expect(layout.edges).toEqual([]);
-    expect(layout.warnings).toEqual([]);
-  });
-
-  it('falls back to the block id for the node label when title is missing', () => {
-    const layout = computeDiagramLayout([makeBlock({ id: 'lonely', x: 0, y: 0 })]);
-    expect(layout.nodes[0].label).toBe('lonely');
-  });
-
-  it('uses block.title for the node label when present', () => {
-    const layout = computeDiagramLayout([makeBlock({ id: 'a', x: 0, y: 0, title: 'Alpha' })]);
-    expect(layout.nodes[0].label).toBe('Alpha');
-  });
-});

package/src/__tests__/diagramText.test.ts

@@ -1,26 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { DIAGRAM_LABEL_LINE_HEIGHT, fitDiagramLabel } from '../doc/utils/diagramText';
-
-describe('fitDiagramLabel', () => {
-  it('keeps a short single-line label at its preferred size', () => {
-    expect(fitDiagramLabel('Web1', 180, 64, 22)).toMatchObject({
-      fontSize: 22,
-      lineCount: 1,
-      firstLineOffset: 0,
-    });
-  });
-
-  it('shrinks and centers a dense multi-line package label inside its card', () => {
-    const fit = fitDiagramLabel(
-      '@bendyline/molen-kernel\nheadless sim — no DOM, no thread\nWorker + Node',
-      252,
-      112,
-      38,
-    );
-
-    expect(fit.fontSize).toBeLessThan(38);
-    expect(fit.lineCount).toBeGreaterThanOrEqual(3);
-    expect(fit.lineCount * fit.fontSize * DIAGRAM_LABEL_LINE_HEIGHT).toBeLessThanOrEqual(96);
-    expect(fit.firstLineOffset).toBeLessThan(0);
-  });
-});

package/src/__tests__/docToMarkdownMedia.test.ts

@@ -1,83 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { parseMarkdown, stringifyMarkdown } from '../markdown/index';
-import { markdownToDoc } from '../doc/markdownToDoc';
-import { docToMarkdown } from '../doc/docToMarkdown';
-
-/** One full normalization cycle: md → doc → md. */
-function normalize(markdown: string): string {
-  return stringifyMarkdown(docToMarkdown(markdownToDoc(parseMarkdown(markdown))));
-}
-
-/** Byte-stability convention: stable after one normalization cycle. */
-function expectStable(markdown: string): string {
-  const once = normalize(markdown);
-  const twice = normalize(once);
-  expect(twice).toBe(once);
-  return once;
-}
-
-describe('docToMarkdown media round-trip', () => {
-  it('preserves a preamble document-anchored narration annotation', () => {
-    const md = `{[audio src=audio/narration-001.webm anchor=document]}\n\n# Hello\n\nBody text.\n`;
-    const once = expectStable(md);
-    expect(once).toContain('{[audio src=audio/narration-001.webm anchor=document]}');
-    // It must come back at the TOP (before the first heading) so reparsing
-    // yields documentMedia again.
-    expect(once.indexOf('{[audio')).toBeLessThan(once.indexOf('# Hello'));
-    const reparsed = markdownToDoc(parseMarkdown(once));
-    expect(reparsed.documentMedia?.length).toBe(1);
-    expect(reparsed.documentMedia![0].anchor).toBe('document');
-  });
-
-  it('preserves a block-level clip mid-contents with params', () => {
-    const md = `# Scene\n\nLead-in paragraph.\n\n{[video src=video/b.mp4 startAt=2 clipStart=1 clipEnd=9 spillover=true]}\n\nTrailing paragraph.\n`;
-    const once = expectStable(md);
-    expect(once).toContain(
-      '{[video src=video/b.mp4 startAt=2 clipStart=1 clipEnd=9 spillover=true]}',
-    );
-    // Original position: after the lead-in, before the trailing paragraph.
-    expect(once.indexOf('Lead-in')).toBeLessThan(once.indexOf('{[video'));
-    expect(once.indexOf('{[video')).toBeLessThan(once.indexOf('Trailing'));
-    const reparsed = markdownToDoc(parseMarkdown(once));
-    const withMedia = reparsed.blocks.find((b) => b.media && b.media.length > 0);
-    expect(withMedia?.media?.[0].clipStart).toBe(1);
-    expect(withMedia?.media?.[0].spillover).toBe(true);
-  });
-
-  it('preserves a document-anchored annotation authored inside a section body', () => {
-    const md = `# Section\n\nSome text.\n\n{[audio src=audio/full.mp3 anchor=document startAt=0:30]}\n\nMore text.\n`;
-    const once = expectStable(md);
-    // Raw text passthrough keeps the mm:ss time form byte-identical.
-    expect(once).toContain('{[audio src=audio/full.mp3 anchor=document startAt=0:30]}');
-    const reparsed = markdownToDoc(parseMarkdown(once));
-    expect(reparsed.documentMedia?.[0].startAt).toBe(30);
-  });
-
-  it('preserves quoted srcs with spaces', () => {
-    const md = `{[audio src="audio/my take.webm" anchor=document]}\n\n# Doc\n\nText.\n`;
-    const once = expectStable(md);
-    expect(once).toContain('src="audio/my take.webm"');
-    const reparsed = markdownToDoc(parseMarkdown(once));
-    expect(reparsed.documentMedia?.[0].src).toBe('audio/my take.webm');
-  });
-
-  it('emits programmatic doc clips (no origin) at the document top canonically', () => {
-    const doc = markdownToDoc(parseMarkdown('# Title\n\nBody.\n'));
-    doc.documentMedia = [
-      { id: 'clip-1', src: 'audio/take.webm', kind: 'audio', startAt: 0, anchor: 'document' },
-    ];
-    const md = stringifyMarkdown(docToMarkdown(doc));
-    expect(md).toContain('{[audio src=audio/take.webm anchor=document]}');
-    expect(md.indexOf('{[audio')).toBeLessThan(md.indexOf('# Title'));
-    // And the emission itself round-trips.
-    const reparsed = markdownToDoc(parseMarkdown(md));
-    expect(reparsed.documentMedia?.length).toBe(1);
-    expect(stringifyMarkdown(docToMarkdown(reparsed))).toBe(md);
-  });
-
-  it('leaves docs without media untouched', () => {
-    const md = `# Plain\n\nNothing to see.\n`;
-    const once = expectStable(md);
-    expect(once).not.toContain('{[audio');
-  });
-});