@bendyline/squisq 2.0.1 → 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,135 +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('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__/materializeTestUtils.ts

@@ -1,17 +0,0 @@
-import type { Layer } from '../schemas/Doc.js';
-import type { DocBlock } from '../schemas/BlockTemplates.js';
-import {
-  materializeBlockLayers,
-  type MaterializeBlockLayersOptions,
-} from '../doc/materializeBlockLayers.js';
-
-/** Materialize isolated test fixtures without inheriting theme atmosphere. */
-export function materializeLayers(
-  block: DocBlock,
-  options: MaterializeBlockLayersOptions = {},
-): Layer[] {
-  return materializeBlockLayers(block, {
-    persistentLayers: false,
-    ...options,
-  }).layers;
-}

package/src/__tests__/mediaAnnotations.test.ts

@@ -1,91 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { parseMarkdown } from '../markdown/parse.js';
-import { markdownToDoc } from '../doc/markdownToDoc.js';
-import { resolveMediaSchedule } from '../schemas/Media.js';
-
-function toDoc(md: string) {
-  return markdownToDoc(parseMarkdown(md), { articleId: 't' });
-}
-
-describe('markdownToDoc media annotations', () => {
-  it('lifts a block-level audio annotation into block.media', () => {
-    const doc = toDoc(
-      '# One {duration=10}\n\nIntro.\n\n{[audio src=narration.mp3 startAt=5 clipEnd=8 spillover=true]}\n',
-    );
-    const block = doc.blocks[0];
-    expect(block.media).toHaveLength(1);
-    expect(block.media![0]).toMatchObject({
-      src: 'narration.mp3',
-      kind: 'audio',
-      startAt: 5,
-      clipEnd: 8,
-      spillover: true,
-      anchor: 'block',
-    });
-    // The annotation paragraph is removed from the visible contents.
-    expect(JSON.stringify(block.contents)).not.toContain('narration.mp3');
-  });
-
-  it('routes anchor=document annotations to doc.documentMedia', () => {
-    const doc = toDoc('{[audio src=voice.mp3 anchor=document]}\n\n# First\n\nBody.\n');
-    expect(doc.documentMedia).toHaveLength(1);
-    expect(doc.documentMedia![0]).toMatchObject({ src: 'voice.mp3', anchor: 'document' });
-    // It is not also attached to the preamble block's media.
-    expect(doc.blocks[0].media).toBeUndefined();
-  });
-
-  it('recognizes a video annotation as kind video', () => {
-    const doc = toDoc('# B {duration=20}\n\n{[video src=clip.mp4 clipStart=2 clipEnd=8]}\n');
-    expect(doc.blocks[0].media![0]).toMatchObject({
-      src: 'clip.mp4',
-      kind: 'video',
-      clipStart: 2,
-      clipEnd: 8,
-    });
-  });
-
-  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');
-    expect(doc.blocks[0].duration).toBe(5);
-  });
-
-  it('feeds resolveMediaSchedule end to end', () => {
-    const doc = toDoc(
-      '{[audio src=voice.mp3 anchor=document]}\n\n# One {duration=30}\n\n# Two {duration=20}\n\n{[audio src=a.mp3 startAt=5 clipEnd=8]}\n',
-    );
-    const sched = resolveMediaSchedule(doc);
-    const doc1 = sched.find((c) => c.anchor === 'document')!;
-    const block = sched.find((c) => c.anchor === 'block')!;
-    expect(doc1.absoluteStart).toBe(0);
-    expect(doc1.absoluteEnd).toBe(50); // spans both blocks
-    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__/mediaSchedule.test.ts

@@ -1,118 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { resolveMediaSchedule, getDocPlaybackDuration } from '../schemas/Media.js';
-import type { Doc, Block } from '../schemas/Doc.js';
-
-function block(partial: Partial<Block>): Block {
-  return {
-    id: partial.id ?? 'b',
-    startTime: partial.startTime ?? 0,
-    duration: partial.duration ?? 10,
-    audioSegment: 0,
-    ...partial,
-  };
-}
-
-function doc(blocks: Block[], extra?: Partial<Doc>): Doc {
-  const lastEnd = blocks.reduce((m, b) => Math.max(m, b.startTime + b.duration), 0);
-  return { articleId: 't', duration: lastEnd, blocks, audio: { segments: [] }, ...extra };
-}
-
-describe('resolveMediaSchedule', () => {
-  it('offsets a block clip by startAt relative to the block start', () => {
-    // Block #2 starts at 30s; a clip with startAt=5 plays at 35s.
-    const d = doc([
-      block({ id: 'one', startTime: 0, duration: 30 }),
-      block({
-        id: 'two',
-        startTime: 30,
-        duration: 20,
-        media: [{ id: 'm1', src: 'a.mp3', kind: 'audio', startAt: 5, clipEnd: 8, anchor: 'block' }],
-      }),
-    ]);
-    const [clip] = resolveMediaSchedule(d);
-    expect(clip.absoluteStart).toBe(35);
-    expect(clip.absoluteEnd).toBe(43); // 35 + (clipEnd 8 - clipStart 0)
-    expect(clip.sourceIn).toBe(0);
-    expect(clip.blockId).toBe('two');
-  });
-
-  it('clamps a non-spillover clip to the block end', () => {
-    const d = doc([
-      block({
-        id: 'b',
-        startTime: 0,
-        duration: 10,
-        media: [
-          { id: 'm', src: 'a.mp3', kind: 'audio', startAt: 2, clipEnd: 100, anchor: 'block' },
-        ],
-      }),
-    ]);
-    const [clip] = resolveMediaSchedule(d);
-    expect(clip.absoluteEnd).toBe(10); // clamped to block end, not 2 + 100
-  });
-
-  it('lets a spillover clip run past the block end', () => {
-    const d = doc([
-      block({
-        id: 'b',
-        startTime: 0,
-        duration: 10,
-        media: [
-          {
-            id: 'm',
-            src: 'a.mp3',
-            kind: 'audio',
-            startAt: 2,
-            clipEnd: 100,
-            spillover: true,
-            anchor: 'block',
-          },
-        ],
-      }),
-      block({ id: 'b2', startTime: 10, duration: 10 }),
-    ]);
-    const [clip] = resolveMediaSchedule(d);
-    expect(clip.absoluteEnd).toBe(102); // 2 + 100, past the block end
-  });
-
-  it('spans the whole document for an anchor=document clip', () => {
-    const d = doc([block({ id: 'b', startTime: 0, duration: 40 })], {
-      documentMedia: [
-        { id: 'narr', src: 'voice.mp3', kind: 'audio', startAt: 0, anchor: 'document' },
-      ],
-    });
-    const [clip] = resolveMediaSchedule(d);
-    expect(clip.absoluteStart).toBe(0);
-    expect(clip.absoluteEnd).toBe(40);
-    expect(clip.anchor).toBe('document');
-  });
-});
-
-describe('getDocPlaybackDuration', () => {
-  it('extends total duration to include media spillover', () => {
-    const d = doc([
-      block({
-        id: 'b',
-        startTime: 0,
-        duration: 10,
-        media: [
-          {
-            id: 'm',
-            src: 'a.mp3',
-            kind: 'audio',
-            startAt: 0,
-            clipEnd: 25,
-            spillover: true,
-            anchor: 'block',
-          },
-        ],
-      }),
-    ]);
-    expect(getDocPlaybackDuration(d)).toBe(25);
-  });
-
-  it('falls back to the block timeline when there is no media', () => {
-    const d = doc([block({ id: 'b', startTime: 0, duration: 12 })]);
-    expect(getDocPlaybackDuration(d)).toBe(12);
-  });
-});

package/src/__tests__/narrationAlign.test.ts

@@ -1,150 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { alignNarration } from '../narration/align';
-import type { NarrationAlignment, NarrationScript } from '../narration/types';
-import type { NarrationTrace } from '../narration/trace';
-import { scriptFromMarkdown, takeFromScript, type SyntheticTake } from './narrationTestSignals';
-
-const SR = 48000;
-
-const MD = `# The River Walk
-
-Every morning we follow the path along the river and count the boats heading out.
-The bakery opens early and the smell of bread carries across the water to the far bank.
-
-By noon the light changes and the whole town seems to slow down for an hour or two.
-
-## The Market
-
-Stalls line the square with fruit and flowers and a man who fixes watches while you wait.
-We always stop for coffee before carrying everything home up the long hill past the church.
-
-## Evening
-
-The lamps come on one street at a time and the river turns the color of old coins.
-`;
-
-const script = scriptFromMarkdown(MD);
-
-/** Burst onsets are at word start; envelope peaks ~half a burst later. */
-const PEAK_OFFSET = 0.08;
-
-function timingErrors(alignment: NarrationAlignment, take: SyntheticTake): number[] {
-  return alignment.words.map((w, k) => Math.abs(w.tSec - (take.trueWordTimes[k] + PEAK_OFFSET)));
-}
-
-function median(values: number[]): number {
-  const sorted = [...values].sort((a, b) => a - b);
-  return sorted[Math.floor(sorted.length / 2)];
-}
-
-function p95(values: number[]): number {
-  const sorted = [...values].sort((a, b) => a - b);
-  return sorted[Math.min(sorted.length - 1, Math.floor(sorted.length * 0.95))];
-}
-
-/** A live trace with a deterministic ±wobble, as a recorded prompter would produce. */
-function traceFromTake(
-  take: SyntheticTake,
-  scriptRef: NarrationScript,
-  wobbleSec: number,
-): NarrationTrace {
-  const samples: { tMs: number; wordPos: number }[] = [];
-  for (let t = 0; t <= take.durationSec; t += 0.25) {
-    const shifted = t + wobbleSec * Math.sin(t * 1.3);
-    // wordPos convention: floor(wordPos) is the ACTIVE token — the word
-    // currently being spoken — not the count of words started.
-    let started = 0;
-    while (started < take.trueWordTimes.length && take.trueWordTimes[started] <= shifted) started++;
-    const wordPos = Math.max(0, started - 1);
-    samples.push({ tMs: t * 1000, wordPos: Math.min(wordPos, scriptRef.tokens.length) });
-  }
-  return { samples };
-}
-
-describe('alignNarration', () => {
-  const take = takeFromScript(script, 150, SR, 21);
-
-  it('clean take without a trace: median error < 0.25 s, p95 < 1 s', () => {
-    const alignment = alignNarration({ pcm: take.pcm, sampleRate: SR, script });
-    expect(alignment.words.length).toBe(script.tokens.length);
-    const errors = timingErrors(alignment, take);
-    expect(median(errors)).toBeLessThan(0.25);
-    expect(p95(errors)).toBeLessThan(1.0);
-    expect(alignment.detectedSyllables).toBeGreaterThan(script.totalSyllables * 0.7);
-  });
-
-  it('clean take with a wobbly trace: median error < 0.15 s, p95 < 0.5 s', () => {
-    const trace = traceFromTake(take, script, 0.8);
-    const alignment = alignNarration({ pcm: take.pcm, sampleRate: SR, script, trace });
-    const errors = timingErrors(alignment, take);
-    expect(median(errors)).toBeLessThan(0.15);
-    expect(p95(errors)).toBeLessThan(0.5);
-  });
-
-  it('survives filler insertions and a dropped syllable', () => {
-    const messy = takeFromScript(script, 150, SR, 22, {
-      extraOnsets: [4.1, 12.4],
-      dropTokenSyllable: [8 * 1000 + 0],
-    });
-    const trace = traceFromTake(messy, script, 0.5);
-    const alignment = alignNarration({ pcm: messy.pcm, sampleRate: SR, script, trace });
-    const errors = timingErrors(alignment, messy);
-    expect(median(errors)).toBeLessThan(0.25);
-  });
-
-  it('block ranges are contiguous, monotonic, and near the true block starts', () => {
-    const trace = traceFromTake(take, script, 0.4);
-    const alignment = alignNarration({ pcm: take.pcm, sampleRate: SR, script, trace });
-    const blocks = alignment.blocks;
-    expect(blocks.length).toBe(script.blocks.length);
-    expect(blocks[0].startSec).toBe(0);
-    for (let b = 0; b < blocks.length - 1; b++) {
-      expect(blocks[b].endSec).toBeCloseTo(blocks[b + 1].startSec, 9);
-      expect(blocks[b].endSec).toBeGreaterThanOrEqual(blocks[b].startSec);
-    }
-    const last = blocks[blocks.length - 1];
-    expect(last.endSec).toBeGreaterThan(last.startSec);
-    expect(last.endSec).toBeLessThanOrEqual(take.durationSec + 1e-6);
-    for (let b = 1; b < blocks.length; b++) {
-      expect(Math.abs(blocks[b].startSec - take.trueBlockStarts[b])).toBeLessThan(0.7);
-    }
-  });
-
-  it('word times are monotonic', () => {
-    const alignment = alignNarration({ pcm: take.pcm, sampleRate: SR, script });
-    for (let i = 1; i < alignment.words.length; i++) {
-      expect(alignment.words[i].tSec).toBeGreaterThanOrEqual(alignment.words[i - 1].tSec);
-    }
-  });
-
-  it('falls back proportionally when nothing is detected', () => {
-    const quiet = new Float32Array(SR * 5);
-    const alignment = alignNarration({ pcm: quiet, sampleRate: SR, script });
-    expect(alignment.detectedSyllables).toBe(0);
-    expect(alignment.words.length).toBe(script.tokens.length);
-    expect(alignment.words.every((w) => w.interpolated)).toBe(true);
-    expect(alignment.blocks.length).toBe(script.blocks.length);
-  });
-
-  it('handles an empty script', () => {
-    const alignment = alignNarration({
-      pcm: new Float32Array(SR),
-      sampleRate: SR,
-      script: {
-        sourceText: '',
-        tokens: [],
-        blocks: [],
-        totalSyllables: 0,
-        cumulativeSyllables: [0],
-      },
-    });
-    expect(alignment.words).toEqual([]);
-    expect(alignment.blocks).toEqual([]);
-  });
-
-  it('is deterministic', () => {
-    const a = alignNarration({ pcm: take.pcm, sampleRate: SR, script });
-    const b = alignNarration({ pcm: take.pcm, sampleRate: SR, script });
-    expect(a).toEqual(b);
-  });
-});