@bendyline/squisq 0.1.1 → 1.0.1

package/dist/timing/readingTime.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Reading time estimation.
+ *
+ * Estimates how long it takes to read text silently vs. narrate it aloud.
+ * Uses configurable words-per-minute rates.
+ */
+/** Result of a reading-time estimate. */
+export interface ReadingTimeEstimate {
+    /** Number of words (plain word count, not spoken equivalents). */
+    words: number;
+    /** Estimated minutes (decimal). */
+    minutes: number;
+    /** Estimated seconds (rounded). */
+    seconds: number;
+}
+/** Options for reading-time estimation. */
+export interface ReadingTimeOptions {
+    /** Words per minute for silent reading (default: 200). */
+    wordsPerMinute?: number;
+}
+/**
+ * Estimate silent reading time for a block of text.
+ *
+ * @param text - The text to estimate
+ * @param options - Optional configuration
+ * @returns Word count + time estimate
+ */
+export declare function estimateReadingTime(text: string, options?: ReadingTimeOptions): ReadingTimeEstimate;
+/** Result of a narration-time estimate. */
+export interface NarrationTimeEstimate {
+    /** Spoken word equivalents (numbers expanded, comma pauses added). */
+    spokenWords: number;
+    /** Estimated minutes (decimal). */
+    minutes: number;
+    /** Estimated seconds (rounded). */
+    seconds: number;
+}
+/** Options for narration-time estimation. */
+export interface NarrationTimeOptions {
+    /** Words per second for narration (default: 2.5 ≈ 150 WPM). */
+    wordsPerSecond?: number;
+}
+/**
+ * Estimate narration (spoken) time for a block of text.
+ *
+ * Unlike silent reading, this accounts for numbers being spoken as
+ * multiple words and pauses at commas.
+ *
+ * @param text - The text to estimate
+ * @param options - Optional configuration
+ * @returns Spoken word equivalents + time estimate
+ */
+export declare function estimateNarrationTime(text: string, options?: NarrationTimeOptions): NarrationTimeEstimate;
+//# sourceMappingURL=readingTime.d.ts.map

package/dist/timing/readingTime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"readingTime.d.ts","sourceRoot":"","sources":["../../src/timing/readingTime.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAOH,yCAAyC;AACzC,MAAM,WAAW,mBAAmB;IAClC,kEAAkE;IAClE,KAAK,EAAE,MAAM,CAAC;IACd,mCAAmC;IACnC,OAAO,EAAE,MAAM,CAAC;IAChB,mCAAmC;IACnC,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,2CAA2C;AAC3C,MAAM,WAAW,kBAAkB;IACjC,0DAA0D;IAC1D,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE,kBAAkB,GAC3B,mBAAmB,CAYrB;AAED,2CAA2C;AAC3C,MAAM,WAAW,qBAAqB;IACpC,sEAAsE;IACtE,WAAW,EAAE,MAAM,CAAC;IACpB,mCAAmC;IACnC,OAAO,EAAE,MAAM,CAAC;IAChB,mCAAmC;IACnC,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,6CAA6C;AAC7C,MAAM,WAAW,oBAAoB;IACnC,+DAA+D;IAC/D,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED;;;;;;;;;GASG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE,oBAAoB,GAC7B,qBAAqB,CAYvB"}

package/dist/timing/readingTime.js

@@ -0,0 +1,49 @@
+/**
+ * Reading time estimation.
+ *
+ * Estimates how long it takes to read text silently vs. narrate it aloud.
+ * Uses configurable words-per-minute rates.
+ */
+import { countSpokenWords, DEFAULT_WORDS_PER_SECOND } from './narrationTiming.js';
+/** Default silent reading rate (adults average ~200–250 WPM). */
+const DEFAULT_READING_WPM = 200;
+/**
+ * Estimate silent reading time for a block of text.
+ *
+ * @param text - The text to estimate
+ * @param options - Optional configuration
+ * @returns Word count + time estimate
+ */
+export function estimateReadingTime(text, options) {
+    const configuredWpm = options?.wordsPerMinute;
+    const wpm = typeof configuredWpm === 'number' && configuredWpm > 0 ? configuredWpm : DEFAULT_READING_WPM;
+    const words = text.split(/\s+/).filter((w) => w.length > 0).length;
+    const minutes = words / wpm;
+    return {
+        words,
+        minutes,
+        seconds: Math.round(minutes * 60),
+    };
+}
+/**
+ * Estimate narration (spoken) time for a block of text.
+ *
+ * Unlike silent reading, this accounts for numbers being spoken as
+ * multiple words and pauses at commas.
+ *
+ * @param text - The text to estimate
+ * @param options - Optional configuration
+ * @returns Spoken word equivalents + time estimate
+ */
+export function estimateNarrationTime(text, options) {
+    const providedWps = options?.wordsPerSecond;
+    const wps = typeof providedWps === 'number' && providedWps > 0 ? providedWps : DEFAULT_WORDS_PER_SECOND;
+    const spokenWords = countSpokenWords(text);
+    const totalSeconds = spokenWords / wps;
+    return {
+        spokenWords,
+        minutes: totalSeconds / 60,
+        seconds: Math.round(totalSeconds),
+    };
+}
+//# sourceMappingURL=readingTime.js.map

package/dist/timing/readingTime.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"readingTime.js","sourceRoot":"","sources":["../../src/timing/readingTime.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,gBAAgB,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAC;AAElF,iEAAiE;AACjE,MAAM,mBAAmB,GAAG,GAAG,CAAC;AAkBhC;;;;;;GAMG;AACH,MAAM,UAAU,mBAAmB,CACjC,IAAY,EACZ,OAA4B;IAE5B,MAAM,aAAa,GAAG,OAAO,EAAE,cAAc,CAAC;IAC9C,MAAM,GAAG,GACP,OAAO,aAAa,KAAK,QAAQ,IAAI,aAAa,GAAG,CAAC,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,mBAAmB,CAAC;IAC/F,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,MAAM,CAAC;IACnE,MAAM,OAAO,GAAG,KAAK,GAAG,GAAG,CAAC;IAE5B,OAAO;QACL,KAAK;QACL,OAAO;QACP,OAAO,EAAE,IAAI,CAAC,KAAK,CAAC,OAAO,GAAG,EAAE,CAAC;KAClC,CAAC;AACJ,CAAC;AAkBD;;;;;;;;;GASG;AACH,MAAM,UAAU,qBAAqB,CACnC,IAAY,EACZ,OAA8B;IAE9B,MAAM,WAAW,GAAG,OAAO,EAAE,cAAc,CAAC;IAC5C,MAAM,GAAG,GACP,OAAO,WAAW,KAAK,QAAQ,IAAI,WAAW,GAAG,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,wBAAwB,CAAC;IAC9F,MAAM,WAAW,GAAG,gBAAgB,CAAC,IAAI,CAAC,CAAC;IAC3C,MAAM,YAAY,GAAG,WAAW,GAAG,GAAG,CAAC;IAEvC,OAAO;QACL,WAAW;QACX,OAAO,EAAE,YAAY,GAAG,EAAE;QAC1B,OAAO,EAAE,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC;KAClC,CAAC;AACJ,CAAC"}

package/package.json

@@ -1,15 +1,15 @@
 {
   "name": "@bendyline/squisq",
-  "version": "0.1.1",
+  "version": "1.0.1",
   "description": "Headless utilities for doc/block rendering, spatial math, Markdown, and storage",
   "license": "MIT",
   "author": "Bendyline",
   "repository": {
     "type": "git",
-    "url": "https://github.com/nicknisi/squisq.git",
+    "url": "https://github.com/bendyline/squisq.git",
     "directory": "packages/core"
   },
-  "homepage": "https://github.com/nicknisi/squisq",
+  "homepage": "https://github.com/bendyline/squisq",
   "keywords": [
     "doc",
     "block",
@@ -65,12 +65,26 @@
       "types": "./dist/markdown/index.d.ts",
       "import": "./dist/markdown/index.js",
       "default": "./dist/markdown/index.js"
+    },
+    "./timing": {
+      "types": "./dist/timing/index.d.ts",
+      "import": "./dist/timing/index.js",
+      "default": "./dist/timing/index.js"
+    },
+    "./random": {
+      "types": "./dist/random/index.d.ts",
+      "import": "./dist/random/index.js",
+      "default": "./dist/random/index.js"
+    },
+    "./generate": {
+      "types": "./dist/generate/index.d.ts",
+      "import": "./dist/generate/index.js",
+      "default": "./dist/generate/index.js"
     }
   },
   "scripts": {
     "build": "tsup",
-    "typecheck": "tsc --noEmit",
-    "prepublishOnly": "npm run build"
+    "typecheck": "tsc --noEmit"
   },
   "dependencies": {
     "hast-util-from-html": "^2.0.0",

package/src/__tests__/contentExtractor.test.ts

@@ -0,0 +1,183 @@
+import { describe, expect, it } from 'vitest';
+import {
+  extractContent,
+  stripMarkdown,
+  type ExtractionResult,
+} from '../generate/contentExtractor.js';
+
+const SAMPLE_TEXT = [
+  'Mount Rainier is the largest volcano in the Cascades, standing at 14,411 feet.',
+  'In July 1899, the mountain was designated a national park.',
+  'The park sees roughly 2 million visitors each year.',
+  '"The mountain was calling me," wrote John Muir after his 1888 expedition.',
+  'Temperatures range from 20 degrees to 70 degrees depending on elevation.',
+  'The park features hiking, camping, fishing, and climbing.',
+  'Imagine standing above the clouds at sunrise!',
+  'Paradise is a popular visitor area known for its wildflower meadows.',
+  'Rainier is the most glaciated peak in the lower 48 states.',
+].join(' ');
+
+describe('extractContent', () => {
+  let result: ExtractionResult;
+
+  // Run extraction once for all tests
+  it('extracts elements from sample text', () => {
+    result = extractContent(SAMPLE_TEXT);
+    expect(result.elements.length).toBeGreaterThan(0);
+    expect(result.sourceLength).toBe(SAMPLE_TEXT.length);
+  });
+
+  it('finds stats', () => {
+    const stats = result.elements.filter((e) => e.type === 'stat');
+    expect(stats.length).toBeGreaterThan(0);
+    // Should find 14,411 feet and/or 2 million
+    const values = stats.map((s) => (s.data.type === 'stat' ? s.data.value : ''));
+    expect(
+      values.some((v) => v.includes('14,411') || v.includes('2 million') || v.includes('feet')),
+    ).toBe(true);
+  });
+
+  it('finds dates', () => {
+    const dates = result.elements.filter((e) => e.type === 'date');
+    expect(dates.length).toBeGreaterThan(0);
+  });
+
+  it('finds quotes', () => {
+    const quotes = result.elements.filter((e) => e.type === 'quote');
+    expect(quotes.length).toBeGreaterThan(0);
+    const quoteData = quotes[0].data;
+    if (quoteData.type === 'quote') {
+      expect(quoteData.quote).toContain('mountain was calling me');
+    }
+  });
+
+  it('respects minConfidence filter', () => {
+    const strict = extractContent(SAMPLE_TEXT, { minConfidence: 0.9 });
+    const loose = extractContent(SAMPLE_TEXT, { minConfidence: 0.1 });
+    expect(loose.elements.length).toBeGreaterThanOrEqual(strict.elements.length);
+  });
+
+  it('respects types filter', () => {
+    const onlyStats = extractContent(SAMPLE_TEXT, { types: ['stat'] });
+    for (const elem of onlyStats.elements) {
+      expect(elem.type).toBe('stat');
+    }
+  });
+
+  it('respects maxPerType', () => {
+    const limited = extractContent(SAMPLE_TEXT, { maxPerType: 1 });
+    const typeCounts = new Map<string, number>();
+    for (const elem of limited.elements) {
+      typeCounts.set(elem.type, (typeCounts.get(elem.type) ?? 0) + 1);
+    }
+    for (const count of typeCounts.values()) {
+      expect(count).toBeLessThanOrEqual(1);
+    }
+  });
+
+  it('deduplicates overlapping extractions', () => {
+    // Every element should have a unique source position range
+    for (let i = 0; i < result.elements.length; i++) {
+      for (let j = i + 1; j < result.elements.length; j++) {
+        const a = result.elements[i];
+        const b = result.elements[j];
+        // They shouldn't share the exact same start position
+        if (a.sourcePosition === b.sourcePosition) {
+          // If they overlap, one should have been removed by dedup
+          // (this is checking that the dedup is working at all)
+          expect(a.type).not.toBe(b.type);
+        }
+      }
+    }
+  });
+
+  it('returns correct stats counts', () => {
+    expect(result.stats.totalCount).toBe(result.elements.length);
+    expect(result.stats.statCount).toBe(result.elements.filter((e) => e.type === 'stat').length);
+  });
+
+  it('sorts elements by source position', () => {
+    for (let i = 1; i < result.elements.length; i++) {
+      expect(result.elements[i].sourcePosition).toBeGreaterThanOrEqual(
+        result.elements[i - 1].sourcePosition,
+      );
+    }
+  });
+});
+
+describe('extractContent — comparisons', () => {
+  it('detects "from X to Y" comparisons', () => {
+    const text = 'Temperatures range from 20 degrees to 70 degrees depending on altitude.';
+    const result = extractContent(text, { types: ['comparison'] });
+    expect(result.elements.length).toBeGreaterThan(0);
+    const comp = result.elements[0].data;
+    if (comp.type === 'comparison') {
+      expect(comp.left.label).toBeTruthy();
+      expect(comp.right.label).toBeTruthy();
+    }
+  });
+});
+
+describe('extractContent — impact lines', () => {
+  it('detects short punchy sentences', () => {
+    const text =
+      'Imagine standing above the clouds! Discover the hidden valley. The weather is variable.';
+    const result = extractContent(text, { types: ['impactLine'] });
+    expect(result.elements.length).toBeGreaterThan(0);
+  });
+});
+
+describe('extractContent — lists', () => {
+  it('detects "including X, Y, and Z" lists', () => {
+    const text = 'Activities including hiking, camping, fishing, and climbing are popular.';
+    const result = extractContent(text, { types: ['list'] });
+    expect(result.elements.length).toBeGreaterThan(0);
+    const listData = result.elements[0].data;
+    if (listData.type === 'list') {
+      expect(listData.items.length).toBeGreaterThanOrEqual(3);
+    }
+  });
+});
+
+describe('extractContent — definitions', () => {
+  it('detects "Term is a definition" patterns', () => {
+    const text =
+      'Paradise is a popular visitor area known for its wildflower meadows and scenic viewpoints.';
+    const result = extractContent(text, { types: ['definition'] });
+    expect(result.elements.length).toBeGreaterThan(0);
+    const defData = result.elements[0].data;
+    if (defData.type === 'definition') {
+      expect(defData.term).toBe('Paradise');
+    }
+  });
+});
+
+describe('stripMarkdown', () => {
+  it('removes headers', () => {
+    expect(stripMarkdown('# Hello\n## World')).toBe('Hello\nWorld');
+  });
+
+  it('removes bold and italic', () => {
+    expect(stripMarkdown('**bold** and *italic*')).toBe('bold and italic');
+  });
+
+  it('removes links, keeping text', () => {
+    expect(stripMarkdown('[Click here](https://example.com)')).toBe('Click here');
+  });
+
+  it('removes images entirely', () => {
+    expect(stripMarkdown('![alt text](image.png)')).toBe('');
+  });
+
+  it('removes code blocks', () => {
+    expect(stripMarkdown('before\n```js\ncode\n```\nafter')).toBe('before\n\nafter');
+  });
+
+  it('removes blockquote markers', () => {
+    expect(stripMarkdown('> quoted text')).toBe('quoted text');
+  });
+
+  it('collapses excess newlines', () => {
+    expect(stripMarkdown('a\n\n\n\nb')).toBe('a\n\nb');
+  });
+});

package/src/__tests__/seededRandom.test.ts

@@ -0,0 +1,142 @@
+import { describe, expect, it } from 'vitest';
+import { SeededRandom, hashString } from '../random/index.js';
+
+describe('SeededRandom', () => {
+  it('produces deterministic output from the same seed', () => {
+    const a = new SeededRandom(42);
+    const b = new SeededRandom(42);
+    expect(a.next()).toBe(b.next());
+    expect(a.next()).toBe(b.next());
+    expect(a.next()).toBe(b.next());
+  });
+
+  it('produces different output from different seeds', () => {
+    const a = new SeededRandom(1);
+    const b = new SeededRandom(2);
+    expect(a.next()).not.toBe(b.next());
+  });
+
+  it('next() returns values in [0, 1)', () => {
+    const rng = new SeededRandom(123);
+    for (let i = 0; i < 100; i++) {
+      const v = rng.next();
+      expect(v).toBeGreaterThanOrEqual(0);
+      expect(v).toBeLessThan(1);
+    }
+  });
+
+  it('nextInt(max) returns values in [0, max)', () => {
+    const rng = new SeededRandom(99);
+    for (let i = 0; i < 100; i++) {
+      const v = rng.nextInt(10);
+      expect(v).toBeGreaterThanOrEqual(0);
+      expect(v).toBeLessThan(10);
+      expect(Number.isInteger(v)).toBe(true);
+    }
+  });
+
+  it('nextIntRange(min, max) stays in range', () => {
+    const rng = new SeededRandom(77);
+    for (let i = 0; i < 100; i++) {
+      const v = rng.nextIntRange(5, 15);
+      expect(v).toBeGreaterThanOrEqual(5);
+      expect(v).toBeLessThan(15);
+    }
+  });
+
+  it('pick returns undefined for empty array', () => {
+    const rng = new SeededRandom(1);
+    expect(rng.pick([])).toBeUndefined();
+  });
+
+  it('pick returns an element from the array', () => {
+    const rng = new SeededRandom(1);
+    const items = ['a', 'b', 'c'];
+    const picked = rng.pick(items);
+    expect(items).toContain(picked);
+  });
+
+  it('pickRequired throws on empty array', () => {
+    const rng = new SeededRandom(1);
+    expect(() => rng.pickRequired([])).toThrow('Cannot pick from empty array');
+  });
+
+  it('pickMultiple returns correct count', () => {
+    const rng = new SeededRandom(42);
+    const result = rng.pickMultiple([1, 2, 3, 4, 5], 3);
+    expect(result).toHaveLength(3);
+    // All elements should be unique
+    expect(new Set(result).size).toBe(3);
+  });
+
+  it('pickMultiple returns all if count >= length', () => {
+    const rng = new SeededRandom(42);
+    const result = rng.pickMultiple([1, 2, 3], 5);
+    expect(result).toHaveLength(3);
+    expect(new Set(result).size).toBe(3);
+  });
+
+  it('shuffle is deterministic', () => {
+    const a = new SeededRandom(42);
+    const b = new SeededRandom(42);
+    expect(a.shuffle([1, 2, 3, 4, 5])).toEqual(b.shuffle([1, 2, 3, 4, 5]));
+  });
+
+  it('shuffled does not modify original', () => {
+    const rng = new SeededRandom(42);
+    const original = [1, 2, 3, 4, 5];
+    const copy = [...original];
+    rng.shuffled(original);
+    expect(original).toEqual(copy);
+  });
+
+  it('pickWeighted respects weights', () => {
+    // Heavily weight 'a' — over many picks it should dominate
+    const rng = new SeededRandom(42);
+    const items = [
+      { item: 'a', weight: 100 },
+      { item: 'b', weight: 1 },
+    ];
+    let aCount = 0;
+    for (let i = 0; i < 100; i++) {
+      if (rng.pickWeighted(items) === 'a') aCount++;
+    }
+    expect(aCount).toBeGreaterThan(80);
+  });
+
+  it('pickWeighted returns undefined for empty', () => {
+    const rng = new SeededRandom(1);
+    expect(rng.pickWeighted([])).toBeUndefined();
+  });
+
+  it('derive creates independent stream', () => {
+    const rng = new SeededRandom(42);
+    const d1 = rng.derive('stream-a');
+    const d2 = rng.derive('stream-b');
+    expect(d1.next()).not.toBe(d2.next());
+  });
+
+  it('handles seed of 0 gracefully', () => {
+    const rng = new SeededRandom(0);
+    const v = rng.next();
+    expect(v).toBeGreaterThanOrEqual(0);
+    expect(v).toBeLessThan(1);
+  });
+});
+
+describe('hashString', () => {
+  it('returns a positive 32-bit integer', () => {
+    const h = hashString('hello world');
+    expect(h).toBeGreaterThanOrEqual(0);
+    expect(h).toBeLessThanOrEqual(0xffffffff);
+    expect(Number.isInteger(h)).toBe(true);
+  });
+
+  it('is deterministic', () => {
+    expect(hashString('test')).toBe(hashString('test'));
+  });
+
+  it('differs for different strings', () => {
+    expect(hashString('abc')).not.toBe(hashString('xyz'));
+  });
+});

package/src/__tests__/slideshowGenerator.test.ts

@@ -0,0 +1,128 @@
+import { describe, expect, it } from 'vitest';
+import { generateSlideshow, type SlideshowImage } from '../generate/index.js';
+import { isTemplateBlock } from '../schemas/BlockTemplates.js';
+
+const ARTICLE_TEXT = [
+  'Mount Rainier is the largest volcano in the Cascades, standing at 14,411 feet.',
+  'In July 1899, President McKinley signed the act establishing Mount Rainier National Park.',
+  'The park encompasses roughly 236,381 acres of old-growth forest and alpine meadows.',
+  '"The mountain was calling me," wrote John Muir after his 1888 expedition to explore the glaciers.',
+  'Temperatures range from 20 degrees to 70 degrees depending on elevation and season.',
+  'Popular activities including hiking, camping, fishing, and climbing draw visitors year-round.',
+  'Paradise is a popular visitor area known for its wildflower meadows and spectacular views.',
+  'The mountain has 25 named glaciers covering about 35 square miles of ice.',
+  'Rainier is the most glaciated peak in the lower 48 states, a remarkable natural wonder.',
+  'Imagine standing above the clouds at sunrise!',
+].join('\n\n');
+
+const SAMPLE_IMAGES: SlideshowImage[] = [
+  { src: '/img/rainier-1.jpg', alt: 'Mount Rainier from Paradise' },
+  { src: '/img/rainier-2.jpg', alt: 'Wildflower meadow', credit: 'NPS Photo' },
+  { src: '/img/rainier-3.jpg', alt: 'Nisqually Glacier' },
+];
+
+describe('generateSlideshow', () => {
+  it('produces a valid Doc with blocks', () => {
+    const doc = generateSlideshow(ARTICLE_TEXT);
+    expect(doc.blocks.length).toBeGreaterThan(0);
+    expect(doc.duration).toBeGreaterThan(0);
+    expect(doc.articleId).toBe('slideshow');
+  });
+
+  it('includes a title slide when title is provided', () => {
+    const doc = generateSlideshow(ARTICLE_TEXT, [], { title: 'Mount Rainier' });
+    expect(doc.articleId).toBe('Mount Rainier');
+    const first = doc.blocks[0];
+    if (isTemplateBlock(first)) {
+      expect(first.template).toBe('titleBlock');
+    }
+  });
+
+  it('embeds themeId in the Doc', () => {
+    const doc = generateSlideshow(ARTICLE_TEXT, [], { themeId: 'cinematic' });
+    expect(doc.themeId).toBe('cinematic');
+  });
+
+  it('interleaves image slides when images are provided', () => {
+    const doc = generateSlideshow(ARTICLE_TEXT, SAMPLE_IMAGES);
+    const imageSlides = doc.blocks.filter(
+      (b) => isTemplateBlock(b) && b.template === 'imageWithCaption',
+    );
+    expect(imageSlides.length).toBeGreaterThan(0);
+  });
+
+  it('produces deterministic output with the same seed', () => {
+    const a = generateSlideshow(ARTICLE_TEXT, SAMPLE_IMAGES, { seed: 42 });
+    const b = generateSlideshow(ARTICLE_TEXT, SAMPLE_IMAGES, { seed: 42 });
+    expect(a.blocks.length).toBe(b.blocks.length);
+    for (let i = 0; i < a.blocks.length; i++) {
+      if (isTemplateBlock(a.blocks[i]) && isTemplateBlock(b.blocks[i])) {
+        const aBlock = a.blocks[i] as { template: string };
+        const bBlock = b.blocks[i] as { template: string };
+        expect(aBlock.template).toBe(bBlock.template);
+      }
+    }
+  });
+
+  it('produces different output with different seeds', () => {
+    const a = generateSlideshow(ARTICLE_TEXT, SAMPLE_IMAGES, { seed: 1 });
+    const b = generateSlideshow(ARTICLE_TEXT, SAMPLE_IMAGES, { seed: 999 });
+    // At least some image accents or motions should differ
+    const aSerialized = JSON.stringify(a.blocks);
+    const bSerialized = JSON.stringify(b.blocks);
+    // They should differ in at least some detail (ambient motions, accent positions)
+    expect(aSerialized).not.toBe(bSerialized);
+  });
+
+  it('handles empty text gracefully', () => {
+    const doc = generateSlideshow('', []);
+    expect(doc.blocks.length).toBe(0);
+    expect(doc.duration).toBe(0);
+  });
+
+  it('handles markdown input when isMarkdown is set', () => {
+    const md = '# Title\n\nThe park covers **236,381 acres** of wilderness.';
+    const doc = generateSlideshow(md, [], { isMarkdown: true });
+    expect(doc.blocks.length).toBeGreaterThan(0);
+  });
+
+  it('uses explicit duration when provided', () => {
+    const doc = generateSlideshow(ARTICLE_TEXT, [], { duration: 60 });
+    expect(doc.duration).toBe(60);
+  });
+
+  it('respects targetSlides option', () => {
+    const doc = generateSlideshow(ARTICLE_TEXT, [], { targetSlides: 3 });
+    // Should have ~3 slides (may be slightly more due to title, images)
+    expect(doc.blocks.length).toBeLessThanOrEqual(5);
+    expect(doc.blocks.length).toBeGreaterThan(0);
+  });
+
+  it('every block has an id and duration', () => {
+    const doc = generateSlideshow(ARTICLE_TEXT, SAMPLE_IMAGES, { title: 'Test' });
+    for (const block of doc.blocks) {
+      if (isTemplateBlock(block)) {
+        expect(block.id).toBeTruthy();
+        expect(block.duration).toBeGreaterThan(0);
+      }
+    }
+  });
+
+  it('rotates color schemes across content slides', () => {
+    const doc = generateSlideshow(ARTICLE_TEXT, [], {
+      colorSchemes: ['blue', 'green'],
+      targetSlides: 6,
+    });
+    const colors: string[] = [];
+    for (const block of doc.blocks) {
+      if (isTemplateBlock(block) && 'colorScheme' in block) {
+        const cs = (block as { colorScheme?: string }).colorScheme;
+        if (cs) colors.push(cs);
+      }
+    }
+    // With 2 schemes, we should see alternation
+    if (colors.length >= 2) {
+      expect(colors[0]).not.toBe(colors[1]);
+    }
+  });
+});