lyrics-transcriber 0.36.1__py3-none-any.whl → 0.39.0__py3-none-any.whl

lyrics_transcriber/frontend/src/components/LyricsAnalyzer.tsx

@@ -1,8 +1,9 @@
 import {
+    AnchorSequence,
     CorrectionData,
+    GapSequence,
     HighlightInfo,
     InteractionMode,
-    LyricsData,
     LyricsSegment
 } from '../types'
 import LockIcon from '@mui/icons-material/Lock'
@@ -19,6 +20,16 @@ import { WordClickInfo, FlashType } from './shared/types'
 import EditModal from './EditModal'
 import ReviewChangesModal from './ReviewChangesModal'
 import AudioPlayer from './AudioPlayer'
+import { nanoid } from 'nanoid'
+import { initializeDataWithIds, normalizeDataForSubmission } from './shared/utils/initializeDataWithIds'
+
+// Add type for window augmentation at the top of the file
+declare global {
+    interface Window {
+        toggleAudioPlayback?: () => void;
+        seekAndPlayAudio?: (startTime: number) => void;
+    }
+}
 
 interface LyricsAnalyzerProps {
     data: CorrectionData
@@ -30,44 +41,18 @@ interface LyricsAnalyzerProps {
 
 export type ModalContent = {
     type: 'anchor'
-    data: LyricsData['anchor_sequences'][0] & {
-        position: number
+    data: AnchorSequence & {
+        wordId: string
         word?: string
     }
 } | {
     type: 'gap'
-    data: LyricsData['gap_sequences'][0] & {
-        position: number
+    data: GapSequence & {
+        wordId: string
         word: string
     }
 }
 
-function normalizeDataForSubmission(data: CorrectionData): CorrectionData {
-    // Create a deep clone to avoid modifying the original
-    const normalized = JSON.parse(JSON.stringify(data))
-
-    // Preserve floating point numbers with original precision
-    const preserveFloats = (obj: Record<string, unknown>): void => {
-        for (const key in obj) {
-            const value = obj[key]
-            if (typeof value === 'number') {
-                // Handle integers and floats differently
-                let formatted: string
-                if (Number.isInteger(value)) {
-                    formatted = value.toFixed(1)  // Force decimal point for integers
-                } else {
-                    formatted = value.toString()  // Keep original precision for floats
-                }
-                obj[key] = parseFloat(formatted)
-            } else if (typeof value === 'object' && value !== null) {
-                preserveFloats(value as Record<string, unknown>)
-            }
-        }
-    }
-    preserveFloats(normalized)
-    return normalized
-}
-
 export default function LyricsAnalyzer({ data: initialData, onFileLoad, apiClient, isReadOnly }: LyricsAnalyzerProps) {
     const [modalContent, setModalContent] = useState<ModalContent | null>(null)
     const [flashingType, setFlashingType] = useState<FlashType>(null)
@@ -77,7 +62,7 @@ export default function LyricsAnalyzer({ data: initialData, onFileLoad, apiClien
         return availableSources.length > 0 ? availableSources[0] : ''
     })
     const [isReviewComplete, setIsReviewComplete] = useState(false)
-    const [data, setData] = useState(initialData)
+    const [data, setData] = useState(() => initializeDataWithIds(initialData))
     // Create deep copy of initial data for comparison later
     const [originalData] = useState(() => JSON.parse(JSON.stringify(initialData)))
     const [interactionMode, setInteractionMode] = useState<InteractionMode>('details')
@@ -93,39 +78,78 @@ export default function LyricsAnalyzer({ data: initialData, onFileLoad, apiClien
     const theme = useTheme()
     const isMobile = useMediaQuery(theme.breakpoints.down('md'))
 
+    // Simple hash function for generating storage keys
+    const generateStorageKey = (text: string): string => {
+        let hash = 0;
+        for (let i = 0; i < text.length; i++) {
+            const char = text.charCodeAt(i);
+            hash = ((hash << 5) - hash) + char;
+            hash = hash & hash; // Convert to 32-bit integer
+        }
+        return `song_${hash}`;
+    }
+
     // Add local storage handling
     useEffect(() => {
-        // On mount, try to load saved data
-        const savedData = localStorage.getItem('lyrics_analyzer_data')
-        if (savedData) {
+        const storageKey = generateStorageKey(initialData.transcribed_text);
+        const savedDataStr = localStorage.getItem('lyrics_analyzer_data');
+        const savedDataObj = savedDataStr ? JSON.parse(savedDataStr) : {};
+
+        if (savedDataObj[storageKey]) {
             try {
-                const parsed = JSON.parse(savedData)
-                // Only restore if it's the same song (matching transcribed text)
+                const parsed = savedDataObj[storageKey];
                 if (parsed.transcribed_text === initialData.transcribed_text) {
-                    console.log('Restored saved progress from local storage')
-                    setData(parsed)
-                } else {
-                    // Clear old data if it's a different song
-                    localStorage.removeItem('lyrics_analyzer_data')
+                    const stripIds = (obj: CorrectionData): LyricsSegment[] => {
+                        const clone = JSON.parse(JSON.stringify(obj));
+                        return clone.corrected_segments.map((segment: LyricsSegment) => {
+                            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                            const { id: _id, ...strippedSegment } = segment;
+                            return {
+                                ...strippedSegment,
+                                words: segment.words.map(word => {
+                                    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                                    const { id: _wordId, ...strippedWord } = word;
+                                    return strippedWord;
+                                })
+                            };
+                        });
+                    };
+
+                    const strippedSaved = stripIds(parsed);
+                    const strippedInitial = stripIds(initialData);
+
+                    const hasChanges = JSON.stringify(strippedSaved) !== JSON.stringify(strippedInitial);
+
+                    if (hasChanges && window.confirm('Found saved progress for this song. Would you like to restore it?')) {
+                        setData(parsed);
+                    } else if (!hasChanges) {
+                        delete savedDataObj[storageKey];
+                        localStorage.setItem('lyrics_analyzer_data', JSON.stringify(savedDataObj));
+                    }
                 }
             } catch (error) {
-                console.error('Failed to parse saved data:', error)
-                localStorage.removeItem('lyrics_analyzer_data')
+                console.error('Failed to parse saved data:', error);
+                delete savedDataObj[storageKey];
+                localStorage.setItem('lyrics_analyzer_data', JSON.stringify(savedDataObj));
             }
         }
-    }, [initialData.transcribed_text])
+    }, [initialData]);
 
     // Save to local storage whenever data changes
     useEffect(() => {
         if (!isReadOnly) {
-            localStorage.setItem('lyrics_analyzer_data', JSON.stringify(data))
+            const storageKey = generateStorageKey(initialData.transcribed_text);
+            const savedDataStr = localStorage.getItem('lyrics_analyzer_data');
+            const savedDataObj = savedDataStr ? JSON.parse(savedDataStr) : {};
+
+            savedDataObj[storageKey] = data;
+            localStorage.setItem('lyrics_analyzer_data', JSON.stringify(savedDataObj));
         }
-    }, [data, isReadOnly])
+    }, [data, isReadOnly, initialData.transcribed_text]);
 
-    // Add keyboard event handlers
+    // Update keyboard event handler
     useEffect(() => {
         const handleKeyDown = (e: KeyboardEvent) => {
-            // Ignore if user is typing in an input or textarea
             if (e.target instanceof HTMLInputElement || e.target instanceof HTMLTextAreaElement) {
                 return
             }
@@ -136,9 +160,9 @@ export default function LyricsAnalyzer({ data: initialData, onFileLoad, apiClien
             } else if (e.key === 'Meta') {
                 setIsCtrlPressed(true)
             } else if (e.key === ' ' || e.code === 'Space') {
-                e.preventDefault() // Prevent page scroll
-                if ((window as any).toggleAudioPlayback) {
-                    (window as any).toggleAudioPlayback()
+                e.preventDefault()
+                if (window.toggleAudioPlayback) {
+                    window.toggleAudioPlayback()
                 }
             }
         }
@@ -186,63 +210,45 @@ export default function LyricsAnalyzer({ data: initialData, onFileLoad, apiClien
 
     const handleWordClick = useCallback((info: WordClickInfo) => {
         if (effectiveMode === 'edit') {
-            let currentPosition = 0
-            const segmentIndex = data.corrected_segments.findIndex(segment => {
-                if (info.wordIndex >= currentPosition &&
-                    info.wordIndex < currentPosition + segment.words.length) {
-                    return true
-                }
-                currentPosition += segment.words.length
-                return false
-            })
+            const segment = data.corrected_segments.find(segment =>
+                segment.words.some(word => word.id === info.word_id)
+            )
 
-            if (segmentIndex !== -1) {
+            if (segment) {
+                const segmentIndex = data.corrected_segments.indexOf(segment)
                 setEditModalSegment({
-                    segment: data.corrected_segments[segmentIndex],
+                    segment,
                     index: segmentIndex,
                     originalSegment: originalData.corrected_segments[segmentIndex]
                 })
             }
         } else {
-            // Existing word click handling for other modes...
+            // Update flash handling for anchors/gaps
             if (info.type === 'anchor' && info.anchor) {
                 handleFlash('word', {
                     type: 'anchor',
-                    transcriptionIndex: info.anchor.transcription_position,
-                    transcriptionLength: info.anchor.length,
-                    referenceIndices: info.anchor.reference_positions,
-                    referenceLength: info.anchor.length
+                    word_ids: info.anchor.word_ids,
+                    reference_word_ids: info.anchor.reference_word_ids
                 })
             } else if (info.type === 'gap' && info.gap) {
                 handleFlash('word', {
                     type: 'gap',
-                    transcriptionIndex: info.gap.transcription_position,
-                    transcriptionLength: info.gap.length,
-                    referenceIndices: {},
-                    referenceLength: info.gap.length
+                    word_ids: info.gap.word_ids
                 })
             }
         }
     }, [effectiveMode, data.corrected_segments, handleFlash, originalData.corrected_segments])
 
     const handleUpdateSegment = useCallback((updatedSegment: LyricsSegment) => {
-        console.log('LyricsAnalyzer - handleUpdateSegment called:', {
-            editModalSegment,
-            updatedSegment,
-            currentSegmentsCount: data.corrected_segments.length
-        })
-
-        if (!editModalSegment) {
-            console.warn('LyricsAnalyzer - No editModalSegment found')
-            return
-        }
+        if (!editModalSegment) return
 
         const newData = { ...data }
-        console.log('LyricsAnalyzer - Before update:', {
-            segmentIndex: editModalSegment.index,
-            oldText: newData.corrected_segments[editModalSegment.index].text,
-            newText: updatedSegment.text
-        })
+
+        // Ensure new words have IDs
+        updatedSegment.words = updatedSegment.words.map(word => ({
+            ...word,
+            id: word.id || nanoid()
+        }))
 
         newData.corrected_segments[editModalSegment.index] = updatedSegment
 
@@ -251,34 +257,37 @@ export default function LyricsAnalyzer({ data: initialData, onFileLoad, apiClien
             .map(segment => segment.text)
             .join('\n')
 
-        console.log('LyricsAnalyzer - After update:', {
-            segmentsCount: newData.corrected_segments.length,
-            updatedText: newData.corrected_text
-        })
-
         setData(newData)
-        setEditModalSegment(null)  // Close the modal
+        setEditModalSegment(null)
     }, [data, editModalSegment])
 
     const handleDeleteSegment = useCallback((segmentIndex: number) => {
-        console.log('LyricsAnalyzer - handleDeleteSegment called:', {
-            segmentIndex,
-            currentSegmentsCount: data.corrected_segments.length
-        })
-
         const newData = { ...data }
+        const deletedSegment = newData.corrected_segments[segmentIndex]
+
+        // Remove segment
         newData.corrected_segments = newData.corrected_segments.filter((_, index) => index !== segmentIndex)
 
+        // Update anchor and gap sequences to remove references to deleted words
+        newData.anchor_sequences = newData.anchor_sequences.map(anchor => ({
+            ...anchor,
+            word_ids: anchor.word_ids.filter(id =>
+                !deletedSegment.words.some(word => word.id === id)
+            )
+        }))
+
+        newData.gap_sequences = newData.gap_sequences.map(gap => ({
+            ...gap,
+            word_ids: gap.word_ids.filter(id =>
+                !deletedSegment.words.some(word => word.id === id)
+            )
+        }))
+
         // Update corrected_text
         newData.corrected_text = newData.corrected_segments
             .map(segment => segment.text)
             .join('\n')
 
-        console.log('LyricsAnalyzer - After delete:', {
-            segmentsCount: newData.corrected_segments.length,
-            updatedText: newData.corrected_text
-        })
-
         setData(newData)
     }, [data])
 
@@ -305,21 +314,34 @@ export default function LyricsAnalyzer({ data: initialData, onFileLoad, apiClien
         }
     }, [apiClient, data])
 
+    // Update play segment handler
     const handlePlaySegment = useCallback((startTime: number) => {
-        // Access the globally exposed seekAndPlay method
-        if ((window as any).seekAndPlayAudio) {
-            (window as any).seekAndPlayAudio(startTime)
+        if (window.seekAndPlayAudio) {
+            window.seekAndPlayAudio(startTime)
         }
     }, [])
 
     const handleResetCorrections = useCallback(() => {
         if (window.confirm('Are you sure you want to reset all corrections? This cannot be undone.')) {
-            // Clear local storage
-            localStorage.removeItem('lyrics_analyzer_data')
-            // Reset data to initial state
-            setData(JSON.parse(JSON.stringify(initialData)))
+            const storageKey = generateStorageKey(initialData.transcribed_text);
+            const savedDataStr = localStorage.getItem('lyrics_analyzer_data');
+            const savedDataObj = savedDataStr ? JSON.parse(savedDataStr) : {};
+
+            // Remove only this song's data
+            delete savedDataObj[storageKey];
+            localStorage.setItem('lyrics_analyzer_data', JSON.stringify(savedDataObj));
+
+            // Reset data to initial state with proper initialization
+            const freshData = initializeDataWithIds(JSON.parse(JSON.stringify(initialData)));
+            setData(freshData);
+
+            // Reset any UI state that might affect highlights
+            setModalContent(null);
+            setFlashingType(null);
+            setHighlightInfo(null);
+            setInteractionMode('details');
         }
-    }, [initialData])
+    }, [initialData]);
 
     return (
         <Box>
@@ -358,27 +380,31 @@ export default function LyricsAnalyzer({ data: initialData, onFileLoad, apiClien
                 <CorrectionMetrics
                     // Anchor metrics
                     anchorCount={data.metadata.anchor_sequences_count}
-                    multiSourceAnchors={data.anchor_sequences.filter(anchor =>
-                        Object.keys(anchor.reference_positions).length > 1).length}
-                    anchorWordCount={data.anchor_sequences.reduce((sum, anchor) => sum + anchor.length, 0)}
+                    multiSourceAnchors={data.anchor_sequences?.filter(anchor =>
+                        // Add null checks
+                        anchor?.reference_word_ids &&
+                        Object.keys(anchor.reference_word_ids || {}).length > 1
+                    ).length ?? 0}
+                    anchorWordCount={data.anchor_sequences?.reduce((sum, anchor) =>
+                        sum + (anchor.length || 0), 0) ?? 0}
                     // Gap metrics
-                    correctedGapCount={data.gap_sequences.filter(gap =>
-                        gap.corrections?.length > 0).length}
-                    uncorrectedGapCount={data.gap_sequences.filter(gap =>
-                        !gap.corrections?.length).length}
+                    correctedGapCount={data.gap_sequences?.filter(gap =>
+                        gap.corrections?.length > 0).length ?? 0}
+                    uncorrectedGapCount={data.gap_sequences?.filter(gap =>
+                        !gap.corrections?.length).length ?? 0}
                     uncorrectedGaps={data.gap_sequences
-                        .filter(gap => !gap.corrections?.length)
+                        ?.filter(gap => !gap.corrections?.length && gap.word_ids)
                         .map(gap => ({
-                            position: gap.transcription_position,
-                            length: gap.length
-                        }))}
+                            position: gap.word_ids?.[0] ?? '',
+                            length: gap.length ?? 0
+                        })) ?? []}
                     // Correction details
-                    replacedCount={data.gap_sequences.reduce((count, gap) =>
-                        count + (gap.corrections?.filter(c => !c.is_deletion && !c.split_total).length ?? 0), 0)}
-                    addedCount={data.gap_sequences.reduce((count, gap) =>
-                        count + (gap.corrections?.filter(c => c.split_total).length ?? 0), 0)}
-                    deletedCount={data.gap_sequences.reduce((count, gap) =>
-                        count + (gap.corrections?.filter(c => c.is_deletion).length ?? 0), 0)}
+                    replacedCount={data.gap_sequences?.reduce((count, gap) =>
+                        count + (gap.corrections?.filter(c => !c.is_deletion && !c.split_total).length ?? 0), 0) ?? 0}
+                    addedCount={data.gap_sequences?.reduce((count, gap) =>
+                        count + (gap.corrections?.filter(c => c.split_total).length ?? 0), 0) ?? 0}
+                    deletedCount={data.gap_sequences?.reduce((count, gap) =>
+                        count + (gap.corrections?.filter(c => c.is_deletion).length ?? 0), 0) ?? 0}
                     onMetricClick={{
                         anchor: () => handleFlash('anchor'),
                         corrected: () => handleFlash('corrected'),

lyrics_transcriber/frontend/src/components/ReferenceView.tsx

@@ -4,11 +4,11 @@ import { ReferenceViewProps } from './shared/types'
 import { calculateReferenceLinePositions } from './shared/utils/referenceLineCalculator'
 import { SourceSelector } from './shared/components/SourceSelector'
 import { HighlightedText } from './shared/components/HighlightedText'
+import { WordCorrection } from '@/types'
 
 export default function ReferenceView({
     referenceTexts,
     anchors,
-    gaps,
     onElementClick,
     onWordClick,
     flashingType,
@@ -16,10 +16,11 @@ export default function ReferenceView({
     currentSource,
     onSourceChange,
     highlightInfo,
-    mode
+    mode,
+    gaps
 }: ReferenceViewProps) {
     // Get available sources from referenceTexts object
-    const availableSources = useMemo(() => 
+    const availableSources = useMemo(() =>
         Object.keys(referenceTexts) as Array<string>,
         [referenceTexts]
     )
@@ -33,6 +34,42 @@ export default function ReferenceView({
         [corrected_segments, anchors, currentSource]
     )
 
+    // Create a mapping of reference words to their corrections
+    const referenceCorrections = useMemo(() => {
+        const corrections = new Map<string, string>();
+
+        console.log('Building referenceCorrections map:', {
+            gapsCount: gaps.length,
+            currentSource,
+        });
+
+        gaps.forEach(gap => {
+            gap.corrections.forEach((correction: WordCorrection) => {
+                // Get the reference position for this correction
+                const referencePosition = correction.reference_positions?.[currentSource];
+
+                if (typeof referencePosition === 'number') {
+                    const wordId = `${currentSource}-word-${referencePosition}`;
+                    corrections.set(wordId, correction.corrected_word);
+
+                    console.log('Adding correction mapping:', {
+                        wordId,
+                        correctedWord: correction.corrected_word,
+                        referencePosition,
+                        correction
+                    });
+                }
+            });
+        });
+
+        console.log('Final referenceCorrections map:', {
+            size: corrections.size,
+            entries: Array.from(corrections.entries())
+        });
+
+        return corrections;
+    }, [gaps, currentSource]);
+
     return (
         <Paper sx={{ p: 2 }}>
             <Box sx={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center', mb: 2 }}>
@@ -49,7 +86,6 @@ export default function ReferenceView({
                 <HighlightedText
                     text={referenceTexts[currentSource]}
                     anchors={anchors}
-                    gaps={gaps}
                     onElementClick={onElementClick}
                     onWordClick={onWordClick}
                     flashingType={flashingType}
@@ -58,6 +94,8 @@ export default function ReferenceView({
                     isReference={true}
                     currentSource={currentSource}
                     linePositions={linePositions}
+                    referenceCorrections={referenceCorrections}
+                    gaps={gaps}
                 />
             </Box>
         </Paper>

lyrics_transcriber/frontend/src/components/ReviewChangesModal.tsx

@@ -26,11 +26,40 @@ interface DiffResult {
     type: 'added' | 'removed' | 'modified'
     path: string
     segmentIndex?: number
-    oldValue?: any
-    newValue?: any
+    oldValue?: string
+    newValue?: string
     wordChanges?: DiffResult[]
 }
 
+// Add interfaces for the word and segment structures
+interface Word {
+    text: string
+    start_time: number
+    end_time: number
+    id?: string
+}
+
+interface Segment {
+    text: string
+    start_time: number
+    end_time: number
+    words: Word[]
+    id?: string
+}
+
+const normalizeWordForComparison = (word: Word): Omit<Word, 'id'> => ({
+    text: word.text,
+    start_time: word.start_time,
+    end_time: word.end_time
+})
+
+const normalizeSegmentForComparison = (segment: Segment): Omit<Segment, 'id'> => ({
+    text: segment.text,
+    start_time: segment.start_time,
+    end_time: segment.end_time,
+    words: segment.words.map(normalizeWordForComparison)
+})
+
 export default function ReviewChangesModal({
     open,
     onClose,
@@ -44,23 +73,25 @@ export default function ReviewChangesModal({
         const diffs: DiffResult[] = []
 
         // Compare corrected segments
-        originalData.corrected_segments.forEach((segment, index) => {
+        originalData.corrected_segments.forEach((originalSegment, index) => {
             const updatedSegment = updatedData.corrected_segments[index]
             if (!updatedSegment) {
                 diffs.push({
                     type: 'removed',
                     path: `Segment ${index}`,
                     segmentIndex: index,
-                    oldValue: segment.text
+                    oldValue: originalSegment.text
                 })
                 return
             }
 
+            const normalizedOriginal = normalizeSegmentForComparison(originalSegment)
+            const normalizedUpdated = normalizeSegmentForComparison(updatedSegment)
             const wordChanges: DiffResult[] = []
 
-            // Compare word-level changes
-            segment.words.forEach((word, wordIndex) => {
-                const updatedWord = updatedSegment.words[wordIndex]
+            // Compare word-level changes based on position rather than IDs
+            normalizedOriginal.words.forEach((word: Omit<Word, 'id'>, wordIndex: number) => {
+                const updatedWord = normalizedUpdated.words[wordIndex]
                 if (!updatedWord) {
                     wordChanges.push({
                         type: 'removed',
@@ -83,9 +114,9 @@ export default function ReviewChangesModal({
             })
 
             // Check for added words
-            if (updatedSegment.words.length > segment.words.length) {
-                for (let i = segment.words.length; i < updatedSegment.words.length; i++) {
-                    const word = updatedSegment.words[i]
+            if (normalizedUpdated.words.length > normalizedOriginal.words.length) {
+                for (let i = normalizedOriginal.words.length; i < normalizedUpdated.words.length; i++) {
+                    const word = normalizedUpdated.words[i]
                     wordChanges.push({
                         type: 'added',
                         path: `Word ${i}`,
@@ -94,21 +125,34 @@ export default function ReviewChangesModal({
                 }
             }
 
-            if (segment.text !== updatedSegment.text ||
-                segment.start_time !== updatedSegment.start_time ||
-                segment.end_time !== updatedSegment.end_time ||
+            if (normalizedOriginal.text !== normalizedUpdated.text ||
+                Math.abs(normalizedOriginal.start_time - normalizedUpdated.start_time) > 0.0001 ||
+                Math.abs(normalizedOriginal.end_time - normalizedUpdated.end_time) > 0.0001 ||
                 wordChanges.length > 0) {
                 diffs.push({
                     type: 'modified',
                     path: `Segment ${index}`,
                     segmentIndex: index,
-                    oldValue: `"${segment.text}" (${segment.start_time.toFixed(4)} - ${segment.end_time.toFixed(4)})`,
-                    newValue: `"${updatedSegment.text}" (${updatedSegment.start_time.toFixed(4)} - ${updatedSegment.end_time.toFixed(4)})`,
+                    oldValue: `"${normalizedOriginal.text}" (${normalizedOriginal.start_time.toFixed(4)} - ${normalizedOriginal.end_time.toFixed(4)})`,
+                    newValue: `"${normalizedUpdated.text}" (${normalizedUpdated.start_time.toFixed(4)} - ${normalizedUpdated.end_time.toFixed(4)})`,
                     wordChanges: wordChanges.length > 0 ? wordChanges : undefined
                 })
             }
         })
 
+        // Check for added segments
+        if (updatedData.corrected_segments.length > originalData.corrected_segments.length) {
+            for (let i = originalData.corrected_segments.length; i < updatedData.corrected_segments.length; i++) {
+                const segment = updatedData.corrected_segments[i]
+                diffs.push({
+                    type: 'added',
+                    path: `Segment ${i}`,
+                    segmentIndex: i,
+                    newValue: `"${segment.text}" (${segment.start_time.toFixed(4)} - ${segment.end_time.toFixed(4)})`
+                })
+            }
+        }
+
         return diffs
     }, [originalData, updatedData])