@contractspec/lib.voice 0.2.0

package/dist/stt/index.js

@@ -0,0 +1,223 @@
+// @bun
+// src/stt/segment-splitter.ts
+class SegmentSplitter {
+  static DEFAULT_MAX_CHUNK_MS = 5 * 60 * 1000;
+  split(audio, maxChunkMs = SegmentSplitter.DEFAULT_MAX_CHUNK_MS) {
+    const totalDurationMs = audio.durationMs ?? this.estimateDurationMs(audio);
+    if (totalDurationMs <= maxChunkMs) {
+      return [audio];
+    }
+    const chunks = [];
+    const bytesPerMs = audio.data.length / Math.max(totalDurationMs, 1);
+    let offsetMs = 0;
+    while (offsetMs < totalDurationMs) {
+      const chunkDurationMs = Math.min(maxChunkMs, totalDurationMs - offsetMs);
+      const startByte = Math.floor(offsetMs * bytesPerMs);
+      const endByte = Math.floor((offsetMs + chunkDurationMs) * bytesPerMs);
+      chunks.push({
+        data: audio.data.slice(startByte, endByte),
+        format: audio.format,
+        sampleRateHz: audio.sampleRateHz,
+        durationMs: chunkDurationMs,
+        channels: audio.channels
+      });
+      offsetMs += chunkDurationMs;
+    }
+    return chunks;
+  }
+  estimateDurationMs(audio) {
+    const bytesPerSample = 2;
+    const channels = audio.channels ?? 1;
+    const totalSamples = audio.data.length / (bytesPerSample * channels);
+    return Math.ceil(totalSamples / audio.sampleRateHz * 1000);
+  }
+}
+
+// src/stt/diarization-mapper.ts
+class DiarizationMapper {
+  map(segments, labelPrefix = "Speaker") {
+    const speakerOrder = [];
+    const speakerStats = new Map;
+    for (const seg of segments) {
+      if (seg.speakerId && !speakerOrder.includes(seg.speakerId)) {
+        speakerOrder.push(seg.speakerId);
+        speakerStats.set(seg.speakerId, {
+          segmentCount: 0,
+          totalSpeakingMs: 0
+        });
+      }
+    }
+    const labeledSegments = segments.map((seg) => {
+      if (!seg.speakerId)
+        return seg;
+      const index = speakerOrder.indexOf(seg.speakerId);
+      const label = `${labelPrefix} ${index + 1}`;
+      const stats = speakerStats.get(seg.speakerId);
+      if (!stats) {
+        return { ...seg, speakerLabel: label };
+      }
+      stats.segmentCount += 1;
+      stats.totalSpeakingMs += seg.endMs - seg.startMs;
+      return { ...seg, speakerLabel: label };
+    });
+    const speakers = speakerOrder.map((id, index) => {
+      const stats = speakerStats.get(id);
+      return {
+        id,
+        label: `${labelPrefix} ${index + 1}`,
+        segmentCount: stats?.segmentCount ?? 0,
+        totalSpeakingMs: stats?.totalSpeakingMs ?? 0
+      };
+    });
+    return { segments: labeledSegments, speakers };
+  }
+}
+
+// src/stt/subtitle-formatter.ts
+class SubtitleFormatter {
+  toSRT(segments) {
+    return segments.map((seg, i) => {
+      const start = this.formatTimeSRT(seg.startMs);
+      const end = this.formatTimeSRT(seg.endMs);
+      const label = seg.speakerLabel ? `[${seg.speakerLabel}] ` : "";
+      return `${i + 1}
+${start} --> ${end}
+${label}${seg.text}`;
+    }).join(`
+
+`);
+  }
+  toVTT(segments) {
+    const header = `WEBVTT
+
+`;
+    const cues = segments.map((seg, i) => {
+      const start = this.formatTimeVTT(seg.startMs);
+      const end = this.formatTimeVTT(seg.endMs);
+      const label = seg.speakerLabel ? `<v ${seg.speakerLabel}>` : "";
+      return `${i + 1}
+${start} --> ${end}
+${label}${seg.text}`;
+    }).join(`
+
+`);
+    return header + cues;
+  }
+  formatTimeSRT(ms) {
+    const hours = Math.floor(ms / 3600000);
+    const minutes = Math.floor(ms % 3600000 / 60000);
+    const seconds = Math.floor(ms % 60000 / 1000);
+    const millis = ms % 1000;
+    return `${this.pad(hours, 2)}:${this.pad(minutes, 2)}:${this.pad(seconds, 2)},${this.pad(millis, 3)}`;
+  }
+  formatTimeVTT(ms) {
+    const hours = Math.floor(ms / 3600000);
+    const minutes = Math.floor(ms % 3600000 / 60000);
+    const seconds = Math.floor(ms % 60000 / 1000);
+    const millis = ms % 1000;
+    return `${this.pad(hours, 2)}:${this.pad(minutes, 2)}:${this.pad(seconds, 2)}.${this.pad(millis, 3)}`;
+  }
+  pad(value, length) {
+    return value.toString().padStart(length, "0");
+  }
+}
+
+// src/stt/transcriber.ts
+class Transcriber {
+  stt;
+  segmentSplitter = new SegmentSplitter;
+  diarizationMapper = new DiarizationMapper;
+  subtitleFormatter = new SubtitleFormatter;
+  constructor(options) {
+    this.stt = options.stt;
+  }
+  async transcribe(brief) {
+    const projectId = generateProjectId();
+    const chunks = this.segmentSplitter.split(brief.audio);
+    const allSegments = [];
+    let fullText = "";
+    let totalDurationMs = 0;
+    let offsetMs = 0;
+    for (const chunk of chunks) {
+      const result = await this.stt.transcribe({
+        audio: chunk,
+        language: brief.language,
+        diarize: brief.diarize,
+        speakerCount: brief.speakerCount,
+        wordTimestamps: true,
+        vocabularyHints: brief.vocabularyHints
+      });
+      const offsetSegments = result.segments.map((seg) => ({
+        text: seg.text,
+        startMs: seg.startMs + offsetMs,
+        endMs: seg.endMs + offsetMs,
+        speakerId: seg.speakerId,
+        speakerName: seg.speakerName,
+        confidence: seg.confidence
+      }));
+      allSegments.push(...offsetSegments);
+      fullText += (fullText ? " " : "") + result.text;
+      totalDurationMs += result.durationMs;
+      offsetMs += chunk.durationMs ?? 0;
+    }
+    let mappedSegments = allSegments;
+    let speakers;
+    if (brief.diarize) {
+      const mapping = this.diarizationMapper.map(allSegments);
+      mappedSegments = mapping.segments;
+      speakers = mapping.speakers;
+    }
+    const transcript = {
+      text: fullText,
+      segments: mappedSegments,
+      language: brief.language ?? "en",
+      durationMs: totalDurationMs
+    };
+    let subtitles;
+    const format = brief.subtitleFormat ?? "none";
+    if (format === "srt") {
+      subtitles = this.subtitleFormatter.toSRT(mappedSegments);
+    } else if (format === "vtt") {
+      subtitles = this.subtitleFormatter.toVTT(mappedSegments);
+    }
+    return {
+      id: projectId,
+      transcript,
+      subtitles,
+      speakers
+    };
+  }
+  async* transcribeStream(audio, options) {
+    if (!this.stt.transcribeStream) {
+      throw new Error("Streaming transcription not supported by the current STT provider");
+    }
+    const stream = this.stt.transcribeStream(audio, {
+      language: options?.language,
+      diarize: options?.diarize,
+      speakerCount: options?.speakerCount,
+      wordTimestamps: true,
+      vocabularyHints: options?.vocabularyHints
+    });
+    for await (const segment of stream) {
+      yield {
+        text: segment.text,
+        startMs: segment.startMs,
+        endMs: segment.endMs,
+        speakerId: segment.speakerId,
+        speakerLabel: segment.speakerName,
+        confidence: segment.confidence
+      };
+    }
+  }
+}
+function generateProjectId() {
+  const timestamp = Date.now().toString(36);
+  const random = Math.random().toString(36).slice(2, 8);
+  return `stt_${timestamp}_${random}`;
+}
+export {
+  Transcriber,
+  SubtitleFormatter,
+  SegmentSplitter,
+  DiarizationMapper
+};

package/dist/stt/segment-splitter.d.ts

@@ -0,0 +1,19 @@
+import type { AudioData } from '../types';
+/**
+ * Split long audio into processable chunks.
+ *
+ * Useful for providers with maximum audio length limits.
+ * Splits at silence boundaries when possible (approximated by byte position).
+ */
+export declare class SegmentSplitter {
+    /** Default maximum chunk duration in ms (5 minutes) */
+    private static readonly DEFAULT_MAX_CHUNK_MS;
+    /**
+     * Split audio into chunks of at most maxChunkMs duration.
+     *
+     * @param audio - Input audio data
+     * @param maxChunkMs - Maximum chunk duration in milliseconds
+     */
+    split(audio: AudioData, maxChunkMs?: number): AudioData[];
+    private estimateDurationMs;
+}

package/dist/stt/segment-splitter.js

@@ -0,0 +1,37 @@
+// @bun
+// src/stt/segment-splitter.ts
+class SegmentSplitter {
+  static DEFAULT_MAX_CHUNK_MS = 5 * 60 * 1000;
+  split(audio, maxChunkMs = SegmentSplitter.DEFAULT_MAX_CHUNK_MS) {
+    const totalDurationMs = audio.durationMs ?? this.estimateDurationMs(audio);
+    if (totalDurationMs <= maxChunkMs) {
+      return [audio];
+    }
+    const chunks = [];
+    const bytesPerMs = audio.data.length / Math.max(totalDurationMs, 1);
+    let offsetMs = 0;
+    while (offsetMs < totalDurationMs) {
+      const chunkDurationMs = Math.min(maxChunkMs, totalDurationMs - offsetMs);
+      const startByte = Math.floor(offsetMs * bytesPerMs);
+      const endByte = Math.floor((offsetMs + chunkDurationMs) * bytesPerMs);
+      chunks.push({
+        data: audio.data.slice(startByte, endByte),
+        format: audio.format,
+        sampleRateHz: audio.sampleRateHz,
+        durationMs: chunkDurationMs,
+        channels: audio.channels
+      });
+      offsetMs += chunkDurationMs;
+    }
+    return chunks;
+  }
+  estimateDurationMs(audio) {
+    const bytesPerSample = 2;
+    const channels = audio.channels ?? 1;
+    const totalSamples = audio.data.length / (bytesPerSample * channels);
+    return Math.ceil(totalSamples / audio.sampleRateHz * 1000);
+  }
+}
+export {
+  SegmentSplitter
+};

package/dist/stt/subtitle-formatter.d.ts

@@ -0,0 +1,19 @@
+import type { TranscriptionSegment } from './types';
+/**
+ * Format transcription segments as SRT or VTT subtitles.
+ */
+export declare class SubtitleFormatter {
+    /**
+     * Convert segments to SRT format.
+     */
+    toSRT(segments: TranscriptionSegment[]): string;
+    /**
+     * Convert segments to WebVTT format.
+     */
+    toVTT(segments: TranscriptionSegment[]): string;
+    /** Format ms as SRT timestamp: HH:MM:SS,mmm */
+    private formatTimeSRT;
+    /** Format ms as VTT timestamp: HH:MM:SS.mmm */
+    private formatTimeVTT;
+    private pad;
+}

package/dist/stt/subtitle-formatter.js

@@ -0,0 +1,52 @@
+// @bun
+// src/stt/subtitle-formatter.ts
+class SubtitleFormatter {
+  toSRT(segments) {
+    return segments.map((seg, i) => {
+      const start = this.formatTimeSRT(seg.startMs);
+      const end = this.formatTimeSRT(seg.endMs);
+      const label = seg.speakerLabel ? `[${seg.speakerLabel}] ` : "";
+      return `${i + 1}
+${start} --> ${end}
+${label}${seg.text}`;
+    }).join(`
+
+`);
+  }
+  toVTT(segments) {
+    const header = `WEBVTT
+
+`;
+    const cues = segments.map((seg, i) => {
+      const start = this.formatTimeVTT(seg.startMs);
+      const end = this.formatTimeVTT(seg.endMs);
+      const label = seg.speakerLabel ? `<v ${seg.speakerLabel}>` : "";
+      return `${i + 1}
+${start} --> ${end}
+${label}${seg.text}`;
+    }).join(`
+
+`);
+    return header + cues;
+  }
+  formatTimeSRT(ms) {
+    const hours = Math.floor(ms / 3600000);
+    const minutes = Math.floor(ms % 3600000 / 60000);
+    const seconds = Math.floor(ms % 60000 / 1000);
+    const millis = ms % 1000;
+    return `${this.pad(hours, 2)}:${this.pad(minutes, 2)}:${this.pad(seconds, 2)},${this.pad(millis, 3)}`;
+  }
+  formatTimeVTT(ms) {
+    const hours = Math.floor(ms / 3600000);
+    const minutes = Math.floor(ms % 3600000 / 60000);
+    const seconds = Math.floor(ms % 60000 / 1000);
+    const millis = ms % 1000;
+    return `${this.pad(hours, 2)}:${this.pad(minutes, 2)}:${this.pad(seconds, 2)}.${this.pad(millis, 3)}`;
+  }
+  pad(value, length) {
+    return value.toString().padStart(length, "0");
+  }
+}
+export {
+  SubtitleFormatter
+};

package/dist/stt/transcriber.d.ts

@@ -0,0 +1,21 @@
+import type { STTBrief, STTOptions, TranscriptionProject, TranscriptionSegment } from './types';
+/**
+ * Main STT orchestrator.
+ *
+ * Pipeline:
+ * 1. Split audio into processable chunks (if needed)
+ * 2. Transcribe via STTProvider
+ * 3. Map speaker IDs to labels (if diarization enabled)
+ * 4. Format subtitles (if requested)
+ */
+export declare class Transcriber {
+    private readonly stt;
+    private readonly segmentSplitter;
+    private readonly diarizationMapper;
+    private readonly subtitleFormatter;
+    constructor(options: STTOptions);
+    /** Transcribe audio to text */
+    transcribe(brief: STTBrief): Promise<TranscriptionProject>;
+    /** Stream transcription (real-time, if provider supports it) */
+    transcribeStream(audio: AsyncIterable<Uint8Array>, options?: Partial<STTBrief>): AsyncIterable<TranscriptionSegment>;
+}

package/dist/stt/transcriber.js

@@ -0,0 +1,220 @@
+// @bun
+// src/stt/segment-splitter.ts
+class SegmentSplitter {
+  static DEFAULT_MAX_CHUNK_MS = 5 * 60 * 1000;
+  split(audio, maxChunkMs = SegmentSplitter.DEFAULT_MAX_CHUNK_MS) {
+    const totalDurationMs = audio.durationMs ?? this.estimateDurationMs(audio);
+    if (totalDurationMs <= maxChunkMs) {
+      return [audio];
+    }
+    const chunks = [];
+    const bytesPerMs = audio.data.length / Math.max(totalDurationMs, 1);
+    let offsetMs = 0;
+    while (offsetMs < totalDurationMs) {
+      const chunkDurationMs = Math.min(maxChunkMs, totalDurationMs - offsetMs);
+      const startByte = Math.floor(offsetMs * bytesPerMs);
+      const endByte = Math.floor((offsetMs + chunkDurationMs) * bytesPerMs);
+      chunks.push({
+        data: audio.data.slice(startByte, endByte),
+        format: audio.format,
+        sampleRateHz: audio.sampleRateHz,
+        durationMs: chunkDurationMs,
+        channels: audio.channels
+      });
+      offsetMs += chunkDurationMs;
+    }
+    return chunks;
+  }
+  estimateDurationMs(audio) {
+    const bytesPerSample = 2;
+    const channels = audio.channels ?? 1;
+    const totalSamples = audio.data.length / (bytesPerSample * channels);
+    return Math.ceil(totalSamples / audio.sampleRateHz * 1000);
+  }
+}
+
+// src/stt/diarization-mapper.ts
+class DiarizationMapper {
+  map(segments, labelPrefix = "Speaker") {
+    const speakerOrder = [];
+    const speakerStats = new Map;
+    for (const seg of segments) {
+      if (seg.speakerId && !speakerOrder.includes(seg.speakerId)) {
+        speakerOrder.push(seg.speakerId);
+        speakerStats.set(seg.speakerId, {
+          segmentCount: 0,
+          totalSpeakingMs: 0
+        });
+      }
+    }
+    const labeledSegments = segments.map((seg) => {
+      if (!seg.speakerId)
+        return seg;
+      const index = speakerOrder.indexOf(seg.speakerId);
+      const label = `${labelPrefix} ${index + 1}`;
+      const stats = speakerStats.get(seg.speakerId);
+      if (!stats) {
+        return { ...seg, speakerLabel: label };
+      }
+      stats.segmentCount += 1;
+      stats.totalSpeakingMs += seg.endMs - seg.startMs;
+      return { ...seg, speakerLabel: label };
+    });
+    const speakers = speakerOrder.map((id, index) => {
+      const stats = speakerStats.get(id);
+      return {
+        id,
+        label: `${labelPrefix} ${index + 1}`,
+        segmentCount: stats?.segmentCount ?? 0,
+        totalSpeakingMs: stats?.totalSpeakingMs ?? 0
+      };
+    });
+    return { segments: labeledSegments, speakers };
+  }
+}
+
+// src/stt/subtitle-formatter.ts
+class SubtitleFormatter {
+  toSRT(segments) {
+    return segments.map((seg, i) => {
+      const start = this.formatTimeSRT(seg.startMs);
+      const end = this.formatTimeSRT(seg.endMs);
+      const label = seg.speakerLabel ? `[${seg.speakerLabel}] ` : "";
+      return `${i + 1}
+${start} --> ${end}
+${label}${seg.text}`;
+    }).join(`
+
+`);
+  }
+  toVTT(segments) {
+    const header = `WEBVTT
+
+`;
+    const cues = segments.map((seg, i) => {
+      const start = this.formatTimeVTT(seg.startMs);
+      const end = this.formatTimeVTT(seg.endMs);
+      const label = seg.speakerLabel ? `<v ${seg.speakerLabel}>` : "";
+      return `${i + 1}
+${start} --> ${end}
+${label}${seg.text}`;
+    }).join(`
+
+`);
+    return header + cues;
+  }
+  formatTimeSRT(ms) {
+    const hours = Math.floor(ms / 3600000);
+    const minutes = Math.floor(ms % 3600000 / 60000);
+    const seconds = Math.floor(ms % 60000 / 1000);
+    const millis = ms % 1000;
+    return `${this.pad(hours, 2)}:${this.pad(minutes, 2)}:${this.pad(seconds, 2)},${this.pad(millis, 3)}`;
+  }
+  formatTimeVTT(ms) {
+    const hours = Math.floor(ms / 3600000);
+    const minutes = Math.floor(ms % 3600000 / 60000);
+    const seconds = Math.floor(ms % 60000 / 1000);
+    const millis = ms % 1000;
+    return `${this.pad(hours, 2)}:${this.pad(minutes, 2)}:${this.pad(seconds, 2)}.${this.pad(millis, 3)}`;
+  }
+  pad(value, length) {
+    return value.toString().padStart(length, "0");
+  }
+}
+
+// src/stt/transcriber.ts
+class Transcriber {
+  stt;
+  segmentSplitter = new SegmentSplitter;
+  diarizationMapper = new DiarizationMapper;
+  subtitleFormatter = new SubtitleFormatter;
+  constructor(options) {
+    this.stt = options.stt;
+  }
+  async transcribe(brief) {
+    const projectId = generateProjectId();
+    const chunks = this.segmentSplitter.split(brief.audio);
+    const allSegments = [];
+    let fullText = "";
+    let totalDurationMs = 0;
+    let offsetMs = 0;
+    for (const chunk of chunks) {
+      const result = await this.stt.transcribe({
+        audio: chunk,
+        language: brief.language,
+        diarize: brief.diarize,
+        speakerCount: brief.speakerCount,
+        wordTimestamps: true,
+        vocabularyHints: brief.vocabularyHints
+      });
+      const offsetSegments = result.segments.map((seg) => ({
+        text: seg.text,
+        startMs: seg.startMs + offsetMs,
+        endMs: seg.endMs + offsetMs,
+        speakerId: seg.speakerId,
+        speakerName: seg.speakerName,
+        confidence: seg.confidence
+      }));
+      allSegments.push(...offsetSegments);
+      fullText += (fullText ? " " : "") + result.text;
+      totalDurationMs += result.durationMs;
+      offsetMs += chunk.durationMs ?? 0;
+    }
+    let mappedSegments = allSegments;
+    let speakers;
+    if (brief.diarize) {
+      const mapping = this.diarizationMapper.map(allSegments);
+      mappedSegments = mapping.segments;
+      speakers = mapping.speakers;
+    }
+    const transcript = {
+      text: fullText,
+      segments: mappedSegments,
+      language: brief.language ?? "en",
+      durationMs: totalDurationMs
+    };
+    let subtitles;
+    const format = brief.subtitleFormat ?? "none";
+    if (format === "srt") {
+      subtitles = this.subtitleFormatter.toSRT(mappedSegments);
+    } else if (format === "vtt") {
+      subtitles = this.subtitleFormatter.toVTT(mappedSegments);
+    }
+    return {
+      id: projectId,
+      transcript,
+      subtitles,
+      speakers
+    };
+  }
+  async* transcribeStream(audio, options) {
+    if (!this.stt.transcribeStream) {
+      throw new Error("Streaming transcription not supported by the current STT provider");
+    }
+    const stream = this.stt.transcribeStream(audio, {
+      language: options?.language,
+      diarize: options?.diarize,
+      speakerCount: options?.speakerCount,
+      wordTimestamps: true,
+      vocabularyHints: options?.vocabularyHints
+    });
+    for await (const segment of stream) {
+      yield {
+        text: segment.text,
+        startMs: segment.startMs,
+        endMs: segment.endMs,
+        speakerId: segment.speakerId,
+        speakerLabel: segment.speakerName,
+        confidence: segment.confidence
+      };
+    }
+  }
+}
+function generateProjectId() {
+  const timestamp = Date.now().toString(36);
+  const random = Math.random().toString(36).slice(2, 8);
+  return `stt_${timestamp}_${random}`;
+}
+export {
+  Transcriber
+};

package/dist/stt/types.d.ts

@@ -0,0 +1,44 @@
+import type { STTProvider, AudioData, VoiceOptions } from '../types';
+export interface STTBrief {
+    audio: AudioData;
+    language?: string;
+    diarize?: boolean;
+    speakerCount?: number;
+    vocabularyHints?: string[];
+    /** Output subtitle format */
+    subtitleFormat?: 'srt' | 'vtt' | 'none';
+}
+export interface TranscriptionProject {
+    id: string;
+    transcript: TranscriptionResult;
+    subtitles?: string;
+    speakers?: SpeakerMap[];
+}
+export interface TranscriptionResult {
+    text: string;
+    segments: TranscriptionSegment[];
+    language: string;
+    durationMs: number;
+    wordTimings?: {
+        word: string;
+        startMs: number;
+        endMs: number;
+    }[];
+}
+export interface TranscriptionSegment {
+    text: string;
+    startMs: number;
+    endMs: number;
+    speakerId?: string;
+    speakerLabel?: string;
+    confidence?: number;
+}
+export interface SpeakerMap {
+    id: string;
+    label: string;
+    segmentCount: number;
+    totalSpeakingMs: number;
+}
+export interface STTOptions extends VoiceOptions {
+    stt: STTProvider;
+}

package/dist/stt/types.js

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

package/dist/sync/duration-negotiator.d.ts

@@ -0,0 +1,37 @@
+import type { VoiceTimingMap } from '../types';
+interface NegotiationResult {
+    /** Updated timing map with negotiated durations */
+    timingMap: VoiceTimingMap;
+    /** Per-scene negotiation details */
+    adjustments: SceneAdjustment[];
+}
+interface SceneAdjustment {
+    sceneId: string;
+    originalSceneDurationInFrames: number;
+    voiceDurationInFrames: number;
+    action: 'no_change' | 'extend_scene' | 'pad_silence' | 'suggest_rate_change';
+    suggestedRate?: number;
+    finalSceneDurationInFrames: number;
+}
+/**
+ * Negotiate duration between voice audio and scene durations.
+ *
+ * One-pass duration balancing:
+ * - Voice fits scene -> no change
+ * - Voice > 110% of scene -> suggest rate increase (cap 1.3x), extend scene
+ * - Voice < 70% of scene -> suggest rate decrease (floor 0.8x), pad silence
+ */
+export declare class DurationNegotiator {
+    private static readonly UPPER_THRESHOLD;
+    private static readonly LOWER_THRESHOLD;
+    private static readonly MAX_RATE;
+    private static readonly MIN_RATE;
+    /**
+     * Negotiate voice-vs-scene durations.
+     *
+     * @param timingMap - Voice timing map with per-segment durations
+     * @param sceneDurations - Map of sceneId -> original scene duration in frames
+     */
+    negotiate(timingMap: VoiceTimingMap, sceneDurations: Map<string, number>): NegotiationResult;
+}
+export {};