diff --git a/docs/archive/2026-09-30-missing-lyrics-vocal-gaps-plan.md b/docs/archive/2026-09-30-missing-lyrics-vocal-gaps-plan.md
index bba583eb..88559bc8 100644
--- a/docs/archive/2026-09-30-missing-lyrics-vocal-gaps-plan.md
+++ b/docs/archive/2026-09-30-missing-lyrics-vocal-gaps-plan.md
@@ -98,3 +98,57 @@ Server-side via `scripts/audit_vocal_gaps.py` (results stored on each job).
- Audio-only runs: record + soft note in review, no gate (precision too low).
- `SectionDetector`: don't label a gap INSTRUMENTAL when the evidence rule fires.
- Review UI: marker at the gap + the reference lines (from either method) offered for insert.
+
+## Phase 2b built: review UI marker + insert
+- `GET /api/review/{job_id}/correction-data` → `vocal_gaps` (typed as `VocalGapsResult` in
+ `frontend/lib/lyrics-review/types.ts`). Only **evidenced** gaps are shown; audio-only
+ suspects stay hidden (precision too low). Nothing shows when `vocal_gaps` is null/empty.
+- Open gaps are derived from the reviewer's CURRENT segments
+ (`lib/lyrics-review/utils/missingLyrics.ts`): a gap is open while no timed word starts in
+ `[start, end)`. `vocal_gaps` is never mutated, so inserting/typing lines hides the marker
+ and undo brings it back. Taken from the loaded data so restored sessions still show it.
+- `MissingLyricsCallout` (above Synced Lyrics): "Possible missing lyrics at m:ss–m:ss", the
+ expected lines (synced reference lines preferred, else anchor-bounded reference lines,
+ with the source name), Play, and **Insert these lines**. `TranscriptionView` draws a
+ dashed amber marker row at the gap's chronological position (all three view modes);
+ clicking it scrolls to the callout.
+- Insert (`hooks/useMissingLyrics.ts`): one segment per line, words split on whitespace,
+ provisional timings spread evenly per word across `[start+0.1, end-0.1]`, inserted before
+ the first segment starting after the gap midpoint, singer inherited from the neighbour.
+ Goes through `updateDataWithHistory` (one undo step) and logs one `segment_add` edit-log
+ entry per line (`details.origin = "missing_lyrics_gap"`).
+- Re-sync guidance: `MissingLyricsResyncHint` lists the inserted lines (while they exist)
+ with a **Sync timing** button each, opening the existing Edit modal (Tap To Sync). No
+ new timing system.
+- Read-only/replay: marker + lines shown, insert disabled.
+- Tests: Jest (`missingLyrics.test.ts`, `useMissingLyrics.test.tsx`,
+ `MissingLyricsCallout.test.tsx`, `TranscriptionView.missingLyrics.test.tsx`) + Playwright
+ regression (`lyrics-review.spec.ts` › "Possible Missing Lyrics": insert, order, undo, Sync
+ timing → Edit modal).
+- Found while building: sonner's `` isn't mounted anywhere (root layout mounts
+ the shadcn `ui/toaster`), so `toast` from `sonner` in the review UI is silently invisible.
+ The hint is therefore inline rather than a toast. Worth a separate fix.
+
+### Phase 2b review fixes (code review)
+- **Edge tolerance:** words starting within 0.05s of a gap edge are its neighbours (backend
+ rounds gap bounds to 2dp and `end` = next word's start, e.g. 19.996 vs 20.0).
+- **Stale-analysis guard:** a gap is only shown if, in the segments AS LOADED, it holds no
+ words and the neighbouring words sit within 1s of both edges (or it touches the song
+ start / has no words after it). The frontend can't recompute `input_key`, so this is the
+ proxy for "the analysis matches this transcription".
+- **Insert position by word times:** a gap inside one segment (words 5–9s + a word at 22s)
+ splits that segment — earlier words keep the id, later words get a fresh id — with the
+ lines inserted between (logged as `segment_split` + `segment_add`).
+- **No fabricated timing:** lines take word timings from the synced reference source
+ (`reference_lyrics[source].segments`, matched by text inside the gap, all words timed);
+ otherwise words are inserted UNTIMED (segment bounds = the gap, so Play/Edit open there)
+ and the existing "N lyric word(s) have no timing yet" submit guard forces a Tap To Sync.
+- **Pending state:** untimed words between the gap's neighbouring timed words (inserted
+ here, typed via Edit/Add Lyrics, or Replace All) → no Insert (no duplicates); the callout
+ shows a "not timed yet" note + Sync timing instead. Timed words inside close the gap.
+- Re-sync hint appends across inserts; a line leaves it once re-synced or deleted.
+- Duet singer: following segment's, then preceding (as `addSegmentBefore`).
+- Display timing offset applied to the callout range, Play time and markers.
+- Read-only tooltip moved to a focusable wrapper (disabled buttons get no hover).
+- Caveat: the submit guard reports via a sonner toast, and sonner's `` isn't
+ mounted, so a blocked submit is currently silent (pre-existing; fix separately).
diff --git a/frontend/app/layout.tsx b/frontend/app/layout.tsx
index 1b41dfab..5502c528 100644
--- a/frontend/app/layout.tsx
+++ b/frontend/app/layout.tsx
@@ -9,6 +9,10 @@ import { ServiceWorkerRegistration } from "@/components/service-worker-registrat
import { GoogleAnalytics } from "@/components/google-analytics"
import ClientErrorInit from "@/components/ClientErrorInit"
import { Toaster } from "@/components/ui/toaster"
+// sonner toasts (lyrics/instrumental review, admin pages) need their own container —
+// without it every sonner toast() is silently dropped (e.g. the "N words have no
+// timing yet" submit guard in lyrics review).
+import { Toaster as SonnerToaster } from "@/components/ui/sonner"
import "./globals.css"
// AvenirNext Bold - matches the font used in actual Nomad theme title card generation
@@ -55,6 +59,7 @@ export default function RootLayout({
{children}
+
diff --git a/frontend/components/lyrics-review/Header.tsx b/frontend/components/lyrics-review/Header.tsx
index 78869d3d..fedec68f 100644
--- a/frontend/components/lyrics-review/Header.tsx
+++ b/frontend/components/lyrics-review/Header.tsx
@@ -249,6 +249,7 @@ export default function Header({
size="icon"
onClick={onUndo}
disabled={!canUndo}
+ aria-label={t('undo')}
className="h-8 w-8"
>
@@ -263,6 +264,7 @@ export default function Header({
size="icon"
onClick={onRedo}
disabled={!canRedo}
+ aria-label={t('redo')}
className="h-8 w-8"
>
diff --git a/frontend/components/lyrics-review/LyricsAnalyzer.tsx b/frontend/components/lyrics-review/LyricsAnalyzer.tsx
index cf6e7f5e..83788a8d 100644
--- a/frontend/components/lyrics-review/LyricsAnalyzer.tsx
+++ b/frontend/components/lyrics-review/LyricsAnalyzer.tsx
@@ -77,6 +77,9 @@ import {
import { computeNeighbourBoundsBySegment } from '@/lib/lyrics-review/utils/contextWords'
import { resolveInitialViewMode } from '@/lib/lyrics-review/utils/segmentTiming'
import { VocalsAudioDataLoader } from './VocalsAudioDataLoader'
+import MissingLyricsCallout, { MissingLyricsResyncHint } from './MissingLyricsCallout'
+import { useMissingLyrics } from '@/lib/lyrics-review/hooks/useMissingLyrics'
+import type { OpenMissingLyricsGap } from '@/lib/lyrics-review/utils/missingLyrics'
// Add type for window augmentation
declare global {
@@ -1135,9 +1138,7 @@ export default function LyricsAnalyzer({
// it here with an actionable message so the user can synchronize first.
const untimed = countUntimedWords(data.corrected_segments)
if (untimed > 0) {
- toast.error(
- `${untimed} lyric word(s) have no timing yet. Open the synchronizer and tap each line to the beat before generating the video.`
- )
+ toast.error(t('toasts.untimedWordsBlockSubmit', { count: untimed }))
return
}
@@ -1229,7 +1230,7 @@ export default function LyricsAnalyzer({
toast.error('Failed to submit corrections. Please try again.')
setIsSubmitting(false) // Reset on error so user can retry
}
- }, [apiClient, data, timingOffsetMs, editLog, isLocalMode, jobId, hasExistingInstrumental, isDuet, autoInstrumentalConfident, offerInlineInstrumentalChoice, currentInstrumental, reviewInstrumentalAnyway])
+ }, [apiClient, data, timingOffsetMs, editLog, isLocalMode, jobId, hasExistingInstrumental, isDuet, autoInstrumentalConfident, offerInlineInstrumentalChoice, currentInstrumental, reviewInstrumentalAnyway, t])
// Play segment handler
const handlePlaySegment = useCallback(
@@ -1522,6 +1523,31 @@ export default function LyricsAnalyzer({
}
}, [editModalSegment, data.corrected_segments, timingOffsetMs])
+ // Possible missing lyrics: evidenced vocal gaps (singing, no words, reference lines
+ // expected) that still have no timed words in the CURRENT segments. The analysis comes
+ // from the loaded data (a restored session may predate it), is checked against the
+ // segments as loaded (stale-analysis guard), and is never mutated — the marker goes
+ // away when words land in the gap and comes back on undo. Inserts go through
+ // updateDataWithHistory (one undo step); the hook also tracks inserted lines that still
+ // need a Tap To Sync for the re-sync hint.
+ const initialSegments = initialData.corrected_segments
+ const missingLyrics = useMissingLyrics({
+ vocalGaps: initialData.vocal_gaps ?? data.vocal_gaps,
+ initialSegments,
+ data,
+ updateDataWithHistory,
+ editLog,
+ isReadOnly,
+ timingOffsetMs,
+ })
+ const insertMissingLyricsLines = missingLyrics.insertLines
+ const handleInsertMissingLyrics = useCallback(
+ (open: OpenMissingLyricsGap) => {
+ insertMissingLyricsLines(open)
+ },
+ [insertMissingLyricsLines]
+ )
+
// Timing offset handlers
const handleOpenTimingOffsetModal = useCallback(() => {
setIsTimingOffsetModalOpen(true)
@@ -1629,6 +1655,22 @@ export default function LyricsAnalyzer({
)}
>
+
+ {!isReadOnly && (
+
+ )}
{waveformsLayout && referenceLayout.collapsed ? (
diff --git a/frontend/components/lyrics-review/MissingLyricsCallout.tsx b/frontend/components/lyrics-review/MissingLyricsCallout.tsx
new file mode 100644
index 00000000..a841f6e0
--- /dev/null
+++ b/frontend/components/lyrics-review/MissingLyricsCallout.tsx
@@ -0,0 +1,194 @@
+'use client'
+
+import { useTranslations } from 'next-intl'
+import { AlertTriangle, Play, ListPlus, Info, X, Timer } from 'lucide-react'
+import { Button } from '@/components/ui/button'
+import { formatGapTime, type OpenMissingLyricsGap } from '@/lib/lyrics-review/utils/missingLyrics'
+import type { LyricsSegment } from '@/lib/lyrics-review/types'
+import { applyOffsetToTime } from '@/lib/lyrics-review/utils/timingUtils'
+
+interface MissingLyricsCalloutProps {
+ gaps: OpenMissingLyricsGap[]
+ isReadOnly: boolean
+ audioReady?: boolean
+ onPlay?: (startTime: number) => void
+ onInsert: (gap: OpenMissingLyricsGap) => void
+ /** Open a segment in the Edit modal (Tap To Sync) — used when lines are pending sync. */
+ onSync?: (segmentIndex: number) => void
+ /**
+ * Display timing offset (ms), applied exactly like the review's displayData so the range
+ * shown — and the time Play receives — match the displayed segments.
+ */
+ timingOffsetMs?: number
+}
+
+/**
+ * Non-blocking warning for sung stretches with no lyrics where the reference lyrics
+ * expect lines ("evidenced" vocal gaps). Lists the expected lines and offers to insert
+ * them as provisional segments. Renders nothing when there are no open gaps.
+ */
+export default function MissingLyricsCallout({
+ gaps,
+ isReadOnly,
+ audioReady = true,
+ onPlay,
+ onInsert,
+ onSync,
+ timingOffsetMs = 0,
+}: MissingLyricsCalloutProps) {
+ const t = useTranslations('lyricsReview.missingLyrics')
+ if (gaps.length === 0) return null
+
+ return (
+
+ {gaps.map((open) => {
+ const displayStart = applyOffsetToTime(open.gap.start, timingOffsetMs) as number
+ const displayEnd = applyOffsetToTime(open.gap.end, timingOffsetMs) as number
+ const range = { start: formatGapTime(displayStart), end: formatGapTime(displayEnd) }
+ const pending = open.pendingSegmentIndex !== null
+ return (
+
+ {onPlay && (
+
+ )}
+ {pending && onSync && !isReadOnly && (
+
+ )}
+ {!pending && open.lines.length > 0 && (
+ // Disabled buttons get pointer-events-none, so the read-only explanation
+ // lives on a focusable wrapper where hover/focus can reach it.
+
+
+
+ )}
+
+
+
+ )
+ })}
+
+ )
+}
+
+interface MissingLyricsResyncHintProps {
+ /** The inserted lines still present in the current segments, with their indices. */
+ lines: { segment: LyricsSegment; index: number }[]
+ /** Open the existing Edit modal (with Tap To Sync) for the segment at `index`. */
+ onSync: (index: number) => void
+ onDismiss: () => void
+}
+
+/**
+ * Shown after "Insert these lines": the inserted words only have placeholder timing,
+ * so guide the reviewer to the existing per-line Tap To Sync in the Edit modal.
+ */
+export function MissingLyricsResyncHint({ lines, onSync, onDismiss }: MissingLyricsResyncHintProps) {
+ const t = useTranslations('lyricsReview.missingLyrics')
+ if (lines.length === 0) return null
+
+ return (
+
+
+
+
{t('insertedTitle')}
+
{t('insertedHint')}
+
+ {lines.map(({ segment, index }) => (
+
+
+ {segment.text}
+
+ ))}
+
+
+
+
+ )
+}
diff --git a/frontend/components/lyrics-review/TranscriptionView.tsx b/frontend/components/lyrics-review/TranscriptionView.tsx
index 12448031..9ea9fb9e 100644
--- a/frontend/components/lyrics-review/TranscriptionView.tsx
+++ b/frontend/components/lyrics-review/TranscriptionView.tsx
@@ -1,13 +1,14 @@
'use client'
import { useTranslations } from 'next-intl'
-import { useState, useMemo } from 'react'
+import { Fragment, useState, useMemo } from 'react'
import { Card, CardContent } from '@/components/ui/card'
import { Button } from '@/components/ui/button'
import { ToggleGroup, ToggleGroupItem } from '@/components/ui/toggle-group'
-import { Play, Trash2, Type, Clock, AudioWaveform } from 'lucide-react'
+import { Play, Trash2, Type, Clock, AudioWaveform, AlertTriangle } from 'lucide-react'
import { HighlightedText } from './shared/HighlightedText'
-import { TranscriptionViewProps, TranscriptionWordPosition } from '@/lib/lyrics-review/types'
+import { TranscriptionViewProps, TranscriptionWordPosition, MissingLyricsMarker } from '@/lib/lyrics-review/types'
+import { formatGapTime } from '@/lib/lyrics-review/utils/missingLyrics'
import { deleteSegment } from '@/lib/lyrics-review/utils/segmentOperations'
import {
computeContextWordsBySegment,
@@ -52,6 +53,7 @@ export default function TranscriptionView({
isDuet,
onSegmentSingerChange,
onSegmentFocus,
+ missingLyricsMarkers,
}: TranscriptionViewProps) {
const t = useTranslations('lyricsReview.transcription')
const tHeader = useTranslations('lyricsReview.header')
@@ -147,6 +149,31 @@ export default function TranscriptionView({
}
}, [data.corrected_segments])
+ // Possible-missing-lyrics markers, grouped by the segment index they sit before.
+ const markersByIndex = useMemo(() => {
+ const map = new Map()
+ for (const m of missingLyricsMarkers ?? []) {
+ map.set(m.beforeSegmentIndex, [...(map.get(m.beforeSegmentIndex) ?? []), m])
+ }
+ return map
+ }, [missingLyricsMarkers])
+
+ const renderMarkers = (index: number) =>
+ (markersByIndex.get(index) ?? []).map((m) => (
+
+ ))
+
const handleDeleteSegment = (segmentIndex: number) => {
if (onDataChange) {
const updatedData = deleteSegment(data, segmentIndex)
@@ -187,8 +214,9 @@ export default function TranscriptionView({
// (e.g. an over-long trailing word) at a glance without opening a modal per line.
) : (
// Advanced rows are full-width pill timelines, so give them a bit
@@ -263,8 +293,9 @@ export default function TranscriptionView({
: ''
return (
+
+ {renderMarkers(segmentIndex)}
+
)
})}
+ {renderMarkers(data.corrected_segments.length)}
)}
diff --git a/frontend/components/lyrics-review/__tests__/MissingLyricsCallout.test.tsx b/frontend/components/lyrics-review/__tests__/MissingLyricsCallout.test.tsx
new file mode 100644
index 00000000..f14f6c1c
--- /dev/null
+++ b/frontend/components/lyrics-review/__tests__/MissingLyricsCallout.test.tsx
@@ -0,0 +1,168 @@
+import { render, screen } from '@testing-library/react'
+import userEvent from '@testing-library/user-event'
+import MissingLyricsCallout, { MissingLyricsResyncHint } from '../MissingLyricsCallout'
+import { findOpenMissingLyricsGaps } from '@/lib/lyrics-review/utils/missingLyrics'
+import type { LyricsSegment, VocalGap } from '@/lib/lyrics-review/types'
+
+const gap = (overrides: Partial = {}): VocalGap => ({
+ start: 20.66,
+ end: 32.4,
+ duration: 11.74,
+ active_fraction: 0.9,
+ longest_run_s: 11.76,
+ reference_lines: { genius: ['plain line'] },
+ synced_reference_lines: { lrclib: ['synced line one', 'synced line two'] },
+ suspect: true,
+ evidenced: true,
+ ...overrides,
+})
+
+const segments: LyricsSegment[] = [
+ { id: 's1', text: 'a', start_time: 10, end_time: 20.66, words: [{ id: 'w1', text: 'a', start_time: 10, end_time: 20.66 }] },
+]
+
+const openGaps = (gaps: VocalGap[] | null, segs = segments) =>
+ findOpenMissingLyricsGaps(gaps === null ? null : { gaps }, segs)
+
+describe('MissingLyricsCallout', () => {
+ it('shows the warning, time range and synced reference lines for an evidenced gap', () => {
+ render()
+ expect(screen.getByText('Possible missing lyrics at 0:20–0:32')).toBeInTheDocument()
+ expect(
+ screen.getByText('The lead vocal is singing here but there are no lyrics.')
+ ).toBeInTheDocument()
+ expect(screen.getByText('Lyrics expected here (from lrclib):')).toBeInTheDocument()
+ expect(screen.getByText('synced line one')).toBeInTheDocument()
+ expect(screen.getByText('synced line two')).toBeInTheDocument()
+ expect(screen.queryByText('plain line')).not.toBeInTheDocument()
+ })
+
+ it('falls back to reference_lines when there are no synced lines', () => {
+ render(
+
+ )
+ expect(screen.getByText('Lyrics expected here (from genius):')).toBeInTheDocument()
+ expect(screen.getByText('plain line')).toBeInTheDocument()
+ })
+
+ it('renders nothing when words already exist in the gap', () => {
+ const filled: LyricsSegment[] = [
+ ...segments,
+ { id: 's2', text: 'b', start_time: 22, end_time: 23, words: [{ id: 'w2', text: 'b', start_time: 22, end_time: 23 }] },
+ ]
+ const { container } = render(
+
+ )
+ expect(container.firstChild).toBeNull()
+ })
+
+ it('renders nothing for non-evidenced gaps or null data', () => {
+ const { container, rerender } = render(
+
+ )
+ expect(container.firstChild).toBeNull()
+ rerender()
+ expect(container.firstChild).toBeNull()
+ })
+
+ it('calls onInsert with the gap when "Insert these lines" is clicked', async () => {
+ const onInsert = jest.fn()
+ const gaps = openGaps([gap()])
+ render()
+ await userEvent.setup().click(screen.getByRole('button', { name: /Insert these lines/ }))
+ expect(onInsert).toHaveBeenCalledWith(gaps[0])
+ })
+
+ it('plays from the gap start', async () => {
+ const onPlay = jest.fn()
+ render()
+ await userEvent.setup().click(screen.getByRole('button', { name: /Play/ }))
+ expect(onPlay).toHaveBeenCalledWith(20.66)
+ })
+
+ it('shows the marker but disables insertion in read-only mode', () => {
+ const onInsert = jest.fn()
+ render()
+ expect(screen.getByText('Possible missing lyrics at 0:20–0:32')).toBeInTheDocument()
+ const btn = screen.getByRole('button', { name: /Insert these lines/ })
+ expect(btn).toBeDisabled()
+ // The disabled button can't receive hover (pointer-events-none), so the explanation
+ // sits on a focusable wrapper.
+ const wrapper = screen.getByTestId('missing-lyrics-insert-wrapper')
+ expect(wrapper).toHaveAttribute('title', 'Editing is disabled in read-only mode')
+ expect(wrapper).toHaveAttribute('tabindex', '0')
+ expect(btn).not.toHaveAttribute('title')
+ expect(btn).toHaveAccessibleName(/read-only/)
+ })
+
+ it('applies the timing offset to the shown range and the Play time', async () => {
+ const onPlay = jest.fn()
+ render(
+
+ )
+ expect(screen.getByText('Possible missing lyrics at 0:22–0:34')).toBeInTheDocument()
+ await userEvent.setup().click(screen.getByRole('button', { name: /Play/ }))
+ expect(onPlay).toHaveBeenCalledWith(22.66)
+ })
+
+ it('pending gap (untimed lyrics already there): no Insert, shows a Sync timing prompt', async () => {
+ const onSync = jest.fn()
+ const pendingGap = { ...openGaps([gap()])[0], pendingSegmentIndex: 3 }
+ render()
+ expect(screen.queryByRole('button', { name: /Insert these lines/ })).not.toBeInTheDocument()
+ expect(screen.getByTestId('missing-lyrics-pending')).toHaveTextContent(/aren't timed yet/)
+ await userEvent.setup().click(screen.getByTestId('missing-lyrics-pending-sync'))
+ expect(onSync).toHaveBeenCalledWith(3)
+ })
+
+ it('hides the insert button and explains when no reference lines are available', () => {
+ render(
+
+ )
+ expect(screen.queryByRole('button', { name: /Insert these lines/ })).not.toBeInTheDocument()
+ expect(screen.getByText(/No reference lines are available/)).toBeInTheDocument()
+ })
+})
+
+describe('MissingLyricsResyncHint', () => {
+ const lines = [
+ { segment: { id: 'a', text: 'first inserted', words: [], start_time: 1, end_time: 2 }, index: 3 },
+ { segment: { id: 'b', text: 'second inserted', words: [], start_time: 2, end_time: 3 }, index: 4 },
+ ]
+
+ it('lists inserted lines with a Sync timing button each, opening the right segment', async () => {
+ const onSync = jest.fn()
+ render()
+ expect(screen.getByText('Check the timing of the inserted lines')).toBeInTheDocument()
+ expect(screen.getByText(/use Tap To Sync/)).toBeInTheDocument()
+ const buttons = screen.getAllByRole('button', { name: /Sync timing/ })
+ expect(buttons).toHaveLength(2)
+ await userEvent.setup().click(buttons[1])
+ expect(onSync).toHaveBeenCalledWith(4)
+ })
+
+ it('can be dismissed and renders nothing with no lines', async () => {
+ const onDismiss = jest.fn()
+ const { container, rerender } = render(
+
+ )
+ await userEvent.setup().click(screen.getByRole('button', { name: 'Dismiss' }))
+ expect(onDismiss).toHaveBeenCalled()
+ rerender()
+ expect(container.firstChild).toBeNull()
+ })
+})
diff --git a/frontend/components/lyrics-review/__tests__/TranscriptionView.missingLyrics.test.tsx b/frontend/components/lyrics-review/__tests__/TranscriptionView.missingLyrics.test.tsx
new file mode 100644
index 00000000..0c33e183
--- /dev/null
+++ b/frontend/components/lyrics-review/__tests__/TranscriptionView.missingLyrics.test.tsx
@@ -0,0 +1,60 @@
+import { render, screen, within } from '@testing-library/react'
+import TranscriptionView from '../TranscriptionView'
+import type { CorrectionData, LyricsSegment } from '@/lib/lyrics-review/types'
+
+const seg = (id: string, start: number, end: number, text: string): LyricsSegment => ({
+ id,
+ text,
+ start_time: start,
+ end_time: end,
+ words: [{ id: `${id}-w`, text, start_time: start, end_time: end }],
+})
+
+const data = {
+ corrected_segments: [seg('s1', 0, 5, 'intro'), seg('s2', 11, 20, 'verse')],
+ original_segments: [],
+ reference_lyrics: {},
+ anchor_sequences: [],
+ gap_sequences: [],
+ corrections: [],
+} as unknown as CorrectionData
+
+const baseProps = {
+ data,
+ onElementClick: jest.fn(),
+ flashingType: null,
+ highlightInfo: null,
+ mode: 'edit' as const,
+}
+
+describe('TranscriptionView missing-lyrics markers', () => {
+ it('renders a marker row between the segments either side of the gap', () => {
+ const { container } = render(
+
+ )
+ const marker = screen.getByTestId('missing-lyrics-marker')
+ expect(within(marker).getByText('Possible missing lyrics 0:05–0:11')).toBeInTheDocument()
+ const text = container.textContent ?? ''
+ expect(text.indexOf('intro')).toBeLessThan(text.indexOf('Possible missing lyrics'))
+ expect(text.indexOf('Possible missing lyrics')).toBeLessThan(text.indexOf('verse'))
+ })
+
+ it('renders a marker after the last segment', () => {
+ const { container } = render(
+
+ )
+ const text = container.textContent ?? ''
+ expect(text.indexOf('verse')).toBeLessThan(text.indexOf('Possible missing lyrics 0:25–0:31'))
+ })
+
+ it('renders no marker without gaps', () => {
+ render()
+ expect(screen.queryByTestId('missing-lyrics-marker')).not.toBeInTheDocument()
+ })
+})
diff --git a/frontend/e2e/regression/lyrics-review.spec.ts b/frontend/e2e/regression/lyrics-review.spec.ts
index e0c94e4a..94dd7e61 100644
--- a/frontend/e2e/regression/lyrics-review.spec.ts
+++ b/frontend/e2e/regression/lyrics-review.spec.ts
@@ -179,7 +179,7 @@ const mockJobData = {
};
// Setup function to configure mocks for local mode
-async function setupLocalModeMocks(page: Page) {
+async function setupLocalModeMocks(page: Page, correctionData: object = mockCorrectionData) {
return setupApiFixtures(page, {
mocks: [
// Job endpoint - returns mock job for local mode
@@ -192,13 +192,13 @@ async function setupLocalModeMocks(page: Page) {
{
method: 'GET',
path: '/api/jobs/local/corrections',
- response: { body: mockCorrectionData },
+ response: { body: correctionData },
},
// Correction data endpoint (new review path)
{
method: 'GET',
path: '/api/review/local/correction-data',
- response: { body: mockCorrectionData },
+ response: { body: correctionData },
},
// Submit corrections endpoint (POST, not PUT)
{
@@ -210,13 +210,13 @@ async function setupLocalModeMocks(page: Page) {
{
method: 'POST',
path: '/api/review/local/handlers',
- response: { body: { status: 'success', data: mockCorrectionData } },
+ response: { body: { status: 'success', data: correctionData } },
},
// Add lyrics endpoint
{
method: 'POST',
path: '/api/review/local/add-lyrics',
- response: { body: { status: 'success', data: mockCorrectionData } },
+ response: { body: { status: 'success', data: correctionData } },
},
// Preview video generation endpoint
{
@@ -847,3 +847,184 @@ test.describe('Combined Review Flow', () => {
await expect(page.locator('button:has-text("Complete Review")')).not.toBeVisible();
});
});
+
+// Possible missing lyrics (vocal-gaps phase 2b): an "evidenced" gap — the lead vocal
+// sings 5.2–9.8s with no transcribed words and the reference expects lines there.
+const missingLyricsCorrectionData = {
+ ...mockCorrectionData,
+ corrected_segments: [
+ mockCorrectionData.corrected_segments[0],
+ {
+ ...mockCorrectionData.corrected_segments[1],
+ start_time: 10.0,
+ end_time: 12.0,
+ words: mockCorrectionData.corrected_segments[1].words.map((w, i) => ({
+ ...w,
+ start_time: 10.0 + i * 0.5,
+ end_time: 10.5 + i * 0.5,
+ })),
+ },
+ ],
+ vocal_gaps: {
+ version: '0.2.0',
+ gaps: [
+ {
+ start: 2.5,
+ end: 10.0,
+ duration: 7.5,
+ active_fraction: 0.8,
+ longest_run_s: 6.1,
+ reference_lines: { genius: ['Plain reference line'] },
+ synced_reference_lines: { lrclib: ['Dropped line number one', 'Dropped line two'] },
+ suspect: true,
+ evidenced: true,
+ },
+ {
+ // Audio-only suspect gap — must NOT be shown.
+ start: 12.0,
+ end: 20.0,
+ duration: 8.0,
+ active_fraction: 0.5,
+ longest_run_s: 3.5,
+ reference_lines: {},
+ synced_reference_lines: {},
+ suspect: true,
+ evidenced: false,
+ },
+ ],
+ suspect_count: 2,
+ evidenced_count: 1,
+ max_suspect_run_s: 6.1,
+ },
+};
+
+// Same fixture, but the synced reference (LRCLIB) carries word timings for both lines,
+// so inserted lines take those timings instead of being inserted untimed.
+const lrclibWord = (id: string, text: string, start: number) => ({ id, text, start_time: start, end_time: start + 0.6 });
+const missingLyricsSyncedRefData = {
+ ...missingLyricsCorrectionData,
+ reference_lyrics: {
+ ...mockCorrectionData.reference_lyrics,
+ lrclib: {
+ segments: [
+ {
+ id: 'lrc_1',
+ text: 'Dropped line number one',
+ start_time: 3.5,
+ end_time: 5.9,
+ words: ['Dropped', 'line', 'number', 'one'].map((t, i) => lrclibWord(`lrc_1_${i}`, t, 3.5 + i * 0.6)),
+ },
+ {
+ id: 'lrc_2',
+ text: 'Dropped line two',
+ start_time: 6.5,
+ end_time: 8.3,
+ words: ['Dropped', 'line', 'two'].map((t, i) => lrclibWord(`lrc_2_${i}`, t, 6.5 + i * 0.6)),
+ },
+ ],
+ metadata: { source: 'lrclib', is_synced: true },
+ },
+ },
+};
+
+const transcriptOrder = async (page: Page) => {
+ const syncedCard = page.locator('h3', { hasText: 'Synced Lyrics' }).locator('xpath=../..');
+ const transcript = await syncedCard.innerText();
+ return {
+ hello: transcript.indexOf('Hello'),
+ dropped: transcript.indexOf('Dropped'),
+ another: transcript.indexOf('another'),
+ };
+};
+
+test.describe('Lyrics Review - Possible Missing Lyrics (untimed insert)', () => {
+ test.beforeEach(async ({ page }) => {
+ await clearAuthToken(page);
+ await setupLocalModeMocks(page, missingLyricsCorrectionData);
+ });
+
+ test('warns about an evidenced gap; Insert adds untimed lines that must be synced; undo restores', async ({ page }) => {
+ await page.goto('/app/jobs/local/review');
+ await page.waitForLoadState('networkidle');
+
+ const callout = page.getByTestId('missing-lyrics-gap');
+ await expect(callout).toHaveCount(1, { timeout: 10000 });
+ await expect(callout).toContainText('Possible missing lyrics at 0:02–0:10');
+ await expect(callout).toContainText('from lrclib');
+ await expect(callout).toContainText('Dropped line number one');
+ await expect(callout).not.toContainText('Plain reference line');
+ await expect(page.getByTestId('missing-lyrics-marker')).toHaveCount(1);
+ await expect(page.getByText(/Possible missing lyrics at 0:12/)).toHaveCount(0);
+
+ await page.getByTestId('missing-lyrics-insert').click();
+
+ // No reference word timings → inserted untimed; the gap is now "pending sync":
+ // no second Insert, a Sync timing prompt instead.
+ await expect(callout).toHaveCount(1);
+ await expect(page.getByTestId('missing-lyrics-insert')).toHaveCount(0);
+ await expect(page.getByTestId('missing-lyrics-pending')).toBeVisible();
+ const hint = page.getByTestId('missing-lyrics-resync-hint');
+ await expect(hint.getByTestId('missing-lyrics-sync-line')).toHaveCount(2);
+ const order = await transcriptOrder(page);
+ expect(order.hello).toBeGreaterThanOrEqual(0);
+ expect(order.dropped).toBeGreaterThan(order.hello);
+ expect(order.another).toBeGreaterThan(order.dropped);
+
+ await page.getByRole('button', { name: 'Undo', exact: true }).click();
+ await expect(page.getByTestId('missing-lyrics-insert')).toHaveCount(1);
+ await expect(page.getByTestId('missing-lyrics-resync-hint')).toHaveCount(0);
+ });
+
+ test('submitting with unsynced inserted lines is blocked with a visible message', async ({ page }) => {
+ // The guard reports via a sonner toast; until the sonner was mounted in
+ // the root layout, the submit was silently swallowed.
+ await page.goto('/app/jobs/local/review');
+ await page.waitForLoadState('networkidle');
+ await page.getByTestId('missing-lyrics-insert').click();
+
+ await page.evaluate(() => window.scrollTo(0, document.body.scrollHeight));
+ await page.getByRole('button', { name: /preview video/i }).click();
+ const dialog = page.locator('[role="dialog"]');
+ await expect(dialog).toBeVisible({ timeout: 10000 });
+ await dialog.getByRole('button', { name: /proceed|complete|generate/i }).last().click();
+
+ await expect(page.getByText(/lyric words? (has|have) no timing yet/)).toBeVisible({ timeout: 5000 });
+ });
+
+ test('"Sync timing" opens the Edit modal (Tap To Sync) for the inserted line', async ({ page }) => {
+ await page.goto('/app/jobs/local/review');
+ await page.waitForLoadState('networkidle');
+ await page.getByTestId('missing-lyrics-insert').click();
+ await page.getByTestId('missing-lyrics-pending-sync').click();
+ const dialog = page.locator('[role="dialog"]');
+ await expect(dialog).toBeVisible({ timeout: 5000 });
+ await expect(dialog.getByRole('button', { name: /Tap To Sync/ }).first()).toBeVisible();
+ await expect(dialog).toContainText('Dropped');
+ });
+});
+
+test.describe('Lyrics Review - Possible Missing Lyrics (synced reference timings)', () => {
+ test.beforeEach(async ({ page }) => {
+ await clearAuthToken(page);
+ await setupLocalModeMocks(page, missingLyricsSyncedRefData);
+ });
+
+ test('Insert uses the LRCLIB word timings, closing the gap; undo brings it back', async ({ page }) => {
+ await page.goto('/app/jobs/local/review');
+ await page.waitForLoadState('networkidle');
+ await expect(page.getByTestId('missing-lyrics-gap')).toHaveCount(1, { timeout: 10000 });
+
+ await page.getByTestId('missing-lyrics-insert').click();
+
+ await expect(page.getByTestId('missing-lyrics-gap')).toHaveCount(0);
+ await expect(page.getByTestId('missing-lyrics-marker')).toHaveCount(0);
+ // Still offered for a check/re-sync until the reviewer touches the timing.
+ await expect(page.getByTestId('missing-lyrics-resync-hint').getByTestId('missing-lyrics-sync-line')).toHaveCount(2);
+ const order = await transcriptOrder(page);
+ expect(order.dropped).toBeGreaterThan(order.hello);
+ expect(order.another).toBeGreaterThan(order.dropped);
+
+ await page.getByRole('button', { name: 'Undo', exact: true }).click();
+ await expect(page.getByTestId('missing-lyrics-gap')).toHaveCount(1);
+ });
+});
diff --git a/frontend/lib/lyrics-review/hooks/__tests__/useMissingLyrics.test.tsx b/frontend/lib/lyrics-review/hooks/__tests__/useMissingLyrics.test.tsx
new file mode 100644
index 00000000..b5c9b56d
--- /dev/null
+++ b/frontend/lib/lyrics-review/hooks/__tests__/useMissingLyrics.test.tsx
@@ -0,0 +1,187 @@
+import { useCallback, useState } from 'react'
+import { renderHook, act } from '@testing-library/react'
+import { useMissingLyrics } from '../useMissingLyrics'
+import { createEditLog } from '../../utils/editLog'
+import { countUntimedWords } from '../../utils/timingCompleteness'
+import type { CorrectionData, LyricsSegment, VocalGap, VocalGapsResult } from '../../types'
+
+const seg = (id: string, start: number, end: number, text: string): LyricsSegment => ({
+ id,
+ text,
+ start_time: start,
+ end_time: end,
+ words: [{ id: `${id}-w`, text, start_time: start, end_time: end }],
+})
+
+const evidenced = (start: number, end: number, lines: string[]): VocalGap => ({
+ start,
+ end,
+ duration: end - start,
+ active_fraction: 0.9,
+ longest_run_s: end - start - 0.5,
+ reference_lines: { genius: lines },
+ synced_reference_lines: {},
+ suspect: true,
+ evidenced: true,
+})
+
+const vocalGaps: VocalGapsResult = {
+ version: '0.2.0',
+ gaps: [
+ evidenced(5, 11, ['line one', 'line two words']),
+ { ...evidenced(20, 26, []), evidenced: false },
+ evidenced(30, 40, ['late line']),
+ ],
+}
+
+const baseData = {
+ corrected_segments: [seg('s1', 0, 5, 'intro'), seg('s2', 11, 20, 'verse'), seg('s3', 26, 30, 'bridge'), seg('s4', 40, 45, 'outro')],
+ reference_lyrics: {},
+} as unknown as CorrectionData
+
+/**
+ * Mirrors LyricsAnalyzer's history machinery (history array + index, push on update,
+ * undo = step the index back) so the test proves insertion is one undoable step.
+ */
+function useHarness({ isReadOnly = false, timingOffsetMs = 0 } = {}) {
+ const [history, setHistory] = useState([baseData])
+ const [index, setIndex] = useState(0)
+ const data = history[index]
+ const updateDataWithHistory = useCallback(
+ (next: CorrectionData) => {
+ const h = history.slice(0, index + 1)
+ h.push(JSON.parse(JSON.stringify(next)))
+ setHistory(h)
+ setIndex(h.length - 1)
+ },
+ [history, index]
+ )
+ const [editLog] = useState(() => createEditLog('job', 'hash'))
+ const missing = useMissingLyrics({
+ vocalGaps,
+ initialSegments: baseData.corrected_segments,
+ data,
+ updateDataWithHistory,
+ editLog,
+ isReadOnly,
+ timingOffsetMs,
+ })
+ return {
+ missing,
+ data,
+ undo: () => setIndex((i) => Math.max(0, i - 1)),
+ historyLength: history.length,
+ editLog,
+ setData: updateDataWithHistory,
+ }
+}
+
+describe('useMissingLyrics', () => {
+ it('exposes only evidenced open gaps, with markers at the chronological position', () => {
+ const { result } = renderHook(() => useHarness())
+ expect(result.current.missing.openGaps.map((g) => g.gap.start)).toEqual([5, 30])
+ expect(result.current.missing.markers[0]).toEqual({
+ id: 'missing-lyrics-5.00-11.00',
+ beforeSegmentIndex: 1,
+ start: 5,
+ end: 11,
+ })
+ })
+
+ it('markers use display time when a timing offset is set', () => {
+ const { result } = renderHook(() => useHarness({ timingOffsetMs: 500 }))
+ expect(result.current.missing.markers[0]).toMatchObject({ start: 5.5, end: 11.5 })
+ })
+
+ it('inserts through the history (one undoable step); untimed lines leave the gap pending; undo restores', () => {
+ const { result } = renderHook(() => useHarness())
+ let ret: ReturnType = null
+ act(() => {
+ ret = result.current.missing.insertLines(result.current.missing.openGaps[0])
+ })
+ expect(ret!.insertedAt).toBe(1)
+ expect(result.current.historyLength).toBe(2)
+ expect(result.current.data.corrected_segments.map((s) => s.text)).toEqual([
+ 'intro',
+ 'line one',
+ 'line two words',
+ 'verse',
+ 'bridge',
+ 'outro',
+ ])
+ // untimed → the submit guard will force a sync
+ expect(countUntimedWords(result.current.data.corrected_segments)).toBe(5)
+ // gap is now pending: still listed but Insert is refused
+ const pending = result.current.missing.openGaps[0]
+ expect(pending.pendingSegmentIndex).toBe(1)
+ let again: unknown = 'unset'
+ act(() => {
+ again = result.current.missing.insertLines(pending)
+ })
+ expect(again).toBeNull()
+ expect(result.current.historyLength).toBe(2)
+
+ const adds = result.current.editLog.entries.filter((e) => e.operation === 'segment_add')
+ expect(adds).toHaveLength(2)
+ expect(adds[0].details).toMatchObject({ origin: 'missing_lyrics_gap', reference_source: 'genius', timed_from_reference: false })
+
+ act(() => result.current.undo())
+ expect(result.current.data.corrected_segments).toHaveLength(4)
+ expect(result.current.missing.openGaps[0].pendingSegmentIndex).toBeNull()
+ })
+
+ it('re-sync hint APPENDS across inserts and drops lines once synced or deleted', () => {
+ const { result } = renderHook(() => useHarness())
+ act(() => {
+ result.current.missing.insertLines(result.current.missing.openGaps[0])
+ })
+ act(() => {
+ result.current.missing.insertLines(result.current.missing.openGaps.find((g) => g.gap.start === 30)!)
+ })
+ expect(result.current.missing.resyncLines.map((l) => l.segment.text)).toEqual([
+ 'line one',
+ 'line two words',
+ 'late line',
+ ])
+
+ // Sync "line one" (timed words), delete "late line"
+ act(() => {
+ const segs = result.current.data.corrected_segments
+ .filter((s) => s.text !== 'late line')
+ .map((s) =>
+ s.text === 'line one'
+ ? {
+ ...s,
+ start_time: 6,
+ end_time: 7,
+ words: s.words.map((w, i) => ({ ...w, start_time: 6 + i * 0.5, end_time: 6.5 + i * 0.5 })),
+ }
+ : s
+ )
+ result.current.setData({ ...result.current.data, corrected_segments: segs })
+ })
+ expect(result.current.missing.resyncLines.map((l) => l.segment.text)).toEqual(['line two words'])
+ expect(result.current.missing.resyncLines[0].index).toBe(2)
+
+ act(() => result.current.missing.dismissResync())
+ expect(result.current.missing.resyncLines).toEqual([])
+ })
+
+ it('does not insert in read-only mode', () => {
+ const { result } = renderHook(() => useHarness({ isReadOnly: true }))
+ let ret: unknown = 'unset'
+ act(() => {
+ ret = result.current.missing.insertLines(result.current.missing.openGaps[0])
+ })
+ expect(ret).toBeNull()
+ expect(result.current.historyLength).toBe(1)
+ })
+
+ it('returns a stable object between renders when nothing changed (safe useCallback dep)', () => {
+ const { result, rerender } = renderHook(() => useHarness())
+ const first = result.current.missing
+ rerender()
+ expect(result.current.missing).toBe(first)
+ expect(result.current.missing.insertLines).toBe(first.insertLines)
+ })
+})
diff --git a/frontend/lib/lyrics-review/hooks/useMissingLyrics.ts b/frontend/lib/lyrics-review/hooks/useMissingLyrics.ts
new file mode 100644
index 00000000..34c16823
--- /dev/null
+++ b/frontend/lib/lyrics-review/hooks/useMissingLyrics.ts
@@ -0,0 +1,144 @@
+import { useCallback, useMemo, useState } from 'react'
+import type {
+ CorrectionData,
+ EditLog,
+ LyricsSegment,
+ MissingLyricsMarker,
+ VocalGapsResult,
+} from '../types'
+import { addEditEntry } from '../utils/editLog'
+import { applyOffsetToTime } from '../utils/timingUtils'
+import {
+ findOpenMissingLyricsGaps,
+ gapInsertIndex,
+ insertMissingLyrics,
+ type OpenMissingLyricsGap,
+} from '../utils/missingLyrics'
+
+interface UseMissingLyricsOptions {
+ /** The backend's analysis (from the loaded correction data; never mutated). */
+ vocalGaps: VocalGapsResult | null | undefined
+ /** Segments as loaded — the stale-analysis guard checks gaps against these. */
+ initialSegments: LyricsSegment[]
+ /** The reviewer's CURRENT data (history[historyIndex]). */
+ data: CorrectionData
+ /** The review's undo/redo-aware data setter. */
+ updateDataWithHistory: (newData: CorrectionData, actionDescription?: string) => void
+ editLog: EditLog
+ isReadOnly: boolean
+ /** Display timing offset (ms) — markers are positioned/labelled in display time. */
+ timingOffsetMs?: number
+}
+
+export interface ResyncLine {
+ segment: LyricsSegment
+ index: number
+}
+
+export interface UseMissingLyricsResult {
+ openGaps: OpenMissingLyricsGap[]
+ /** Marker rows for TranscriptionView, in DISPLAY time (offset applied). */
+ markers: MissingLyricsMarker[]
+ /**
+ * Insert the gap's reference lines as new segments (one undoable history step).
+ * Returns the inserted segments + their index, or null when nothing was inserted
+ * (read-only, pending untimed words already there, or no lines).
+ */
+ insertLines: (gap: OpenMissingLyricsGap) => { insertedAt: number; inserted: LyricsSegment[] } | null
+ /** Lines inserted via the callout that still need syncing (present, unsynced). */
+ resyncLines: ResyncLine[]
+ dismissResync: () => void
+}
+
+/** Timing fingerprint, to tell whether an inserted line was re-synced since insertion. */
+const timingSignature = (segment: LyricsSegment) =>
+ segment.words.map((w) => `${w.start_time}-${w.end_time}`).join('|')
+
+export function useMissingLyrics({
+ vocalGaps,
+ initialSegments,
+ data,
+ updateDataWithHistory,
+ editLog,
+ isReadOnly,
+ timingOffsetMs = 0,
+}: UseMissingLyricsOptions): UseMissingLyricsResult {
+ const segments = data.corrected_segments
+ const openGaps = useMemo(
+ () => findOpenMissingLyricsGaps(vocalGaps, segments, initialSegments),
+ [vocalGaps, segments, initialSegments]
+ )
+
+ const markers = useMemo(
+ () =>
+ openGaps.map(({ id, gap }) => ({
+ id,
+ beforeSegmentIndex: gapInsertIndex(gap, segments),
+ start: applyOffsetToTime(gap.start, timingOffsetMs) as number,
+ end: applyOffsetToTime(gap.end, timingOffsetMs) as number,
+ })),
+ [openGaps, segments, timingOffsetMs]
+ )
+
+ // Inserted segment id -> timing signature at insertion. Appended across inserts.
+ const [inserted, setInserted] = useState>({})
+
+ const insertLines = useCallback(
+ (open: OpenMissingLyricsGap) => {
+ if (isReadOnly || open.lines.length === 0 || open.pendingSegmentIndex !== null) return null
+ const result = insertMissingLyrics(data, open)
+ if (result.inserted.length === 0) return null
+ if (result.split) {
+ addEditEntry(editLog, 'segment_split', {
+ segment_id: data.corrected_segments[result.split.index]?.id ?? null,
+ segment_index: result.split.index,
+ details: { origin: 'missing_lyrics_gap', new_segment_id: result.split.newSegmentId },
+ })
+ }
+ result.inserted.forEach((segment, i) => {
+ addEditEntry(editLog, 'segment_add', {
+ segment_id: segment.id,
+ segment_index: result.insertedAt + i,
+ word_ids_after: segment.words.map((w) => w.id),
+ text_after: segment.text,
+ details: {
+ origin: 'missing_lyrics_gap',
+ gap_start: open.gap.start,
+ gap_end: open.gap.end,
+ reference_source: open.source,
+ synced_reference: open.synced,
+ timed_from_reference: segment.words.every((w) => w.start_time !== null),
+ },
+ })
+ })
+ updateDataWithHistory(result.data, 'insert missing lyrics')
+ setInserted((prev) => {
+ const next = { ...prev }
+ for (const s of result.inserted) next[s.id] = timingSignature(s)
+ return next
+ })
+ return { insertedAt: result.insertedAt, inserted: result.inserted }
+ },
+ [data, editLog, isReadOnly, updateDataWithHistory]
+ )
+
+ // Derived: only lines that still exist and haven't been re-synced since insertion
+ // (untimed words, or timings unchanged from the reference) stay in the hint.
+ const resyncLines = useMemo(() => {
+ const out: ResyncLine[] = []
+ segments.forEach((segment, index) => {
+ const sig = inserted[segment.id]
+ if (sig === undefined) return
+ const untimed = segment.words.some((w) => w.start_time === null || w.end_time === null)
+ if (untimed || timingSignature(segment) === sig) out.push({ segment, index })
+ })
+ return out
+ }, [segments, inserted])
+
+ const dismissResync = useCallback(() => setInserted({}), [])
+
+ return useMemo(
+ () => ({ openGaps, markers, insertLines, resyncLines, dismissResync }),
+ [openGaps, markers, insertLines, resyncLines, dismissResync]
+ )
+}
diff --git a/frontend/lib/lyrics-review/types.ts b/frontend/lib/lyrics-review/types.ts
index 6f60ad6c..d3f071c9 100644
--- a/frontend/lib/lyrics-review/types.ts
+++ b/frontend/lib/lyrics-review/types.ts
@@ -184,6 +184,11 @@ export interface CorrectionData {
// Instrumental selection data (added for combined review flow)
instrumental_options?: InstrumentalOption[]
backing_vocals_analysis?: BackingVocalsAnalysis | null
+ // Sung stretches with no transcribed words (possible missing lyrics), from the
+ // backend's vocal-gaps analysis (backend/services/auto_approval/vocal_gaps.py).
+ // Absent/null when the job wasn't analyzed. Read-only: the review UI derives
+ // which gaps are still open from the current segments, never mutates this.
+ vocal_gaps?: VocalGapsResult | null
// Replay mode (read-only re-open of a completed job via ?replay=true). Present
// only in replay; carries the reviewer's ordered edit log for narration.
replay?: {
@@ -198,6 +203,33 @@ export interface CorrectionData {
}
}
+/** One transcription gap where the lead vocal is singing (see vocal_gaps.py). */
+export interface VocalGap {
+ start: number
+ end: number
+ duration: number
+ active_fraction: number
+ longest_run_s: number
+ /** source -> reference lines between the anchors either side of the gap */
+ reference_lines?: Record
+ /** source -> synced reference lines (e.g. LRCLIB) timestamped inside the gap */
+ synced_reference_lines?: Record
+ /** sung run long enough to be dropped lyrics (audio only — noisy) */
+ suspect: boolean
+ /** suspect AND reference lyrics place lines in this gap (reliable) */
+ evidenced: boolean
+}
+
+export interface VocalGapsResult {
+ version?: string
+ gaps?: VocalGap[]
+ suspect_count?: number
+ evidenced_count?: number
+ max_suspect_run_s?: number
+ input_key?: string
+ error?: string | null
+}
+
/** Instrumental option from the combined review endpoint */
export interface InstrumentalOption {
id: string // "clean" | "with_backing"
@@ -484,6 +516,16 @@ export interface TranscriptionViewProps {
isDuet?: boolean
onSegmentSingerChange?: (segmentIdx: number, next: SingerId) => void
onSegmentFocus?: (segmentIndex: number | null) => void
+ /** Possible-missing-lyrics markers, drawn as a row before `beforeSegmentIndex`. */
+ missingLyricsMarkers?: MissingLyricsMarker[]
+}
+
+export interface MissingLyricsMarker {
+ id: string
+ /** Index in corrected_segments the marker sits before (== length → after the last). */
+ beforeSegmentIndex: number
+ start: number
+ end: number
}
export interface ReferenceViewProps extends BaseViewProps {
diff --git a/frontend/lib/lyrics-review/utils/__tests__/missingLyrics.test.ts b/frontend/lib/lyrics-review/utils/__tests__/missingLyrics.test.ts
new file mode 100644
index 00000000..25d2df00
--- /dev/null
+++ b/frontend/lib/lyrics-review/utils/__tests__/missingLyrics.test.ts
@@ -0,0 +1,332 @@
+import {
+ buildMissingLyricsSegments,
+ findOpenMissingLyricsGaps,
+ formatGapTime,
+ gapHasWords,
+ gapInsertIndex,
+ insertMissingLyrics,
+ isGapConsistentWithSegments,
+ pendingUntimedSegmentIndex,
+ pickReferenceLines,
+ planGapInsertion,
+} from '../missingLyrics'
+import { countUntimedWords } from '../timingCompleteness'
+import type { CorrectionData, LyricsSegment, VocalGap, VocalGapsResult, Word } from '../../types'
+
+const seg = (id: string, start: number, end: number, texts: string[] = ['a'], singer?: 0 | 1 | 2): LyricsSegment => {
+ const step = (end - start) / texts.length
+ const words = texts.map((text, i) => ({
+ id: `${id}-w${i}`,
+ text,
+ start_time: start + i * step,
+ end_time: start + (i + 1) * step,
+ }))
+ return { id, text: texts.join(' '), words, start_time: start, end_time: end, ...(singer !== undefined ? { singer } : {}) }
+}
+
+const untimedSeg = (id: string, texts: string[]): LyricsSegment => ({
+ id,
+ text: texts.join(' '),
+ start_time: null,
+ end_time: null,
+ words: texts.map((text, i) => ({ id: `${id}-w${i}`, text, start_time: null, end_time: null })),
+})
+
+const gap = (overrides: Partial = {}): VocalGap => ({
+ start: 20.66,
+ end: 32.4,
+ duration: 11.74,
+ active_fraction: 0.9,
+ longest_run_s: 11.76,
+ reference_lines: { genius: ['plain one', 'plain two'] },
+ synced_reference_lines: { lrclib: ['synced one two', 'synced three'] },
+ suspect: true,
+ evidenced: true,
+ ...overrides,
+})
+
+const result = (gaps: VocalGap[]): VocalGapsResult => ({ version: '0.2.0', gaps })
+
+const segments = [seg('s1', 15, 20.66, ['before', 'gap']), seg('s2', 32.4, 36, ['after', 'gap'])]
+
+const dataWith = (segs: LyricsSegment[], reference_lyrics: Record = {}) =>
+ ({ corrected_segments: segs, reference_lyrics }) as unknown as CorrectionData
+
+describe('findOpenMissingLyricsGaps', () => {
+ it('returns an evidenced gap with no words in its range', () => {
+ const open = findOpenMissingLyricsGaps(result([gap()]), segments)
+ expect(open).toHaveLength(1)
+ expect(open[0].id).toBe('missing-lyrics-20.66-32.40')
+ expect(open[0].pendingSegmentIndex).toBeNull()
+ })
+
+ it('hides the gap once a timed word starts inside it', () => {
+ const filled = [...segments, seg('new', 25, 26, ['added'])]
+ expect(findOpenMissingLyricsGaps(result([gap()]), filled, segments)).toEqual([])
+ })
+
+ it('treats words within the 2dp rounding tolerance of the edges as neighbours', () => {
+ // Backend rounds: the next word really starts at 19.996 but gap.end is 20.0
+ const g = gap({ start: 10, end: 20 })
+ const segs = [seg('a', 8, 10.03, ['x']), seg('b', 19.996, 21, ['y'])]
+ expect(gapHasWords(g, segs)).toBe(false)
+ expect(findOpenMissingLyricsGaps(result([g]), segs)).toHaveLength(1)
+ // ...but a word clearly inside still closes it
+ expect(gapHasWords(g, [...segs, seg('c', 19.9, 19.95, ['z'])])).toBe(true)
+ })
+
+ it('does not show non-evidenced (audio-only) suspect gaps', () => {
+ expect(findOpenMissingLyricsGaps(result([gap({ evidenced: false })]), segments)).toEqual([])
+ })
+
+ it('returns nothing for null / empty / missing gaps', () => {
+ expect(findOpenMissingLyricsGaps(null, segments)).toEqual([])
+ expect(findOpenMissingLyricsGaps(undefined, segments)).toEqual([])
+ expect(findOpenMissingLyricsGaps({ version: '0.2.0' }, segments)).toEqual([])
+ expect(findOpenMissingLyricsGaps(result([]), segments)).toEqual([])
+ })
+
+ it('sorts open gaps chronologically', () => {
+ const segs = [...segments, seg('s3', 60, 62, ['end'])]
+ const open = findOpenMissingLyricsGaps(result([gap({ start: 36, end: 60 }), gap()]), segs)
+ expect(open.map((o) => o.gap.start)).toEqual([20.66, 36])
+ })
+
+ it('marks a gap pending (not open-for-insert) when untimed words sit at its position', () => {
+ const segs = [segments[0], untimedSeg('u', ['typed', 'lyrics']), segments[1]]
+ const open = findOpenMissingLyricsGaps(result([gap()]), segs, segments)
+ expect(open).toHaveLength(1)
+ expect(open[0].pendingSegmentIndex).toBe(1)
+ })
+
+ it('does not count untimed words elsewhere in the song as pending', () => {
+ const segs = [untimedSeg('u', ['early']), ...segments, seg('s3', 40, 41), untimedSeg('v', ['late'])]
+ expect(pendingUntimedSegmentIndex(gap(), segs)).toBeNull()
+ })
+})
+
+describe('stale-analysis guard (isGapConsistentWithSegments)', () => {
+ it('accepts a gap bracketed by words at load', () => {
+ expect(isGapConsistentWithSegments(gap(), segments)).toBe(true)
+ })
+
+ it('rejects a gap whose neighbouring words are far away (analysis from another transcription)', () => {
+ const shifted = [seg('s1', 10, 15, ['a']), seg('s2', 35, 36, ['b'])]
+ expect(isGapConsistentWithSegments(gap(), shifted)).toBe(false)
+ expect(findOpenMissingLyricsGaps(result([gap()]), shifted)).toEqual([])
+ })
+
+ it('rejects a gap that had words inside it at load', () => {
+ expect(isGapConsistentWithSegments(gap(), [...segments, seg('m', 25, 26)])).toBe(false)
+ })
+
+ it('accepts a gap touching the song start or with no words after it', () => {
+ expect(isGapConsistentWithSegments(gap({ start: 0, end: 15 }), segments)).toBe(true)
+ expect(isGapConsistentWithSegments(gap({ start: 36, end: 50 }), segments)).toBe(true)
+ expect(isGapConsistentWithSegments(gap({ start: 5, end: 15 }), segments)).toBe(false)
+ })
+
+ it('uses the INITIAL segments, so a gap stays trusted after the reviewer edits', () => {
+ // current segments had the neighbour deleted; initial still brackets it
+ const current = [segments[1]]
+ expect(findOpenMissingLyricsGaps(result([gap()]), current, segments)).toHaveLength(1)
+ })
+})
+
+describe('pickReferenceLines', () => {
+ it('prefers synced reference lines', () => {
+ expect(pickReferenceLines(gap())).toEqual({ source: 'lrclib', lines: ['synced one two', 'synced three'], synced: true })
+ })
+
+ it('falls back to reference_lines when synced is empty or missing', () => {
+ expect(pickReferenceLines(gap({ synced_reference_lines: { lrclib: [] } }))).toEqual({
+ source: 'genius',
+ lines: ['plain one', 'plain two'],
+ synced: false,
+ })
+ expect(pickReferenceLines(gap({ synced_reference_lines: undefined })).source).toBe('genius')
+ })
+
+ it('drops blank lines and returns empty when nothing is left', () => {
+ expect(pickReferenceLines(gap({ synced_reference_lines: {}, reference_lines: { g: [' ', ''] } }))).toEqual({
+ source: null,
+ lines: [],
+ synced: false,
+ })
+ })
+})
+
+describe('buildMissingLyricsSegments', () => {
+ const refSeg = (id: string, text: string, start: number, timed = true): LyricsSegment => {
+ const ws = text.split(' ')
+ const words: Word[] = ws.map((t, i) => ({
+ id: `${id}-${i}`,
+ text: t,
+ start_time: timed || i === 0 ? start + i * 0.5 : null,
+ end_time: timed || i === 0 ? start + i * 0.5 + 0.4 : null,
+ }))
+ return { id, text, words, start_time: start, end_time: start + ws.length * 0.5 }
+ }
+
+ it('inserts words UNTIMED (no fabricated timing) when there is no synced reference', () => {
+ const out = buildMissingLyricsSegments(gap(), ['one two', 'three'])
+ expect(out.map((s) => s.words.map((w) => w.text))).toEqual([['one', 'two'], ['three']])
+ out.flatMap((s) => s.words).forEach((w) => {
+ expect(w.start_time).toBeNull()
+ expect(w.end_time).toBeNull()
+ })
+ // segment bounds = the gap, so Play / the Edit modal open on the right stretch
+ expect(out[0].start_time).toBe(20.66)
+ expect(out[0].end_time).toBe(32.4)
+ })
+
+ it('the existing submit guard catches untimed inserted words', () => {
+ const out = buildMissingLyricsSegments(gap(), ['one two', 'three'])
+ expect(countUntimedWords([...segments, ...out])).toBe(3)
+ })
+
+ it('uses the synced reference word timings when the line matches inside the gap', () => {
+ const refs = [refSeg('r0', 'Synced one two', 5), refSeg('r1', 'synced one two', 22), refSeg('r2', 'synced three', 26)]
+ const out = buildMissingLyricsSegments(gap(), ['synced one two', 'synced three'], undefined, refs)
+ expect(out[0].words.map((w) => [w.text, w.start_time, w.end_time])).toEqual([
+ ['synced', 22, 22.4],
+ ['one', 22.5, 22.9],
+ ['two', 23, 23.4],
+ ])
+ expect(out[0].start_time).toBe(22)
+ expect(out[0].end_time).toBe(23.4)
+ expect(out[1].words[0].start_time).toBe(26)
+ expect(countUntimedWords(out)).toBe(0)
+ // fresh ids, not the reference word ids
+ expect(out[0].words[0].id).not.toBe('r1-0')
+ })
+
+ it('falls back to untimed for a line whose reference words are not all timed', () => {
+ const refs = [refSeg('r1', 'synced one two', 22, false)]
+ const out = buildMissingLyricsSegments(gap(), ['synced one two'], undefined, refs)
+ expect(out[0].words.every((w) => w.start_time === null)).toBe(true)
+ })
+
+ it('uses each reference line once for a repeated line', () => {
+ const refs = [refSeg('r1', 'la la', 22), refSeg('r2', 'la la', 25)]
+ const out = buildMissingLyricsSegments(gap(), ['la la', 'la la'], undefined, refs)
+ expect(out.map((s) => s.start_time)).toEqual([22, 25])
+ })
+
+ it('gives every word and segment a unique id and carries the singer', () => {
+ const out = buildMissingLyricsSegments(gap(), ['a b', 'c'], 2)
+ const ids = [...out.map((s) => s.id), ...out.flatMap((s) => s.words.map((w) => w.id))]
+ expect(new Set(ids).size).toBe(ids.length)
+ out.forEach((s) => expect(s.singer).toBe(2))
+ })
+
+ it('returns no segments for blank lines', () => {
+ expect(buildMissingLyricsSegments(gap(), [' '])).toEqual([])
+ })
+})
+
+describe('insertion position', () => {
+ it('inserts between the segments either side of the gap', () => {
+ const data = dataWith(segments)
+ expect(gapInsertIndex(gap(), segments)).toBe(1)
+ const out = insertMissingLyrics(data, { gap: gap(), lines: ['x y', 'z'], source: 'genius', synced: false })
+ expect(out.insertedAt).toBe(1)
+ expect(out.split).toBeNull()
+ expect(out.data.corrected_segments.map((s) => s.text)).toEqual(['before gap', 'x y', 'z', 'after gap'])
+ expect(data.corrected_segments).toHaveLength(2) // pure
+ })
+
+ it('handles a gap before the first segment and after the last one', () => {
+ expect(gapInsertIndex(gap({ start: 0, end: 15 }), segments)).toBe(0)
+ expect(gapInsertIndex(gap({ start: 36, end: 50 }), segments)).toBe(2)
+ })
+
+ it('splits a segment the gap sits inside (gap between two of its words)', () => {
+ // segment A: words 5–9s plus a trailing word at 22s → gap [9, 22)
+ const a: LyricsSegment = {
+ id: 'A',
+ text: 'one two three',
+ start_time: 5,
+ end_time: 23,
+ singer: 1,
+ words: [
+ { id: 'w1', text: 'one', start_time: 5, end_time: 7 },
+ { id: 'w2', text: 'two', start_time: 7, end_time: 9 },
+ { id: 'w3', text: 'three', start_time: 22, end_time: 23 },
+ ],
+ }
+ const segs = [seg('pre', 0, 4), a, seg('post', 25, 26)]
+ const g = gap({ start: 9, end: 22 })
+ expect(gapInsertIndex(g, segs)).toBe(2)
+
+ const plan = planGapInsertion(g, segs)
+ expect(plan.split).toEqual({ index: 1, newSegmentId: expect.any(String) })
+
+ const out = insertMissingLyrics(dataWith(segs), { gap: g, lines: ['dropped line'], source: 'genius', synced: false })
+ const texts = out.data.corrected_segments.map((s) => s.text)
+ expect(texts).toEqual(['a', 'one two', 'dropped line', 'three', 'a'])
+ const [, first, , second] = out.data.corrected_segments
+ expect(first.id).toBe('A')
+ expect([first.start_time, first.end_time]).toEqual([5, 9])
+ expect(second.id).toBe(out.split!.newSegmentId)
+ expect(second.id).not.toBe('A')
+ expect([second.start_time, second.end_time]).toEqual([22, 23])
+ expect(second.words.map((w) => w.id)).toEqual(['w3']) // word ids preserved
+ expect(second.singer).toBe(1)
+ expect(out.data.corrected_segments[2].singer).toBe(1)
+ })
+
+ it('duet: inherits the FOLLOWING segment singer, then the preceding (like addSegmentBefore)', () => {
+ const segs = [seg('s1', 15, 20.66, ['a'], 1), seg('s2', 32.4, 36, ['b'], 2)]
+ const out = insertMissingLyrics(dataWith(segs), { gap: gap(), lines: ['x'], source: 'g', synced: false })
+ expect(out.inserted[0].singer).toBe(2)
+ // gap after the last segment → falls back to the preceding singer
+ const tail = insertMissingLyrics(dataWith(segs), { gap: gap({ start: 36, end: 50 }), lines: ['x'], source: 'g', synced: false })
+ expect(tail.inserted[0].singer).toBe(2)
+ const segs2 = [seg('s1', 15, 20.66, ['a'], 1)]
+ const tail2 = insertMissingLyrics(dataWith(segs2), { gap: gap({ start: 20.66, end: 30 }), lines: ['x'], source: 'g', synced: false })
+ expect(tail2.inserted[0].singer).toBe(1)
+ })
+
+ it('looks up synced timings from data.reference_lyrics[source]', () => {
+ const ref = {
+ lrclib: {
+ segments: [
+ {
+ id: 'r',
+ text: 'synced three',
+ start_time: 26,
+ end_time: 27,
+ words: [
+ { id: 'r0', text: 'synced', start_time: 26, end_time: 26.5 },
+ { id: 'r1', text: 'three', start_time: 26.5, end_time: 27 },
+ ],
+ },
+ ],
+ },
+ }
+ const out = insertMissingLyrics(dataWith(segments, ref), {
+ gap: gap(),
+ lines: ['synced one two', 'synced three'],
+ source: 'lrclib',
+ synced: true,
+ })
+ expect(out.inserted[0].words.every((w) => w.start_time === null)).toBe(true) // no ref match
+ expect(out.inserted[1].words.map((w) => w.start_time)).toEqual([26, 26.5])
+ })
+
+ it('after inserting untimed lines the gap becomes pending (no second Insert)', () => {
+ const out = insertMissingLyrics(dataWith(segments), { gap: gap(), lines: ['x y'], source: 'g', synced: false })
+ const open = findOpenMissingLyricsGaps(result([gap()]), out.data.corrected_segments, segments)
+ expect(open).toHaveLength(1)
+ expect(open[0].pendingSegmentIndex).toBe(1)
+ })
+})
+
+describe('formatGapTime', () => {
+ it('formats as m:ss, flooring seconds', () => {
+ expect(formatGapTime(20.66)).toBe('0:20')
+ expect(formatGapTime(32.4)).toBe('0:32')
+ expect(formatGapTime(125.9)).toBe('2:05')
+ })
+})
diff --git a/frontend/lib/lyrics-review/utils/missingLyrics.ts b/frontend/lib/lyrics-review/utils/missingLyrics.ts
new file mode 100644
index 00000000..052c8a23
--- /dev/null
+++ b/frontend/lib/lyrics-review/utils/missingLyrics.ts
@@ -0,0 +1,316 @@
+import { nanoid } from 'nanoid'
+import type { CorrectionData, LyricsSegment, VocalGap, VocalGapsResult, Word } from '../types'
+
+/**
+ * Possible missing lyrics: "evidenced" vocal gaps (the lead vocal is singing, the
+ * transcription has no words there, AND reference lyrics place lines there).
+ *
+ * Everything here is derived from the reviewer's edit state — the backend's
+ * `vocal_gaps` payload is never mutated, so a marker goes away as soon as timed words
+ * land in the gap and comes back on undo.
+ *
+ * Rules (all times in the raw segment timeline, i.e. before any display timing offset):
+ *
+ * - **Edge tolerance.** The backend rounds gap bounds to 2dp and a gap's end IS the next
+ * word's start, so words starting within `GAP_EDGE_TOLERANCE_S` of either edge are the
+ * neighbours, not lyrics inside the gap.
+ * - **Stale analysis guard.** The analysis may have run on an older transcription (e.g. the
+ * job was re-transcribed). A gap is only trusted if, in the segments AS LOADED, it holds
+ * no words and is bracketed by words within `GAP_BRACKET_TOLERANCE_S` on each side (or it
+ * touches the song start / has no words after it).
+ * - **Open vs pending.** Open = no timed words inside. Pending = no timed words inside but
+ * UNTIMED words sit between the gap's neighbouring timed words in document order (the
+ * reviewer added lyrics there, or inserted them via the callout, but hasn't synced them
+ * yet) → no Insert (would duplicate), just a "sync timing" prompt.
+ */
+
+/** Words starting this close to a gap edge are its neighbours (backend rounds to 2dp). */
+export const GAP_EDGE_TOLERANCE_S = 0.05
+/** Stale-analysis guard: neighbouring words must sit this close to the gap edges at load. */
+export const GAP_BRACKET_TOLERANCE_S = 1.0
+
+export interface OpenMissingLyricsGap {
+ /** Stable id for React keys / test ids (derived from the gap's times). */
+ id: string
+ gap: VocalGap
+ /** Reference source the lines came from. */
+ source: string | null
+ /** The reference lines expected in the gap (may be empty if none survived trimming). */
+ lines: string[]
+ /** True when `lines` came from `synced_reference_lines` (timestamped inside the gap). */
+ synced: boolean
+ /**
+ * Set when untimed words already sit at the gap's position: index of the segment holding
+ * the first of them (to open for Tap To Sync). Insert is not offered in this state.
+ */
+ pendingSegmentIndex: number | null
+}
+
+export const missingLyricsGapId = (gap: VocalGap): string =>
+ `missing-lyrics-${gap.start.toFixed(2)}-${gap.end.toFixed(2)}`
+
+const firstNonEmpty = (
+ bySource: Record | undefined
+): { source: string; lines: string[] } | null => {
+ for (const [source, raw] of Object.entries(bySource ?? {})) {
+ const lines = (raw ?? []).map((l) => (l ?? '').trim()).filter(Boolean)
+ if (lines.length > 0) return { source, lines }
+ }
+ return null
+}
+
+/** Prefer synced reference lines (timestamped inside the gap), else the anchor-bounded ones. */
+export const pickReferenceLines = (
+ gap: VocalGap
+): { source: string | null; lines: string[]; synced: boolean } => {
+ const synced = firstNonEmpty(gap.synced_reference_lines)
+ if (synced) return { ...synced, synced: true }
+ const plain = firstNonEmpty(gap.reference_lines)
+ if (plain) return { ...plain, synced: false }
+ return { source: null, lines: [], synced: false }
+}
+
+const isTimed = (w: Word): w is Word & { start_time: number; end_time: number } =>
+ w.start_time !== null && w.end_time !== null
+
+/** Starts inside the gap, ignoring words within the edge tolerance (the neighbours). */
+const startsInsideGap = (start: number, gap: VocalGap): boolean =>
+ start >= gap.start + GAP_EDGE_TOLERANCE_S && start < gap.end - GAP_EDGE_TOLERANCE_S
+
+/** True when any word with a start time begins inside the gap (edge tolerance applied). */
+export const gapHasWords = (gap: VocalGap, segments: LyricsSegment[]): boolean =>
+ segments.some((seg) =>
+ seg.words.some((w) => w.start_time !== null && startsInsideGap(w.start_time, gap))
+ )
+
+/**
+ * Stale-analysis guard (see module doc): in the segments as loaded, the gap must be empty
+ * and bracketed by words near both edges (or touch the song start / have nothing after it).
+ */
+export const isGapConsistentWithSegments = (gap: VocalGap, segments: LyricsSegment[]): boolean => {
+ if (gapHasWords(gap, segments)) return false
+ const timed = segments.flatMap((s) => s.words).filter(isTimed)
+ const before = timed.filter((w) => w.start_time < gap.start + GAP_EDGE_TOLERANCE_S)
+ const after = timed.filter((w) => w.start_time >= gap.end - GAP_EDGE_TOLERANCE_S)
+ const prevOk =
+ before.length === 0
+ ? gap.start <= GAP_BRACKET_TOLERANCE_S
+ : Math.abs(Math.max(...before.map((w) => w.end_time)) - gap.start) <= GAP_BRACKET_TOLERANCE_S
+ const nextOk =
+ after.length === 0 ||
+ Math.abs(Math.min(...after.map((w) => w.start_time)) - gap.end) <= GAP_BRACKET_TOLERANCE_S
+ return prevOk && nextOk
+}
+
+/**
+ * Untimed words positioned (in document order) between the gap's neighbouring timed
+ * words. Returns the segment index of the first one, or null.
+ */
+export const pendingUntimedSegmentIndex = (
+ gap: VocalGap,
+ segments: LyricsSegment[]
+): number | null => {
+ const flat = segments.flatMap((s, segIdx) => s.words.map((w) => ({ w, segIdx })))
+ let prevPos = -1
+ let nextPos = flat.length
+ flat.forEach(({ w }, pos) => {
+ if (w.start_time === null) return
+ if (w.start_time < gap.start + GAP_EDGE_TOLERANCE_S) prevPos = Math.max(prevPos, pos)
+ else if (w.start_time >= gap.end - GAP_EDGE_TOLERANCE_S) nextPos = Math.min(nextPos, pos)
+ })
+ for (let pos = prevPos + 1; pos < nextPos; pos++) {
+ if (flat[pos].w.start_time === null) return flat[pos].segIdx
+ }
+ return null
+}
+
+/**
+ * Evidenced gaps that still have no timed words in the current segments, in time order.
+ * `initialSegments` (the segments as loaded) drives the stale-analysis guard.
+ */
+export const findOpenMissingLyricsGaps = (
+ vocalGaps: VocalGapsResult | null | undefined,
+ segments: LyricsSegment[],
+ initialSegments: LyricsSegment[] = segments
+): OpenMissingLyricsGap[] => {
+ const gaps = vocalGaps?.gaps ?? []
+ return gaps
+ .filter(
+ (gap) =>
+ gap.evidenced &&
+ gap.end > gap.start &&
+ isGapConsistentWithSegments(gap, initialSegments) &&
+ !gapHasWords(gap, segments)
+ )
+ .sort((a, b) => a.start - b.start)
+ .map((gap) => ({
+ id: missingLyricsGapId(gap),
+ gap,
+ ...pickReferenceLines(gap),
+ pendingSegmentIndex: pendingUntimedSegmentIndex(gap, segments),
+ }))
+}
+
+const gapMid = (gap: VocalGap) => (gap.start + gap.end) / 2
+
+const segmentFromWords = (base: LyricsSegment, words: Word[], id = base.id): LyricsSegment => {
+ const timed = words.filter(isTimed)
+ return {
+ ...base,
+ id,
+ words,
+ text: words.map((w) => w.text).join(' '),
+ start_time: timed.length ? Math.min(...timed.map((w) => w.start_time)) : null,
+ end_time: timed.length ? Math.max(...timed.map((w) => w.end_time)) : null,
+ }
+}
+
+/**
+ * Where lines for this gap belong, based on WORD times (gaps sit between consecutive
+ * words, so one can fall inside a segment). If a segment has timed words both before and
+ * after the gap it is split there: words before keep the segment, words after move to a
+ * new segment with a fresh id (like splitSegment). Pure.
+ */
+export const planGapInsertion = (
+ gap: VocalGap,
+ segments: LyricsSegment[]
+): { segments: LyricsSegment[]; insertAt: number; split: { index: number; newSegmentId: string } | null } => {
+ const mid = gapMid(gap)
+ for (let i = 0; i < segments.length; i++) {
+ const words = segments[i].words
+ const k = words.findIndex((w) => w.start_time !== null && w.start_time >= mid)
+ const hasBefore = words.some((w, j) => j < k && w.start_time !== null)
+ if (k > 0 && hasBefore) {
+ const newSegmentId = nanoid()
+ const a = segmentFromWords(segments[i], words.slice(0, k))
+ const b = segmentFromWords(segments[i], words.slice(k), newSegmentId)
+ return {
+ segments: [...segments.slice(0, i), a, b, ...segments.slice(i + 1)],
+ insertAt: i + 1,
+ split: { index: i, newSegmentId },
+ }
+ }
+ }
+ const idx = segments.findIndex((s) => s.words.some((w) => w.start_time !== null && w.start_time >= mid))
+ return { segments, insertAt: idx === -1 ? segments.length : idx, split: null }
+}
+
+/** Index the gap's lines go at (without splitting) — for marker placement. */
+export const gapInsertIndex = (gap: VocalGap, segments: LyricsSegment[]): number => {
+ const plan = planGapInsertion(gap, segments)
+ // A split puts the marker between the two halves: before the (still unsplit) segment's
+ // later words — i.e. after the segment being split.
+ return plan.split ? plan.split.index + 1 : plan.insertAt
+}
+
+const normalize = (s: string) => s.toLowerCase().replace(/\s+/g, ' ').trim()
+
+/**
+ * Build one segment per line.
+ *
+ * Timing: when `referenceSegments` (the SYNCED reference source, e.g. LRCLIB) has a segment
+ * with the same text starting inside the gap and every word timed, its word timings are
+ * used. Otherwise the line's words are inserted UNTIMED (start/end null), so the review's
+ * "N lyric word(s) have no timing yet" submit guard forces a Tap To Sync. Untimed lines get
+ * the gap as their segment bounds so Play / the Edit modal open on the right stretch.
+ * No timings are fabricated.
+ */
+export const buildMissingLyricsSegments = (
+ gap: VocalGap,
+ lines: string[],
+ singer?: LyricsSegment['singer'],
+ referenceSegments: LyricsSegment[] | null = null
+): LyricsSegment[] => {
+ const used = new Set()
+ const withSinger = singer !== undefined ? { singer } : {}
+ const out: LyricsSegment[] = []
+ for (const line of lines) {
+ const texts = line.split(/\s+/).filter(Boolean)
+ if (texts.length === 0) continue
+ const ref = (referenceSegments ?? []).find((r) => {
+ if (used.has(r.id) || normalize(r.text) !== normalize(line)) return false
+ const first = r.words.find((w) => w.start_time !== null)
+ return (
+ first !== undefined &&
+ first.start_time! >= gap.start &&
+ first.start_time! <= gap.end &&
+ r.words.length > 0 &&
+ r.words.every(isTimed)
+ )
+ })
+ if (ref) {
+ used.add(ref.id)
+ const words: Word[] = ref.words.map((w) => ({
+ id: nanoid(),
+ text: w.text,
+ start_time: w.start_time,
+ end_time: w.end_time,
+ confidence: 1.0,
+ }))
+ out.push({
+ id: nanoid(),
+ text: words.map((w) => w.text).join(' '),
+ words,
+ start_time: words[0].start_time,
+ end_time: words[words.length - 1].end_time,
+ ...withSinger,
+ })
+ } else {
+ const words: Word[] = texts.map((text) => ({
+ id: nanoid(),
+ text,
+ start_time: null,
+ end_time: null,
+ confidence: 1.0,
+ }))
+ out.push({
+ id: nanoid(),
+ text: texts.join(' '),
+ words,
+ start_time: gap.start,
+ end_time: gap.end,
+ ...withSinger,
+ })
+ }
+ }
+ return out
+}
+
+/**
+ * Insert the gap's reference lines into `data.corrected_segments` at the right
+ * chronological position (splitting a segment that spans the gap). Pure.
+ */
+export const insertMissingLyrics = (
+ data: CorrectionData,
+ open: Pick
+): {
+ data: CorrectionData
+ insertedAt: number
+ inserted: LyricsSegment[]
+ split: { index: number; newSegmentId: string } | null
+} => {
+ const plan = planGapInsertion(open.gap, data.corrected_segments)
+ // Same convention as addSegmentBefore: prefer the following segment's singer, then the
+ // preceding one's.
+ const following = plan.segments[plan.insertAt]
+ const preceding = plan.segments[plan.insertAt - 1]
+ const singer = following?.singer ?? preceding?.singer
+ const referenceSegments =
+ open.synced && open.source ? data.reference_lyrics?.[open.source]?.segments ?? null : null
+ const inserted = buildMissingLyricsSegments(open.gap, open.lines, singer, referenceSegments)
+ if (inserted.length === 0) {
+ return { data, insertedAt: plan.insertAt, inserted, split: null }
+ }
+ const corrected_segments = [
+ ...plan.segments.slice(0, plan.insertAt),
+ ...inserted,
+ ...plan.segments.slice(plan.insertAt),
+ ]
+ return { data: { ...data, corrected_segments }, insertedAt: plan.insertAt, inserted, split: plan.split }
+}
+
+/** m:ss (floored) for the callout's time range. */
+export const formatGapTime = (seconds: number): string => {
+ const s = Math.max(0, Math.floor(seconds))
+ return `${Math.floor(s / 60)}:${String(s % 60).padStart(2, '0')}`
+}
diff --git a/frontend/messages/ar.json b/frontend/messages/ar.json
index 44774c1e..c061a81a 100644
--- a/frontend/messages/ar.json
+++ b/frontend/messages/ar.json
@@ -985,7 +985,8 @@
"playFromGap": "التشغيل من نهاية هذه الفجوة",
"editSegment": "تعديل المقطع {index}",
"untimedSegment": "لا توجد توقيتات للكلمات — انقر للتعديل",
- "waveforms": "الأشكال الموجية"
+ "waveforms": "الأشكال الموجية",
+ "missingLyricsMarker": "كلمات مفقودة محتملة {start}–{end}"
},
"editActionBar": {
"reset": "إعادة تعيين",
@@ -1431,7 +1432,8 @@
"wordOverrideNote": "تجاوزات المغني على مستوى الكلمة تنطبق على فيديو الكاريوكي فقط — يستخدم إخراج CDG المغني الرئيسي للمقطع."
},
"toasts": {
- "customLyricsSaved": "تم تطبيق الكلمات المخصصة. يرجى مزامنة كل مقطع معدل يدوياً لضمان توافق توقيت الكلمات بشكل مثالي."
+ "customLyricsSaved": "تم تطبيق الكلمات المخصصة. يرجى مزامنة كل مقطع معدل يدوياً لضمان توافق توقيت الكلمات بشكل مثالي.",
+ "untimedWordsBlockSubmit": "{count, plural, one {# كلمة من كلمات الأغنية ليس لها} other {# كلمات من كلمات الأغنية ليس لها}} توقيت بعد. افتح أداة المزامنة واضغط على كل سطر مع الإيقاع قبل إنشاء الفيديو."
},
"autoCorrect": {
"accept": "قبول الاقتراح",
@@ -1493,6 +1495,20 @@
"cancelSync": "إلغاء",
"hold": "اضغط مطولاً...",
"tap": "انقر"
+ },
+ "missingLyrics": {
+ "description": "الصوت الرئيسي يغني هنا، ولكن لا توجد كلمات.",
+ "expectedFrom": "كلمات متوقعة هنا (من {source}):",
+ "insert": "إدراج هذه الأسطر",
+ "insertedHint": "افتح كل سطر واستخدم Tap To Sync لتتطابق الكلمات مع الغناء. يجب مزامنة الأسطر التي لا تحتوي على توقيت قبل إنشاء الفيديو.",
+ "insertedTitle": "تحقق من توقيت الأسطر المدرجة",
+ "noLines": "لا تتوفر أسطر مرجعية لهذا المقطع — أضف الكلمات يدويًا.",
+ "play": "تشغيل",
+ "readOnly": "التعديل معطّل في وضع القراءة فقط",
+ "syncTiming": "مزامنة التوقيت",
+ "title": "كلمات مفقودة محتملة عند {start}–{end}",
+ "dismiss": "تجاهل",
+ "pendingSync": "تمت إضافة كلمات الأغنية هنا ولكن لم يتم ضبط توقيتها بعد. استخدم مزامنة التوقيت (Tap To Sync) قبل إنشاء الفيديو."
}
},
"instrumentalReview": {
diff --git a/frontend/messages/ca.json b/frontend/messages/ca.json
index a348123c..7c1d590f 100644
--- a/frontend/messages/ca.json
+++ b/frontend/messages/ca.json
@@ -985,7 +985,8 @@
"playFromGap": "Reprodueix des del final d'aquesta pausa",
"editSegment": "Edita el segment {index}",
"untimedSegment": "Sense sincronització de paraules — fes clic per editar",
- "waveforms": "Formes d'ona"
+ "waveforms": "Formes d'ona",
+ "missingLyricsMarker": "Possible falta de lletra {start}–{end}"
},
"editActionBar": {
"reset": "Restableix",
@@ -1431,7 +1432,8 @@
"wordOverrideNote": "Les modificacions de cantant a nivell de paraula només s'apliquen al vídeo de karaoke — la sortida CDG utilitza el cantant principal del segment."
},
"toasts": {
- "customLyricsSaved": "Lletra personalitzada aplicada. Sincronitza manualment cada segment editat per assegurar-te que els temps de les paraules són correctes per a la lletra personalitzada."
+ "customLyricsSaved": "Lletra personalitzada aplicada. Sincronitza manualment cada segment editat per assegurar-te que els temps de les paraules són correctes per a la lletra personalitzada.",
+ "untimedWordsBlockSubmit": "{count, plural, one {# paraula de la lletra encara no té} other {# paraules de la lletra encara no tenen}} sincronització. Obre el sincronitzador i prem cada línia al ritme abans de generar el vídeo."
},
"autoCorrect": {
"accept": "Accepta el suggeriment",
@@ -1493,6 +1495,20 @@
"cancelSync": "Cancel·la",
"hold": "MANTÉN...",
"tap": "TOCA"
+ },
+ "missingLyrics": {
+ "description": "La veu principal canta aquí, però no hi ha lletra.",
+ "expectedFrom": "Lletra esperada aquí (de {source}):",
+ "insert": "Insereix aquestes línies",
+ "insertedHint": "Obre cada línia i utilitza Tap To Sync perquè les paraules coincideixin amb la veu. Les línies sense temporització s'han de sincronitzar abans de poder generar el vídeo.",
+ "insertedTitle": "Comprova la temporització de les línies inserides",
+ "noLines": "No hi ha línies de referència disponibles per a aquesta part — afegeix la lletra manualment.",
+ "play": "Reprodueix",
+ "readOnly": "L'edició està desactivada en el mode de només lectura",
+ "syncTiming": "Sincronitza la temporització",
+ "title": "Possible falta de lletra a {start}–{end}",
+ "dismiss": "Descarta",
+ "pendingSync": "S'ha afegit lletra aquí, però encara no està sincronitzada. Utilitza Sincronitza la temporització (Tap To Sync) abans de generar el vídeo."
}
},
"instrumentalReview": {
diff --git a/frontend/messages/cs.json b/frontend/messages/cs.json
index e1cbfe13..38d700d4 100644
--- a/frontend/messages/cs.json
+++ b/frontend/messages/cs.json
@@ -985,7 +985,8 @@
"playFromGap": "Přehrát od konce této mezery",
"editSegment": "Upravit segment {index}",
"untimedSegment": "Bez časování slov — klikni pro úpravu",
- "waveforms": "Zvukové křivky"
+ "waveforms": "Zvukové křivky",
+ "missingLyricsMarker": "Možný chybějící text {start}–{end}"
},
"editActionBar": {
"reset": "Resetovat",
@@ -1431,7 +1432,8 @@
"wordOverrideNote": "Přepsání zpěváka na úrovni slov se vztahuje pouze na karaoke video — výstup CDG používá hlavního zpěváka segmentu."
},
"toasts": {
- "customLyricsSaved": "Vlastní text byl aplikován. Ručně synchronizuj každý upravený segment, aby bylo zajištěno správné načasování slov pro upravený text."
+ "customLyricsSaved": "Vlastní text byl aplikován. Ručně synchronizuj každý upravený segment, aby bylo zajištěno správné načasování slov pro upravený text.",
+ "untimedWordsBlockSubmit": "{count, plural, one {# slovo textu ještě nemá} few {# slova textu ještě nemají} other {# slov textu ještě nemá}} časování. Otevři synchronizátor a před vygenerováním videa odklepej každý řádek do rytmu."
},
"autoCorrect": {
"accept": "Přijmout návrh",
@@ -1493,6 +1495,20 @@
"cancelSync": "Zrušit",
"hold": "DRŽ...",
"tap": "KLEPNI"
+ },
+ "missingLyrics": {
+ "description": "Tady zpívá hlavní vokál, ale chybí text.",
+ "expectedFrom": "Tady se očekává text (z {source}):",
+ "insert": "Vložit tyto řádky",
+ "insertedHint": "Otevři každý řádek a použij Tap To Sync, aby slova seděla ke zpěvu. Řádky bez časování je potřeba před vygenerováním videa synchronizovat.",
+ "insertedTitle": "Zkontroluj časování vložených řádků",
+ "noLines": "Pro tuto část nejsou k dispozici žádné referenční řádky – přidej text ručně.",
+ "play": "Přehrát",
+ "readOnly": "V režimu pouze pro čtení jsou úpravy zakázány",
+ "syncTiming": "Synchronizovat časování",
+ "title": "Možný chybějící text v čase {start}–{end}",
+ "dismiss": "Zavřít",
+ "pendingSync": "Sem byl přidán text, ale zatím není načasovaný. Před vygenerováním videa použij Synchronizovat časování (Tap To Sync)."
}
},
"instrumentalReview": {
diff --git a/frontend/messages/da.json b/frontend/messages/da.json
index 29728a33..f7c51205 100644
--- a/frontend/messages/da.json
+++ b/frontend/messages/da.json
@@ -985,7 +985,8 @@
"playFromGap": "Afspil fra slutningen af denne pause",
"editSegment": "Rediger segment {index}",
"untimedSegment": "Ingen tidsangivelser for ord — klik for at redigere",
- "waveforms": "Bølgeformer"
+ "waveforms": "Bølgeformer",
+ "missingLyricsMarker": "Muligvis manglende sangtekst {start}–{end}"
},
"editActionBar": {
"reset": "Nulstil",
@@ -1431,7 +1432,8 @@
"wordOverrideNote": "Sanger-tilsidesættelser på ordniveau gælder kun for karaoke-videoen — CDG-output bruger segmentets primære sanger."
},
"toasts": {
- "customLyricsSaved": "Tilpasset sangtekst anvendt. Synkroniser manuelt hvert redigeret segment for at sikre, at ordtimingen passer til den tilpassede sangtekst."
+ "customLyricsSaved": "Tilpasset sangtekst anvendt. Synkroniser manuelt hvert redigeret segment for at sikre, at ordtimingen passer til den tilpassede sangtekst.",
+ "untimedWordsBlockSubmit": "{count, plural, one {# ord i sangteksten har} other {# ord i sangteksten har}} endnu ingen timing. Åbn synkroniseringsværktøjet og tryk på hver linje i takt med rytmen, før du genererer videoen."
},
"autoCorrect": {
"accept": "Accepter forslag",
@@ -1493,6 +1495,20 @@
"cancelSync": "Annuller",
"hold": "HOLD...",
"tap": "TRYK"
+ },
+ "missingLyrics": {
+ "description": "Leadvokalen synger her, men der er ingen sangtekst.",
+ "expectedFrom": "Forventet sangtekst her (fra {source}):",
+ "insert": "Indsæt disse linjer",
+ "insertedHint": "Åbn hver linje, og brug Tap To Sync, så ordene passer til sangen. Linjer uden timing skal synkroniseres, før videoen kan genereres.",
+ "insertedTitle": "Tjek timingen på de indsatte linjer",
+ "noLines": "Der er ingen referencelinjer tilgængelige for denne del – tilføj sangteksten manuelt.",
+ "play": "Afspil",
+ "readOnly": "Redigering er deaktiveret i skrivebeskyttet tilstand",
+ "syncTiming": "Synkroniser timing",
+ "title": "Muligvis manglende sangtekst ved {start}–{end}",
+ "dismiss": "Afvis",
+ "pendingSync": "Der er tilføjet sangtekst her, men den er ikke timet endnu. Brug Synkroniser timing (Tap To Sync), før du genererer videoen."
}
},
"instrumentalReview": {
diff --git a/frontend/messages/de.json b/frontend/messages/de.json
index 03322a5a..c8379b32 100644
--- a/frontend/messages/de.json
+++ b/frontend/messages/de.json
@@ -985,7 +985,8 @@
"playFromGap": "Vom Ende dieser Lücke abspielen",
"editSegment": "Bearbeite Segment {index}",
"untimedSegment": "Keine Wort-Timings — klicke zum Bearbeiten",
- "waveforms": "Wellenformen"
+ "waveforms": "Wellenformen",
+ "missingLyricsMarker": "Möglicherweise fehlender Text {start}–{end}"
},
"editActionBar": {
"reset": "Zurücksetzen",
@@ -1431,7 +1432,8 @@
"wordOverrideNote": "Sänger-Überschreibungen auf Wortebene gelten nur für das Karaoke-Video — die CDG-Ausgabe verwendet den Hauptsänger des Segments."
},
"toasts": {
- "customLyricsSaved": "Benutzerdefinierter Text angewendet. Synchronisiere jedes bearbeitete Segment manuell, um sicherzustellen, dass das Wort-Timing für den neuen Text stimmt."
+ "customLyricsSaved": "Benutzerdefinierter Text angewendet. Synchronisiere jedes bearbeitete Segment manuell, um sicherzustellen, dass das Wort-Timing für den neuen Text stimmt.",
+ "untimedWordsBlockSubmit": "{count, plural, one {# Wort im Text hat} other {# Wörter im Text haben}} noch kein Timing. Öffne die Textsynchronisation und tippe jede Zeile im Takt an, bevor du das Video generierst."
},
"autoCorrect": {
"accept": "Vorschlag akzeptieren",
@@ -1493,6 +1495,20 @@
"cancelSync": "Abbrechen",
"hold": "HALTEN...",
"tap": "TIPPEN"
+ },
+ "missingLyrics": {
+ "description": "Hier ist der Hauptgesang zu hören, aber es gibt keinen Text.",
+ "expectedFrom": "Hier wird Text erwartet (aus {source}):",
+ "insert": "Diese Zeilen einfügen",
+ "insertedHint": "Öffne jede Zeile und nutze Tap To Sync, damit die Wörter zum Gesang passen. Zeilen ohne Timing müssen synchronisiert werden, bevor das Video generiert werden kann.",
+ "insertedTitle": "Überprüfe das Timing der eingefügten Zeilen",
+ "noLines": "Für diesen Teil sind keine Referenzzeilen verfügbar – füge den Text manuell hinzu.",
+ "play": "Abspielen",
+ "readOnly": "Die Bearbeitung ist im schreibgeschützten Modus deaktiviert",
+ "syncTiming": "Timing synchronisieren",
+ "title": "Möglicherweise fehlender Text bei {start}–{end}",
+ "dismiss": "Ausblenden",
+ "pendingSync": "Hier wurde Text hinzugefügt, der aber noch kein Timing hat. Nutze Timing synchronisieren (Tap To Sync), bevor du das Video generierst."
}
},
"instrumentalReview": {
diff --git a/frontend/messages/el.json b/frontend/messages/el.json
index 2f116f41..4d1c4c56 100644
--- a/frontend/messages/el.json
+++ b/frontend/messages/el.json
@@ -985,7 +985,8 @@
"playFromGap": "Αναπαραγωγή από το τέλος αυτού του κενού",
"editSegment": "Επεξεργασία τμήματος {index}",
"untimedSegment": "Χωρίς χρονισμό λέξεων — κάνε κλικ για επεξεργασία",
- "waveforms": "Κυματομορφές"
+ "waveforms": "Κυματομορφές",
+ "missingLyricsMarker": "Πιθανώς λείπουν στίχοι {start}–{end}"
},
"editActionBar": {
"reset": "Επαναφορά",
@@ -1431,7 +1432,8 @@
"wordOverrideNote": "Οι παρακάμψεις τραγουδιστή σε επίπεδο λέξης ισχύουν μόνο για το βίντεο καραόκε — η έξοδος CDG χρησιμοποιεί τον κύριο τραγουδιστή του τμήματος."
},
"toasts": {
- "customLyricsSaved": "Οι προσαρμοσμένοι στίχοι εφαρμόστηκαν. Συγχρόνισε χειροκίνητα κάθε επεξεργασμένο τμήμα για να βεβαιωθείς ότι ο χρονισμός των λέξεων είναι σωστός για τους προσαρμοσμένους στίχους."
+ "customLyricsSaved": "Οι προσαρμοσμένοι στίχοι εφαρμόστηκαν. Συγχρόνισε χειροκίνητα κάθε επεξεργασμένο τμήμα για να βεβαιωθείς ότι ο χρονισμός των λέξεων είναι σωστός για τους προσαρμοσμένους στίχους.",
+ "untimedWordsBlockSubmit": "{count, plural, one {# λέξη των στίχων δεν έχει} other {# λέξεις των στίχων δεν έχουν}} ακόμα χρονισμό. Άνοιξε τον συγχρονιστή και πάτα κάθε γραμμή στον ρυθμό πριν δημιουργήσεις το βίντεο."
},
"autoCorrect": {
"accept": "Αποδοχή πρότασης",
@@ -1493,6 +1495,20 @@
"cancelSync": "Ακύρωση",
"hold": "ΚΡΑΤΑ...",
"tap": "ΠΑΤΑ"
+ },
+ "missingLyrics": {
+ "description": "Η κύρια φωνή τραγουδάει εδώ, αλλά δεν υπάρχουν στίχοι.",
+ "expectedFrom": "Αναμένονται στίχοι εδώ (από {source}):",
+ "insert": "Εισαγωγή αυτών των γραμμών",
+ "insertedHint": "Άνοιξε κάθε στίχο και χρησιμοποίησε το Tap To Sync ώστε οι λέξεις να ευθυγραμμιστούν με το τραγούδι. Οι στίχοι χωρίς χρονισμό πρέπει να συγχρονιστούν πριν μπορέσει να δημιουργηθεί το βίντεο.",
+ "insertedTitle": "Έλεγξε τον χρονισμό των στίχων που προστέθηκαν",
+ "noLines": "Δεν υπάρχουν διαθέσιμες γραμμές αναφοράς για αυτό το σημείο — πρόσθεσε τους στίχους χειροκίνητα.",
+ "play": "Αναπαραγωγή",
+ "readOnly": "Η επεξεργασία είναι απενεργοποιημένη στη λειτουργία μόνο για ανάγνωση",
+ "syncTiming": "Συγχρονισμός χρόνου",
+ "title": "Πιθανώς λείπουν στίχοι στο {start}–{end}",
+ "dismiss": "Απόρριψη",
+ "pendingSync": "Έχουν προστεθεί στίχοι εδώ, αλλά δεν έχουν χρονιστεί ακόμα. Χρησιμοποίησε τον Συγχρονισμό χρονισμού (Tap To Sync) πριν δημιουργήσεις το βίντεο."
}
},
"instrumentalReview": {
diff --git a/frontend/messages/en.json b/frontend/messages/en.json
index 94188562..ec44b2e2 100644
--- a/frontend/messages/en.json
+++ b/frontend/messages/en.json
@@ -997,7 +997,8 @@
"aiTooltipEstimated": "Auto-corrected by our system. The timing here was estimated, so play this line and adjust the word timings if needed.",
"longWordWarning": "This word lasts {seconds}s — unusually long. Play the line and check its end time hasn't run into the instrumental.",
"longGapWarning": "{seconds}s gap before the next word — often a stray early word (e.g. a phantom \"and\"). Click to play from here.",
- "playFromGap": "Play from the end of this gap"
+ "playFromGap": "Play from the end of this gap",
+ "missingLyricsMarker": "Possible missing lyrics {start}–{end}"
},
"editActionBar": {
"reset": "Reset",
@@ -1122,7 +1123,8 @@
"noCorrections": "No agentic corrections"
},
"toasts": {
- "customLyricsSaved": "Custom lyrics applied. Manually sync each edited segment to ensure word timings are good for customised lyrics."
+ "customLyricsSaved": "Custom lyrics applied. Manually sync each edited segment to ensure word timings are good for customised lyrics.",
+ "untimedWordsBlockSubmit": "{count, plural, one {# lyric word has} other {# lyric words have}} no timing yet. Open the synchronizer and tap each line to the beat before generating the video."
},
"modals": {
"addLyrics": {
@@ -1505,6 +1507,20 @@
"conflictTooltip": "There are different suggestions for these words — accepting one variant rejects the others.",
"cachedBadge": "cached",
"cachedTooltip": "Restored from a previous run on the same lyrics — no AI cost was incurred."
+ },
+ "missingLyrics": {
+ "title": "Possible missing lyrics at {start}–{end}",
+ "description": "The lead vocal is singing here but there are no lyrics.",
+ "expectedFrom": "Lyrics expected here (from {source}):",
+ "noLines": "No reference lines are available for this part — add the lyrics manually.",
+ "play": "Play",
+ "insert": "Insert these lines",
+ "readOnly": "Editing is disabled in read-only mode",
+ "insertedHint": "Open each line and use Tap To Sync so the words line up with the singing. Lines without timing must be synced before the video can be generated.",
+ "syncTiming": "Sync timing",
+ "insertedTitle": "Check the timing of the inserted lines",
+ "dismiss": "Dismiss",
+ "pendingSync": "Lyrics have been added here but aren't timed yet. Use Sync timing (Tap To Sync) before generating the video."
}
},
"instrumentalReview": {
diff --git a/frontend/messages/es.json b/frontend/messages/es.json
index 6aa9fa6c..2d4f004d 100644
--- a/frontend/messages/es.json
+++ b/frontend/messages/es.json
@@ -985,7 +985,8 @@
"playFromGap": "Reproducir desde el final de este hueco",
"editSegment": "Editar segmento {index}",
"untimedSegment": "Sin tiempos por palabra — haz clic para editar",
- "waveforms": "Formas de onda"
+ "waveforms": "Formas de onda",
+ "missingLyricsMarker": "Posible letra faltante {start}–{end}"
},
"editActionBar": {
"reset": "Restablecer",
@@ -1431,7 +1432,8 @@
"wordOverrideNote": "Las anulaciones de cantante a nivel de palabra se aplican solo al video de karaoke — la salida CDG usa el cantante principal del segmento."
},
"toasts": {
- "customLyricsSaved": "Letras personalizadas aplicadas. Sincroniza manualmente cada segmento editado para asegurar que los tiempos de las palabras sean correctos para las letras personalizadas."
+ "customLyricsSaved": "Letras personalizadas aplicadas. Sincroniza manualmente cada segmento editado para asegurar que los tiempos de las palabras sean correctos para las letras personalizadas.",
+ "untimedWordsBlockSubmit": "{count, plural, one {# palabra de la letra aún no tiene sincronización} other {# palabras de la letra aún no tienen sincronización}}. Abre el sincronizador y pulsa cada línea al ritmo antes de generar el video."
},
"autoCorrect": {
"accept": "Aceptar sugerencia",
@@ -1493,6 +1495,20 @@
"cancelSync": "Cancelar",
"hold": "MANTÉN...",
"tap": "TOCA"
+ },
+ "missingLyrics": {
+ "description": "La voz principal está cantando aquí, pero no hay letra.",
+ "expectedFrom": "Letra esperada aquí (de {source}):",
+ "insert": "Insertar estas líneas",
+ "insertedHint": "Abre cada línea y usa Tap To Sync para que las palabras coincidan con la voz. Las líneas sin tiempos deben sincronizarse antes de poder generar el video.",
+ "insertedTitle": "Revisa los tiempos de las líneas insertadas",
+ "noLines": "No hay líneas de referencia disponibles para esta parte — agrega la letra manualmente.",
+ "play": "Reproducir",
+ "readOnly": "La edición está desactivada en el modo de solo lectura",
+ "syncTiming": "Sincronizar tiempos",
+ "title": "Posible letra faltante en {start}–{end}",
+ "dismiss": "Descartar",
+ "pendingSync": "Se han añadido letras aquí, pero aún no tienen tiempos. Usa Sincronizar tiempos (Tap To Sync) antes de generar el video."
}
},
"instrumentalReview": {
diff --git a/frontend/messages/fi.json b/frontend/messages/fi.json
index 72181eff..5958a554 100644
--- a/frontend/messages/fi.json
+++ b/frontend/messages/fi.json
@@ -985,7 +985,8 @@
"playFromGap": "Toista tämän tauon lopusta",
"editSegment": "Muokkaa segmenttiä {index}",
"untimedSegment": "Ei sana-ajoituksia — muokkaa klikkaamalla",
- "waveforms": "Aaltomuodot"
+ "waveforms": "Aaltomuodot",
+ "missingLyricsMarker": "Mahdollisesti puuttuvia sanoituksia {start}–{end}"
},
"editActionBar": {
"reset": "Nollaa",
@@ -1431,7 +1432,8 @@
"wordOverrideNote": "Sanakohtaiset laulajamuutokset koskevat vain karaokevideota — CDG-tuloste käyttää segmentin päälaulajaa."
},
"toasts": {
- "customLyricsSaved": "Mukautetut sanoitukset otettu käyttöön. Synkronoi jokainen muokattu segmentti manuaalisesti varmistaaksesi, että sanojen ajoitukset sopivat mukautettuihin sanoituksiin."
+ "customLyricsSaved": "Mukautetut sanoitukset otettu käyttöön. Synkronoi jokainen muokattu segmentti manuaalisesti varmistaaksesi, että sanojen ajoitukset sopivat mukautettuihin sanoituksiin.",
+ "untimedWordsBlockSubmit": "{count, plural, one {# sanoituksen sanalta puuttuu} other {# sanoituksen sanalta puuttuu}} vielä ajoitus. Avaa synkronointityökalu ja napauta jokainen rivi biitin tahtiin ennen videon luomista."
},
"autoCorrect": {
"accept": "Hyväksy ehdotus",
@@ -1493,6 +1495,20 @@
"cancelSync": "Peruuta",
"hold": "PIDÄ...",
"tap": "NAPAUTA"
+ },
+ "missingLyrics": {
+ "description": "Päälaulu kuuluu tässä, mutta sanoituksia ei ole.",
+ "expectedFrom": "Tähän odotetaan sanoituksia (lähteestä {source}):",
+ "insert": "Lisää nämä rivit",
+ "insertedHint": "Avaa jokainen rivi ja käytä Tap To Sync -toimintoa, jotta sanat täsmäävät laulun kanssa. Rivit, joilla ei ole ajoitusta, on synkronoitava ennen kuin video voidaan luoda.",
+ "insertedTitle": "Tarkista lisättyjen rivien ajoitus",
+ "noLines": "Tähän osioon ei ole saatavilla viiterivejä – lisää sanoitukset manuaalisesti.",
+ "play": "Toista",
+ "readOnly": "Muokkaus on poistettu käytöstä vain luku -tilassa",
+ "syncTiming": "Synkronoi ajoitus",
+ "title": "Mahdollisesti puuttuvia sanoituksia kohdassa {start}–{end}",
+ "dismiss": "Ohita",
+ "pendingSync": "Tähän on lisätty sanoituksia, mutta niitä ei ole vielä ajoitettu. Käytä Synkronoi ajoitus (Tap To Sync) -toimintoa ennen videon luomista."
}
},
"instrumentalReview": {
diff --git a/frontend/messages/fr.json b/frontend/messages/fr.json
index 7c2be32d..ce6752f3 100644
--- a/frontend/messages/fr.json
+++ b/frontend/messages/fr.json
@@ -985,7 +985,8 @@
"playFromGap": "Jouer à partir de la fin de ce blanc",
"editSegment": "Modifier le segment {index}",
"untimedSegment": "Aucune synchronisation des mots — clique pour modifier",
- "waveforms": "Formes d'onde"
+ "waveforms": "Formes d'onde",
+ "missingLyricsMarker": "Paroles potentiellement manquantes {start}–{end}"
},
"editActionBar": {
"reset": "Réinitialiser",
@@ -1431,7 +1432,8 @@
"wordOverrideNote": "Les modifications de chanteur au niveau des mots s'appliquent uniquement à la vidéo karaoké — la sortie CDG utilise le chanteur principal du segment."
},
"toasts": {
- "customLyricsSaved": "Paroles personnalisées appliquées. Synchronise manuellement chaque segment modifié pour t'assurer que le timing des mots est correct."
+ "customLyricsSaved": "Paroles personnalisées appliquées. Synchronise manuellement chaque segment modifié pour t'assurer que le timing des mots est correct.",
+ "untimedWordsBlockSubmit": "{count, plural, one {# mot n'a} other {# mots n'ont}} pas encore de timing. Ouvre le synchroniseur et appuie sur chaque ligne en rythme avant de générer la vidéo."
},
"autoCorrect": {
"accept": "Accepter la suggestion",
@@ -1493,6 +1495,20 @@
"cancelSync": "Annuler",
"hold": "MAINTIENS...",
"tap": "APPUIE"
+ },
+ "missingLyrics": {
+ "description": "La voix principale chante ici, mais il n'y a pas de paroles.",
+ "expectedFrom": "Paroles attendues ici (d'après {source}) :",
+ "insert": "Insérer ces lignes",
+ "insertedHint": "Ouvre chaque ligne et utilise Tap To Sync pour que les mots soient calés sur le chant. Les lignes sans minutage doivent être synchronisées avant de pouvoir générer la vidéo.",
+ "insertedTitle": "Vérifie le minutage des lignes insérées",
+ "noLines": "Aucune ligne de référence n'est disponible pour cette partie — ajoute les paroles manuellement.",
+ "play": "Lecture",
+ "readOnly": "La modification est désactivée en mode lecture seule",
+ "syncTiming": "Synchroniser le timing",
+ "title": "Paroles potentiellement manquantes à {start}–{end}",
+ "dismiss": "Ignorer",
+ "pendingSync": "Des paroles ont été ajoutées ici, mais ne sont pas encore synchronisées. Utilise Synchroniser le minutage (Tap To Sync) avant de générer la vidéo."
}
},
"instrumentalReview": {
diff --git a/frontend/messages/he.json b/frontend/messages/he.json
index 0acc9a11..d46dfb03 100644
--- a/frontend/messages/he.json
+++ b/frontend/messages/he.json
@@ -985,7 +985,8 @@
"playFromGap": "נגן מסוף הפער הזה",
"editSegment": "עריכת מקטע {index}",
"untimedSegment": "ללא תזמון מילים — לחצו לעריכה",
- "waveforms": "צורות גל"
+ "waveforms": "צורות גל",
+ "missingLyricsMarker": "ייתכן שחסרות מילים {start}–{end}"
},
"editActionBar": {
"reset": "אפס",
@@ -1431,7 +1432,8 @@
"wordOverrideNote": "עקיפות זמר ברמת המילה חלות על וידאו הקריוקי בלבד — פלט CDG משתמש בזמר הראשי של המקטע."
},
"toasts": {
- "customLyricsSaved": "המילים המותאמות אישית הוחלו. יש לסנכרן ידנית כל מקטע שנערך כדי להבטיח שתזמוני המילים מדויקים."
+ "customLyricsSaved": "המילים המותאמות אישית הוחלו. יש לסנכרן ידנית כל מקטע שנערך כדי להבטיח שתזמוני המילים מדויקים.",
+ "untimedWordsBlockSubmit": "{count, plural, one {למילה אחת} other {ל-# מילים}} עדיין אין תזמון. פתחו את המסנכרן והקישו על כל שורה לפי הקצב לפני יצירת הסרטון."
},
"autoCorrect": {
"accept": "קבל הצעה",
@@ -1493,6 +1495,20 @@
"cancelSync": "ביטול",
"hold": "החזק...",
"tap": "הקש"
+ },
+ "missingLyrics": {
+ "description": "יש כאן שירה מובילה, אך אין מילים.",
+ "expectedFrom": "מילים צפויות כאן (מתוך {source}):",
+ "insert": "הוסף שורות אלה",
+ "insertedHint": "פתחו כל שורה והשתמשו ב-Tap To Sync כדי שהמילים יתאימו לשירה. יש לסנכרן שורות ללא תזמון לפני שניתן יהיה ליצור את הסרטון.",
+ "insertedTitle": "בדקו את התזמון של השורות שנוספו",
+ "noLines": "אין שורות מקור זמינות לקטע זה — הוסף את המילים באופן ידני.",
+ "play": "נגן",
+ "readOnly": "העריכה מושבתת במצב קריאה בלבד",
+ "syncTiming": "סנכרון תזמון",
+ "title": "ייתכן שחסרות מילים ב-{start}–{end}",
+ "dismiss": "התעלם",
+ "pendingSync": "נוספו לכאן מילים אך הן עדיין לא מתוזמנות. השתמשו בסנכרון תזמון (Tap To Sync) לפני יצירת הסרטון."
}
},
"instrumentalReview": {
diff --git a/frontend/messages/hi.json b/frontend/messages/hi.json
index 57e1a69d..a23c7c2b 100644
--- a/frontend/messages/hi.json
+++ b/frontend/messages/hi.json
@@ -985,7 +985,8 @@
"playFromGap": "इस गैप के अंत से प्ले करो",
"editSegment": "सेगमेंट {index} एडिट करो",
"untimedSegment": "शब्दों की टाइमिंग नहीं है — एडिट करने के लिए क्लिक करो",
- "waveforms": "वेवफॉर्म"
+ "waveforms": "वेवफॉर्म",
+ "missingLyricsMarker": "संभवतः छूटे हुए लिरिक्स {start}–{end}"
},
"editActionBar": {
"reset": "रीसेट करो",
@@ -1431,7 +1432,8 @@
"wordOverrideNote": "वर्ड-लेवल गायक ओवरराइड्स केवल कराओके वीडियो पर लागू होते हैं — CDG आउटपुट सेगमेंट के मुख्य गायक का उपयोग करता है।"
},
"toasts": {
- "customLyricsSaved": "कस्टम लिरिक्स लागू हो गए। यह पक्का करने के लिए कि कस्टमाइज़्ड लिरिक्स के लिए शब्दों की टाइमिंग सही है, हर एडिट किए गए हिस्से को मैन्युअली सिंक करो।"
+ "customLyricsSaved": "कस्टम लिरिक्स लागू हो गए। यह पक्का करने के लिए कि कस्टमाइज़्ड लिरिक्स के लिए शब्दों की टाइमिंग सही है, हर एडिट किए गए हिस्से को मैन्युअली सिंक करो।",
+ "untimedWordsBlockSubmit": "{count, plural, one {लिरिक्स के # शब्द की} other {लिरिक्स के # शब्दों की}} अभी तक कोई टाइमिंग नहीं है। वीडियो जनरेट करने से पहले सिंक्रोनाइज़र खोलो और बीट के साथ हर लाइन पर टैप करो।"
},
"autoCorrect": {
"accept": "सुझाव स्वीकार करो",
@@ -1493,6 +1495,20 @@
"cancelSync": "कैंसल",
"hold": "दबाए रखो...",
"tap": "टैप करो"
+ },
+ "missingLyrics": {
+ "description": "लीड वोकल यहाँ गा रहे हैं लेकिन कोई लिरिक्स नहीं हैं।",
+ "expectedFrom": "यहाँ लिरिक्स होने चाहिए ({source} से):",
+ "insert": "ये पंक्तियाँ जोड़ो",
+ "insertedHint": "हर लाइन को खोलो और Tap To Sync का इस्तेमाल करो ताकि शब्द गायन के साथ मेल खाएँ। वीडियो जनरेट करने से पहले बिना टाइमिंग वाली लाइनों को सिंक करना ज़रूरी है।",
+ "insertedTitle": "जोड़ी गई लाइनों की टाइमिंग चेक करो",
+ "noLines": "इस हिस्से के लिए कोई संदर्भ पंक्तियाँ उपलब्ध नहीं हैं — लिरिक्स मैन्युअली जोड़ो।",
+ "play": "चलाओ",
+ "readOnly": "रीड-ओनली मोड में एडिटिंग बंद है",
+ "syncTiming": "टाइमिंग सिंक करो",
+ "title": "{start}–{end} पर संभवतः छूटे हुए लिरिक्स",
+ "dismiss": "हटाओ",
+ "pendingSync": "यहाँ लिरिक्स जोड़ दिए गए हैं लेकिन अभी उनकी टाइमिंग सेट नहीं है। वीडियो जनरेट करने से पहले Sync timing (Tap To Sync) का इस्तेमाल करो।"
}
},
"instrumentalReview": {
diff --git a/frontend/messages/hr.json b/frontend/messages/hr.json
index 8e500eeb..25a16e8a 100644
--- a/frontend/messages/hr.json
+++ b/frontend/messages/hr.json
@@ -985,7 +985,8 @@
"playFromGap": "Reproduciraj od kraja ove pauze",
"editSegment": "Uredi segment {index}",
"untimedSegment": "Nema vremenskih oznaka riječi — klikni za uređivanje",
- "waveforms": "Valni oblici"
+ "waveforms": "Valni oblici",
+ "missingLyricsMarker": "Možda nedostaje tekst {start}–{end}"
},
"editActionBar": {
"reset": "Poništi",
@@ -1431,7 +1432,8 @@
"wordOverrideNote": "Izmjene pjevača na razini riječi primjenjuju se samo na karaoke video — CDG izlaz koristi glavnog pjevača segmenta."
},
"toasts": {
- "customLyricsSaved": "Prilagođeni tekst je primijenjen. Ručno sinkroniziraj svaki uređeni segment kako bi tempiranje riječi bilo točno za prilagođeni tekst."
+ "customLyricsSaved": "Prilagođeni tekst je primijenjen. Ručno sinkroniziraj svaki uređeni segment kako bi tempiranje riječi bilo točno za prilagođeni tekst.",
+ "untimedWordsBlockSubmit": "{count, plural, one {# riječ teksta još nema} few {# riječi teksta još nemaju} other {# riječi teksta još nema}} vremensku oznaku. Otvori sinkronizator i tapkaj svaki redak u ritmu prije generiranja videozapisa."
},
"autoCorrect": {
"accept": "Prihvati prijedlog",
@@ -1493,6 +1495,20 @@
"cancelSync": "Odustani",
"hold": "DRŽI...",
"tap": "TAPNI"
+ },
+ "missingLyrics": {
+ "description": "Glavni vokal ovdje pjeva, ali nema teksta.",
+ "expectedFrom": "Ovdje se očekuje tekst (iz {source}):",
+ "insert": "Umetni ove retke",
+ "insertedHint": "Otvori svaki redak i upotrijebi Tap To Sync kako bi se riječi uskladile s pjevanjem. Retci bez vremenskih oznaka moraju se sinkronizirati prije nego što se videozapis može generirati.",
+ "insertedTitle": "Provjeri vremensko usklađivanje umetnutih redaka",
+ "noLines": "Nema dostupnih referentnih redaka za ovaj dio — dodaj tekst ručno.",
+ "play": "Reproduciraj",
+ "readOnly": "Uređivanje je onemogućeno u načinu samo za čitanje",
+ "syncTiming": "Sinkroniziraj vrijeme",
+ "title": "Možda nedostaje tekst na {start}–{end}",
+ "dismiss": "Odbaci",
+ "pendingSync": "Ovdje je dodan tekst pjesme, ali još nije vremenski usklađen. Upotrijebi sinkronizaciju vremena (Tap To Sync) prije generiranja videozapisa."
}
},
"instrumentalReview": {
diff --git a/frontend/messages/hu.json b/frontend/messages/hu.json
index f337ef19..6c86a87c 100644
--- a/frontend/messages/hu.json
+++ b/frontend/messages/hu.json
@@ -985,7 +985,8 @@
"playFromGap": "Lejátszás a szünet végétől",
"editSegment": "{index}. szegmens szerkesztése",
"untimedSegment": "Nincs szóidőzítés — kattints a szerkesztéshez",
- "waveforms": "Hullámformák"
+ "waveforms": "Hullámformák",
+ "missingLyricsMarker": "Lehetséges hiányzó dalszöveg: {start}–{end}"
},
"editActionBar": {
"reset": "Visszaállítás",
@@ -1431,7 +1432,8 @@
"wordOverrideNote": "A szavankénti énekes-felülbírálások csak a karaoke videóra vonatkoznak — a CDG kimenet a szegmens fő énekesét használja."
},
"toasts": {
- "customLyricsSaved": "Egyedi dalszöveg alkalmazva. Szinkronizáld manuálisan az összes szerkesztett szegmenst, hogy a szavak időzítése megfelelő legyen a testreszabott dalszöveghez."
+ "customLyricsSaved": "Egyedi dalszöveg alkalmazva. Szinkronizáld manuálisan az összes szerkesztett szegmenst, hogy a szavak időzítése megfelelő legyen a testreszabott dalszöveghez.",
+ "untimedWordsBlockSubmit": "{count, plural, one {# szó a dalszövegben} other {# szó a dalszövegben}} még nincs időzítve. Nyisd meg a szinkronizálót, és a videó generálása előtt koppints az egyes sorokra az ütemre."
},
"autoCorrect": {
"accept": "Javaslat elfogadása",
@@ -1493,6 +1495,20 @@
"cancelSync": "Mégse",
"hold": "TARTSD...",
"tap": "KOPPINTS"
+ },
+ "missingLyrics": {
+ "description": "Itt énekel a vezérvokál, de nincs dalszöveg.",
+ "expectedFrom": "Itt dalszöveg várható (forrás: {source}):",
+ "insert": "Szúrd be ezeket a sorokat",
+ "insertedHint": "Nyisd meg az egyes sorokat, és használd a Tap To Sync funkciót, hogy a szavak illeszkedjenek az énekhez. Az időzítés nélküli sorokat szinkronizálni kell a videó generálása előtt.",
+ "insertedTitle": "Ellenőrizd a beszúrt sorok időzítését",
+ "noLines": "Ehhez a részhez nincsenek elérhető referenciasorok — add hozzá a dalszöveget manuálisan.",
+ "play": "Lejátszás",
+ "readOnly": "A szerkesztés csak olvasható módban le van tiltva",
+ "syncTiming": "Időzítés szinkronizálása",
+ "title": "Lehetséges hiányzó dalszöveg itt: {start}–{end}",
+ "dismiss": "Elvetés",
+ "pendingSync": "Ide bekerült a dalszöveg, de még nincs időzítve. Használd az Időzítés szinkronizálása (Tap To Sync) funkciót a videó generálása előtt."
}
},
"instrumentalReview": {
diff --git a/frontend/messages/id.json b/frontend/messages/id.json
index 5200697b..265c2b1d 100644
--- a/frontend/messages/id.json
+++ b/frontend/messages/id.json
@@ -985,7 +985,8 @@
"playFromGap": "Putar dari akhir jeda ini",
"editSegment": "Edit segmen {index}",
"untimedSegment": "Tidak ada timing kata — klik untuk mengedit",
- "waveforms": "Bentuk gelombang"
+ "waveforms": "Bentuk gelombang",
+ "missingLyricsMarker": "Kemungkinan ada lirik yang hilang {start}–{end}"
},
"editActionBar": {
"reset": "Atur Ulang",
@@ -1431,7 +1432,8 @@
"wordOverrideNote": "Penggantian penyanyi tingkat kata hanya berlaku untuk video karaoke — output CDG menggunakan penyanyi utama segmen tersebut."
},
"toasts": {
- "customLyricsSaved": "Lirik kustom berhasil diterapkan. Sinkronkan setiap segmen yang diedit secara manual untuk memastikan ketepatan waktu lirik yang baru."
+ "customLyricsSaved": "Lirik kustom berhasil diterapkan. Sinkronkan setiap segmen yang diedit secara manual untuk memastikan ketepatan waktu lirik yang baru.",
+ "untimedWordsBlockSubmit": "{count, plural, one {# kata lirik} other {# kata lirik}} belum diatur waktunya. Buka alat sinkronisasi dan ketuk setiap baris mengikuti irama sebelum membuat video."
},
"autoCorrect": {
"accept": "Terima saran",
@@ -1493,6 +1495,20 @@
"cancelSync": "Batal",
"hold": "TAHAN...",
"tap": "KETUK"
+ },
+ "missingLyrics": {
+ "description": "Vokal utama bernyanyi di sini, tetapi tidak ada lirik.",
+ "expectedFrom": "Lirik yang diperkirakan ada di sini (dari {source}):",
+ "insert": "Sisipkan baris ini",
+ "insertedHint": "Buka setiap baris dan gunakan Tap To Sync agar kata-katanya selaras dengan nyanyian. Baris tanpa pengaturan waktu harus disinkronkan sebelum video dapat dibuat.",
+ "insertedTitle": "Periksa pengaturan waktu baris yang disisipkan",
+ "noLines": "Tidak ada baris referensi yang tersedia untuk bagian ini — tambahkan lirik secara manual.",
+ "play": "Putar",
+ "readOnly": "Pengeditan dinonaktifkan dalam mode hanya-baca",
+ "syncTiming": "Sinkronkan waktu",
+ "title": "Kemungkinan ada lirik yang hilang pada {start}–{end}",
+ "dismiss": "Abaikan",
+ "pendingSync": "Lirik telah ditambahkan di sini, tetapi belum diatur waktunya. Gunakan Sinkronkan waktu (Tap To Sync) sebelum membuat video."
}
},
"instrumentalReview": {
diff --git a/frontend/messages/it.json b/frontend/messages/it.json
index 7397e851..96766123 100644
--- a/frontend/messages/it.json
+++ b/frontend/messages/it.json
@@ -985,7 +985,8 @@
"playFromGap": "Riproduci dalla fine di questa pausa",
"editSegment": "Modifica segmento {index}",
"untimedSegment": "Nessuna sincronizzazione delle parole — clicca per modificare",
- "waveforms": "Forme d'onda"
+ "waveforms": "Forme d'onda",
+ "missingLyricsMarker": "Possibile testo mancante {start}–{end}"
},
"editActionBar": {
"reset": "Reimposta",
@@ -1431,7 +1432,8 @@
"wordOverrideNote": "Le sovrascritture del cantante a livello di parola si applicano solo al video karaoke — l'output CDG usa il cantante principale del segmento."
},
"toasts": {
- "customLyricsSaved": "Testo personalizzato applicato. Sincronizza manualmente ogni segmento modificato per assicurarti che il tempismo delle parole sia corretto per il testo personalizzato."
+ "customLyricsSaved": "Testo personalizzato applicato. Sincronizza manualmente ogni segmento modificato per assicurarti che il tempismo delle parole sia corretto per il testo personalizzato.",
+ "untimedWordsBlockSubmit": "{count, plural, one {# parola del testo non è ancora sincronizzata} other {# parole del testo non sono ancora sincronizzate}}. Apri il sincronizzatore e tocca ogni riga a tempo prima di generare il video."
},
"autoCorrect": {
"accept": "Accetta suggerimento",
@@ -1493,6 +1495,20 @@
"cancelSync": "Annulla",
"hold": "TIENI PREMUTO...",
"tap": "TOCCA"
+ },
+ "missingLyrics": {
+ "description": "La voce solista sta cantando qui, ma non c'è testo.",
+ "expectedFrom": "Testo previsto qui (da {source}):",
+ "insert": "Inserisci queste righe",
+ "insertedHint": "Apri ogni riga e usa Tap To Sync in modo che le parole vadano a tempo con il cantato. Le righe senza tempistiche devono essere sincronizzate prima di poter generare il video.",
+ "insertedTitle": "Controlla le tempistiche delle righe inserite",
+ "noLines": "Nessuna riga di riferimento disponibile per questa parte — aggiungi il testo manualmente.",
+ "play": "Riproduci",
+ "readOnly": "La modifica è disabilitata in modalità solo lettura",
+ "syncTiming": "Sincronizza i tempi",
+ "title": "Possibile testo mancante a {start}–{end}",
+ "dismiss": "Ignora",
+ "pendingSync": "Il testo è stato aggiunto qui, ma non è ancora sincronizzato. Usa Sincronizza tempistiche (Tap To Sync) prima di generare il video."
}
},
"instrumentalReview": {
diff --git a/frontend/messages/ja.json b/frontend/messages/ja.json
index b858a891..b3830fe1 100644
--- a/frontend/messages/ja.json
+++ b/frontend/messages/ja.json
@@ -985,7 +985,8 @@
"playFromGap": "このギャップの終わりから再生",
"editSegment": "セグメント {index} を編集",
"untimedSegment": "単語のタイミング未設定 — クリックして編集",
- "waveforms": "波形"
+ "waveforms": "波形",
+ "missingLyricsMarker": "歌詞が抜けている可能性 {start}–{end}"
},
"editActionBar": {
"reset": "リセット",
@@ -1431,7 +1432,8 @@
"wordOverrideNote": "単語ごとのシンガーの上書きはカラオケ動画にのみ適用されます。CDG出力ではセグメントのメインシンガーが使用されます。"
},
"toasts": {
- "customLyricsSaved": "カスタム歌詞を適用しました。カスタマイズした歌詞のタイミングが合うように、編集した各セグメントを手動で同期してください。"
+ "customLyricsSaved": "カスタム歌詞を適用しました。カスタマイズした歌詞のタイミングが合うように、編集した各セグメントを手動で同期してください。",
+ "untimedWordsBlockSubmit": "{count, plural, one {歌詞の#個の単語に} other {歌詞の#個の単語に}}まだタイミングが設定されていません。動画を生成する前にシンクロナイザーを開き、ビートに合わせて各行をタップしてください。"
},
"autoCorrect": {
"accept": "提案を採用する",
@@ -1493,6 +1495,20 @@
"cancelSync": "キャンセル",
"hold": "長押し...",
"tap": "タップ"
+ },
+ "missingLyrics": {
+ "description": "ここでリードボーカルが歌っていますが、歌詞がありません。",
+ "expectedFrom": "ここに入る想定の歌詞({source}より):",
+ "insert": "これらの行を挿入",
+ "insertedHint": "各行を開いて「Tap To Sync」を使い、歌声に合わせて歌詞のタイミングを調整してください。動画を生成する前に、タイミングが未設定の行を同期する必要があります。",
+ "insertedTitle": "挿入された行のタイミングを確認",
+ "noLines": "このパートで利用できる参照用の歌詞がありません。手動で歌詞を追加してください。",
+ "play": "再生",
+ "readOnly": "読み取り専用モードでは編集できません",
+ "syncTiming": "タイミングを同期",
+ "title": "{start}–{end} で歌詞が抜けている可能性があります",
+ "dismiss": "閉じる",
+ "pendingSync": "ここに歌詞が追加されましたが、まだタイミングが設定されていません。動画を生成する前に「タイミングを同期(Tap To Sync)」を行ってください。"
}
},
"instrumentalReview": {
diff --git a/frontend/messages/ko.json b/frontend/messages/ko.json
index 6362050c..d0a02429 100644
--- a/frontend/messages/ko.json
+++ b/frontend/messages/ko.json
@@ -985,7 +985,8 @@
"playFromGap": "이 공백의 끝부분부터 재생",
"editSegment": "구간 {index} 편집",
"untimedSegment": "단어 타이밍 없음 — 클릭해서 편집하세요",
- "waveforms": "파형"
+ "waveforms": "파형",
+ "missingLyricsMarker": "가사 누락 가능 구간 {start}–{end}"
},
"editActionBar": {
"reset": "초기화",
@@ -1431,7 +1432,8 @@
"wordOverrideNote": "단어별 가수 설정은 노래방 비디오에만 적용됩니다 — CDG 출력은 해당 구간의 메인 가수를 사용합니다."
},
"toasts": {
- "customLyricsSaved": "맞춤형 가사가 적용되었습니다. 단어 타이밍이 잘 맞도록 편집된 각 구간을 수동으로 동기화해 주세요."
+ "customLyricsSaved": "맞춤형 가사가 적용되었습니다. 단어 타이밍이 잘 맞도록 편집된 각 구간을 수동으로 동기화해 주세요.",
+ "untimedWordsBlockSubmit": "{count, plural, one {아직 타이밍이 설정되지 않은 가사 단어가 #개 있습니다.} other {아직 타이밍이 설정되지 않은 가사 단어가 #개 있습니다.}} 비디오를 생성하기 전에 싱크 도구를 열고 박자에 맞춰 각 줄을 탭해 주세요."
},
"autoCorrect": {
"accept": "제안 수락",
@@ -1493,6 +1495,20 @@
"cancelSync": "취소",
"hold": "길게 누르기...",
"tap": "탭"
+ },
+ "missingLyrics": {
+ "description": "리드 보컬이 노래하고 있지만 가사가 없습니다.",
+ "expectedFrom": "이 부분의 예상 가사({source}):",
+ "insert": "이 가사 삽입",
+ "insertedHint": "각 줄을 열고 노래에 맞춰 가사가 나오도록 Tap To Sync를 사용해 보세요. 타이밍이 설정되지 않은 줄은 비디오를 생성하기 전에 반드시 싱크를 맞춰야 합니다.",
+ "insertedTitle": "삽입된 줄의 타이밍을 확인해 주세요",
+ "noLines": "이 부분에 대한 참조 가사가 없습니다. 가사를 직접 추가해 주세요.",
+ "play": "재생",
+ "readOnly": "읽기 전용 모드에서는 편집할 수 없습니다",
+ "syncTiming": "타이밍 싱크 맞추기",
+ "title": "{start}–{end} 구간 가사 누락 가능성",
+ "dismiss": "닫기",
+ "pendingSync": "가사가 추가되었지만 아직 타이밍이 설정되지 않았습니다. 비디오를 생성하기 전에 타이밍 싱크(Tap To Sync)를 진행해 주세요."
}
},
"instrumentalReview": {
diff --git a/frontend/messages/ms.json b/frontend/messages/ms.json
index 1530f53c..4b31c8c1 100644
--- a/frontend/messages/ms.json
+++ b/frontend/messages/ms.json
@@ -985,7 +985,8 @@
"playFromGap": "Main dari penghujung jurang ini",
"editSegment": "Sunting segmen {index}",
"untimedSegment": "Tiada pemasaan perkataan — klik untuk sunting",
- "waveforms": "Bentuk gelombang"
+ "waveforms": "Bentuk gelombang",
+ "missingLyricsMarker": "Kemungkinan lirik tertinggal {start}–{end}"
},
"editActionBar": {
"reset": "Tetapkan Semula",
@@ -1431,7 +1432,8 @@
"wordOverrideNote": "Tetapan ganti penyanyi peringkat perkataan hanya digunakan pada video karaoke — output CDG menggunakan penyanyi utama segmen tersebut."
},
"toasts": {
- "customLyricsSaved": "Lirik tersuai digunakan. Segerakkan setiap segmen yang disunting secara manual untuk memastikan pemasaan perkataan adalah tepat untuk lirik tersuai."
+ "customLyricsSaved": "Lirik tersuai digunakan. Segerakkan setiap segmen yang disunting secara manual untuk memastikan pemasaan perkataan adalah tepat untuk lirik tersuai.",
+ "untimedWordsBlockSubmit": "{count, plural, one {# perkataan lirik belum ada pemasaan} other {# perkataan lirik belum ada pemasaan}}. Buka penyegerak dan ketik setiap baris mengikut rentak sebelum menjana video."
},
"autoCorrect": {
"accept": "Terima cadangan",
@@ -1493,6 +1495,20 @@
"cancelSync": "Batal",
"hold": "TAHAN...",
"tap": "TEKAN"
+ },
+ "missingLyrics": {
+ "description": "Vokal utama sedang menyanyi di sini tetapi tiada lirik.",
+ "expectedFrom": "Lirik sepatutnya ada di sini (daripada {source}):",
+ "insert": "Masukkan baris ini",
+ "insertedHint": "Buka setiap baris dan gunakan Tap To Sync supaya perkataan selaras dengan nyanyian. Baris tanpa pemasaan mesti disegerakkan sebelum video boleh dijana.",
+ "insertedTitle": "Semak pemasaan baris yang dimasukkan",
+ "noLines": "Tiada baris rujukan tersedia untuk bahagian ini — tambah lirik secara manual.",
+ "play": "Mainkan",
+ "readOnly": "Penyuntingan dilumpuhkan dalam mod baca sahaja",
+ "syncTiming": "Segerakkan masa",
+ "title": "Kemungkinan lirik tertinggal pada {start}–{end}",
+ "dismiss": "Tolak",
+ "pendingSync": "Lirik telah ditambah di sini tetapi belum ditetapkan masanya. Gunakan Segerakkan pemasaan (Tap To Sync) sebelum menjana video."
}
},
"instrumentalReview": {
diff --git a/frontend/messages/nb.json b/frontend/messages/nb.json
index c3703a54..5a06409a 100644
--- a/frontend/messages/nb.json
+++ b/frontend/messages/nb.json
@@ -985,7 +985,8 @@
"playFromGap": "Spill av fra slutten av dette mellomrommet",
"editSegment": "Rediger segment {index}",
"untimedSegment": "Ingen tidsstempler for ord — klikk for å redigere",
- "waveforms": "Bølgeformer"
+ "waveforms": "Bølgeformer",
+ "missingLyricsMarker": "Mulig manglende sangtekst {start}–{end}"
},
"editActionBar": {
"reset": "Tilbakestill",
@@ -1431,7 +1432,8 @@
"wordOverrideNote": "Overstyring av sanger på ordnivå gjelder kun for karaokevideoen — CDG-utdata bruker segmentets hovedsanger."
},
"toasts": {
- "customLyricsSaved": "Egendefinert tekst er lagt til. Synkroniser hvert redigerte segment manuelt for å sikre at timingen av ordene stemmer for den tilpassede teksten."
+ "customLyricsSaved": "Egendefinert tekst er lagt til. Synkroniser hvert redigerte segment manuelt for å sikre at timingen av ordene stemmer for den tilpassede teksten.",
+ "untimedWordsBlockSubmit": "{count, plural, one {# tekstord har} other {# tekstord har}} ingen timing ennå. Åpne synkronisatoren og trykk på hver linje i takt med musikken før du genererer videoen."
},
"autoCorrect": {
"accept": "Godta forslag",
@@ -1493,6 +1495,20 @@
"cancelSync": "Avbryt",
"hold": "HOLD...",
"tap": "TRYKK"
+ },
+ "missingLyrics": {
+ "description": "Hovedvokalen synger her, men det er ingen sangtekst.",
+ "expectedFrom": "Forventet sangtekst her (fra {source}):",
+ "insert": "Sett inn disse linjene",
+ "insertedHint": "Åpne hver linje og bruk Tap To Sync slik at ordene stemmer med sangen. Linjer uten timing må synkroniseres før videoen kan genereres.",
+ "insertedTitle": "Sjekk timingen på de innsatte linjene",
+ "noLines": "Ingen referanselinjer er tilgjengelige for denne delen – legg til sangteksten manuelt.",
+ "play": "Spill av",
+ "readOnly": "Redigering er deaktivert i skrivebeskyttet modus",
+ "syncTiming": "Synkroniser timing",
+ "title": "Mulig manglende sangtekst ved {start}–{end}",
+ "dismiss": "Lukk",
+ "pendingSync": "Det er lagt til sangtekst her, men den er ikke timet ennå. Bruk Synkroniser timing (Tap To Sync) før du genererer videoen."
}
},
"instrumentalReview": {
diff --git a/frontend/messages/nl.json b/frontend/messages/nl.json
index fd0fbeb6..d540275b 100644
--- a/frontend/messages/nl.json
+++ b/frontend/messages/nl.json
@@ -985,7 +985,8 @@
"playFromGap": "Afspelen vanaf het einde van deze pauze",
"editSegment": "Bewerk segment {index}",
"untimedSegment": "Geen woordtimings — klik om te bewerken",
- "waveforms": "Golfvormen"
+ "waveforms": "Golfvormen",
+ "missingLyricsMarker": "Mogelijk ontbrekende songtekst {start}–{end}"
},
"editActionBar": {
"reset": "Resetten",
@@ -1431,7 +1432,8 @@
"wordOverrideNote": "Zangeraanpassingen op woordniveau zijn alleen van toepassing op de karaokevideo — CDG-uitvoer gebruikt de hoofdzanger van het segment."
},
"toasts": {
- "customLyricsSaved": "Aangepaste songtekst toegepast. Synchroniseer elk bewerkt segment handmatig zodat de timing van de woorden perfect aansluit op de nieuwe songtekst."
+ "customLyricsSaved": "Aangepaste songtekst toegepast. Synchroniseer elk bewerkt segment handmatig zodat de timing van de woorden perfect aansluit op de nieuwe songtekst.",
+ "untimedWordsBlockSubmit": "{count, plural, one {# woord in de songtekst heeft} other {# woorden in de songtekst hebben}} nog geen timing. Open de synchronizer en tik elke regel mee op de maat voordat je de video genereert."
},
"autoCorrect": {
"accept": "Accepteer suggestie",
@@ -1493,6 +1495,20 @@
"cancelSync": "Annuleren",
"hold": "HOUD VAST...",
"tap": "TIK"
+ },
+ "missingLyrics": {
+ "description": "Hier is leadzang te horen, maar er is geen songtekst.",
+ "expectedFrom": "Hier wordt songtekst verwacht (van {source}):",
+ "insert": "Deze regels invoegen",
+ "insertedHint": "Open elke regel en gebruik Tap To Sync zodat de woorden synchroon lopen met de zang. Regels zonder timing moeten worden gesynchroniseerd voordat je de video kunt genereren.",
+ "insertedTitle": "Controleer de timing van de ingevoegde regels",
+ "noLines": "Er zijn geen referentieregels beschikbaar voor dit deel — voeg de songtekst handmatig toe.",
+ "play": "Afspelen",
+ "readOnly": "Bewerken is uitgeschakeld in de alleen-lezenmodus",
+ "syncTiming": "Timing synchroniseren",
+ "title": "Mogelijk ontbrekende songtekst bij {start}–{end}",
+ "dismiss": "Sluiten",
+ "pendingSync": "Er is hier songtekst toegevoegd, maar die is nog niet getimed. Gebruik Timing synchroniseren (Tap To Sync) voordat je de video genereert."
}
},
"instrumentalReview": {
diff --git a/frontend/messages/pl.json b/frontend/messages/pl.json
index 261a34a0..382a80b8 100644
--- a/frontend/messages/pl.json
+++ b/frontend/messages/pl.json
@@ -985,7 +985,8 @@
"playFromGap": "Odtwórz od końca tej przerwy",
"editSegment": "Edytuj segment {index}",
"untimedSegment": "Brak synchronizacji słów — kliknij, aby edytować",
- "waveforms": "Fale dźwiękowe"
+ "waveforms": "Fale dźwiękowe",
+ "missingLyricsMarker": "Możliwy brak tekstu {start}–{end}"
},
"editActionBar": {
"reset": "Resetuj",
@@ -1431,7 +1432,8 @@
"wordOverrideNote": "Nadpisania wokalisty na poziomie słów dotyczą tylko wideo karaoke — plik CDG używa głównego wokalisty segmentu."
},
"toasts": {
- "customLyricsSaved": "Zastosowano własny tekst. Zsynchronizuj ręcznie każdy edytowany segment, aby upewnić się, że czas wyświetlania słów pasuje do nowego tekstu."
+ "customLyricsSaved": "Zastosowano własny tekst. Zsynchronizuj ręcznie każdy edytowany segment, aby upewnić się, że czas wyświetlania słów pasuje do nowego tekstu.",
+ "untimedWordsBlockSubmit": "{count, plural, one {# słowo tekstu nie ma} few {# słowa tekstu nie mają} many {# słów tekstu nie ma} other {# słów tekstu nie ma}} jeszcze synchronizacji. Otwórz synchronizator i wystukaj każdą linijkę do rytmu przed wygenerowaniem wideo."
},
"autoCorrect": {
"accept": "Zaakceptuj sugestię",
@@ -1493,6 +1495,20 @@
"cancelSync": "Anuluj",
"hold": "PRZYTRZYMAJ...",
"tap": "STUKNIJ"
+ },
+ "missingLyrics": {
+ "description": "W tym miejscu słychać główny wokal, ale brakuje tekstu.",
+ "expectedFrom": "Oczekiwany tekst w tym miejscu (z {source}):",
+ "insert": "Wstaw te wersy",
+ "insertedHint": "Otwórz każdą linijkę i użyj opcji Tap To Sync, aby dopasować słowa do śpiewu. Linijki bez przypisanego czasu muszą zostać zsynchronizowane przed wygenerowaniem wideo.",
+ "insertedTitle": "Sprawdź synchronizację wstawionych linijek",
+ "noLines": "Brak wersów referencyjnych dla tego fragmentu — dodaj tekst ręcznie.",
+ "play": "Odtwórz",
+ "readOnly": "Edycja jest wyłączona w trybie tylko do odczytu",
+ "syncTiming": "Zsynchronizuj czas",
+ "title": "Możliwy brak tekstu w {start}–{end}",
+ "dismiss": "Odrzuć",
+ "pendingSync": "Tekst został tutaj dodany, ale nie jest jeszcze zsynchronizowany. Użyj opcji Synchronizuj czas (Tap To Sync) przed wygenerowaniem wideo."
}
},
"instrumentalReview": {
diff --git a/frontend/messages/pt.json b/frontend/messages/pt.json
index dba42143..04ef9ca8 100644
--- a/frontend/messages/pt.json
+++ b/frontend/messages/pt.json
@@ -985,7 +985,8 @@
"playFromGap": "Tocar a partir do final deste intervalo",
"editSegment": "Editar segmento {index}",
"untimedSegment": "Sem marcação de tempo nas palavras — clique para editar",
- "waveforms": "Formas de onda"
+ "waveforms": "Formas de onda",
+ "missingLyricsMarker": "Possível letra ausente {start}–{end}"
},
"editActionBar": {
"reset": "Redefinir",
@@ -1431,7 +1432,8 @@
"wordOverrideNote": "As substituições de cantor no nível da palavra se aplicam apenas ao vídeo de karaokê — a saída CDG usa o cantor principal do segmento."
},
"toasts": {
- "customLyricsSaved": "Letras personalizadas aplicadas. Sincronize manualmente cada segmento editado para garantir que o tempo das palavras fique adequado para as novas letras."
+ "customLyricsSaved": "Letras personalizadas aplicadas. Sincronize manualmente cada segmento editado para garantir que o tempo das palavras fique adequado para as novas letras.",
+ "untimedWordsBlockSubmit": "{count, plural, one {# palavra da letra ainda não tem} other {# palavras da letra ainda não têm}} sincronização. Abra o sincronizador e toque em cada linha no ritmo antes de gerar o vídeo."
},
"autoCorrect": {
"accept": "Aceitar sugestão",
@@ -1493,6 +1495,20 @@
"cancelSync": "Cancelar",
"hold": "SEGURE...",
"tap": "TOQUE"
+ },
+ "missingLyrics": {
+ "description": "O vocal principal está cantando aqui, mas não há letra.",
+ "expectedFrom": "Letra esperada aqui (de {source}):",
+ "insert": "Inserir estas linhas",
+ "insertedHint": "Abra cada linha e use o Toque para Sincronizar para que as palavras fiquem alinhadas com a voz. Linhas sem marcação de tempo devem ser sincronizadas antes que o vídeo possa ser gerado.",
+ "insertedTitle": "Verifique a sincronização das linhas inseridas",
+ "noLines": "Nenhuma linha de referência disponível para esta parte — adicione a letra manualmente.",
+ "play": "Reproduzir",
+ "readOnly": "A edição está desativada no modo somente leitura",
+ "syncTiming": "Sincronizar tempo",
+ "title": "Possível letra ausente em {start}–{end}",
+ "dismiss": "Dispensar",
+ "pendingSync": "A letra foi adicionada aqui, mas ainda não está sincronizada. Use Sincronizar tempo (Toque para Sincronizar) antes de gerar o vídeo."
}
},
"instrumentalReview": {
diff --git a/frontend/messages/ro.json b/frontend/messages/ro.json
index 702e2a68..6ba2c715 100644
--- a/frontend/messages/ro.json
+++ b/frontend/messages/ro.json
@@ -985,7 +985,8 @@
"playFromGap": "Redă de la sfârșitul acestei pauze",
"editSegment": "Editează segmentul {index}",
"untimedSegment": "Fără sincronizare pe cuvinte — dă click pentru a edita",
- "waveforms": "Forme de undă"
+ "waveforms": "Forme de undă",
+ "missingLyricsMarker": "Posibile versuri lipsă {start}–{end}"
},
"editActionBar": {
"reset": "Resetează",
@@ -1431,7 +1432,8 @@
"wordOverrideNote": "Suprascrierile cântărețului la nivel de cuvânt se aplică doar videoclipului de karaoke — rezultatul CDG folosește cântărețul principal al segmentului."
},
"toasts": {
- "customLyricsSaved": "Versurile personalizate au fost aplicate. Sincronizează manual fiecare segment editat pentru a te asigura că temporizarea cuvintelor este corectă pentru versurile personalizate."
+ "customLyricsSaved": "Versurile personalizate au fost aplicate. Sincronizează manual fiecare segment editat pentru a te asigura că temporizarea cuvintelor este corectă pentru versurile personalizate.",
+ "untimedWordsBlockSubmit": "{count, plural, one {# cuvânt din versuri nu are} few {# cuvinte din versuri nu au} other {# de cuvinte din versuri nu au}} încă sincronizare. Deschide sincronizatorul și apasă pe fiecare vers pe ritm înainte de a genera videoclipul."
},
"autoCorrect": {
"accept": "Acceptă sugestia",
@@ -1493,6 +1495,20 @@
"cancelSync": "Anulează",
"hold": "ȚINE...",
"tap": "APASĂ"
+ },
+ "missingLyrics": {
+ "description": "Vocea principală cântă aici, dar nu există versuri.",
+ "expectedFrom": "Versuri așteptate aici (din {source}):",
+ "insert": "Inserează aceste rânduri",
+ "insertedHint": "Deschide fiecare vers și folosește Tap To Sync astfel încât cuvintele să se potrivească cu vocea. Versurile fără timpi trebuie sincronizate înainte ca videoclipul să poată fi generat.",
+ "insertedTitle": "Verifică sincronizarea versurilor inserate",
+ "noLines": "Nu există rânduri de referință disponibile pentru această parte — adaugă versurile manual.",
+ "play": "Redă",
+ "readOnly": "Editarea este dezactivată în modul doar citire",
+ "syncTiming": "Sincronizează timpii",
+ "title": "Posibile versuri lipsă la {start}–{end}",
+ "dismiss": "Închide",
+ "pendingSync": "Aici au fost adăugate versuri, dar nu sunt încă sincronizate. Folosește Sincronizare timpi (Tap To Sync) înainte de a genera videoclipul."
}
},
"instrumentalReview": {
diff --git a/frontend/messages/ru.json b/frontend/messages/ru.json
index 8cc9ba2b..8ca6747b 100644
--- a/frontend/messages/ru.json
+++ b/frontend/messages/ru.json
@@ -985,7 +985,8 @@
"playFromGap": "Воспроизвести с конца этой паузы",
"editSegment": "Редактировать сегмент {index}",
"untimedSegment": "Нет таймингов слов — нажми, чтобы отредактировать",
- "waveforms": "Звуковые волны"
+ "waveforms": "Звуковые волны",
+ "missingLyricsMarker": "Возможно, пропущен текст {start}–{end}"
},
"editActionBar": {
"reset": "Сбросить",
@@ -1431,7 +1432,8 @@
"wordOverrideNote": "Переопределения исполнителя на уровне слов применяются только к караоке-видео — в формате CDG используется основной исполнитель сегмента."
},
"toasts": {
- "customLyricsSaved": "Свой текст применен. Синхронизируй каждый измененный сегмент вручную, чтобы тайминги слов точно совпадали с новым текстом."
+ "customLyricsSaved": "Свой текст применен. Синхронизируй каждый измененный сегмент вручную, чтобы тайминги слов точно совпадали с новым текстом.",
+ "untimedWordsBlockSubmit": "{count, plural, one {У # слова в тексте} few {У # слов в тексте} many {У # слов в тексте} other {У # слов в тексте}} ещё нет тайминга. Открой синхронизатор и нажимай на каждую строку в такт перед созданием видео."
},
"autoCorrect": {
"accept": "Принять правку",
@@ -1493,6 +1495,20 @@
"cancelSync": "Отмена",
"hold": "УДЕРЖИВАЙ...",
"tap": "НАЖМИ"
+ },
+ "missingLyrics": {
+ "description": "Здесь звучит основной вокал, но текста нет.",
+ "expectedFrom": "Здесь должен быть текст (из {source}):",
+ "insert": "Вставить эти строки",
+ "insertedHint": "Открой каждую строку и используй Tap To Sync, чтобы слова совпадали с вокалом. Строки без тайминга нужно синхронизировать перед генерацией видео.",
+ "insertedTitle": "Проверь тайминг вставленных строк",
+ "noLines": "Для этой части нет строк из источника — добавь текст вручную.",
+ "play": "Воспроизвести",
+ "readOnly": "Редактирование недоступно в режиме «только для чтения»",
+ "syncTiming": "Синхронизировать тайминг",
+ "title": "Возможно, пропущен текст на {start}–{end}",
+ "dismiss": "Скрыть",
+ "pendingSync": "Сюда добавлен текст песни, но тайминг ещё не задан. Используй синхронизацию тайминга (Tap To Sync) перед генерацией видео."
}
},
"instrumentalReview": {
diff --git a/frontend/messages/sk.json b/frontend/messages/sk.json
index 6edbda48..17e4e66e 100644
--- a/frontend/messages/sk.json
+++ b/frontend/messages/sk.json
@@ -985,7 +985,8 @@
"playFromGap": "Prehrať od konca tejto medzery",
"editSegment": "Uprav segment {index}",
"untimedSegment": "Žiadne časovanie slov — klikni pre úpravu",
- "waveforms": "Zvukové vlny"
+ "waveforms": "Zvukové vlny",
+ "missingLyricsMarker": "Možný chýbajúci text {start}–{end}"
},
"editActionBar": {
"reset": "Obnoviť",
@@ -1431,7 +1432,8 @@
"wordOverrideNote": "Úpravy speváka na úrovni slov sa aplikujú len na karaoke video — CDG výstup používa hlavného speváka segmentu."
},
"toasts": {
- "customLyricsSaved": "Vlastný text bol aplikovaný. Manuálne synchronizuj každý upravený segment, aby sa zabezpečilo správne načasovanie slov pre prispôsobený text."
+ "customLyricsSaved": "Vlastný text bol aplikovaný. Manuálne synchronizuj každý upravený segment, aby sa zabezpečilo správne načasovanie slov pre prispôsobený text.",
+ "untimedWordsBlockSubmit": "{count, plural, one {# slovo textu ešte nemá} few {# slová textu ešte nemajú} other {# slov textu ešte nemá}} časovanie. Otvor synchronizátor a pred vygenerovaním videa vyťukaj každý riadok do rytmu."
},
"autoCorrect": {
"accept": "Prijať návrh",
@@ -1493,6 +1495,20 @@
"cancelSync": "Zrušiť",
"hold": "DRŽ...",
"tap": "ŤUKNI"
+ },
+ "missingLyrics": {
+ "description": "Hlavný vokál tu spieva, ale nie je tu žiadny text.",
+ "expectedFrom": "Tu sa očakáva text (z {source}):",
+ "insert": "Vložiť tieto riadky",
+ "insertedHint": "Otvor každý riadok a použi funkciu Tap To Sync, aby slová sedeli so spevom. Riadky bez načasovania musíš pred vygenerovaním videa zosynchronizovať.",
+ "insertedTitle": "Skontroluj načasovanie vložených riadkov",
+ "noLines": "Pre túto časť nie sú k dispozícii žiadne referenčné riadky – pridaj text ručne.",
+ "play": "Prehrať",
+ "readOnly": "V režime len na čítanie sú úpravy zakázané",
+ "syncTiming": "Synchronizovať časovanie",
+ "title": "Možný chýbajúci text v čase {start}–{end}",
+ "dismiss": "Zavrieť",
+ "pendingSync": "Sem bol pridaný text piesne, ale zatiaľ nie je načasovaný. Pred vygenerovaním videa použi Synchronizovať časovanie (Tap To Sync)."
}
},
"instrumentalReview": {
diff --git a/frontend/messages/sv.json b/frontend/messages/sv.json
index a406bea5..5e5863b1 100644
--- a/frontend/messages/sv.json
+++ b/frontend/messages/sv.json
@@ -985,7 +985,8 @@
"playFromGap": "Spela upp från slutet av detta mellanrum",
"editSegment": "Redigera segment {index}",
"untimedSegment": "Ingen ordtajming — klicka för att redigera",
- "waveforms": "Vågformer"
+ "waveforms": "Vågformer",
+ "missingLyricsMarker": "Eventuellt saknad låttext {start}–{end}"
},
"editActionBar": {
"reset": "Återställ",
@@ -1431,7 +1432,8 @@
"wordOverrideNote": "Åsidosättningar av sångare på ordnivå gäller endast för karaokevideon — CDG-utdata använder segmentets huvudsakliga sångare."
},
"toasts": {
- "customLyricsSaved": "Anpassad låttext tillämpad. Synkronisera varje redigerat segment manuellt för att säkerställa att tajmingen stämmer för den anpassade låttexten."
+ "customLyricsSaved": "Anpassad låttext tillämpad. Synkronisera varje redigerat segment manuellt för att säkerställa att tajmingen stämmer för den anpassade låttexten.",
+ "untimedWordsBlockSubmit": "{count, plural, one {# ord i låttexten har} other {# ord i låttexten har}} ingen timing än. Öppna synkroniseraren och tryck på varje rad i takt med musiken innan du genererar videon."
},
"autoCorrect": {
"accept": "Acceptera förslag",
@@ -1493,6 +1495,20 @@
"cancelSync": "Avbryt",
"hold": "HÅLL IN...",
"tap": "TRYCK"
+ },
+ "missingLyrics": {
+ "description": "Här hörs leadsång men det finns ingen låttext.",
+ "expectedFrom": "Låttext förväntas här (från {source}):",
+ "insert": "Infoga dessa rader",
+ "insertedHint": "Öppna varje rad och använd Tap To Sync så att orden matchar sången. Rader utan timing måste synkas innan videon kan genereras.",
+ "insertedTitle": "Kontrollera timingen för de infogade raderna",
+ "noLines": "Inga referensrader finns tillgängliga för den här delen – lägg till låttexten manuellt.",
+ "play": "Spela",
+ "readOnly": "Redigering är inaktiverad i skrivskyddat läge",
+ "syncTiming": "Synka timing",
+ "title": "Eventuellt saknad låttext vid {start}–{end}",
+ "dismiss": "Avfärda",
+ "pendingSync": "Låttext har lagts till här men är inte tajmad än. Använd Synka timing (Tap To Sync) innan du genererar videon."
}
},
"instrumentalReview": {
diff --git a/frontend/messages/th.json b/frontend/messages/th.json
index 2e1dc5bf..e9a59aec 100644
--- a/frontend/messages/th.json
+++ b/frontend/messages/th.json
@@ -985,7 +985,8 @@
"playFromGap": "เล่นจากจุดสิ้นสุดของช่องว่างนี้",
"editSegment": "แก้ไขส่วนที่ {index}",
"untimedSegment": "ไม่มีการกำหนดเวลาคำ — คลิกเพื่อแก้ไข",
- "waveforms": "คลื่นเสียง"
+ "waveforms": "คลื่นเสียง",
+ "missingLyricsMarker": "อาจมีเนื้อเพลงตกหล่น {start}–{end}"
},
"editActionBar": {
"reset": "รีเซ็ต",
@@ -1431,7 +1432,8 @@
"wordOverrideNote": "การตั้งค่านักร้องระดับคำจะใช้กับวิดีโอคาราโอเกะเท่านั้น — ไฟล์ CDG จะใช้นักร้องหลักของท่อนนั้น"
},
"toasts": {
- "customLyricsSaved": "ใช้เนื้อเพลงที่กำหนดเองแล้ว โปรดซิงค์จังหวะของแต่ละท่อนที่แก้ไขด้วยตัวเอง เพื่อให้แน่ใจว่าจังหวะร้องตรงกับเนื้อเพลงใหม่"
+ "customLyricsSaved": "ใช้เนื้อเพลงที่กำหนดเองแล้ว โปรดซิงค์จังหวะของแต่ละท่อนที่แก้ไขด้วยตัวเอง เพื่อให้แน่ใจว่าจังหวะร้องตรงกับเนื้อเพลงใหม่",
+ "untimedWordsBlockSubmit": "{count, plural, one {มีคำในเนื้อเพลง # คำที่ยังไม่ได้กำหนดจังหวะ} other {มีคำในเนื้อเพลง # คำที่ยังไม่ได้กำหนดจังหวะ}} เปิดตัวซิงโครไนเซอร์แล้วแตะแต่ละบรรทัดให้ตรงจังหวะก่อนสร้างวิดีโอ"
},
"autoCorrect": {
"accept": "ยอมรับคำแนะนำ",
@@ -1493,6 +1495,20 @@
"cancelSync": "ยกเลิก",
"hold": "กดค้าง...",
"tap": "แตะ"
+ },
+ "missingLyrics": {
+ "description": "มีเสียงร้องหลักในช่วงนี้ แต่ไม่มีเนื้อเพลง",
+ "expectedFrom": "เนื้อเพลงที่ควรอยู่ตรงนี้ (จาก {source}):",
+ "insert": "แทรกท่อนเหล่านี้",
+ "insertedHint": "เปิดแต่ละบรรทัดแล้วใช้ Tap To Sync เพื่อให้เนื้อร้องตรงกับเสียงร้อง บรรทัดที่ยังไม่ได้กำหนดเวลาต้องซิงค์ก่อนจึงจะสามารถสร้างวิดีโอได้",
+ "insertedTitle": "ตรวจสอบจังหวะของบรรทัดที่แทรกเข้ามา",
+ "noLines": "ไม่มีเนื้อเพลงอ้างอิงสำหรับส่วนนี้ — โปรดเพิ่มเนื้อเพลงด้วยตนเอง",
+ "play": "เล่น",
+ "readOnly": "ไม่สามารถแก้ไขได้ในโหมดอ่านอย่างเดียว",
+ "syncTiming": "ซิงค์เวลา",
+ "title": "อาจมีเนื้อเพลงตกหล่นที่ {start}–{end}",
+ "dismiss": "ปิดทิ้ง",
+ "pendingSync": "เพิ่มเนื้อร้องตรงนี้แล้วแต่ยังไม่ได้กำหนดเวลา โปรดใช้การซิงค์จังหวะ (Tap To Sync) ก่อนสร้างวิดีโอ"
}
},
"instrumentalReview": {
diff --git a/frontend/messages/tl.json b/frontend/messages/tl.json
index 0d2c7945..d448b8b8 100644
--- a/frontend/messages/tl.json
+++ b/frontend/messages/tl.json
@@ -985,7 +985,8 @@
"playFromGap": "I-play mula sa dulo ng puwang na ito",
"editSegment": "I-edit ang segment {index}",
"untimedSegment": "Walang timing ng salita — i-click para i-edit",
- "waveforms": "Mga waveform"
+ "waveforms": "Mga waveform",
+ "missingLyricsMarker": "Posibleng may kulang na lyrics {start}–{end}"
},
"editActionBar": {
"reset": "I-reset",
@@ -1431,7 +1432,8 @@
"wordOverrideNote": "Ang mga word-level singer override ay para lang sa karaoke video — ginagamit ng CDG output ang pangunahing singer ng segment."
},
"toasts": {
- "customLyricsSaved": "Nailapat na ang custom na lyrics. I-sync nang manu-mano ang bawat na-edit na segment para masigurong maayos ang timing ng mga salita sa na-customize na lyrics."
+ "customLyricsSaved": "Nailapat na ang custom na lyrics. I-sync nang manu-mano ang bawat na-edit na segment para masigurong maayos ang timing ng mga salita sa na-customize na lyrics.",
+ "untimedWordsBlockSubmit": "{count, plural, one {# salita sa lyrics ang} other {# salita sa lyrics ang}} wala pang timing. Buksan ang synchronizer at i-tap ang bawat linya kasabay ng beat bago i-generate ang video."
},
"autoCorrect": {
"accept": "Tanggapin ang mungkahi",
@@ -1493,6 +1495,20 @@
"cancelSync": "Kanselahin",
"hold": "I-HOLD...",
"tap": "I-TAP"
+ },
+ "missingLyrics": {
+ "description": "Kumakanta ang lead vocal dito pero walang lyrics.",
+ "expectedFrom": "Inaasahang may lyrics dito (mula sa {source}):",
+ "insert": "I-insert ang mga linyang ito",
+ "insertedHint": "Buksan ang bawat linya at gamitin ang Tap To Sync para sumabay ang mga salita sa pagkanta. Kailangang i-sync ang mga linyang walang timing bago ma-generate ang video.",
+ "insertedTitle": "I-check ang timing ng mga idinagdag na linya",
+ "noLines": "Walang available na reference lines para sa bahaging ito — manu-manong idagdag ang lyrics.",
+ "play": "I-play",
+ "readOnly": "Naka-disable ang pag-edit sa read-only mode",
+ "syncTiming": "I-sync ang timing",
+ "title": "Posibleng may kulang na lyrics sa {start}–{end}",
+ "dismiss": "I-dismiss",
+ "pendingSync": "May idinagdag na lyrics dito pero wala pang timing. Gamitin ang Sync timing (Tap To Sync) bago i-generate ang video."
}
},
"instrumentalReview": {
diff --git a/frontend/messages/tr.json b/frontend/messages/tr.json
index e19f4d05..3ad1264f 100644
--- a/frontend/messages/tr.json
+++ b/frontend/messages/tr.json
@@ -985,7 +985,8 @@
"playFromGap": "Bu boşluğun sonundan itibaren oynat",
"editSegment": "{index}. bölümü düzenle",
"untimedSegment": "Kelime zamanlaması yok — düzenlemek için tıkla",
- "waveforms": "Dalga formları"
+ "waveforms": "Dalga formları",
+ "missingLyricsMarker": "Olası eksik şarkı sözleri {start}–{end}"
},
"editActionBar": {
"reset": "Sıfırla",
@@ -1431,7 +1432,8 @@
"wordOverrideNote": "Kelime düzeyindeki şarkıcı geçersiz kılmaları yalnızca karaoke videosuna uygulanır — CDG çıktısı bölümün ana şarkıcısını kullanır."
},
"toasts": {
- "customLyricsSaved": "Özel şarkı sözleri uygulandı. Özelleştirilmiş sözlerde kelime zamanlamalarının doğru olduğundan emin olmak için düzenlenen her bölümü manuel olarak senkronize et."
+ "customLyricsSaved": "Özel şarkı sözleri uygulandı. Özelleştirilmiş sözlerde kelime zamanlamalarının doğru olduğundan emin olmak için düzenlenen her bölümü manuel olarak senkronize et.",
+ "untimedWordsBlockSubmit": "{count, plural, one {# kelimenin} other {# kelimenin}} henüz zamanlaması yok. Videoyu oluşturmadan önce senkronizatörü aç ve her satıra ritme göre dokun."
},
"autoCorrect": {
"accept": "Öneriyi kabul et",
@@ -1493,6 +1495,20 @@
"cancelSync": "İptal",
"hold": "BASILI TUT...",
"tap": "DOKUN"
+ },
+ "missingLyrics": {
+ "description": "Ana vokal burada şarkı söylüyor ama şarkı sözü yok.",
+ "expectedFrom": "Burada şarkı sözü bekleniyor ({source} kaynağından):",
+ "insert": "Bu satırları ekle",
+ "insertedHint": "Her satırı aç ve kelimelerin şarkıyla hizalanması için Tap To Sync özelliğini kullan. Video oluşturulmadan önce zamanlaması olmayan satırların senkronize edilmesi gerekir.",
+ "insertedTitle": "Eklenen satırların zamanlamasını kontrol et",
+ "noLines": "Bu kısım için referans satır bulunmuyor — şarkı sözlerini manuel olarak ekle.",
+ "play": "Oynat",
+ "readOnly": "Salt okunur modda düzenleme devre dışıdır",
+ "syncTiming": "Zamanlamayı senkronize et",
+ "title": "{start}–{end} arasında olası eksik şarkı sözleri",
+ "dismiss": "Kapat",
+ "pendingSync": "Şarkı sözleri buraya eklendi ancak henüz zamanlanmadı. Videoyu oluşturmadan önce Zamanlamayı senkronize et (Tap To Sync) özelliğini kullan."
}
},
"instrumentalReview": {
diff --git a/frontend/messages/uk.json b/frontend/messages/uk.json
index b04d5ef0..5ba9a250 100644
--- a/frontend/messages/uk.json
+++ b/frontend/messages/uk.json
@@ -985,7 +985,8 @@
"playFromGap": "Відтворити з кінця цієї паузи",
"editSegment": "Редагувати сегмент {index}",
"untimedSegment": "Немає таймінгів слів — натисни, щоб редагувати",
- "waveforms": "Аудіохвилі"
+ "waveforms": "Аудіохвилі",
+ "missingLyricsMarker": "Можливо, пропущено текст {start}–{end}"
},
"editActionBar": {
"reset": "Скинути",
@@ -1431,7 +1432,8 @@
"wordOverrideNote": "Перевизначення виконавця на рівні слів застосовуються лише до караоке-відео — у файлі CDG використовується основний виконавець сегмента."
},
"toasts": {
- "customLyricsSaved": "Власний текст застосовано. Синхронізуй кожен відредагований сегмент вручну, щоб переконатися, що таймінги слів підходять для зміненого тексту."
+ "customLyricsSaved": "Власний текст застосовано. Синхронізуй кожен відредагований сегмент вручну, щоб переконатися, що таймінги слів підходять для зміненого тексту.",
+ "untimedWordsBlockSubmit": "{count, plural, one {# слово тексту ще не має} few {# слова тексту ще не мають} many {# слів тексту ще не мають} other {# слів тексту ще не мають}} таймінгу. Відкрий синхронізатор і натискай на кожен рядок у такт перед генерацією відео."
},
"autoCorrect": {
"accept": "Прийняти пропозицію",
@@ -1493,6 +1495,20 @@
"cancelSync": "Скасувати",
"hold": "УТРИМУЙ...",
"tap": "НАТИСНИ"
+ },
+ "missingLyrics": {
+ "description": "Тут звучить основний вокал, але тексту пісні немає.",
+ "expectedFrom": "Тут очікується текст (із {source}):",
+ "insert": "Вставити ці рядки",
+ "insertedHint": "Відкрий кожен рядок і скористайся Tap To Sync, щоб слова збігалися зі співом. Рядки без таймінгу потрібно синхронізувати перед генерацією відео.",
+ "insertedTitle": "Перевір таймінг вставлених рядків",
+ "noLines": "Для цієї частини немає еталонних рядків — додай текст вручну.",
+ "play": "Відтворити",
+ "readOnly": "Редагування вимкнено в режимі лише для читання",
+ "syncTiming": "Синхронізувати таймінг",
+ "title": "Можливо, пропущено текст на {start}–{end}",
+ "dismiss": "Закрити",
+ "pendingSync": "Сюди додано текст пісні, але для нього ще не налаштовано таймінг. Скористайся синхронізацією таймінгу (Tap To Sync) перед генерацією відео."
}
},
"instrumentalReview": {
diff --git a/frontend/messages/vi.json b/frontend/messages/vi.json
index 2c0b4c47..f88d2a8e 100644
--- a/frontend/messages/vi.json
+++ b/frontend/messages/vi.json
@@ -985,7 +985,8 @@
"playFromGap": "Phát từ cuối khoảng trống này",
"editSegment": "Chỉnh sửa đoạn {index}",
"untimedSegment": "Chưa căn thời gian chữ — nhấp để chỉnh sửa",
- "waveforms": "Dạng sóng"
+ "waveforms": "Dạng sóng",
+ "missingLyricsMarker": "Có thể thiếu lời bài hát {start}–{end}"
},
"editActionBar": {
"reset": "Đặt lại",
@@ -1431,7 +1432,8 @@
"wordOverrideNote": "Các ghi đè ca sĩ cấp độ từ chỉ áp dụng cho video karaoke — đầu ra CDG sử dụng ca sĩ chính của đoạn."
},
"toasts": {
- "customLyricsSaved": "Đã áp dụng lời bài hát tùy chỉnh. Hãy đồng bộ hóa thủ công từng phân đoạn đã chỉnh sửa để đảm bảo nhịp điệu hiển thị từ khớp với lời bài hát tùy chỉnh."
+ "customLyricsSaved": "Đã áp dụng lời bài hát tùy chỉnh. Hãy đồng bộ hóa thủ công từng phân đoạn đã chỉnh sửa để đảm bảo nhịp điệu hiển thị từ khớp với lời bài hát tùy chỉnh.",
+ "untimedWordsBlockSubmit": "{count, plural, one {# từ trong lời bài hát} other {# từ trong lời bài hát}} chưa được khớp thời gian. Bạn hãy mở trình đồng bộ và nhấn từng dòng theo nhịp trước khi tạo video."
},
"autoCorrect": {
"accept": "Chấp nhận đề xuất",
@@ -1493,6 +1495,20 @@
"cancelSync": "Hủy",
"hold": "GIỮ...",
"tap": "CHẠM"
+ },
+ "missingLyrics": {
+ "description": "Đoạn này có giọng hát chính nhưng không có lời bài hát.",
+ "expectedFrom": "Lời bài hát dự kiến cho đoạn này (từ {source}):",
+ "insert": "Chèn các dòng này",
+ "insertedHint": "Mở từng dòng và dùng Tap To Sync để các từ khớp với giọng hát. Bạn cần đồng bộ các dòng chưa có mốc thời gian trước khi có thể tạo video.",
+ "insertedTitle": "Kiểm tra mốc thời gian của các dòng đã chèn",
+ "noLines": "Không có dòng tham chiếu nào cho đoạn này — bạn hãy tự thêm lời bài hát.",
+ "play": "Phát",
+ "readOnly": "Không thể chỉnh sửa ở chế độ chỉ đọc",
+ "syncTiming": "Đồng bộ thời gian",
+ "title": "Có thể thiếu lời bài hát tại {start}–{end}",
+ "dismiss": "Bỏ qua",
+ "pendingSync": "Lời bài hát đã được thêm vào đây nhưng chưa có mốc thời gian. Bạn hãy dùng tính năng Đồng bộ thời gian (Tap To Sync) trước khi tạo video."
}
},
"instrumentalReview": {
diff --git a/frontend/messages/zh.json b/frontend/messages/zh.json
index 230da92f..ba11c685 100644
--- a/frontend/messages/zh.json
+++ b/frontend/messages/zh.json
@@ -985,7 +985,8 @@
"playFromGap": "从该间隙的末尾开始播放",
"editSegment": "编辑片段 {index}",
"untimedSegment": "无单词时间轴 — 点击编辑",
- "waveforms": "波形图"
+ "waveforms": "波形图",
+ "missingLyricsMarker": "可能缺失歌词 {start}–{end}"
},
"editActionBar": {
"reset": "重置",
@@ -1431,7 +1432,8 @@
"wordOverrideNote": "词级歌手覆盖设置仅适用于卡拉OK视频 — CDG 输出将使用该片段的主要歌手。"
},
"toasts": {
- "customLyricsSaved": "已应用自定义歌词。请手动同步每个编辑过的片段,以确保自定义歌词的每个词都能准确同步。"
+ "customLyricsSaved": "已应用自定义歌词。请手动同步每个编辑过的片段,以确保自定义歌词的每个词都能准确同步。",
+ "untimedWordsBlockSubmit": "{count, plural, one {还有 # 个歌词字词} other {还有 # 个歌词字词}}尚未设置时间。在生成视频前,请打开同步器并跟随节拍点击每一行。"
},
"autoCorrect": {
"accept": "接受建议",
@@ -1493,6 +1495,20 @@
"cancelSync": "取消",
"hold": "按住...",
"tap": "点击"
+ },
+ "missingLyrics": {
+ "description": "主唱在此处有演唱,但没有歌词。",
+ "expectedFrom": "此处应有歌词(来自 {source}):",
+ "insert": "插入这些歌词",
+ "insertedHint": "展开每一行并使用 Tap To Sync,使歌词与演唱完美对齐。未设定时间轴的行必须先完成同步,才能生成视频。",
+ "insertedTitle": "检查已插入歌词行的时间轴",
+ "noLines": "此部分没有可用的参考歌词——请手动添加歌词。",
+ "play": "播放",
+ "readOnly": "只读模式下无法编辑",
+ "syncTiming": "同步时间",
+ "title": "{start}–{end} 处可能缺失歌词",
+ "dismiss": "忽略",
+ "pendingSync": "此处已添加歌词,但尚未设定时间轴。在生成视频前,请先使用“同步时间轴 (Tap To Sync)”。"
}
},
"instrumentalReview": {
diff --git a/pyproject.toml b/pyproject.toml
index 1cbcd5f6..ae16eb31 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,6 +1,6 @@
[tool.poetry]
name = "karaoke-gen"
-version = "0.258.0"
+version = "0.259.0"
description = "Generate karaoke videos with synchronized lyrics. Handles the entire process from downloading audio and lyrics to creating the final video with title screens."
authors = ["Andrew Beveridge "]
license = "MIT"