@bendyline/squisq 2.0.1 → 2.2.0

package/src/__tests__/narrationFeatures.test.ts

@@ -1,71 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { createFeatureState, extractFrameFeatures, featureStep } from '../narration/features';
-import { tone, noise } from './narrationTestSignals';
-
-const RATES = [48000, 44100];
-
-describe('extractFrameFeatures', () => {
-  it.each(RATES)('band energy passes speech band and rejects hum/hiss @ %d Hz', (sr) => {
-    const inBand = extractFrameFeatures(tone(1000, 0.5, sr), sr);
-    const hum = extractFrameFeatures(tone(60, 0.5, sr), sr);
-    const hiss = extractFrameFeatures(tone(8000, 0.5, sr), sr);
-
-    // Skip filter warm-up frames; compare steady-state medians.
-    const median = (frames: { bandEnergy: number }[]) => {
-      const vals = frames
-        .slice(5)
-        .map((f) => f.bandEnergy)
-        .sort((a, b) => a - b);
-      return vals[Math.floor(vals.length / 2)];
-    };
-    expect(median(inBand)).toBeGreaterThan(median(hum) * 10);
-    expect(median(inBand)).toBeGreaterThan(median(hiss) * 10);
-  });
-
-  it.each(RATES)('zcr orders noise above tone @ %d Hz', (sr) => {
-    const noisy = extractFrameFeatures(noise(0.3, sr, 0.2, 7), sr);
-    const tonal = extractFrameFeatures(tone(300, 0.3, sr), sr);
-    expect(noisy[5].zcr).toBeGreaterThan(tonal[5].zcr);
-  });
-
-  it('rms measures a known-amplitude tone (~amp/√2)', () => {
-    const sr = 48000;
-    const frames = extractFrameFeatures(tone(440, 0.3, sr, 0.5), sr);
-    expect(frames[5].rms).toBeGreaterThan(0.3);
-    expect(frames[5].rms).toBeLessThan(0.4);
-  });
-
-  it.each(RATES)('streaming chunks produce the same frames as one batch @ %d Hz', (sr) => {
-    const pcm = noise(0.5, sr, 0.1, 42);
-    const batch = extractFrameFeatures(pcm, sr);
-
-    let state = createFeatureState(sr);
-    const streamed: ReturnType<typeof extractFrameFeatures> = [];
-    // Uneven chunk sizes exercise the carry logic.
-    const chunks = [100, 1024, 333, 4096, 57];
-    let offset = 0;
-    let pick = 0;
-    while (offset < pcm.length) {
-      const size = Math.min(chunks[pick++ % chunks.length], pcm.length - offset);
-      const step = featureStep(state, pcm.subarray(offset, offset + size));
-      state = step.state;
-      streamed.push(...step.frames);
-      offset += size;
-    }
-
-    expect(streamed.length).toBe(batch.length);
-    for (let i = 0; i < batch.length; i++) {
-      expect(streamed[i].tSec).toBeCloseTo(batch[i].tSec, 9);
-      expect(streamed[i].rms).toBeCloseTo(batch[i].rms, 9);
-      expect(streamed[i].bandEnergy).toBeCloseTo(batch[i].bandEnergy, 9);
-      expect(streamed[i].zcr).toBeCloseTo(batch[i].zcr, 9);
-    }
-  });
-
-  it('frame centers advance by the hop', () => {
-    const sr = 48000;
-    const frames = extractFrameFeatures(noise(0.3, sr, 0.1, 3), sr, { hopSec: 0.02 });
-    expect(frames.length).toBeGreaterThan(5);
-    expect(frames[1].tSec - frames[0].tSec).toBeCloseTo(0.02, 3);
-  });
-});

package/src/__tests__/narrationNuclei.test.ts

@@ -1,45 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { extractFrameFeatures } from '../narration/features';
-import { createVadState, vadStep } from '../narration/vad';
-import { detectSyllableOnsets } from '../narration/nuclei';
-import { syllableTrain } from './narrationTestSignals';
-
-const SR = 48000;
-
-function detect(pcm: Float32Array): number[] {
-  const frames = extractFrameFeatures(pcm, SR, { hopSec: 0.01 });
-  let vad = createVadState();
-  const flags = frames.map((f) => {
-    vad = vadStep(vad, f);
-    return vad.speaking;
-  });
-  return detectSyllableOnsets(frames, flags);
-}
-
-describe('detectSyllableOnsets', () => {
-  it('finds each burst in a syllable train (±1 count, ±60 ms timing)', () => {
-    const truth = [0.6, 0.9, 1.2, 1.5, 2.2, 2.5, 2.8, 3.6, 3.9, 4.2, 4.5, 4.8];
-    const onsets = detect(syllableTrain(truth, SR, { seed: 11 }));
-    expect(Math.abs(onsets.length - truth.length)).toBeLessThanOrEqual(1);
-
-    // Each detected onset lies near some true burst (peak ≈ burst center,
-    // so allow the 80 ms half-burst plus 60 ms tolerance).
-    for (const t of onsets) {
-      const nearest = Math.min(...truth.map((x) => Math.abs(t - (x + 0.08))));
-      expect(nearest).toBeLessThanOrEqual(0.06 + 0.04);
-    }
-  });
-
-  it('suppresses double-bursts closer than the minimum spacing', () => {
-    // Two bursts 60 ms apart → their envelopes merge / spacing gate fires:
-    // at most one onset in that neighborhood.
-    const onsets = detect(syllableTrain([1.0, 1.06, 2.0], SR, { seed: 12 }));
-    const nearOne = onsets.filter((t) => t > 0.8 && t < 1.5);
-    expect(nearOne.length).toBeLessThanOrEqual(1);
-  });
-
-  it('reports nothing on silence/noise', () => {
-    const onsets = detect(syllableTrain([], SR, { totalSec: 2, seed: 13 }));
-    expect(onsets.length).toBe(0);
-  });
-});

package/src/__tests__/narrationPacing.test.ts

@@ -1,189 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import {
-  createPacingState,
-  pacingStep,
-  reanchorPacing,
-  type PacingState,
-  type PacingTick,
-} from '../narration/pacing';
-import { expectedSyllablesAt } from '../narration/script';
-import { DEFAULT_PACING_CONFIG, type PacingConfig } from '../narration/types';
-import { scriptFromMarkdown } from './narrationTestSignals';
-
-const MD = `# Cadence
-
-The quick brown fox jumps over the lazy dog while we keep a steady pace for this test.
-It continues with more plain words that carry roughly one or two syllables each one.
-
-Another paragraph starts after a pause and keeps going with the same easy words for a while.
-
-## Second Section
-
-More text lives here so the script is long enough that the prompter never runs off the end.
-The prompter should track the reader through all of it without drifting away from the voice.
-`;
-
-const script = scriptFromMarkdown(MD);
-const BASE_WPS = DEFAULT_PACING_CONFIG.baseWpm / 60;
-const DT = 0.02;
-
-/** Drive the controller with speaking ticks emitting onsets at `sylRate` (syl/s). */
-function drive(
-  state: PacingState,
-  fromSec: number,
-  durSec: number,
-  opts: { speaking: boolean; sylRate?: number },
-  config?: Partial<PacingConfig>,
-): PacingState {
-  let acc = 0;
-  let next = state;
-  for (let t = fromSec; t < fromSec + durSec; t += DT) {
-    let onsets = 0;
-    if (opts.speaking && opts.sylRate) {
-      acc += opts.sylRate * DT;
-      while (acc >= 1) {
-        onsets += 1;
-        acc -= 1;
-      }
-    }
-    const tick: PacingTick = { tSec: t, speaking: opts.speaking, onsets };
-    next = pacingStep(next, tick, script, config);
-  }
-  return next;
-}
-
-const meanSylPerWord = script.totalSyllables / script.tokens.length;
-
-describe('pacingStep', () => {
-  it('halts within 250 ms of silence', () => {
-    let state = drive(createPacingState(), 0, 3, {
-      speaking: true,
-      sylRate: BASE_WPS * meanSylPerWord,
-    });
-    expect(state.velocityWps).toBeGreaterThan(BASE_WPS * 0.5);
-    const velocityAtSilence = state.velocityWps;
-    state = drive(state, 3, 0.25, { speaking: false });
-    expect(state.velocityWps).toBeLessThan(velocityAtSilence * 0.05);
-    state = drive(state, 3.25, 0.3, { speaking: false });
-    expect(state.velocityWps).toBe(0);
-    expect(state.halted).toBe(true);
-  });
-
-  it('tracks the reader rate monotonically', () => {
-    // Faster reading → faster prompter is the whole point of voice pacing.
-    let prevSlope = 0;
-    for (const mult of [0.6, 1.0, 1.8]) {
-      const sylRate = mult * BASE_WPS * meanSylPerWord;
-      const state = drive(createPacingState(), 0, 8, { speaking: true, sylRate });
-      const slope = state.wordPos / 8;
-      expect(slope).toBeGreaterThan(prevSlope);
-      prevSlope = slope;
-    }
-  });
-
-  it('stays word-aligned when the reader matches the set pace', () => {
-    const sylRate = BASE_WPS * meanSylPerWord;
-    const state = drive(createPacingState(), 0, 8, { speaking: true, sylRate });
-    const drift =
-      expectedSyllablesAt(script, state.wordPos) - (state.anchorExpectedSyl + state.cumDetectedSyl);
-    expect(Math.abs(drift)).toBeLessThan(6);
-  });
-
-  it('the WPM setting is a live lever: higher baseWpm → faster cruise', () => {
-    // Same modest voice rate, different set pace. Because the set pace is a
-    // real feedforward term (not cancelled), doubling baseWpm must visibly
-    // speed the prompter up — the bug the user reported.
-    const sylRate = 0.8 * BASE_WPS * meanSylPerWord;
-    const slow = drive(createPacingState(), 0, 8, { speaking: true, sylRate });
-    const fast = drive(createPacingState(), 0, 8, { speaking: true, sylRate }, { baseWpm: 260 });
-    expect(fast.wordPos).toBeGreaterThan(slow.wordPos * 1.3);
-  });
-
-  it('never crawls below the set pace floor while speaking', () => {
-    // A detector that reports almost nothing must still cruise near the set
-    // pace (blend keeps baseWps in play) — so the prompter can't stall out
-    // when syllable detection under-counts.
-    const state = drive(createPacingState(), 0, 6, { speaking: true, sylRate: 0.05 });
-    const slope = state.wordPos / 6;
-    expect(slope).toBeGreaterThan(BASE_WPS * DEFAULT_PACING_CONFIG.minRateMult * 0.8);
-  });
-
-  it('clamps velocity at the cruise-band bounds', () => {
-    // Absurdly fast reader: velocity respects the maxRateMult × set-pace
-    // clamp (plus the bounded PI correction).
-    let state = createPacingState();
-    let acc = 0;
-    const sylRate = 6 * BASE_WPS * meanSylPerWord;
-    for (let t = 0; t < 5; t += DT) {
-      acc += sylRate * DT;
-      let onsets = 0;
-      while (acc >= 1) {
-        onsets += 1;
-        acc -= 1;
-      }
-      state = pacingStep(state, { tSec: t, speaking: true, onsets }, script);
-      expect(state.velocityWps).toBeLessThanOrEqual(
-        BASE_WPS * DEFAULT_PACING_CONFIG.maxRateMult * (1 + DEFAULT_PACING_CONFIG.maxCorrection) +
-          1e-9,
-      );
-    }
-  });
-
-  it('silence halts the prompter and never drags it backward', () => {
-    // Park mid-script ahead of the detected syllables, then go silent. An
-    // under-counting detector makes err > 0 ("prompter ahead"); the
-    // forward-only correction must NOT slow or rewind — the prompter simply
-    // holds position (velocity halts) rather than snapping back.
-    const startPos = Math.min(20, script.tokens.length - 1);
-    const anchored = reanchorPacing(createPacingState(), startPos, script);
-    const state = drive({ ...anchored, wordPos: startPos + 3 }, 0, 2.5, { speaking: false });
-    expect(state.velocityWps).toBe(0);
-    expect(state.wordPos).toBeGreaterThanOrEqual(startPos + 3 - 1e-9);
-  });
-
-  it('catches up forward when the reader is ahead of the prompter', () => {
-    // Feed a strong syllable stream while the prompter starts behind: the
-    // forward-only boost (and, past the threshold, a forward resync) must
-    // pull the highlight forward to meet the voice.
-    const state = drive(createPacingState(), 0, 6, {
-      speaking: true,
-      sylRate: 2 * BASE_WPS * meanSylPerWord,
-    });
-    const detected = state.cumDetectedSyl;
-    // The prompter should have advanced to roughly where those syllables land.
-    const expectedPos = expectedSyllablesAt(script, state.wordPos);
-    expect(expectedPos).toBeGreaterThan(detected * 0.6);
-  });
-
-  it('reanchorPacing resets error tracking but keeps the learned rate', () => {
-    const state = drive(createPacingState(), 0, 4, {
-      speaking: true,
-      sylRate: BASE_WPS * meanSylPerWord,
-    });
-    const ema = state.emaSylPerSec;
-    expect(ema).toBeGreaterThan(0);
-    const anchored = reanchorPacing(state, 5, script);
-    expect(anchored.wordPos).toBe(5);
-    expect(anchored.cumDetectedSyl).toBe(0);
-    expect(anchored.errIntegral).toBe(0);
-    expect(anchored.emaSylPerSec).toBe(ema);
-  });
-
-  it('is pure: identical tick sequences yield identical states', () => {
-    const run = () => {
-      let state = createPacingState();
-      state = drive(state, 0, 2, { speaking: true, sylRate: 4 });
-      state = drive(state, 2, 1, { speaking: false });
-      state = drive(state, 3, 2, { speaking: true, sylRate: 6 });
-      return state;
-    };
-    expect(JSON.stringify(run())).toBe(JSON.stringify(run()));
-  });
-
-  it('never leaves the script bounds', () => {
-    let state = createPacingState();
-    state = drive(state, 0, 60, { speaking: true, sylRate: 40 });
-    expect(state.wordPos).toBeLessThanOrEqual(script.tokens.length);
-    expect(state.wordPos).toBeGreaterThanOrEqual(0);
-  });
-});

package/src/__tests__/narrationScript.test.ts

@@ -1,149 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { parseMarkdown } from '../markdown/parse';
-import { markdownToDoc } from '../doc/markdownToDoc';
-import {
-  buildNarrationScript,
-  expectedSyllablesAt,
-  wordPosAtExpectedSyllables,
-  wordIndexAtChar,
-  wordIndexAtTime,
-} from '../narration/script';
-import type { WordTiming } from '../narration/types';
-
-const MD = `# Morning Routine
-
-Every day starts the same way. Coffee first, then a walk.
-
-The second paragraph has more words in it, honestly.
-
-## The Walk
-
-We head down to the river and watch the boats go by.
-`;
-
-function build() {
-  return buildNarrationScript(markdownToDoc(parseMarkdown(MD)));
-}
-
-describe('buildNarrationScript', () => {
-  it('charOffsets index sourceText exactly', () => {
-    const script = build();
-    expect(script.tokens.length).toBeGreaterThan(10);
-    for (const token of script.tokens) {
-      expect(script.sourceText.slice(token.charOffset, token.charEnd)).toBe(token.text);
-    }
-  });
-
-  it('block ranges cover all tokens contiguously', () => {
-    const script = build();
-    expect(script.blocks.length).toBeGreaterThanOrEqual(2);
-    let cursor = 0;
-    for (let b = 0; b < script.blocks.length; b++) {
-      const range = script.blocks[b];
-      expect(range.tokenStart).toBe(cursor);
-      expect(range.tokenEnd).toBeGreaterThan(range.tokenStart);
-      for (let i = range.tokenStart; i < range.tokenEnd; i++) {
-        expect(script.tokens[i].blockIndex).toBe(b);
-        expect(script.tokens[i].blockId).toBe(range.blockId);
-      }
-      cursor = range.tokenEnd;
-    }
-    expect(cursor).toBe(script.tokens.length);
-  });
-
-  it('assigns pause classes: sentence, paragraph, block boundary', () => {
-    const script = build();
-    const tokenByText = (text: string) => script.tokens.find((t) => t.text === text)!;
-
-    // "way." ends a sentence mid-paragraph → 1
-    expect(tokenByText('way.').pauseAfter).toBe(1);
-    // "walk." ends the paragraph (blank line follows within the block) → 2
-    expect(tokenByText('walk.').pauseAfter).toBe(2);
-    // Last token of each block → 3
-    for (const range of script.blocks) {
-      expect(script.tokens[range.tokenEnd - 1].pauseAfter).toBe(3);
-    }
-    // Plain word mid-sentence → 0
-    expect(tokenByText('starts').pauseAfter).toBe(0);
-  });
-
-  it('includes headings as spoken text and honors includeTitles=false', () => {
-    const doc = markdownToDoc(parseMarkdown(MD));
-    const withTitles = buildNarrationScript(doc);
-    const withoutTitles = buildNarrationScript(doc, { includeTitles: false });
-    expect(withTitles.sourceText).toContain('Morning Routine');
-    expect(withoutTitles.sourceText).not.toContain('Morning Routine');
-    expect(withoutTitles.tokens.length).toBeLessThan(withTitles.tokens.length);
-  });
-
-  it('is deterministic', () => {
-    const a = build();
-    const b = build();
-    expect(a).toEqual(b);
-  });
-
-  it('marks standalone punctuation as non-spoken with zero syllables', () => {
-    const script = buildNarrationScript(
-      markdownToDoc(parseMarkdown('# Intro\n\nSquisq — short — turns plain Markdown into slides.')),
-    );
-    const dashes = script.tokens.filter((t) => t.text === '—');
-    expect(dashes.length).toBe(2);
-    for (const dash of dashes) {
-      expect(dash.spoken).toBe(false);
-      expect(dash.syllables).toBe(0);
-      expect(dash.spokenWordEquiv).toBe(0);
-    }
-    // Real words stay spoken; the em-dashes add nothing to the syllable total.
-    for (const word of script.tokens.filter((t) => /[a-z]/i.test(t.text))) {
-      expect(word.spoken).toBe(true);
-      expect(word.syllables).toBeGreaterThanOrEqual(1);
-    }
-    const spokenSyllables = script.tokens
-      .filter((t) => t.spoken)
-      .reduce((sum, t) => sum + t.syllables, 0);
-    expect(script.totalSyllables).toBe(spokenSyllables);
-  });
-
-  it('cumulative syllables are consistent prefix sums', () => {
-    const script = build();
-    expect(script.cumulativeSyllables.length).toBe(script.tokens.length + 1);
-    expect(script.cumulativeSyllables[0]).toBe(0);
-    for (let i = 0; i < script.tokens.length; i++) {
-      expect(script.cumulativeSyllables[i + 1] - script.cumulativeSyllables[i]).toBe(
-        script.tokens[i].syllables,
-      );
-    }
-    expect(script.totalSyllables).toBe(script.cumulativeSyllables[script.tokens.length]);
-  });
-});
-
-describe('script query helpers', () => {
-  it('expectedSyllablesAt interpolates and inverts', () => {
-    const script = build();
-    expect(expectedSyllablesAt(script, 0)).toBe(0);
-    expect(expectedSyllablesAt(script, script.tokens.length)).toBe(script.totalSyllables);
-    const mid = script.tokens.length / 2;
-    const syl = expectedSyllablesAt(script, mid);
-    expect(wordPosAtExpectedSyllables(script, syl)).toBeCloseTo(mid, 5);
-  });
-
-  it('wordIndexAtChar finds the containing token', () => {
-    const script = build();
-    for (const i of [0, 3, script.tokens.length - 1]) {
-      const token = script.tokens[i];
-      expect(wordIndexAtChar(script, token.charOffset)).toBe(i);
-      expect(wordIndexAtChar(script, token.charEnd - 1)).toBe(i);
-    }
-  });
-
-  it('wordIndexAtTime picks the last started word', () => {
-    const words: WordTiming[] = [
-      { tokenIndex: 0, tSec: 0.5, interpolated: false },
-      { tokenIndex: 1, tSec: 1.0, interpolated: false },
-      { tokenIndex: 2, tSec: 2.0, interpolated: false },
-    ];
-    expect(wordIndexAtTime(words, 0)).toBe(0);
-    expect(wordIndexAtTime(words, 1.2)).toBe(1);
-    expect(wordIndexAtTime(words, 5)).toBe(2);
-  });
-});

package/src/__tests__/narrationSessionRepro.test.ts

@@ -1,62 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { createNarrationSession, narrationSessionStep } from '../narration/session';
-import { createFeatureState, featureStep } from '../narration/features';
-import { scriptFromMarkdown } from './narrationTestSignals';
-
-/**
- * Repro of the browser flow: 1024-sample worklet hops (exactly one
- * frameSize) fed one at a time into a live session. Guards the carry /
- * aliasing path that only this hop pattern exercises.
- */
-describe('narration session with worklet-sized hops', () => {
-  it('featureStep reports real RMS for steady 1024-sample hops', () => {
-    let state = createFeatureState(48000);
-    let lastRms = -1;
-    for (let k = 0; k < 30; k++) {
-      const hop = new Float32Array(1024);
-      for (let i = 0; i < 1024; i++) {
-        hop[i] = 0.6 * Math.sin(((k * 1024 + i) * 2 * Math.PI * 700) / 48000);
-      }
-      const step = featureStep(state, hop);
-      state = step.state;
-      for (const frame of step.frames) lastRms = frame.rms;
-    }
-    expect(lastRms).toBeGreaterThan(0.3);
-  });
-
-  it('survives callers that recycle hop buffers after each step', () => {
-    // Chrome invalidates buffers transferred out of an AudioWorklet once
-    // the message handler returns. The carry must OWN its memory (slice,
-    // not subarray) or later frames silently read zeros.
-    let state = createFeatureState(48000);
-    let lastRms = -1;
-    for (let k = 0; k < 30; k++) {
-      const hop = new Float32Array(1024);
-      for (let i = 0; i < 1024; i++) {
-        hop[i] = 0.6 * Math.sin(((k * 1024 + i) * 2 * Math.PI * 700) / 48000);
-      }
-      const step = featureStep(state, hop);
-      state = step.state;
-      hop.fill(0); // simulate the buffer being recycled
-      for (const frame of step.frames) lastRms = frame.rms;
-    }
-    expect(lastRms).toBeGreaterThan(0.3);
-  });
-
-  it('narrationSessionStep exposes real lastFrame rms for the same hops', () => {
-    const script = scriptFromMarkdown('# One\n\nalpha beta gamma delta epsilon zeta eta theta.');
-    let session = createNarrationSession(48000, script, {
-      vad: { enterRatio: 3, exitRatio: 2.5 },
-      pacing: { baseWpm: 150 },
-    });
-    for (let k = 0; k < 30; k++) {
-      const hop = new Float32Array(1024);
-      for (let i = 0; i < 1024; i++) {
-        hop[i] = 0.6 * Math.sin(((k * 1024 + i) * 2 * Math.PI * 700) / 48000);
-      }
-      session = narrationSessionStep(session, hop);
-    }
-    expect(session.lastFrame).not.toBeNull();
-    expect(session.lastFrame!.rms).toBeGreaterThan(0.3);
-  });
-});

package/src/__tests__/narrationSidecar.test.ts

@@ -1,88 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { buildNarrationTimingJson, parseNarrationTimingJson } from '../narration/sidecar';
-import { alignNarration } from '../narration/align';
-import { scriptFromMarkdown, takeFromScript } from './narrationTestSignals';
-
-const script = scriptFromMarkdown('# One\n\nAlpha beta gamma.\n\n# Two\n\nDelta epsilon zeta.');
-
-/** The legacy v1 gate from audioMapping.parseTimingJson. */
-function passesLegacyGate(payload: unknown): boolean {
-  const p = payload as { sourceText?: unknown; duration?: unknown };
-  return typeof p.sourceText === 'string' && typeof p.duration === 'number';
-}
-
-describe('narration sidecar v3', () => {
-  const take = takeFromScript(script, 150, 48000, 31);
-  const alignment = alignNarration({ pcm: take.pcm, sampleRate: 48000, script });
-  const sidecar = buildNarrationTimingJson(script, alignment, take.durationSec, { baseWpm: 150 });
-
-  it('build → parse round-trips', () => {
-    const parsed = parseNarrationTimingJson(JSON.stringify(sidecar));
-    expect(parsed).not.toBeNull();
-    expect(parsed!.version).toBe(3);
-    expect(parsed!.sourceText).toBe(script.sourceText);
-    expect(parsed!.bookmarks.length).toBe(script.tokens.length);
-    expect(parsed!.blocks.length).toBe(script.blocks.length);
-    expect(parsed!.generator?.method).toBe('dsp-align');
-  });
-
-  it('fills bookmarks with real char offsets and monotonic times', () => {
-    for (let i = 0; i < sidecar.bookmarks.length; i++) {
-      const bookmark = sidecar.bookmarks[i];
-      expect(bookmark.charOffset).toBe(script.tokens[i].charOffset);
-      expect(bookmark.textFragment).toBe(script.tokens[i].text);
-      if (i > 0) expect(bookmark.time).toBeGreaterThanOrEqual(sidecar.bookmarks[i - 1].time);
-    }
-  });
-
-  it('v3 payloads still pass the legacy v1 parser gate (superset contract)', () => {
-    expect(passesLegacyGate(JSON.parse(JSON.stringify(sidecar)))).toBe(true);
-  });
-
-  it('parses v1 payloads with empty blocks', () => {
-    const v1 = { sourceText: 'hello world', duration: 12.5, bookmarks: [] };
-    const parsed = parseNarrationTimingJson(JSON.stringify(v1));
-    expect(parsed).not.toBeNull();
-    expect(parsed!.version).toBe(3);
-    expect(parsed!.blocks).toEqual([]);
-    expect(parsed!.duration).toBe(12.5);
-  });
-
-  it('rejects malformed payloads', () => {
-    expect(parseNarrationTimingJson('not json')).toBeNull();
-    expect(parseNarrationTimingJson('{"duration": 3}')).toBeNull();
-    expect(parseNarrationTimingJson('{"sourceText": "x", "duration": "3"}')).toBeNull();
-    expect(parseNarrationTimingJson('null')).toBeNull();
-  });
-
-  it('sorts and clamps hand-edited block ranges defensively', () => {
-    const messy = {
-      sourceText: 'a b c',
-      duration: 10,
-      blocks: [
-        { blockIndex: 1, charStart: 2, charEnd: 4, startSec: 6, endSec: 5 },
-        { blockIndex: 0, charStart: 0, charEnd: 2, startSec: 2, endSec: 4 },
-        { blockIndex: 2, charStart: 4, charEnd: 5, startSec: 'bad', endSec: 9 },
-      ],
-    };
-    const parsed = parseNarrationTimingJson(JSON.stringify(messy));
-    expect(parsed).not.toBeNull();
-    expect(parsed!.blocks.length).toBe(2); // the malformed one is dropped
-    expect(parsed!.blocks[0].startSec).toBe(2);
-    expect(parsed!.blocks[1].startSec).toBe(6);
-    expect(parsed!.blocks[1].endSec).toBe(6); // endSec clamped to startSec
-  });
-
-  it('drops non-finite bookmark entries instead of failing the file', () => {
-    const payload = {
-      sourceText: 'a b',
-      duration: 5,
-      bookmarks: [
-        { id: 'w0', time: 0.5, charOffset: 0 },
-        { id: 'bad', time: Number.NaN, charOffset: 2 },
-      ],
-    };
-    const parsed = parseNarrationTimingJson(JSON.stringify(payload));
-    expect(parsed!.bookmarks.length).toBe(1);
-  });
-});

package/src/__tests__/narrationSyllables.test.ts

@@ -1,65 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { estimateSyllables } from '../narration/syllables';
-
-describe('estimateSyllables', () => {
-  // Pinned corpus: exact values are part of the deterministic contract.
-  // ±1 misses on unusual words are acceptable and documented; these
-  // pins catch unintended drift, not linguistic perfection.
-  const corpus: Array<[string, number]> = [
-    ['a', 1],
-    ['the', 1],
-    ['word', 1],
-    ['hello', 2],
-    ['reading', 2],
-    ['syllable', 3],
-    ['teleprompter', 4],
-    ['narration', 3],
-    ['deterministic', 5],
-    ['table', 2],
-    ['little', 2],
-    ['whale', 1],
-    ['give', 1],
-    ['make', 1],
-    ['makes', 1],
-    ['boxes', 2],
-    ['riches', 2],
-    ['walked', 1],
-    ['wanted', 2],
-    ['loaded', 2],
-    ['agreed', 2],
-    ['squisq', 1],
-    ['beam-splitter', 3],
-    ["don't", 1],
-    ['yellow', 2],
-    ['rhythm', 1],
-    ['HTML', 4],
-    ['NASA', 2],
-    ['USA', 2], // vowel-bearing caps fall through to vowel groups (u + a)
-    ['Hello,', 2],
-    ['"quoted"', 2],
-    ['end.', 1],
-  ];
-
-  it.each(corpus)('%s → %d', (word, expected) => {
-    expect(estimateSyllables(word)).toBe(expected);
-  });
-
-  it('expands numbers via spoken-word equivalents', () => {
-    // "1910" → "nineteen ten" ≈ 2 words × 1.3 × 1.4 ≈ 4
-    expect(estimateSyllables('1910')).toBeGreaterThanOrEqual(3);
-    expect(estimateSyllables('1910')).toBeLessThanOrEqual(5);
-    // "175,000" is many spoken words
-    expect(estimateSyllables('175,000')).toBeGreaterThanOrEqual(5);
-    expect(estimateSyllables('7')).toBeGreaterThanOrEqual(1);
-  });
-
-  it('never returns less than 1 for non-empty tokens', () => {
-    for (const t of ['x', '—', '...', '?!', 'b2b', 'C-3PO']) {
-      expect(estimateSyllables(t)).toBeGreaterThanOrEqual(1);
-    }
-  });
-
-  it('is deterministic', () => {
-    expect(estimateSyllables('deterministic')).toBe(estimateSyllables('deterministic'));
-  });
-});