387 audio dubbing feature

src/activationHelpers/contextAware/commands.ts

@@ -188,7 +188,7 @@ export async function registerCommands(context: vscode.ExtensionContext) {
             filesToExport: string[];
             options?: { skipValidation?: boolean; removeIds?: boolean; };
         }) => {
-            await exportCodexContent(format, userSelectedPath, filesToExport, options);
+            return exportCodexContent(format, userSelectedPath, filesToExport, options);
         }
     );
 

src/exportHandler/audioExporter.ts

@@ -5,6 +5,7 @@ import { exec } from "child_process";
 import { promisify } from "util";
 import * as os from "os";
 import * as fs from "fs";
+import { CodexCellTypes } from "../../types/enums";
 
 const execAsync = promisify(exec);
 
@@ -20,6 +21,12 @@ type ExportAudioOptions = {
     includeTimestamps?: boolean;
 };
 
+type AudioCellData = {
+    startTime?: number;
+    endTime?: number;
+    audioStartTime?: number;
+    audioEndTime?: number;
+};
 
 function sanitizeFileComponent(input: string): string {
     return input
@@ -125,7 +132,8 @@ function computeDialogueLineNumbers(
         const isMerged = !!(data && data.merged);
         const isDeleted = !!(data && data.deleted);
         const isParatext = cell?.metadata?.type === "paratext";
-        if (!isValidKind || isMerged || isDeleted || isParatext) continue;
+        const isMilestone = cell?.metadata?.type === CodexCellTypes.MILESTONE;
+        if (!isValidKind || isMerged || isDeleted || isParatext || isMilestone) continue;
         const id: string | undefined = cell?.metadata?.id;
         if (!id) continue;
         line += 1;
@@ -540,6 +548,10 @@ export async function exportAudioAttachments(
                         debug(`Skipping cell with kind ${cell.kind}`);
                         continue;
                     }
+                    if (cell?.metadata?.type === CodexCellTypes.MILESTONE) {
+                        debug(`Skipping milestone cell: ${cell?.metadata?.id}`);
+                        continue;
+                    }
                     if (!isActiveCell(cell)) {
                         debug(`Skipping inactive cell: ${cell?.metadata?.id}`);
                         continue;
@@ -588,9 +600,9 @@ export async function exportAudioAttachments(
                     }
 
                     // Build destination filename: <file>_<lang>_<label>_<line>.wav (always export as WAV)
-                    const timeFromCell = (cell?.metadata?.data || {}) as { startTime?: number; endTime?: number; };
-                    const start = timeFromCell.startTime;
-                    const end = timeFromCell.endTime;
+                    const timeFromCell = (cell?.metadata?.data || {}) as AudioCellData;
+                    const start = timeFromCell.audioStartTime || timeFromCell.startTime;
+                    const end = timeFromCell.audioEndTime || timeFromCell.endTime;
                     const originalExt = extname(absoluteSrc.fsPath) || ".wav";
                     const labelRaw = cell?.metadata?.cellLabel || "unlabeled";
                     const label = sanitizeFileComponent(String(labelRaw).toLowerCase());

src/exportHandler/exportHandler.ts

@@ -9,7 +9,7 @@ import * as fs from "fs";
 import { exec } from "child_process";
 import { promisify } from "util";
 import { removeHtmlTags, generateSrtData } from "./subtitleUtils";
-import { generateVttData } from "./vttUtils";
+import { generateVttData, hasOverlappingCues } from "./vttUtils";
 // import { exportRtfWithPandoc } from "../../webviews/codex-webviews/src/NewSourceUploader/importers/rtf/pandocNodeBridge";
 
 const execAsync = promisify(exec);
@@ -61,6 +61,36 @@ function getActiveCells(cells: CodexNotebookAsJSONData["cells"]) {
     });
 }
 
+const SUBTITLE_OVERLAP_WARNING =
+    "Some selected files have overlapping subtitle timestamps. To split overlapping cues so they appear at different times, use the WebVTT with Cue Splitting option. Do you want to export anyway?";
+
+/**
+ * Checks selected files for overlapping VTT/SRT cues. If any file has overlaps, shows a warning
+ * and asks the user to confirm. Returns true if export should proceed, false to cancel.
+ */
+async function checkSubtitleOverlapsAndConfirm(filesToExport: string[]): Promise<boolean> {
+    let hasOverlaps = false;
+    for (const filePath of filesToExport) {
+        try {
+            const codexData = await readCodexNotebookFromUri(vscode.Uri.file(filePath));
+            const cells = getActiveCells(codexData.cells);
+            if (hasOverlappingCues(cells)) {
+                hasOverlaps = true;
+                break;
+            }
+        } catch {
+            // If we can't read a file, skip overlap check for it; export will fail later if needed
+        }
+    }
+    if (!hasOverlaps) return true;
+    const choice = await vscode.window.showWarningMessage(
+        SUBTITLE_OVERLAP_WARNING,
+        { modal: true },
+        "Export anyway"
+    );
+    return choice === "Export anyway";
+}
+
 /**
  * Maps book codes to their full names for USFM export
  */
@@ -305,6 +335,7 @@ export enum CodexExportFormat {
     SUBTITLES_SRT = "subtitles-srt",
     SUBTITLES_VTT_WITH_STYLES = "subtitles-vtt-with-styles",
     SUBTITLES_VTT_WITHOUT_STYLES = "subtitles-vtt-without-styles",
+    SUBTITLES_VTT_WITH_CUE_SPLITTING = "subtitles-vtt-with-cue-splitting",
     XLIFF = "xliff",
     CSV = "csv",
     TSV = "tsv",
@@ -1470,51 +1501,66 @@ async function exportCodexContentAsRebuild(
     );
 }
 
+/**
+ * @returns true if export completed, false if user cancelled due to subtitle overlap warning.
+ */
 export async function exportCodexContent(
     format: CodexExportFormat,
     userSelectedPath: string,
     filesToExport: string[],
     options?: ExportOptions
-) {
+): Promise<boolean> {
     switch (format) {
         case CodexExportFormat.PLAINTEXT:
             await exportCodexContentAsPlaintext(userSelectedPath, filesToExport, options);
-            break;
+            return true;
         case CodexExportFormat.USFM:
             await exportCodexContentAsUsfm(userSelectedPath, filesToExport, options);
-            break;
+            return true;
         case CodexExportFormat.HTML:
             await exportCodexContentAsHtml(userSelectedPath, filesToExport, options);
-            break;
+            return true;
         case CodexExportFormat.AUDIO: {
             const { exportAudioAttachments } = await import("./audioExporter");
             await exportAudioAttachments(userSelectedPath, filesToExport, { includeTimestamps: (options as any)?.includeTimestamps });
-            break;
+            return true;
         }
         case CodexExportFormat.SUBTITLES_VTT_WITH_STYLES:
-            await exportCodexContentAsSubtitlesVtt(userSelectedPath, filesToExport, options, true);
-            break;
+            if (await checkSubtitleOverlapsAndConfirm(filesToExport)) {
+                await exportCodexContentAsSubtitlesVtt(userSelectedPath, filesToExport, options, true);
+                return true;
+            }
+            return false;
         case CodexExportFormat.SUBTITLES_VTT_WITHOUT_STYLES:
-            await exportCodexContentAsSubtitlesVtt(userSelectedPath, filesToExport, options, false);
-            break;
+            if (await checkSubtitleOverlapsAndConfirm(filesToExport)) {
+                await exportCodexContentAsSubtitlesVtt(userSelectedPath, filesToExport, options, false);
+                return true;
+            }
+            return false;
+        case CodexExportFormat.SUBTITLES_VTT_WITH_CUE_SPLITTING:
+            await exportCodexContentAsSubtitlesVtt(userSelectedPath, filesToExport, options, false, true);
+            return true;
         case CodexExportFormat.SUBTITLES_SRT:
-            await exportCodexContentAsSubtitlesSrt(userSelectedPath, filesToExport, options);
-            break;
+            if (await checkSubtitleOverlapsAndConfirm(filesToExport)) {
+                await exportCodexContentAsSubtitlesSrt(userSelectedPath, filesToExport, options);
+                return true;
+            }
+            return false;
         case CodexExportFormat.XLIFF:
             await exportCodexContentAsXliff(userSelectedPath, filesToExport, options);
-            break;
+            return true;
         case CodexExportFormat.CSV:
             await exportCodexContentAsCsv(userSelectedPath, filesToExport, options);
-            break;
+            return true;
         case CodexExportFormat.TSV:
             await exportCodexContentAsTsv(userSelectedPath, filesToExport, options);
-            break;
+            return true;
         case CodexExportFormat.REBUILD_EXPORT:
             await exportCodexContentAsRebuild(userSelectedPath, filesToExport, options);
-            break;
+            return true;
         case CodexExportFormat.BACKTRANSLATIONS:
             await exportCodexContentAsBacktranslations(userSelectedPath, filesToExport, options);
-            break;
+            return true;
     }
 }
 
@@ -1624,7 +1670,8 @@ export const exportCodexContentAsSubtitlesVtt = async (
     userSelectedPath: string,
     filesToExport: string[],
     options?: ExportOptions,
-    includeStyles: boolean = true
+    includeStyles: boolean = true,
+    cueSplitting: boolean = false
 ) => {
     try {
         debug("Starting exportCodexContentAsSubtitlesVtt function");
@@ -1672,7 +1719,7 @@ export const exportCodexContentAsSubtitlesVtt = async (
                     debug(`File has ${cells.length} active cells`);
 
                     // Generate VTT content
-                    const vttContent = generateVttData(cells, includeStyles, file.fsPath); // Include styles for VTT
+                    const vttContent = generateVttData(cells, includeStyles, cueSplitting, file.fsPath); // Include styles for VTT
                     debug({ vttContent, cells, includeStyles });
 
                     // Write file

src/exportHandler/vttUtils.ts

@@ -1,7 +1,5 @@
-import { useMemo } from "react";
-import { CodexNotebookAsJSONData, QuillCellContent } from "@types";
+import { CodexNotebookAsJSONData } from "@types";
 import { removeHtmlTags } from "./subtitleUtils";
-import { ExportOptions } from "./exportHandler";
 import * as vscode from "vscode";
 
 /**
@@ -53,9 +51,17 @@ const processVttContent = (content: string): string => {
     return ensureDialogueLineBreaks(processed);
 };
 
+type ProcessedUnit = {
+    id: string | undefined;
+    startTime: number;
+    endTime: number;
+    finalText: string;
+};
+
 export const generateVttData = (
     cells: CodexNotebookAsJSONData["cells"],
     includeStyles: boolean,
+    cueSplitting: boolean,
     filePath: string
 ): string => {
     if (!cells.length) return "";
@@ -65,24 +71,37 @@ export const generateVttData = (
         return date.toISOString().substr(11, 12);
     };
 
-    const cues = cells
-        // Filter out merged cells before processing
+    const units: ProcessedUnit[] = cells
         .filter((unit) => {
             const metadata = unit.metadata;
             return !metadata?.data?.merged && !!unit.metadata?.data?.startTime;
         })
         .map((unit, index) => {
-            const startTime = unit.metadata?.data?.startTime ?? index;
-            const endTime = unit.metadata?.data?.endTime ?? index + 1;
+            const startTime = Number(unit.metadata?.data?.startTime ?? index);
+            const endTime = Number(unit.metadata?.data?.endTime ?? index + 1);
             const text = includeStyles ? processVttContent(unit.value) : removeHtmlTags(unit.value);
             const finalText = ensureDialogueLineBreaks(text);
-            return `${unit.metadata?.id}
-${formatTime(Number(startTime))} --> ${formatTime(Number(endTime))}
-${finalText}
+            return {
+                id: unit.metadata?.cellLabel || unit.metadata?.id,
+                startTime,
+                endTime,
+                finalText,
+            };
+        });
 
-`;
-        })
-        .join("\n");
+    const cues =
+        cueSplitting && units.length > 0
+            ? buildSplitCues(units, formatTime)
+            : units
+                .map(
+                    (unit) =>
+                        `${unit.id}
+${formatTime(unit.startTime)} --> ${formatTime(unit.endTime)}
+${unit.finalText}
+
+`
+                )
+                .join("\n");
 
     if (cues.length === 0) {
         vscode.window.showInformationMessage("No cues found in the " + filePath);
@@ -91,3 +110,62 @@ ${finalText}
 
 ${cues}`;
 };
+
+/**
+ * Returns true if any two cues in the given cells have overlapping time ranges.
+ * Uses the same cell filtering as generateVttData (excludes merged, requires startTime).
+ * Two cues [s1,e1] and [s2,e2] overlap when s1 < e2 && s2 < e1.
+ */
+export const hasOverlappingCues = (cells: CodexNotebookAsJSONData["cells"]): boolean => {
+    const units = cells
+        .filter((unit) => {
+            const metadata = unit.metadata;
+            return !metadata?.data?.merged && !!unit.metadata?.data?.startTime;
+        })
+        .map((unit, index) => ({
+            startTime: Number(unit.metadata?.data?.startTime ?? index),
+            endTime: Number(unit.metadata?.data?.endTime ?? index + 1),
+        }));
+
+    for (let i = 0; i < units.length; i++) {
+        for (let j = i + 1; j < units.length; j++) {
+            const a = units[i];
+            const b = units[j];
+            if (a.startTime < b.endTime && b.startTime < a.endTime) return true;
+        }
+    }
+    return false;
+};
+
+/**
+ * Build VTT cues by splitting on all unique timestamps. For each adjacent pair of timestamps,
+ * emits one cue containing the concatenated text of all units active in that time range.
+ * Cue is active in [tStart, tEnd) when unit.startTime < tEnd && unit.endTime > tStart.
+ */
+function buildSplitCues(units: ProcessedUnit[], formatTime: (s: number) => string): string {
+    const timestamps = new Set<number>();
+    for (const unit of units) {
+        timestamps.add(unit.startTime);
+        timestamps.add(unit.endTime);
+    }
+    const sorted = Array.from(timestamps).sort((a, b) => a - b);
+
+    const parts: string[] = [];
+    for (let i = 0; i < sorted.length - 1; i++) {
+        const tStart = sorted[i];
+        const tEnd = sorted[i + 1];
+        if (tStart === tEnd) continue;
+
+        const active = units.filter((unit) => unit.startTime < tEnd && unit.endTime > tStart);
+        if (active.length === 0) continue;
+
+        const text = active.map((unit) => unit.finalText).join("\n\n");
+        const cueId = `${active[0].id}-split`;
+        parts.push(`${cueId}
+${formatTime(tStart)} --> ${formatTime(tEnd)}
+${text}
+
+`);
+    }
+    return parts.join("\n");
+}

src/globalProvider.ts

@@ -146,8 +146,6 @@ export abstract class BaseWebviewProvider implements vscode.WebviewViewProvider
     public postMessage(message: any): void {
         if (this._view) {
             safePostMessageToView(this._view, message, "Global");
-        } else {
-            console.error(`WebviewView ${this.getWebviewId()} is not initialized`);
         }
     }
 
@@ -201,14 +199,18 @@ export class GlobalProvider {
 
             const destination = message.destination;
             if (destination === "webview") {
-                this.postMessageToAllWebviews(message);
+                // Forward the message to all webviews, preserving the original structure
+                // Send the full GlobalMessage object so webviews receive command, destination, and content
+                this.providers.forEach((provider, _key) => {
+                    provider.postMessage(message as GlobalMessage);
+                });
             } else if (destination === "provider") {
                 this.postMessageToAllProviders(message);
             }
         }
     }
     public postMessageToAllProviders(message: any) {
-        this.providers.forEach((provider, key) => {
+        this.providers.forEach((provider, _key) => {
             provider.receiveMessage(message);
         });
     }
@@ -227,7 +229,7 @@ export class GlobalProvider {
             content,
         };
 
-        this.providers.forEach((provider, key) => {
+        this.providers.forEach((provider, _key) => {
             provider.postMessage(message);
         });
     }