@contractspec/lib.voice 0.2.0

package/dist/tts/index.d.ts

@@ -0,0 +1,6 @@
+export { VoiceSynthesizer } from './voice-synthesizer';
+export { PaceAnalyzer } from './pace-analyzer';
+export { EmphasisPlanner } from './emphasis-planner';
+export { SegmentSynthesizer } from './segment-synthesizer';
+export { AudioAssembler } from './audio-assembler';
+export type { TTSBrief, TTSVoiceConfig, PacingConfig, TTSProject, TTSScript, TTSScriptSegment, SynthesizedSegment, TTSOptions, VideoTTSBrief, } from './types';

package/dist/tts/index.js

@@ -0,0 +1,440 @@
+// @bun
+// src/audio/audio-concatenator.ts
+class AudioConcatenator {
+  concatenate(segments) {
+    if (segments.length === 0) {
+      return {
+        data: new Uint8Array(0),
+        format: "wav",
+        sampleRateHz: 44100,
+        durationMs: 0,
+        channels: 1
+      };
+    }
+    const [firstSegment] = segments;
+    if (!firstSegment) {
+      return {
+        data: new Uint8Array(0),
+        format: "wav",
+        sampleRateHz: 44100,
+        durationMs: 0,
+        channels: 1
+      };
+    }
+    if (segments.length === 1) {
+      return { ...firstSegment };
+    }
+    const referenceFormat = firstSegment.format;
+    const referenceSampleRate = firstSegment.sampleRateHz;
+    const referenceChannels = firstSegment.channels ?? 1;
+    for (const seg of segments) {
+      if (seg.format !== referenceFormat) {
+        throw new Error(`Format mismatch: expected ${referenceFormat}, got ${seg.format}`);
+      }
+      if (seg.sampleRateHz !== referenceSampleRate) {
+        throw new Error(`Sample rate mismatch: expected ${referenceSampleRate}, got ${seg.sampleRateHz}`);
+      }
+    }
+    const totalBytes = segments.reduce((sum, s) => sum + s.data.length, 0);
+    const combined = new Uint8Array(totalBytes);
+    let offset = 0;
+    for (const seg of segments) {
+      combined.set(seg.data, offset);
+      offset += seg.data.length;
+    }
+    const totalDurationMs = segments.reduce((sum, s) => sum + (s.durationMs ?? 0), 0);
+    return {
+      data: combined,
+      format: referenceFormat,
+      sampleRateHz: referenceSampleRate,
+      durationMs: totalDurationMs,
+      channels: referenceChannels
+    };
+  }
+}
+
+// src/audio/duration-estimator.ts
+class DurationEstimator {
+  static DEFAULT_WPM = 150;
+  estimateSeconds(text, wordsPerMinute) {
+    const wpm = wordsPerMinute ?? DurationEstimator.DEFAULT_WPM;
+    const wordCount = text.split(/\s+/).filter(Boolean).length;
+    return Math.ceil(wordCount / wpm * 60);
+  }
+  estimateMs(text, wordsPerMinute) {
+    const wpm = wordsPerMinute ?? DurationEstimator.DEFAULT_WPM;
+    const wordCount = text.split(/\s+/).filter(Boolean).length;
+    return Math.ceil(wordCount / wpm * 60 * 1000);
+  }
+  estimateWordCount(durationSeconds, wordsPerMinute) {
+    const wpm = wordsPerMinute ?? DurationEstimator.DEFAULT_WPM;
+    return Math.round(durationSeconds / 60 * wpm);
+  }
+}
+
+// src/audio/silence-generator.ts
+class SilenceGenerator {
+  generate(durationMs, format = "wav", sampleRateHz = 44100, channels = 1) {
+    const totalSamples = Math.ceil(sampleRateHz * durationMs / 1000);
+    const bytesPerSample = 2;
+    const dataSize = totalSamples * bytesPerSample * channels;
+    const data = new Uint8Array(dataSize);
+    return {
+      data,
+      format,
+      sampleRateHz,
+      durationMs,
+      channels
+    };
+  }
+}
+
+// src/tts/pace-analyzer.ts
+var CONTENT_TYPE_PACING = {
+  intro: {
+    rate: 0.95,
+    emphasis: "normal",
+    tone: "authoritative",
+    leadingSilenceMs: 0,
+    trailingSilenceMs: 500
+  },
+  problem: {
+    rate: 0.9,
+    emphasis: "strong",
+    tone: "urgent",
+    leadingSilenceMs: 300,
+    trailingSilenceMs: 500
+  },
+  solution: {
+    rate: 1,
+    emphasis: "normal",
+    tone: "calm",
+    leadingSilenceMs: 300,
+    trailingSilenceMs: 500
+  },
+  metric: {
+    rate: 0.85,
+    emphasis: "strong",
+    tone: "excited",
+    leadingSilenceMs: 300,
+    trailingSilenceMs: 600
+  },
+  cta: {
+    rate: 0.9,
+    emphasis: "strong",
+    tone: "authoritative",
+    leadingSilenceMs: 400,
+    trailingSilenceMs: 0
+  },
+  transition: {
+    rate: 1.1,
+    emphasis: "reduced",
+    tone: "neutral",
+    leadingSilenceMs: 200,
+    trailingSilenceMs: 300
+  }
+};
+
+class PaceAnalyzer {
+  analyze(segments, baseRate = 1) {
+    return segments.map((segment) => {
+      const defaults = CONTENT_TYPE_PACING[segment.contentType];
+      return {
+        sceneId: segment.sceneId,
+        rate: defaults.rate * baseRate,
+        emphasis: defaults.emphasis,
+        tone: defaults.tone,
+        leadingSilenceMs: defaults.leadingSilenceMs,
+        trailingSilenceMs: defaults.trailingSilenceMs
+      };
+    });
+  }
+  getDefaults(contentType) {
+    return { ...CONTENT_TYPE_PACING[contentType] };
+  }
+}
+
+// src/tts/emphasis-planner.ts
+class EmphasisPlanner {
+  llm;
+  model;
+  paceAnalyzer;
+  constructor(options) {
+    this.llm = options?.llm;
+    this.model = options?.model;
+    this.paceAnalyzer = new PaceAnalyzer;
+  }
+  async plan(segments, baseRate = 1) {
+    if (!this.llm) {
+      return this.paceAnalyzer.analyze(segments, baseRate);
+    }
+    try {
+      return await this.planWithLlm(segments, baseRate);
+    } catch {
+      return this.paceAnalyzer.analyze(segments, baseRate);
+    }
+  }
+  async planWithLlm(segments, baseRate) {
+    if (!this.llm) {
+      return this.paceAnalyzer.analyze(segments, baseRate);
+    }
+    const response = await this.llm.chat([
+      {
+        role: "system",
+        content: [
+          {
+            type: "text",
+            text: [
+              "You are a voice director planning emphasis and pacing for TTS narration.",
+              "For each segment, return a JSON array of directives.",
+              "Each directive has: sceneId, rate (0.7-1.3), emphasis (reduced|normal|strong),",
+              "tone (neutral|urgent|excited|calm|authoritative), leadingSilenceMs, trailingSilenceMs.",
+              "Return ONLY a JSON array, no other text."
+            ].join(`
+`)
+          }
+        ]
+      },
+      {
+        role: "user",
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(segments.map((s) => ({
+              sceneId: s.sceneId,
+              text: s.text,
+              contentType: s.contentType
+            })))
+          }
+        ]
+      }
+    ], { model: this.model, temperature: 0.3, responseFormat: "json" });
+    const text = response.message.content.find((p) => p.type === "text");
+    if (!text || text.type !== "text") {
+      return this.paceAnalyzer.analyze(segments, baseRate);
+    }
+    const parsed = JSON.parse(text.text);
+    return parsed.map((d) => ({
+      ...d,
+      rate: d.rate * baseRate
+    }));
+  }
+}
+
+// src/tts/segment-synthesizer.ts
+class SegmentSynthesizer {
+  tts;
+  constructor(tts) {
+    this.tts = tts;
+  }
+  async synthesizeAll(segments, voice, directives) {
+    const directiveMap = new Map(directives.map((d) => [d.sceneId, d]));
+    const results = await Promise.all(segments.map((segment) => this.synthesizeOne(segment, voice, directiveMap.get(segment.sceneId))));
+    return results;
+  }
+  async synthesizeOne(segment, voice, directive) {
+    const result = await this.tts.synthesize({
+      text: segment.text,
+      voiceId: voice.voiceId,
+      language: voice.language,
+      style: voice.style,
+      stability: voice.stability,
+      rate: directive?.rate,
+      emphasis: directive?.emphasis
+    });
+    return {
+      sceneId: segment.sceneId,
+      audio: result.audio,
+      durationMs: result.audio.durationMs ?? 0,
+      wordTimings: result.wordTimings?.map((wt) => ({
+        word: wt.word,
+        startMs: wt.startMs,
+        endMs: wt.endMs
+      }))
+    };
+  }
+}
+
+// src/tts/audio-assembler.ts
+class AudioAssembler {
+  concatenator = new AudioConcatenator;
+  silenceGenerator = new SilenceGenerator;
+  assemble(segments, directives, defaultPauseMs = 500) {
+    if (segments.length === 0) {
+      return {
+        data: new Uint8Array(0),
+        format: "wav",
+        sampleRateHz: 44100,
+        durationMs: 0,
+        channels: 1
+      };
+    }
+    const [firstSegment] = segments;
+    if (!firstSegment) {
+      return {
+        data: new Uint8Array(0),
+        format: "wav",
+        sampleRateHz: 44100,
+        durationMs: 0,
+        channels: 1
+      };
+    }
+    const directiveMap = new Map(directives.map((d) => [d.sceneId, d]));
+    const reference = firstSegment.audio;
+    const parts = [];
+    for (let i = 0;i < segments.length; i++) {
+      const segment = segments[i];
+      if (!segment) {
+        continue;
+      }
+      const directive = directiveMap.get(segment.sceneId);
+      const leadingSilenceMs = directive?.leadingSilenceMs ?? 0;
+      if (leadingSilenceMs > 0) {
+        parts.push(this.silenceGenerator.generate(leadingSilenceMs, reference.format, reference.sampleRateHz, reference.channels ?? 1));
+      }
+      parts.push(segment.audio);
+      const trailingSilenceMs = directive?.trailingSilenceMs ?? (i < segments.length - 1 ? defaultPauseMs : 0);
+      if (trailingSilenceMs > 0) {
+        parts.push(this.silenceGenerator.generate(trailingSilenceMs, reference.format, reference.sampleRateHz, reference.channels ?? 1));
+      }
+    }
+    return this.concatenator.concatenate(parts);
+  }
+}
+
+// src/tts/voice-synthesizer.ts
+class VoiceSynthesizer {
+  segmentSynthesizer;
+  emphasisPlanner;
+  audioAssembler = new AudioAssembler;
+  durationEstimator = new DurationEstimator;
+  paceAnalyzer = new PaceAnalyzer;
+  options;
+  constructor(options) {
+    this.options = options;
+    this.segmentSynthesizer = new SegmentSynthesizer(options.tts);
+    this.emphasisPlanner = new EmphasisPlanner({
+      llm: options.llm,
+      model: options.model
+    });
+  }
+  async synthesize(brief) {
+    const script = this.buildScript(brief);
+    return this.executePipeline(script, brief.voice, brief.pacing);
+  }
+  async synthesizeForVideo(brief) {
+    const script = this.buildScriptFromScenePlan(brief);
+    return this.executePipeline(script, brief.voice, brief.pacing, brief.fps);
+  }
+  async executePipeline(script, voice, pacing, fps) {
+    const projectId = generateProjectId();
+    const baseRate = pacing?.baseRate ?? 1;
+    const pacingDirectives = await this.emphasisPlanner.plan(script.segments, baseRate);
+    const synthesized = await this.segmentSynthesizer.synthesizeAll(script.segments, voice, pacingDirectives);
+    const pauseMs = pacing?.segmentPauseMs ?? 500;
+    const assembledAudio = this.audioAssembler.assemble(synthesized, pacingDirectives, pauseMs);
+    const effectiveFps = fps ?? this.options.fps ?? 30;
+    const breathingRoomFactor = pacing?.breathingRoomFactor ?? 1.15;
+    const timingMap = this.buildTimingMap(synthesized, effectiveFps, breathingRoomFactor);
+    return {
+      id: projectId,
+      script,
+      pacingDirectives,
+      segments: synthesized,
+      assembledAudio,
+      timingMap
+    };
+  }
+  buildScript(brief) {
+    const segments = [];
+    const introText = `${brief.content.title}. ${brief.content.summary}`;
+    segments.push({
+      sceneId: "intro",
+      text: introText,
+      estimatedDurationSeconds: this.durationEstimator.estimateSeconds(introText),
+      contentType: "intro"
+    });
+    if (brief.content.problems.length > 0) {
+      const text = brief.content.problems.join(". ");
+      segments.push({
+        sceneId: "problems",
+        text,
+        estimatedDurationSeconds: this.durationEstimator.estimateSeconds(text),
+        contentType: "problem"
+      });
+    }
+    if (brief.content.solutions.length > 0) {
+      const text = brief.content.solutions.join(". ");
+      segments.push({
+        sceneId: "solutions",
+        text,
+        estimatedDurationSeconds: this.durationEstimator.estimateSeconds(text),
+        contentType: "solution"
+      });
+    }
+    if (brief.content.metrics && brief.content.metrics.length > 0) {
+      const text = brief.content.metrics.join(". ");
+      segments.push({
+        sceneId: "metrics",
+        text,
+        estimatedDurationSeconds: this.durationEstimator.estimateSeconds(text),
+        contentType: "metric"
+      });
+    }
+    if (brief.content.callToAction) {
+      segments.push({
+        sceneId: "cta",
+        text: brief.content.callToAction,
+        estimatedDurationSeconds: this.durationEstimator.estimateSeconds(brief.content.callToAction),
+        contentType: "cta"
+      });
+    }
+    const fullText = segments.map((s) => s.text).join(" ");
+    const estimatedDurationSeconds = segments.reduce((sum, s) => sum + s.estimatedDurationSeconds, 0);
+    return { fullText, segments, estimatedDurationSeconds };
+  }
+  buildScriptFromScenePlan(brief) {
+    const segments = brief.scenePlan.scenes.filter((scene) => scene.narrationText).map((scene) => {
+      const text = scene.narrationText ?? "";
+      return {
+        sceneId: scene.id,
+        text,
+        estimatedDurationSeconds: this.durationEstimator.estimateSeconds(text),
+        contentType: "intro"
+      };
+    });
+    const fullText = segments.map((s) => s.text).join(" ");
+    const estimatedDurationSeconds = segments.reduce((sum, s) => sum + s.estimatedDurationSeconds, 0);
+    return { fullText, segments, estimatedDurationSeconds };
+  }
+  buildTimingMap(segments, fps, breathingRoomFactor) {
+    const timingSegments = segments.map((seg) => {
+      const durationInFrames = Math.ceil(seg.durationMs / 1000 * fps);
+      return {
+        sceneId: seg.sceneId,
+        durationMs: seg.durationMs,
+        durationInFrames,
+        recommendedSceneDurationInFrames: Math.ceil(durationInFrames * breathingRoomFactor),
+        wordTimings: seg.wordTimings?.map((wt) => ({
+          word: wt.word,
+          startMs: wt.startMs,
+          endMs: wt.endMs
+        }))
+      };
+    });
+    const totalDurationMs = segments.reduce((sum, s) => sum + s.durationMs, 0);
+    return { totalDurationMs, segments: timingSegments, fps };
+  }
+}
+function generateProjectId() {
+  const timestamp = Date.now().toString(36);
+  const random = Math.random().toString(36).slice(2, 8);
+  return `tts_${timestamp}_${random}`;
+}
+export {
+  VoiceSynthesizer,
+  SegmentSynthesizer,
+  PaceAnalyzer,
+  EmphasisPlanner,
+  AudioAssembler
+};

package/dist/tts/pace-analyzer.d.ts

@@ -0,0 +1,30 @@
+import type { VoicePacingDirective } from '../types';
+import type { TTSScriptSegment } from './types';
+type ContentType = TTSScriptSegment['contentType'];
+type Tone = VoicePacingDirective['tone'];
+type Emphasis = VoicePacingDirective['emphasis'];
+interface PacingDefaults {
+    rate: number;
+    emphasis: Emphasis;
+    tone: Tone;
+    leadingSilenceMs: number;
+    trailingSilenceMs: number;
+}
+/**
+ * Analyze content segments and produce pacing directives.
+ *
+ * Uses a deterministic content-type -> pacing mapping as fallback.
+ * When an LLM is provided, can enhance with fine-grained analysis.
+ */
+export declare class PaceAnalyzer {
+    /**
+     * Generate pacing directives for a list of script segments.
+     *
+     * @param segments - The TTS script segments to analyze
+     * @param baseRate - Base rate multiplier applied to all directives
+     */
+    analyze(segments: TTSScriptSegment[], baseRate?: number): VoicePacingDirective[];
+    /** Get the default pacing for a content type */
+    getDefaults(contentType: ContentType): PacingDefaults;
+}
+export {};

package/dist/tts/pace-analyzer.js

@@ -0,0 +1,68 @@
+// @bun
+// src/tts/pace-analyzer.ts
+var CONTENT_TYPE_PACING = {
+  intro: {
+    rate: 0.95,
+    emphasis: "normal",
+    tone: "authoritative",
+    leadingSilenceMs: 0,
+    trailingSilenceMs: 500
+  },
+  problem: {
+    rate: 0.9,
+    emphasis: "strong",
+    tone: "urgent",
+    leadingSilenceMs: 300,
+    trailingSilenceMs: 500
+  },
+  solution: {
+    rate: 1,
+    emphasis: "normal",
+    tone: "calm",
+    leadingSilenceMs: 300,
+    trailingSilenceMs: 500
+  },
+  metric: {
+    rate: 0.85,
+    emphasis: "strong",
+    tone: "excited",
+    leadingSilenceMs: 300,
+    trailingSilenceMs: 600
+  },
+  cta: {
+    rate: 0.9,
+    emphasis: "strong",
+    tone: "authoritative",
+    leadingSilenceMs: 400,
+    trailingSilenceMs: 0
+  },
+  transition: {
+    rate: 1.1,
+    emphasis: "reduced",
+    tone: "neutral",
+    leadingSilenceMs: 200,
+    trailingSilenceMs: 300
+  }
+};
+
+class PaceAnalyzer {
+  analyze(segments, baseRate = 1) {
+    return segments.map((segment) => {
+      const defaults = CONTENT_TYPE_PACING[segment.contentType];
+      return {
+        sceneId: segment.sceneId,
+        rate: defaults.rate * baseRate,
+        emphasis: defaults.emphasis,
+        tone: defaults.tone,
+        leadingSilenceMs: defaults.leadingSilenceMs,
+        trailingSilenceMs: defaults.trailingSilenceMs
+      };
+    });
+  }
+  getDefaults(contentType) {
+    return { ...CONTENT_TYPE_PACING[contentType] };
+  }
+}
+export {
+  PaceAnalyzer
+};

package/dist/tts/segment-synthesizer.d.ts

@@ -0,0 +1,21 @@
+import type { TTSProvider, VoicePacingDirective } from '../types';
+import type { SynthesizedSegment, TTSScriptSegment, TTSVoiceConfig } from './types';
+/**
+ * Synthesize individual script segments via TTSProvider.
+ *
+ * Applies pacing directives (rate, emphasis) to each synthesis call.
+ * Runs segments in parallel via Promise.all().
+ */
+export declare class SegmentSynthesizer {
+    private readonly tts;
+    constructor(tts: TTSProvider);
+    /**
+     * Synthesize all segments in parallel.
+     *
+     * @param segments - Script segments to synthesize
+     * @param voice - Voice configuration
+     * @param directives - Pacing directives per segment (matched by sceneId)
+     */
+    synthesizeAll(segments: TTSScriptSegment[], voice: TTSVoiceConfig, directives: VoicePacingDirective[]): Promise<SynthesizedSegment[]>;
+    private synthesizeOne;
+}

package/dist/tts/segment-synthesizer.js

@@ -0,0 +1,37 @@
+// @bun
+// src/tts/segment-synthesizer.ts
+class SegmentSynthesizer {
+  tts;
+  constructor(tts) {
+    this.tts = tts;
+  }
+  async synthesizeAll(segments, voice, directives) {
+    const directiveMap = new Map(directives.map((d) => [d.sceneId, d]));
+    const results = await Promise.all(segments.map((segment) => this.synthesizeOne(segment, voice, directiveMap.get(segment.sceneId))));
+    return results;
+  }
+  async synthesizeOne(segment, voice, directive) {
+    const result = await this.tts.synthesize({
+      text: segment.text,
+      voiceId: voice.voiceId,
+      language: voice.language,
+      style: voice.style,
+      stability: voice.stability,
+      rate: directive?.rate,
+      emphasis: directive?.emphasis
+    });
+    return {
+      sceneId: segment.sceneId,
+      audio: result.audio,
+      durationMs: result.audio.durationMs ?? 0,
+      wordTimings: result.wordTimings?.map((wt) => ({
+        word: wt.word,
+        startMs: wt.startMs,
+        endMs: wt.endMs
+      }))
+    };
+  }
+}
+export {
+  SegmentSynthesizer
+};

package/dist/tts/types.d.ts

@@ -0,0 +1,76 @@
+import type { ContentBrief } from '@contractspec/lib.content-gen/types';
+import type { TTSProvider, AudioData, VoiceTimingMap, VoicePacingDirective, VoiceOptions } from '../types';
+export interface TTSBrief {
+    content: ContentBrief;
+    voice: TTSVoiceConfig;
+    pacing?: PacingConfig;
+    targetDurationSeconds?: number;
+    locale?: string;
+}
+export interface TTSVoiceConfig {
+    voiceId: string;
+    language?: string;
+    style?: number;
+    stability?: number;
+}
+export interface PacingConfig {
+    /** Base speaking rate multiplier. Default 1.0 */
+    baseRate?: number;
+    strategy: 'uniform' | 'dynamic' | 'scene-matched';
+    /** Pause between segments in ms. Default 500 */
+    segmentPauseMs?: number;
+    /** Breathing room factor for scene duration. Default 1.15 */
+    breathingRoomFactor?: number;
+}
+export interface TTSProject {
+    id: string;
+    script: TTSScript;
+    pacingDirectives: VoicePacingDirective[];
+    segments?: SynthesizedSegment[];
+    assembledAudio?: AudioData;
+    timingMap?: VoiceTimingMap;
+}
+export interface TTSScript {
+    fullText: string;
+    segments: TTSScriptSegment[];
+    estimatedDurationSeconds: number;
+}
+export interface TTSScriptSegment {
+    sceneId: string;
+    text: string;
+    estimatedDurationSeconds: number;
+    contentType: 'intro' | 'problem' | 'solution' | 'metric' | 'cta' | 'transition';
+}
+export interface SynthesizedSegment {
+    sceneId: string;
+    audio: AudioData;
+    durationMs: number;
+    wordTimings?: {
+        word: string;
+        startMs: number;
+        endMs: number;
+    }[];
+}
+export interface TTSOptions extends VoiceOptions {
+    tts: TTSProvider;
+    defaultVoiceId?: string;
+    fps?: number;
+    defaultPacing?: PacingConfig;
+}
+/** Video-aware brief: takes a ScenePlan instead of standalone content */
+export interface VideoTTSBrief {
+    content: ContentBrief;
+    scenePlan: {
+        scenes: {
+            id: string;
+            compositionId: string;
+            durationInFrames: number;
+            narrationText?: string;
+        }[];
+        estimatedDurationSeconds: number;
+    };
+    voice: TTSVoiceConfig;
+    pacing?: PacingConfig;
+    fps: number;
+    locale?: string;
+}

package/dist/tts/types.js

@@ -0,0 +1 @@
+// @bun