@bendyline/squisq 2.0.1 → 2.2.0

package/src/__tests__/themeCompile.test.ts

@@ -1,225 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import {
-  compileTheme,
-  parseTheme,
-  serializeTheme,
-  STARTER_THEME,
-  deriveColorPalette,
-} from '../schemas/themeCompile.js';
-import { createThemeRegistry } from '../schemas/Theme.js';
-import type { Theme } from '../schemas/Theme.js';
-import { resolveTheme, DEFAULT_THEME, THEMES } from '../schemas/themeLibrary.js';
-import { resolveFontFamily } from '../schemas/fontStacks.js';
-
-describe('deriveColorPalette', () => {
-  it('fills all 8 palette slots from a single primary seed', () => {
-    const palette = deriveColorPalette({ primary: '#3182ce' });
-    expect(palette.primary).toBe('#3182ce');
-    expect(palette.background).toMatch(/^#[0-9a-f]{6}$/);
-    expect(palette.text).toMatch(/^#[0-9a-f]{6}$/);
-    expect(palette.warning).toMatch(/^#[0-9a-f]{6}$/);
-  });
-
-  it('lets explicit partial colors win over derived values', () => {
-    const palette = deriveColorPalette({ primary: '#3182ce' }, { warning: '#ff00ff' });
-    expect(palette.warning).toBe('#ff00ff');
-  });
-
-  it('high contrast spread > balanced spread > subtle spread (in lightness range)', () => {
-    const subtle = deriveColorPalette({ primary: '#3182ce' }, {}, { contrast: 'subtle' });
-    const balanced = deriveColorPalette({ primary: '#3182ce' }, {}, { contrast: 'balanced' });
-    const high = deriveColorPalette({ primary: '#3182ce' }, {}, { contrast: 'high' });
-    // All should be valid
-    for (const p of [subtle, balanced, high]) {
-      expect(p.background).toMatch(/^#[0-9a-f]{6}$/);
-    }
-  });
-});
-
-describe('compileTheme', () => {
-  it('compiles a minimal partial into a complete validated Theme', () => {
-    const theme = compileTheme({
-      name: 'My Theme',
-      seedColors: { primary: '#3182ce' },
-    });
-    expect(theme.id).toMatch(/^custom/);
-    expect(theme.name).toBe('My Theme');
-    expect(theme.colors.primary).toBe('#3182ce');
-    expect(theme.colors.background).toMatch(/^#[0-9a-f]{6}$/);
-    expect(theme.typography.bodyFont).toEqual(STARTER_THEME.typography.bodyFont);
-    expect(theme.colorSchemes).toEqual(STARTER_THEME.colorSchemes);
-    expect(theme.schemaVersion).toBe('1');
-  });
-
-  it('passes through fully-specified themes (built-ins should re-compile to identical Theme)', () => {
-    const reCompiled = compileTheme(DEFAULT_THEME);
-    expect(reCompiled.colors).toEqual(DEFAULT_THEME.colors);
-    expect(reCompiled.typography).toEqual(DEFAULT_THEME.typography);
-  });
-
-  it('honors typography overrides', () => {
-    const theme = compileTheme({
-      seedColors: { primary: '#3182ce' },
-      typography: {
-        titleFont: { stackId: 'playfair' },
-        bodyFont: { custom: { name: 'Georgia', fallback: 'serif' } },
-      },
-    });
-    expect(theme.typography.titleFont).toEqual({ stackId: 'playfair' });
-    expect(theme.typography.bodyFont).toEqual({
-      custom: { name: 'Georgia', fallback: 'serif' },
-    });
-  });
-});
-
-describe('compileTheme base inheritance', () => {
-  it('inherits renderStyle and colorSchemes from a chosen base', () => {
-    const base = resolveTheme('cinematic');
-    const theme = compileTheme(
-      { id: 'brand', name: 'Brand', seedColors: { primary: '#3182ce' } },
-      { base },
-    );
-    expect(theme.basedOn).toBe('cinematic');
-    // renderStyle inherited from the base (not the starter's 'standard')
-    expect(theme.renderStyle.name).toBe(base.renderStyle.name);
-    // colorSchemes inherited wholesale from the base
-    expect(theme.colorSchemes).toEqual(base.colorSchemes);
-    // ...but colors are still derived from the user's seed
-    expect(theme.colors.primary).toBe('#3182ce');
-  });
-
-  it('replaces colorSchemes wholesale when the partial supplies them (removal sticks)', () => {
-    const base = resolveTheme('cinematic');
-    const theme = compileTheme(
-      {
-        id: 'brand',
-        name: 'Brand',
-        seedColors: { primary: '#3182ce' },
-        colorSchemes: { onlyOne: { bg: '#111111', text: '#eeeeee', accent: '#3182ce' } },
-      },
-      { base },
-    );
-    // Only the scheme the user kept — the base's blue/green/… are gone.
-    expect(Object.keys(theme.colorSchemes)).toEqual(['onlyOne']);
-  });
-
-  it('defaults to the neutral starter when no base is given (basedOn unset)', () => {
-    const theme = compileTheme({
-      id: 'brand',
-      name: 'Brand',
-      seedColors: { primary: '#3182ce' },
-    });
-    expect(theme.basedOn).toBeUndefined();
-    expect(theme.renderStyle.name).toBe('standard');
-  });
-});
-
-describe('parseTheme / serializeTheme round-trip', () => {
-  it('serialize → parse is lossless for built-ins', () => {
-    for (const [id, theme] of Object.entries(THEMES)) {
-      const json = serializeTheme(theme);
-      const parsed = parseTheme(json);
-      expect(parsed).toEqual(theme);
-      expect(parsed.id).toBe(id);
-    }
-  });
-
-  it('parseTheme throws on invalid JSON', () => {
-    expect(() => parseTheme('not json')).toThrow(/Invalid theme JSON/);
-  });
-
-  it('parseTheme throws on JSON that fails validation', () => {
-    expect(() => parseTheme('{}')).toThrow(/Invalid parsed theme/);
-  });
-});
-
-describe('caller-owned theme registries', () => {
-  it('an explicit registry can override a built-in without process-global leakage', () => {
-    const overlay = compileTheme({
-      id: 'standard',
-      name: 'Standard Override',
-      seedColors: { primary: '#ff0000' },
-    });
-    const registry = createThemeRegistry([overlay]);
-    const resolved = resolveTheme('standard', registry);
-    expect(resolved.name).toBe('Standard Override');
-    expect(resolved.colors.primary).toBe('#ff0000');
-    expect(resolveTheme('standard').name).toBe('Standard Light');
-  });
-
-  it('resolves a custom id only through the registry that owns it', () => {
-    const custom = compileTheme({
-      id: 'custom-test-1',
-      name: 'Custom Test One',
-      seedColors: { primary: '#00aabb' },
-    });
-    const registry = createThemeRegistry([custom]);
-    expect(resolveTheme('custom-test-1', registry).name).toBe('Custom Test One');
-    expect(resolveTheme('custom-test-1')).toBe(DEFAULT_THEME);
-    expect(registry.list().map((theme) => theme.id)).toContain('custom-test-1');
-  });
-
-  it('resolveTheme falls back to default for unknown ids', () => {
-    expect(resolveTheme('nonexistent-theme')).toBe(DEFAULT_THEME);
-    expect(resolveTheme(undefined)).toBe(DEFAULT_THEME);
-  });
-
-  it('validates and stores an immutable snapshot', () => {
-    const registry = createThemeRegistry();
-    const source = compileTheme({
-      id: 'isolated-theme',
-      name: 'Isolated',
-      seedColors: { primary: '#336699' },
-    });
-    registry.register(source);
-    source.name = 'Changed later';
-    source.colors.primary = '#ffffff';
-
-    const stored = registry.get('isolated-theme')!;
-    expect(stored.name).toBe('Isolated');
-    expect(stored.colors.primary).toBe('#336699');
-    expect(Object.isFrozen(stored)).toBe(true);
-    expect(Object.isFrozen(stored.colors)).toBe(true);
-    expect(() => registry.register({ id: 'invalid' } as Theme)).toThrow(/invalid theme/i);
-  });
-
-  it('supports caller-owned registries with isolated state', () => {
-    const source = compileTheme({
-      id: 'tenant-theme',
-      name: 'Tenant',
-      seedColors: { primary: '#123456' },
-    });
-    const tenantA = createThemeRegistry([source]);
-    const tenantB = createThemeRegistry();
-    expect(tenantA.get('tenant-theme')?.name).toBe('Tenant');
-    expect(tenantB.get('tenant-theme')).toBeUndefined();
-  });
-
-  it('freezes built-ins so lookup ergonomics do not expose mutable global state', () => {
-    expect(Object.isFrozen(THEMES)).toBe(true);
-    expect(Object.isFrozen(resolveTheme('cinematic'))).toBe(true);
-  });
-});
-
-describe('FontFamily resolution', () => {
-  it('resolves stackId to a CSS family string', () => {
-    expect(resolveFontFamily({ stackId: 'inter' }, 'fallback')).toContain('Inter');
-  });
-
-  it('resolves { custom } to a quoted CSS family with fallback', () => {
-    const css = resolveFontFamily(
-      { custom: { name: 'My Font', fallback: 'sans-serif' } },
-      'fallback',
-    );
-    expect(css).toContain('"My Font"');
-    expect(css).toContain('sans-serif');
-  });
-
-  it('returns roleFallback for unknown stackId', () => {
-    expect(resolveFontFamily({ stackId: 'no-such-stack' }, 'my-fallback')).toBe('my-fallback');
-  });
-
-  it('accepts legacy raw strings for backward compat', () => {
-    expect(resolveFontFamily('Georgia, serif', 'fallback')).toBe('Georgia, serif');
-  });
-});

package/src/__tests__/themeValidator.test.ts

@@ -1,131 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { validateTheme, assertTheme } from '../schemas/themeValidator.js';
-import { THEMES, DEFAULT_THEME } from '../schemas/themeLibrary.js';
-import type { Theme } from '../schemas/Theme.js';
-
-function clone<T>(v: T): T {
-  return JSON.parse(JSON.stringify(v)) as T;
-}
-
-describe('validateTheme', () => {
-  it('accepts every built-in theme', () => {
-    for (const [id, theme] of Object.entries(THEMES)) {
-      const result = validateTheme(theme);
-      if (!result.valid) {
-        throw new Error(
-          `Built-in theme "${id}" failed validation:\n${result.errors
-            .map((e) => `  ${e.path}: ${e.message}`)
-            .join('\n')}`,
-        );
-      }
-      expect(result.valid).toBe(true);
-    }
-  });
-
-  it('rejects non-objects', () => {
-    expect(validateTheme(null).valid).toBe(false);
-    expect(validateTheme('a string').valid).toBe(false);
-    expect(validateTheme(42).valid).toBe(false);
-  });
-
-  it('flags missing required fields', () => {
-    const result = validateTheme({ schemaVersion: '1', id: 'x', name: 'X' });
-    expect(result.valid).toBe(false);
-    const paths = result.errors.map((e) => e.path);
-    expect(paths).toContain('colors');
-    expect(paths).toContain('typography');
-    expect(paths).toContain('renderStyle');
-    expect(paths).toContain('colorSchemes');
-  });
-
-  it('flags raw font strings (legacy shape)', () => {
-    const bad = clone(DEFAULT_THEME) as unknown as Record<string, unknown>;
-    (bad.typography as Record<string, unknown>).bodyFont = 'Inter, sans-serif';
-    const result = validateTheme(bad);
-    expect(result.valid).toBe(false);
-    expect(result.errors.some((e) => e.path === 'typography.bodyFont')).toBe(true);
-  });
-
-  it('flags raw CSS gradient strings in persistentLayers', () => {
-    const bad = clone(DEFAULT_THEME) as Theme;
-    bad.persistentLayers = {
-      bottomLayers: [
-        // intentionally invalid: raw `gradient` string is not allowed
-        {
-          template: 'gradientBackground',
-          config: {
-            type: 'gradientBackground',
-            gradient: 'linear-gradient(...)' as never,
-          },
-        },
-      ],
-    };
-    const result = validateTheme(bad);
-    expect(result.valid).toBe(false);
-    expect(
-      result.errors.some((e) => e.path.endsWith('config.gradient') && /raw CSS/i.test(e.message)),
-    ).toBe(true);
-  });
-
-  it('flags malformed hex colors', () => {
-    const bad = clone(DEFAULT_THEME);
-    bad.colors.primary = 'rgb(0,0,0)';
-    const result = validateTheme(bad);
-    expect(result.valid).toBe(false);
-    expect(result.errors.some((e) => e.path === 'colors.primary')).toBe(true);
-  });
-
-  it('flags wrong schemaVersion', () => {
-    const bad = clone(DEFAULT_THEME) as unknown as Record<string, unknown>;
-    bad.schemaVersion = '2';
-    const result = validateTheme(bad);
-    expect(result.valid).toBe(false);
-    expect(result.errors.some((e) => e.path === 'schemaVersion')).toBe(true);
-  });
-
-  it('accepts FontFamily { custom } shape', () => {
-    const t = clone(DEFAULT_THEME);
-    t.typography.bodyFont = { custom: { name: 'Georgia', fallback: 'serif' } };
-    expect(validateTheme(t).valid).toBe(true);
-  });
-
-  it('rejects FontFamily.custom with bad fallback', () => {
-    const bad = clone(DEFAULT_THEME) as unknown as Record<string, unknown>;
-    (bad.typography as Record<string, unknown>).bodyFont = {
-      custom: { name: 'Georgia', fallback: 'invalid' },
-    };
-    const result = validateTheme(bad);
-    expect(result.valid).toBe(false);
-    expect(result.errors.some((e) => e.path === 'typography.bodyFont.custom.fallback')).toBe(true);
-  });
-
-  it('accepts theme with seedColors', () => {
-    const t = clone(DEFAULT_THEME);
-    t.seedColors = { primary: '#3182ce', accent: '#63b3ed' };
-    expect(validateTheme(t).valid).toBe(true);
-  });
-
-  it('accepts PowerPoint-style default transitions', () => {
-    const t = clone(DEFAULT_THEME);
-    t.renderStyle.defaultTransition = { type: 'checkerboard', duration: 1 };
-    expect(validateTheme(t).valid).toBe(true);
-  });
-
-  it('rejects seedColors without primary', () => {
-    const bad = clone(DEFAULT_THEME);
-    bad.seedColors = { accent: '#63b3ed' } as never;
-    const result = validateTheme(bad);
-    expect(result.valid).toBe(false);
-    expect(result.errors.some((e) => e.path === 'seedColors.primary')).toBe(true);
-  });
-});
-
-describe('assertTheme', () => {
-  it('returns the theme unchanged when valid', () => {
-    expect(assertTheme(DEFAULT_THEME)).toBe(DEFAULT_THEME);
-  });
-
-  it('throws with a readable error summary on invalid input', () => {
-    expect(() => assertTheme({}, 'test theme')).toThrow(/Invalid test theme/);
-  });
-});

package/src/__tests__/timing.test.ts

@@ -1,167 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import {
-  countSpokenWords,
-  estimateSpokenWordCount,
-  estimateTimeFromText,
-  calculatePrefixDuration,
-  estimateNarrationDuration,
-  estimateReadingTime,
-  estimateNarrationTime,
-  DEFAULT_WORDS_PER_SECOND,
-} from '../timing/index.js';
-
-// ── narrationTiming ────────────────────────────────────────────────
-
-describe('estimateSpokenWordCount', () => {
-  it('counts a regular word as 1', () => {
-    expect(estimateSpokenWordCount('hello')).toBe(1);
-  });
-
-  it('expands a small number (50 → "fifty" → 1 word × 1.3)', () => {
-    expect(estimateSpokenWordCount('50')).toBeCloseTo(1.3);
-  });
-
-  it('expands a year (1910 → "nineteen ten" → 2 × 1.3)', () => {
-    expect(estimateSpokenWordCount('1910')).toBeCloseTo(2.6);
-  });
-
-  it('expands a large number (175000)', () => {
-    // "one hundred seventy-five" (4 words) + "thousand" (1) = 5 words × 1.3
-    expect(estimateSpokenWordCount('175000')).toBeCloseTo(6.5, 1);
-  });
-
-  it('handles 2024 as a year', () => {
-    // "twenty twenty-four" → 3 words × 1.3
-    expect(estimateSpokenWordCount('2024')).toBeCloseTo(3.9);
-  });
-
-  it('handles zero', () => {
-    // "zero" → 1 word × 1.3
-    expect(estimateSpokenWordCount('0')).toBeCloseTo(1.3);
-  });
-
-  it('handles non-numeric strings', () => {
-    expect(estimateSpokenWordCount('hello')).toBe(1);
-    expect(estimateSpokenWordCount('')).toBe(1);
-  });
-});
-
-describe('countSpokenWords', () => {
-  it('counts plain text words', () => {
-    expect(countSpokenWords('the quick brown fox')).toBe(4);
-  });
-
-  it('includes comma pause penalties', () => {
-    const withComma = countSpokenWords('hello, world');
-    const without = countSpokenWords('hello world');
-    expect(withComma).toBeGreaterThan(without);
-    expect(withComma - without).toBeCloseTo(0.3);
-  });
-
-  it('expands numbers within text', () => {
-    const result = countSpokenWords('In 1910 there were 50 houses');
-    // "In"(1) + "1910"(2.6) + "there"(1) + "were"(1) + "50"(1.3) + "houses"(1)
-    expect(result).toBeCloseTo(7.9);
-  });
-
-  it('returns 0 for empty text', () => {
-    expect(countSpokenWords('')).toBe(0);
-  });
-});
-
-describe('estimateTimeFromText', () => {
-  it('returns 0 at the beginning', () => {
-    expect(estimateTimeFromText('hello world', 0, 10)).toBe(0);
-  });
-
-  it('returns proportional time at the midpoint', () => {
-    const time = estimateTimeFromText('one two three four', 8, 20);
-    // "one two" = 2 words before offset 8, total = 4 words → 50% → 10s
-    expect(time).toBeCloseTo(10);
-  });
-
-  it('returns totalDuration at the end', () => {
-    const text = 'some text here';
-    const time = estimateTimeFromText(text, text.length, 30);
-    expect(time).toBeCloseTo(30);
-  });
-
-  it('returns 0 for empty text', () => {
-    expect(estimateTimeFromText('', 0, 10)).toBe(0);
-  });
-});
-
-describe('calculatePrefixDuration', () => {
-  it('returns 0 for empty string', () => {
-    expect(calculatePrefixDuration('')).toBe(0);
-  });
-
-  it('estimates based on word count', () => {
-    // 5 words at 2.5 wps = 2 seconds
-    expect(calculatePrefixDuration('one two three four five')).toBeCloseTo(2);
-  });
-
-  it('adds pause time for paragraph breaks', () => {
-    const withBreak = calculatePrefixDuration('Title\n\nContent here');
-    const without = calculatePrefixDuration('Title Content here');
-    expect(withBreak).toBeGreaterThan(without);
-    // One paragraph break → +0.5s
-    expect(withBreak - without).toBeCloseTo(0.5);
-  });
-});
-
-describe('estimateNarrationDuration', () => {
-  it('estimates simple text', () => {
-    // 5 words at 2.5 wps = 2 seconds
-    expect(estimateNarrationDuration('one two three four five')).toBeCloseTo(2);
-  });
-
-  it('accepts custom rate', () => {
-    // 5 words at 5 wps = 1 second
-    expect(estimateNarrationDuration('one two three four five', 5)).toBeCloseTo(1);
-  });
-});
-
-// ── readingTime ────────────────────────────────────────────────────
-
-describe('estimateReadingTime', () => {
-  it('estimates 200-word text at 1 minute', () => {
-    const text = Array(200).fill('word').join(' ');
-    const result = estimateReadingTime(text);
-    expect(result.words).toBe(200);
-    expect(result.minutes).toBeCloseTo(1);
-    expect(result.seconds).toBe(60);
-  });
-
-  it('respects custom WPM', () => {
-    const text = Array(100).fill('word').join(' ');
-    const result = estimateReadingTime(text, { wordsPerMinute: 100 });
-    expect(result.minutes).toBeCloseTo(1);
-  });
-
-  it('returns 0 for empty text', () => {
-    const result = estimateReadingTime('');
-    expect(result.words).toBe(0);
-    expect(result.seconds).toBe(0);
-  });
-});
-
-describe('estimateNarrationTime', () => {
-  it('accounts for number expansion', () => {
-    const plain = estimateNarrationTime('five words in this text');
-    const withNum = estimateNarrationTime('In 1910 there were 50 houses');
-    // Numbers add more spoken-word equivalents
-    expect(withNum.spokenWords).toBeGreaterThan(plain.spokenWords);
-  });
-
-  it('returns reasonable seconds', () => {
-    const result = estimateNarrationTime('one two three four five');
-    expect(result.seconds).toBe(2); // 5 words / 2.5 wps = 2s
-  });
-});
-
-describe('DEFAULT_WORDS_PER_SECOND', () => {
-  it('is 2.5', () => {
-    expect(DEFAULT_WORDS_PER_SECOND).toBe(2.5);
-  });
-});

package/src/__tests__/transformProvenance.test.ts

@@ -1,160 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { parseMarkdown } from '../markdown/parse';
-import { markdownToDoc, flattenRenderableBlocks } from '../doc/markdownToDoc';
-import { applyTransform } from '../transform/applyTransform';
-import { allocateTiming } from '../transform/timingAllocator';
-import { isTemplateBlock, type TemplateBlock } from '../schemas/BlockTemplates';
-import type { Block, Doc } from '../schemas/Doc';
-
-const MD = `# The Numbers
-
-Revenue grew to 4,200 units in 2019 which was a big jump for the small team.
-"We never expected this kind of growth," said the founder about the year.
-
-# The Turning Point
-
-By 2021 the company had 87 employees across three offices and a plan.
-The expansion cost 1,500,000 dollars and took fourteen months to finish.
-
-# The Result
-
-Today the product ships to 40 countries and the team keeps growing steadily.
-`;
-
-function makeDoc(): Doc {
-  return markdownToDoc(parseMarkdown(MD));
-}
-
-/** Blocks a transform produced (positional transform-* ids). */
-function transformedBlocks(doc: Doc): Block[] {
-  return doc.blocks.filter((b) => b.id.startsWith('transform-'));
-}
-
-describe('transform provenance', () => {
-  it('every extraction-derived slide carries a sourceBlockId from the input doc', () => {
-    const source = makeDoc();
-    const sourceIds = new Set(flattenRenderableBlocks(source.blocks).map((b) => b.id));
-    const { doc } = applyTransform(source, 'data-driven');
-
-    const produced = transformedBlocks(doc).filter(
-      (b) => b.id !== 'transform-intro' && b.id !== 'transform-outro',
-    );
-    expect(produced.length).toBeGreaterThan(0);
-    for (const block of produced) {
-      expect(block.sourceBlockId, `block ${block.id} missing provenance`).toBeTruthy();
-      expect(sourceIds.has(block.sourceBlockId!)).toBe(true);
-    }
-  });
-
-  it('sourceStartTime is SECONDS on the doc timeline, not a char offset (regression)', () => {
-    const source = makeDoc();
-    const sourceEnd = Math.max(
-      ...flattenRenderableBlocks(source.blocks).map((b) => b.startTime + b.duration),
-    );
-    const { doc } = applyTransform(source, 'data-driven');
-
-    for (const block of doc.blocks) {
-      const tb = block as unknown as TemplateBlock;
-      if (typeof tb.sourceStartTime !== 'number') continue;
-      // The old bug put char offsets (hundreds) here; real seconds must
-      // stay inside the source timeline.
-      expect(tb.sourceStartTime).toBeLessThanOrEqual(sourceEnd + 1);
-      expect(tb.sourceStartTime).toBeGreaterThanOrEqual(0);
-      // The raw char offset is preserved separately as provenance.
-      expect(typeof tb.sourceCharOffset).toBe('number');
-    }
-  });
-
-  it('narration-timed source blocks anchor their slides inside the source range', () => {
-    const source = makeDoc();
-    // Simulate applyNarrationTiming: give the source blocks recorded times.
-    const flat = flattenRenderableBlocks(source.blocks);
-    const bounds = [0, 20, 45, 70];
-    flat.forEach((block, i) => {
-      block.startTime = bounds[i] ?? 70;
-      block.duration = (bounds[i + 1] ?? 70) - (bounds[i] ?? 70);
-    });
-    source.duration = 70;
-
-    const { doc } = applyTransform(source, 'data-driven');
-    const bySource = new Map(flat.map((b) => [b.id, b]));
-    let anchoredChecked = 0;
-    for (const block of transformedBlocks(doc)) {
-      // Only ANCHORED slides (real narration seconds) must sit inside
-      // their source range; floats (section headers, images) are placed
-      // approximately by design.
-      const tb = block as unknown as TemplateBlock;
-      if (!block.sourceBlockId || typeof tb.sourceStartTime !== 'number') continue;
-      const origin = bySource.get(block.sourceBlockId);
-      if (!origin || origin.duration <= 0) continue;
-      expect(block.startTime).toBeGreaterThanOrEqual(origin.startTime - 1e-6);
-      expect(block.startTime).toBeLessThan(origin.startTime + origin.duration + 1e-6);
-      anchoredChecked++;
-    }
-    expect(anchoredChecked).toBeGreaterThan(0);
-  });
-
-  it('transformed timelines stay contiguous (no uncovered narration seconds)', () => {
-    const source = makeDoc();
-    const { doc } = applyTransform(source, 'data-driven');
-    const sorted = [...doc.blocks].sort((a, b) => a.startTime - b.startTime);
-    for (let i = 0; i < sorted.length - 1; i++) {
-      const end = sorted[i].startTime + sorted[i].duration;
-      expect(end).toBeCloseTo(sorted[i + 1].startTime, 5);
-    }
-  });
-});
-
-describe('allocateTiming fallback', () => {
-  it('keeps the historical rescale behavior when no anchors exist', () => {
-    const floats: TemplateBlock[] = [
-      { template: 'sectionHeader', id: 'a', duration: 5, audioSegment: 0, title: 'A' },
-      { template: 'sectionHeader', id: 'b', duration: 5, audioSegment: 0, title: 'B' },
-    ];
-    const result = allocateTiming(floats, 20);
-    expect(result[0].startTime).toBe(0);
-    expect(result[0].duration).toBe(10);
-    expect(result[1].startTime).toBe(10);
-    expect(result[1].duration).toBe(10);
-  });
-
-  it('anchored blocks keep their positions; floats fill the gaps', () => {
-    const blocks: TemplateBlock[] = [
-      // A floating intro before the first anchor.
-      { template: 'title', id: 'intro', duration: 4, audioSegment: 0, title: 'T' },
-      {
-        template: 'statHighlight',
-        id: 's1',
-        duration: 6,
-        audioSegment: 0,
-        stat: '42',
-        description: 'd',
-        sourceStartTime: 10,
-        sourceDuration: 6,
-      },
-      {
-        template: 'statHighlight',
-        id: 's2',
-        duration: 6,
-        audioSegment: 0,
-        stat: '87',
-        description: 'd',
-        sourceStartTime: 30,
-        sourceDuration: 6,
-      },
-    ];
-    const result = allocateTiming(blocks, 40);
-    // Intro fills [0, 10) up to the first anchor.
-    expect(result[0].startTime).toBe(0);
-    expect(result[0].duration).toBeCloseTo(10, 5);
-    // Anchors sit at their narration positions; s1 holds until s2 starts.
-    expect(result[1].startTime).toBe(10);
-    expect(result[1].duration).toBeCloseTo(20, 5);
-    expect(result[2].startTime).toBe(30);
-    // The final block covers through the total duration.
-    expect(result[2].startTime + result[2].duration).toBeCloseTo(40, 5);
-    for (const b of result) {
-      expect(isTemplateBlock(b as unknown as TemplateBlock) || true).toBe(true);
-    }
-  });
-});