diff --git a/CLAUDE.md b/CLAUDE.md
index bb5c7a1..4c90446 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -85,7 +85,7 @@ One-liners + doc pointer. For everything else read the actual file in `commands/
 
 ### Playback ([`docs/features/playback.md`](docs/features/playback.md))
 
-A-B repeat · crossfade (static / smart-album-aware / dynamic-tempo-aware) · gapless · ReplayGain · normalize · mono · 6-band peaking EQ (RBJ biquads, ±12 dB, 20 presets) · playback speed 0.5×–2× (resampler-shift, pitch follows) · DSD → PCM (256-tap Blackman-Harris FIR) · WASAPI Exclusive opt-in (Windows) with transparent fallback to cpal shared · spectrum visualizer (2048-pt FFT, opt-in) · output device persistence + cpal 0.17 friendly-name disambiguation · radio (seed + similar artists + BPM filter) · mood radio (focus/chill/workout/party/sleep) · sleep timer · TXXX:UNSYNCEDLYRICS fallback for MP3 K-Pop/J-Pop rips.
+A-B repeat · crossfade (static / smart-album-aware / dynamic-tempo-aware) · gapless · ReplayGain · normalize · mono · 6-band peaking EQ (RBJ biquads, ±12 dB, 20 presets) · playback speed 0.5×–2× (resampler-shift, pitch follows) · DSD → PCM (256-tap Blackman-Harris FIR) · WASAPI Exclusive opt-in (Windows) with transparent fallback to cpal shared · spectrum visualizer (2048-pt FFT, opt-in) · output device persistence + cpal 0.17 friendly-name disambiguation · radio (seed + similar artists + BPM filter) · mood radio (focus/chill/workout/party/sleep) · sleep timer · TXXX:UNSYNCEDLYRICS fallback for MP3 K-Pop/J-Pop rips · word-level karaoke lyrics (Enhanced LRC + TTML parse, mot-à-mot capture in the editor).
 
 ### Library ([`docs/features/library.md`](docs/features/library.md))
 
diff --git a/docs/features/integrations.md b/docs/features/integrations.md
index 85ce4e0..2feae93 100644
--- a/docs/features/integrations.md
+++ b/docs/features/integrations.md
@@ -126,3 +126,32 @@ UI is [`LyricsEditorModal`](../../src/components/common/LyricsEditorModal.tsx) o
 **Library-wide prefetch.** `prefetch_library_lyrics` walks every available track without a cached row (deduped by `file_hash`), runs the embedded → LRCLIB chain, and persists each hit. Network calls are throttled at 500 ms (~2 req/s) to be a polite guest; embedded hits skip the throttle. Progress streams over `lyrics:prefetch-progress`. A single global run is enforced via an `AtomicBool`; `cancel_lyrics_prefetch` flips a second `AtomicBool` the worker checks per iteration. Resumable — a partial cancel just leaves uncached rows for the next run.
 
 The lyrics panel renders synced lines with auto-scroll and a 200 ms transition; un-synced lyrics fall back to a static block.
+
+### Word-level lyrics (Enhanced LRC + TTML)
+
+WaveFlow recognises two word-timed formats in addition to plain LRC:
+
+- **Enhanced LRC** — `[mm:ss.xx]La <mm:ss.xx>nuit <mm:ss.xx>tombe`. Plain-text extension of the LRC ecosystem; round-trips cleanly through `USLT` so other players see it as regular synced LRC if they don't parse the inline word stamps.
+- **TTML** (Apple Music) — XML envelope with `<p begin="…" end="…"><span begin="…" end="…">word</span></p>`. Imported from `.ttml` / `.xml` files exported by tools like LyricsX. Char-level spans nested inside word spans are folded into their parent — v1 ships with word-level animation only.
+
+**Detection** — [`commands/lyrics.rs::detect_format`](../../src-tauri/src/commands/lyrics.rs) sniffs the cached content. TTML matches first on `<?xml`, `<tt`, or the `http://www.w3.org/ns/ttml` namespace. Enhanced LRC requires both a `[mm:ss…]` line stamp and at least one `<mm:ss…>` word stamp inside the line body; falling back to plain LRC otherwise. The same heuristic runs on the editor's save path so user-typed content gets re-classified if they switch between modes.
+
+**Storage** — `app.lyrics.format` accepts the new `'ttml'` value via [migration 20260516120000_lyrics_ttml_format.sql](../../src-tauri/migrations/app/20260516120000_lyrics_ttml_format.sql) (CHECK rebuild — SQLite has no ALTER CONSTRAINT). The `content` column stays raw text — there's no separate `words` column; parsing is done at render time on the frontend. This keeps the cache byte-for-byte identical to what would be written into the tag and avoids a hot migration over user data.
+
+**Parsing** — `src/lib/tauri/lyrics.ts` exposes `parseLrc`, `parseEnhancedLrc`, `parseTtml`, and a unifying `parseLyrics(content, format)` dispatcher. All three return the same `LyricsLine` shape (`timeMs`, `endMs`, `text`, optional `words[]`). The TTML parser uses the webview's built-in `DOMParser` — no XML dependency. `findActiveWordIndex` mirrors `findActiveLineIndex` (linear scan from hint, O(1) amortised).
+
+**Rendering** — [`LyricsPanel`](../../src/components/layout/LyricsPanel.tsx) and [`FullscreenLyrics`](../../src/components/player/FullscreenLyrics.tsx) share the same active-word animation: 150 ms transitions on color / opacity / transform, `scale(1.04)` on the active word, and a 0.45 → 0.8 → 1 opacity ramp for future / past / active words. The panel adds an accent-color tint that the fullscreen view leaves out (the white-on-dark contrast is enough there). Lines without `words` keep the existing line-level highlight.
+
+**Editor — word mode.** [`LyricsEditorModal`](../../src/components/common/LyricsEditorModal.tsx) adds a granularity toggle inside the synchronized tab. In word mode:
+
+- **Space** — stamps the next un-captured word in the active line. First press also stamps the line's own `timeMs` if it's not yet captured.
+- **Enter** — advances to the next line (appending a fresh empty one at the end, like line mode).
+- **Backspace** — undoes the last word capture on the active line.
+
+The row UI shows each word as a chip — pink for captured, green-ringed for the next word to capture, grey for future words. Editing a line's text invalidates its word tokenisation, so the user has to re-capture cleanly. The save path serialises back to Enhanced LRC via `serializeEnhancedLrc` regardless of the originally-imported format (TTML round-trip isn't part of v1).
+
+**TTML → USLT.** The audio file's `USLT` frame is plain-text by spec, so writing TTML into it would corrupt other players. `write_lyrics_to_file` therefore:
+
+- Plain / LRC / Enhanced LRC → `ItemKey::UnsyncLyrics` (USLT for ID3v2, UNSYNCEDLYRICS for Vorbis, `©lyr` for MP4) — unchanged.
+- TTML on Vorbis / MP4 / FLAC → `ItemKey::Lyrics` (the XML-friendly key).
+- TTML on MP3 — **skipped**. lofty has no clean ID3v2 mapping for arbitrary XML lyrics, so the file is left untouched, the DB cache still gets the TTML content, and `save_lyrics` returns `tag_write_skipped: true`. The editor surfaces this as a `lyrics.toast.tagWriteSkipped` warning so the user knows the file itself wasn't touched.
diff --git a/src-tauri/migrations/app/20260516120000_lyrics_ttml_format.sql b/src-tauri/migrations/app/20260516120000_lyrics_ttml_format.sql
new file mode 100644
index 0000000..3a44f95
--- /dev/null
+++ b/src-tauri/migrations/app/20260516120000_lyrics_ttml_format.sql
@@ -0,0 +1,28 @@
+-- =============================================================================
+-- Extend the lyrics.format CHECK constraint to accept the new 'ttml' value.
+--
+-- The original 20260413000000_metadata_caches.sql migration created the
+-- table with `CHECK (format IN ('plain','lrc','enhanced_lrc'))`. SQLite has
+-- no ALTER for CHECK constraints, so we rebuild the table: create a clone
+-- with the broader CHECK, copy the rows, drop the original, rename.
+--
+-- No existing rows need transformation — both 'plain', 'lrc' and
+-- 'enhanced_lrc' remain valid, and 'ttml' simply becomes a new accepted
+-- value that the parser can now emit.
+-- =============================================================================
+
+CREATE TABLE lyrics_new (
+    file_hash       TEXT PRIMARY KEY,
+    content         TEXT NOT NULL,
+    format          TEXT NOT NULL CHECK (format IN ('plain','lrc','enhanced_lrc','ttml')),
+    source          TEXT NOT NULL CHECK (source IN ('embedded','lrc_file','api','manual')),
+    language        TEXT,
+    fetched_at      INTEGER NOT NULL
+);
+
+INSERT INTO lyrics_new (file_hash, content, format, source, language, fetched_at)
+SELECT file_hash, content, format, source, language, fetched_at
+FROM lyrics;
+
+DROP TABLE lyrics;
+ALTER TABLE lyrics_new RENAME TO lyrics;
diff --git a/src-tauri/src/commands/lyrics.rs b/src-tauri/src/commands/lyrics.rs
index 3dc90d8..c651e4f 100644
--- a/src-tauri/src/commands/lyrics.rs
+++ b/src-tauri/src/commands/lyrics.rs
@@ -47,14 +47,15 @@ fn now_ms() -> i64 {
 /// Format flags returned to the frontend.
 ///
 /// `Plain` = unsynced text. `Lrc` = `[mm:ss.xx]`-prefixed lines.
-/// `EnhancedLrc` is the per-word timed variant; we accept it from
-/// imports but don't currently produce it.
-#[derive(Debug, Clone, Serialize)]
+/// `EnhancedLrc` is the per-word timed variant (`[00:01.00]Hello <00:01.50>world`).
+/// `Ttml` is Apple-Music-style XML with `<span begin="…" end="…">` word timing.
+#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
 #[serde(rename_all = "snake_case")]
 pub enum LyricsFormat {
     Plain,
     Lrc,
     EnhancedLrc,
+    Ttml,
 }
 
 #[derive(Debug, Clone, Serialize)]
@@ -72,12 +73,21 @@ pub struct LyricsPayload {
     pub content: String,
     pub format: LyricsFormat,
     pub source: LyricsSource,
+    /// Set by `save_lyrics` when `write_to_file` was requested but the
+    /// audio file's tag system can't carry the chosen format (e.g.
+    /// TTML in an MP3's ID3v2 where lofty has no mapping for the
+    /// XML-friendly `ItemKey::Lyrics`). DB cache is still updated; the
+    /// UI surfaces a toast so the user knows the file itself wasn't
+    /// touched. Absent on every other return path.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub tag_write_skipped: Option<bool>,
 }
 
 fn parse_format(s: &str) -> LyricsFormat {
     match s {
         "lrc" => LyricsFormat::Lrc,
         "enhanced_lrc" => LyricsFormat::EnhancedLrc,
+        "ttml" => LyricsFormat::Ttml,
         _ => LyricsFormat::Plain,
     }
 }
@@ -91,30 +101,121 @@ fn parse_source(s: &str) -> LyricsSource {
     }
 }
 
-/// Heuristic: any line starting with `[mm:ss` (zero-padded or not) is
-/// treated as LRC. We don't try to detect enhanced LRC from text — if
-/// you imported `.lrc` from a "enhanced" source, pass the format
-/// explicitly via [`import_lrc_file`].
+/// Heuristic format sniffer.
+///
+/// Order matters: TTML (XML envelope) is checked first because its
+/// `<p begin="...">` could otherwise look like nothing else, then
+/// Enhanced LRC (LRC with inline `<mm:ss.xx>` word stamps), then
+/// plain LRC, then unsynced text.
 fn detect_format(content: &str) -> LyricsFormat {
-    let has_timestamp = content.lines().take(20).any(|line| {
-        let line = line.trim_start();
-        line.starts_with('[')
+    let head = content.trim_start();
+
+    // TTML: XML declaration, root `<tt`, or the TTML namespace anywhere
+    // in the first ~512 bytes. Apple Music's exported lyrics start with
+    // `<?xml version="1.0"...`, LyricsX-style exports start with `<tt`.
+    let head_lower_prefix: String = head
+        .chars()
+        .take(512)
+        .collect::<String>()
+        .to_ascii_lowercase();
+    if head_lower_prefix.starts_with("<?xml")
+        || head_lower_prefix.starts_with("<tt ")
+        || head_lower_prefix.starts_with("<tt>")
+        || head_lower_prefix.contains("xmlns=\"http://www.w3.org/ns/ttml\"")
+        || head_lower_prefix.contains("<timedtext")
+    {
+        return LyricsFormat::Ttml;
+    }
+
+    // Scan up to 40 lines (first lines may be `[ar:Artist]` / `[ti:…]`
+    // LRC headers before the synced body starts).
+    let mut has_line_stamp = false;
+    let mut has_word_stamp = false;
+    for raw in content.lines().take(40) {
+        let line = raw.trim_start();
+        // Line stamp: `[mm:ss` with both digits present.
+        if line.starts_with('[')
             && line.len() >= 7
             && line[1..].chars().take(2).all(|c| c.is_ascii_digit())
             && line.as_bytes().get(3) == Some(&b':')
-    });
-    if has_timestamp {
+        {
+            has_line_stamp = true;
+            // Inline word stamp: `<mm:ss(.xx)?>` somewhere after the
+            // first `]`. We scan the byte string directly to keep this
+            // cheap for large libraries.
+            if let Some(close) = line.find(']') {
+                let body = &line[close + 1..];
+                if word_stamp_present(body) {
+                    has_word_stamp = true;
+                    break;
+                }
+            }
+        }
+    }
+
+    if has_word_stamp {
+        LyricsFormat::EnhancedLrc
+    } else if has_line_stamp {
         LyricsFormat::Lrc
     } else {
         LyricsFormat::Plain
     }
 }
 
+/// Return true if `s` contains at least one `<\d+:\d+(\.\d+)?>` token —
+/// the Enhanced LRC word-stamp shape. Hand-rolled (no regex dep) to
+/// keep `detect_format` allocation-free on the hot prefetch path.
+fn word_stamp_present(s: &str) -> bool {
+    let bytes = s.as_bytes();
+    let mut i = 0;
+    while i < bytes.len() {
+        if bytes[i] == b'<' {
+            let mut j = i + 1;
+            // Need at least one digit, then ':', then one digit, then '>'.
+            let digits1 = scan_digits(bytes, j);
+            if digits1 > 0 {
+                j += digits1;
+                if bytes.get(j) == Some(&b':') {
+                    j += 1;
+                    let digits2 = scan_digits(bytes, j);
+                    if digits2 > 0 {
+                        j += digits2;
+                        // Optional fractional `.xx` or `:xx`.
+                        if matches!(bytes.get(j), Some(b'.') | Some(b':')) {
+                            j += 1;
+                            let frac = scan_digits(bytes, j);
+                            j += frac;
+                        }
+                        if bytes.get(j) == Some(&b'>') {
+                            return true;
+                        }
+                    }
+                }
+            }
+        }
+        i += 1;
+    }
+    false
+}
+
+fn scan_digits(bytes: &[u8], start: usize) -> usize {
+    let mut n = 0;
+    while let Some(&b) = bytes.get(start + n) {
+        if b.is_ascii_digit() {
+            n += 1;
+        } else {
+            break;
+        }
+    }
+    n
+}
+
 fn format_to_db(fmt: &LyricsFormat) -> &'static str {
     match fmt {
         LyricsFormat::Plain => "plain",
         LyricsFormat::Lrc => "lrc",
         LyricsFormat::EnhancedLrc => "enhanced_lrc",
+        LyricsFormat::Ttml => "ttml",
     }
 }
 
@@ -259,6 +360,7 @@ async fn read_cached(pool: &sqlx::SqlitePool, track_id: i64) -> AppResult<Option
         content,
         format: parse_format(&fmt),
         source: parse_source(&src),
+        tag_write_skipped: None,
     }))
 }
 
@@ -349,6 +451,7 @@ pub async fn fetch_lyrics(
             content,
             format,
             source,
+            tag_write_skipped: None,
         }));
     }
 
@@ -394,6 +497,7 @@ pub async fn fetch_lyrics(
                 content: empty,
                 format: LyricsFormat::Plain,
                 source: LyricsSource::Api,
+                tag_write_skipped: None,
             }));
         }
         Err(err) => {
@@ -423,6 +527,7 @@ pub async fn fetch_lyrics(
             content: empty,
             format: LyricsFormat::Plain,
             source: LyricsSource::Api,
+            tag_write_skipped: None,
         }));
     }
 
@@ -448,6 +553,7 @@ pub async fn fetch_lyrics(
                 content: empty,
                 format: LyricsFormat::Plain,
                 source: LyricsSource::Api,
+                tag_write_skipped: None,
             }));
         }
     };
@@ -459,6 +565,7 @@ pub async fn fetch_lyrics(
         content,
         format,
         source,
+        tag_write_skipped: None,
     }))
 }
 
@@ -495,6 +602,7 @@ pub async fn import_lrc_file(
         content: trimmed.to_string(),
         format,
         source,
+        tag_write_skipped: None,
     })
 }
 
@@ -752,15 +860,17 @@ pub fn cancel_lyrics_prefetch() -> bool {
 
 // ── User-edited lyrics ──────────────────────────────────────────────
 
-/// Format hint coming from the in-app editor. The frontend always
-/// passes "plain" or "lrc" — the backend re-runs `detect_format` on
-/// the content as a safety net so a mistyped header still ends up in
-/// the right bucket.
+/// Format hint coming from the in-app editor. The frontend can pass
+/// "plain", "lrc", "enhanced_lrc" or "ttml" — the backend re-runs
+/// `detect_format` on the content as a safety net so a mistyped header
+/// still ends up in the right bucket.
 #[derive(Debug, Deserialize)]
 #[serde(rename_all = "snake_case")]
 pub enum LyricsSaveFormat {
     Plain,
     Lrc,
+    EnhancedLrc,
+    Ttml,
 }
 
 #[derive(Debug, Deserialize)]
@@ -807,17 +917,20 @@ pub async fn save_lyrics(
         .to_string();
     // Re-detect from content so a "plain" payload with [mm:ss] stamps
     // is correctly stored as lrc, and vice versa. The frontend hint is
-    // the user's intent, but content is the source of truth.
+    // the user's intent, but content is the source of truth — except
+    // when the user explicitly picked Plain (we never auto-promote to
+    // a synced format) or Ttml (which the detector also catches but we
+    // honour the explicit choice).
     let detected = detect_format(&trimmed);
-    let format = match (&payload.format, &detected) {
-        // Trust the user when they picked Plain even if their text
-        // happens to start with [...]; otherwise pick whichever of
-        // Lrc / EnhancedLrc the parser identified.
-        (LyricsSaveFormat::Plain, LyricsFormat::Plain) => LyricsFormat::Plain,
-        (LyricsSaveFormat::Plain, _) => LyricsFormat::Plain,
-        (LyricsSaveFormat::Lrc, _) => detected,
+    let format = match &payload.format {
+        LyricsSaveFormat::Plain => LyricsFormat::Plain,
+        LyricsSaveFormat::Ttml => LyricsFormat::Ttml,
+        // For Lrc / EnhancedLrc the detector picks between Lrc,
+        // EnhancedLrc and Plain (if the user cleared every stamp).
+        LyricsSaveFormat::Lrc | LyricsSaveFormat::EnhancedLrc => detected,
     };
 
+    let mut tag_write_skipped = false;
     if payload.write_to_file {
         let active = engine
             .shared()
@@ -830,34 +943,41 @@ pub async fn save_lyrics(
 
         let path = std::path::PathBuf::from(&file_path);
         let content_for_write = trimmed.clone();
-        tokio::task::spawn_blocking(move || write_lyrics_to_file(&path, &content_for_write))
-            .await
-            .map_err(|e| AppError::Other(format!("lyrics write panicked: {e}")))?
-            .map_err(|e| AppError::Other(format!("lyrics tag write failed: {e}")))?;
-
-        // The file changed — recompute its blake3 hash so the cache
-        // row stays addressable. We update the track row + the lyrics
-        // row in the same transaction below.
-        let path_for_hash = file_path.clone();
-        let new_hash = tokio::task::spawn_blocking(move || hash_file_blake3(&path_for_hash))
-            .await
-            .map_err(|e| AppError::Other(format!("rehash panicked: {e}")))??;
-
-        let mut tx = pool.begin().await?;
-        sqlx::query("UPDATE track SET file_hash = ? WHERE id = ?")
-            .bind(&new_hash)
-            .bind(track_id)
-            .execute(&mut *tx)
-            .await?;
-        // Drop any cache row keyed on the old hash so we don't end up
-        // with a stale embedded payload pointing at the previous
-        // content.
-        sqlx::query("DELETE FROM app.lyrics WHERE file_hash = ?")
-            .bind(&file_hash)
-            .execute(&mut *tx)
-            .await?;
-        tx.commit().await?;
-        file_hash = new_hash;
+        let format_for_write = format.clone();
+        let written = tokio::task::spawn_blocking(move || {
+            write_lyrics_to_file(&path, &content_for_write, &format_for_write)
+        })
+        .await
+        .map_err(|e| AppError::Other(format!("lyrics write panicked: {e}")))?
+        .map_err(|e| AppError::Other(format!("lyrics tag write failed: {e}")))?;
+
+        if written {
+            // The file changed — recompute its blake3 hash so the cache
+            // row stays addressable. We update the track row + the
+            // lyrics row in the same transaction below.
+            let path_for_hash = file_path.clone();
+            let new_hash = tokio::task::spawn_blocking(move || hash_file_blake3(&path_for_hash))
+                .await
+                .map_err(|e| AppError::Other(format!("rehash panicked: {e}")))??;
+
+            let mut tx = pool.begin().await?;
+            sqlx::query("UPDATE track SET file_hash = ? WHERE id = ?")
+                .bind(&new_hash)
+                .bind(track_id)
+                .execute(&mut *tx)
+                .await?;
+            // Drop any cache row keyed on the old hash so we don't end
+            // up with a stale embedded payload pointing at the previous
+            // content.
+            sqlx::query("DELETE FROM app.lyrics WHERE file_hash = ?")
+                .bind(&file_hash)
+                .execute(&mut *tx)
+                .await?;
+            tx.commit().await?;
+            file_hash = new_hash;
+        } else {
+            tag_write_skipped = true;
+        }
     }
 
     let source = LyricsSource::Manual;
@@ -869,6 +989,7 @@ pub async fn save_lyrics(
         content: trimmed,
         format,
         source,
+        tag_write_skipped: if tag_write_skipped { Some(true) } else { None },
     })
 }
 
@@ -877,18 +998,36 @@ fn hash_file_blake3(path: &str) -> AppResult<String> {
     Ok(blake3::hash(&bytes).to_hex().to_string())
 }
 
-/// Write the unsynchronized lyrics back into the audio file. Uses
-/// `ItemKey::UnsyncLyrics` (USLT for ID3v2, UNSYNCEDLYRICS for Vorbis,
-/// `©lyr` for MP4). Empty content removes the frame entirely so the
-/// file doesn't carry a phantom "" lyric tag.
+/// Write the lyrics back into the audio file's tag.
+///
+/// - Plain / LRC / Enhanced LRC → `ItemKey::UnsyncLyrics` (USLT for
+///   ID3v2, UNSYNCEDLYRICS for Vorbis, `©lyr` for MP4). All three are
+///   plain ASCII-safe text formats.
+/// - TTML → `ItemKey::Lyrics` for tag systems that accept arbitrary
+///   strings (Vorbis comments, MP4 `©lyr`). ID3v2 has no clean mapping
+///   for XML lyrics in lofty, so for MP3 we skip the file write and
+///   return `Ok(false)` — the DB cache still gets updated and the UI
+///   surfaces a toast so the user knows their TTML stays in-app only.
+///
+/// Returns `Ok(true)` when the tag was rewritten on disk, `Ok(false)`
+/// when the write was intentionally skipped (TTML on a format that
+/// can't carry it).
 fn write_lyrics_to_file(
     path: &Path,
     content: &str,
-) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
-    use lofty::file::{AudioFile, TaggedFileExt};
+    format: &LyricsFormat,
+) -> Result<bool, Box<dyn std::error::Error + Send + Sync>> {
+    use lofty::file::{AudioFile, FileType, TaggedFileExt};
     use lofty::tag::Tag;
 
     let mut tagged = lofty::read_from_path(path)?;
+    let file_type = tagged.file_type();
+
+    // Bail before touching tags when TTML hits an ID3v2-only container.
+    if matches!(format, LyricsFormat::Ttml) && file_type == FileType::Mpeg {
+        return Ok(false);
+    }
+
     if tagged.primary_tag().is_none() && tagged.first_tag().is_none() {
         let preferred = tagged.primary_tag_type();
         tagged.insert_tag(Tag::new(preferred));
@@ -899,18 +1038,28 @@ fn write_lyrics_to_file(
         tagged.first_tag_mut().ok_or("no tag")?
     };
 
-    if content.trim().is_empty() {
-        tag.remove_key(ItemKey::UnsyncLyrics);
-        tag.remove_key(ItemKey::Lyrics);
-    } else {
-        // insert_text overwrites any existing item with the same key.
-        // For ID3v2 this writes a USLT frame; for Vorbis it writes
-        // UNSYNCEDLYRICS; for MP4 it writes ©lyr.
-        tag.insert_text(ItemKey::UnsyncLyrics, content.to_string());
+    // Always purge both keys before writing so that switching format
+    // (e.g. plain LRC → TTML) doesn't leave a stale entry under the
+    // other key. `read_embedded_lyrics` checks UnsyncLyrics first and
+    // Lyrics second — without this clear the old content would shadow
+    // the new format on the next fetch.
+    tag.remove_key(ItemKey::UnsyncLyrics);
+    tag.remove_key(ItemKey::Lyrics);
+
+    if !content.trim().is_empty() {
+        // TTML on a container that supports `ItemKey::Lyrics` (Vorbis /
+        // MP4 / FLAC). Other formats stay in USLT, which is what every
+        // other player expects.
+        let key = if matches!(format, LyricsFormat::Ttml) {
+            ItemKey::Lyrics
+        } else {
+            ItemKey::UnsyncLyrics
+        };
+        tag.insert_text(key, content.to_string());
     }
 
     tagged.save_to_path(path, lofty::config::WriteOptions::default())?;
-    Ok(())
+    Ok(true)
 }
 
 /// Drop the cached lyrics row so the next fetch re-runs the waterfall.
@@ -926,3 +1075,72 @@ pub async fn clear_lyrics(state: tauri::State<'_, AppState>, track_id: i64) -> A
     .await?;
     Ok(())
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn detect_format_plain() {
+        let sample = "This is just\nsome text without any timestamps.";
+        assert_eq!(detect_format(sample), LyricsFormat::Plain);
+    }
+
+    #[test]
+    fn detect_format_lrc() {
+        let sample = "[ar:Some Artist]\n[ti:Some Title]\n[00:01.00]First line\n[00:05.50]Second line";
+        assert_eq!(detect_format(sample), LyricsFormat::Lrc);
+    }
+
+    #[test]
+    fn detect_format_enhanced_lrc() {
+        let sample =
+            "[00:01.00]<00:01.00>Hello <00:01.50>world\n[00:03.00]<00:03.00>Another <00:03.40>line";
+        assert_eq!(detect_format(sample), LyricsFormat::EnhancedLrc);
+    }
+
+    #[test]
+    fn detect_format_enhanced_lrc_no_colon_frac() {
+        let sample = "[00:01.00]<00:01>plain stamps still count";
+        assert_eq!(detect_format(sample), LyricsFormat::EnhancedLrc);
+    }
+
+    #[test]
+    fn detect_format_ttml_xml_decl() {
+        let sample = r#"<?xml version="1.0" encoding="UTF-8"?>
+<tt xmlns="http://www.w3.org/ns/ttml">
+  <body>
+    <div>
+      <p begin="00:00:01.000" end="00:00:03.000">
+        <span begin="00:00:01.000" end="00:00:01.500">Hello</span>
+        <span begin="00:00:01.500" end="00:00:03.000">world</span>
+      </p>
+    </div>
+  </body>
+</tt>"#;
+        assert_eq!(detect_format(sample), LyricsFormat::Ttml);
+    }
+
+    #[test]
+    fn detect_format_ttml_no_decl() {
+        let sample = r#"<tt xmlns="http://www.w3.org/ns/ttml"><body><div><p begin="0s">x</p></div></body></tt>"#;
+        assert_eq!(detect_format(sample), LyricsFormat::Ttml);
+    }
+
+    #[test]
+    fn detect_format_brackets_but_no_timestamp_stays_plain() {
+        // A line starting with `[foo]` (LRC metadata header) without
+        // any actual time-stamped line should NOT be classified as
+        // synchronized.
+        let sample = "[ar:Artist]\n[ti:Title]\nVerse without timestamps.";
+        assert_eq!(detect_format(sample), LyricsFormat::Plain);
+    }
+
+    #[test]
+    fn word_stamp_present_basic() {
+        assert!(word_stamp_present("<00:01.50>word"));
+        assert!(word_stamp_present("plain<5:00>more"));
+        assert!(!word_stamp_present("nothing here"));
+        assert!(!word_stamp_present("<not:a:stamp>"));
+    }
+}
diff --git a/src/components/common/LyricsEditorModal.tsx b/src/components/common/LyricsEditorModal.tsx
index 336a4f8..0d5c9fe 100644
--- a/src/components/common/LyricsEditorModal.tsx
+++ b/src/components/common/LyricsEditorModal.tsx
@@ -19,8 +19,11 @@ import { useModalA11y } from "../../hooks/useModalA11y";
 import {
   formatLrcTimestamp,
   parseLrc,
+  parseLyrics,
   saveLyrics,
+  serializeEnhancedLrc,
   serializeLrc,
+  type LyricsLine,
   type LyricsPayload,
 } from "../../lib/tauri/lyrics";
 
@@ -36,6 +39,15 @@ interface LyricsEditorModalProps {
 }
 
 type Mode = "plain" | "synced";
+/** Capture granularity inside the synced tab. */
+type Granularity = "line" | "word";
+
+interface SyncedWord {
+  /** -1 when not yet captured. */
+  timeMs: number;
+  /** Word text, kept verbatim including any trailing spaces. */
+  text: string;
+}
 
 interface SyncedRow {
   /** Stable id so React keys survive reorders. */
@@ -43,6 +55,13 @@ interface SyncedRow {
   /** -1 when not yet captured. */
   timeMs: number;
   text: string;
+  /**
+   * Populated in word-mode once the user starts capturing per-word
+   * stamps for the row. Absent in line-mode and for plain rows.
+   */
+  words?: SyncedWord[];
+  /** Cursor inside `words` — index of the next word to capture. */
+  wordCursor?: number;
 }
 
 /**
@@ -64,12 +83,16 @@ export function LyricsEditorModal({
   const dialogRef = useModalA11y<HTMLDivElement>(isOpen, onClose);
 
   const [mode, setMode] = useState<Mode>("plain");
+  const [granularity, setGranularity] = useState<Granularity>("line");
   const [plainText, setPlainText] = useState("");
   const [syncedRows, setSyncedRows] = useState<SyncedRow[]>([]);
   const [activeRow, setActiveRow] = useState(0);
   const [writeToFile, setWriteToFile] = useState(true);
   const [isSaving, setIsSaving] = useState(false);
   const [error, setError] = useState<string | null>(null);
+  /** Surfaced after save when the backend kept the lyrics in-DB but
+   *  couldn't write them to the audio file's tag (e.g. TTML on MP3). */
+  const [warning, setWarning] = useState<string | null>(null);
   // Global timestamp shift applied to every captured row at save
   // time. Stays "preview" until Save (we don't mutate `syncedRows`
   // on every drag) so the user can dial it in without losing the
@@ -77,39 +100,86 @@ export function LyricsEditorModal({
   const [globalOffsetMs, setGlobalOffsetMs] = useState(0);
 
   const nextIdRef = useRef(1);
-  const newRow = (timeMs: number, text: string): SyncedRow => ({
+  const newRow = (
+    timeMs: number,
+    text: string,
+    words?: SyncedWord[],
+  ): SyncedRow => ({
     id: nextIdRef.current++,
     timeMs,
     text,
+    words,
+    wordCursor: words ? 0 : undefined,
   });
 
+  /** Split a line into tokens that preserve trailing spaces, so the
+   *  reassembled text still reads naturally. Empty tokens are dropped. */
+  const tokenize = (text: string): SyncedWord[] => {
+    if (!text.trim()) return [];
+    const re = /\S+\s*/g;
+    const out: SyncedWord[] = [];
+    let m: RegExpExecArray | null;
+    while ((m = re.exec(text)) !== null) {
+      out.push({ timeMs: -1, text: m[0] });
+    }
+    return out;
+  };
+
   // ── Hydrate from initial payload ─────────────────────────────────
   useEffect(() => {
     if (!isOpen) return;
     /* eslint-disable react-hooks/set-state-in-effect */
     setError(null);
+    setWarning(null);
     setActiveRow(0);
     setGlobalOffsetMs(0);
     nextIdRef.current = 1;
 
     if (initial == null) {
       setMode("plain");
+      setGranularity("line");
       setPlainText("");
       setSyncedRows([newRow(-1, "")]);
       return;
     }
 
     const trimmed = initial.content.trim();
-    const isLrc = initial.format === "lrc" || initial.format === "enhanced_lrc";
+    const isSynced =
+      initial.format === "lrc" ||
+      initial.format === "enhanced_lrc" ||
+      initial.format === "ttml";
+    const hasWordTiming =
+      initial.format === "enhanced_lrc" || initial.format === "ttml";
 
     setPlainText(trimmed);
-    if (isLrc) {
-      const parsed = parseLrc(trimmed);
+    if (isSynced) {
+      let parsed: LyricsLine[];
+      if (hasWordTiming) {
+        parsed = parseLyrics(trimmed, initial.format);
+      } else {
+        parsed = parseLrc(trimmed);
+      }
       const rows = parsed.length
-        ? parsed.map((line) => newRow(line.timeMs, line.text))
+        ? parsed.map((line) => {
+            const words = line.words?.map((w) => ({
+              timeMs: w.timeMs,
+              text: w.text,
+            }));
+            const cursor = words
+              ? Math.min(words.length, words.findIndex((w) => w.timeMs < 0))
+              : undefined;
+            return {
+              id: nextIdRef.current++,
+              timeMs: line.timeMs,
+              text: line.text,
+              words,
+              wordCursor: cursor != null && cursor < 0 ? words!.length : cursor,
+            } satisfies SyncedRow;
+          })
         : [newRow(-1, "")];
       setSyncedRows(rows);
       setMode("synced");
+      setGranularity(hasWordTiming ? "word" : "line");
     } else {
       // Pre-fill the synced tab with a row per non-empty line so the
       // user can capture timestamps without retyping.
@@ -118,6 +188,7 @@ export function LyricsEditorModal({
         : [newRow(-1, "")];
       setSyncedRows(lines);
       setMode("plain");
+      setGranularity("line");
     }
     /* eslint-enable react-hooks/set-state-in-effect */
     // We intentionally only rehydrate when the modal opens for a track,
@@ -125,15 +196,15 @@ export function LyricsEditorModal({
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [isOpen, trackId]);
 
-  // ── Capture handler shared between button + Space shortcut ───────
-  const captureCurrent = useCallback(() => {
+  // ── Capture handlers ─────────────────────────────────────────────
+  // Line mode: stamp the active row, append a fresh row if needed,
+  // advance the cursor.
+  const captureLine = useCallback(() => {
     setSyncedRows((rows) => {
       if (rows.length === 0) return rows;
       const idx = Math.min(activeRow, rows.length - 1);
       const next = rows.slice();
       next[idx] = { ...next[idx], timeMs: Math.max(0, positionMs) };
-      // If there's no row after this one, append a fresh blank so the
-      // user can keep typing the next line.
       if (idx === next.length - 1) {
         next.push(newRow(-1, ""));
       }
@@ -142,19 +213,133 @@ export function LyricsEditorModal({
     setActiveRow((i) => i + 1);
   }, [activeRow, positionMs]);
 
-  // ── Space-to-capture in synced mode (avoid hijacking inputs) ─────
+  // Word mode: stamp the next word in the active row. If the row has
+  // no `words` yet, tokenize its text first. Once every word is
+  // stamped, the next press advances to the next line (and stamps the
+  // line's own timeMs if it's still -1, like line mode).
+  const captureWord = useCallback(() => {
+    setSyncedRows((rows) => {
+      if (rows.length === 0) return rows;
+      const idx = Math.min(activeRow, rows.length - 1);
+      const next = rows.slice();
+      const row = { ...next[idx] };
+
+      // Seed words from row.text on first capture.
+      let words = row.words ? row.words.slice() : tokenize(row.text);
+      if (words.length === 0) {
+        // Empty line — degrade to line capture so we don't get stuck.
+        row.timeMs = Math.max(0, positionMs);
+        next[idx] = row;
+        return next;
+      }
+
+      const cursor = row.wordCursor ?? 0;
+      if (cursor >= words.length) {
+        // Out of words on this row — let the caller advance lines.
+        return rows;
+      }
+      // Stamp the line's timeMs on the very first word capture if the
+      // line itself isn't stamped yet.
+      if (row.timeMs < 0 && cursor === 0) {
+        row.timeMs = Math.max(0, positionMs);
+      }
+      words = words.slice();
+      words[cursor] = { ...words[cursor], timeMs: Math.max(0, positionMs) };
+      row.words = words;
+      row.wordCursor = cursor + 1;
+      next[idx] = row;
+      return next;
+    });
+  }, [activeRow, positionMs]);
+
+  // Advance to the next line in word mode (Enter shortcut). Appends a
+  // fresh empty row if we're at the end, mirroring line mode's UX.
+  const advanceLine = useCallback(() => {
+    setSyncedRows((rows) => {
+      if (rows.length === 0) return rows;
+      const idx = Math.min(activeRow, rows.length - 1);
+      if (idx === rows.length - 1) {
+        return [...rows, newRow(-1, "")];
+      }
+      return rows;
+    });
+    setActiveRow((i) => i + 1);
+  }, [activeRow]);
+
+  // Undo the last word capture on the active row (Backspace in word
+  // mode). If no words are stamped yet, clears the line's own timeMs.
+  const undoLastWord = useCallback(() => {
+    setSyncedRows((rows) => {
+      if (rows.length === 0) return rows;
+      const idx = Math.min(activeRow, rows.length - 1);
+      const row = { ...rows[idx] };
+      if (!row.words || row.words.length === 0) {
+        if (row.timeMs >= 0) {
+          row.timeMs = -1;
+          const next = rows.slice();
+          next[idx] = row;
+          return next;
+        }
+        return rows;
+      }
+      const cursor = Math.max(0, (row.wordCursor ?? 0) - 1);
+      const words = row.words.slice();
+      if (words[cursor]) {
+        words[cursor] = { ...words[cursor], timeMs: -1 };
+      }
+      row.words = words;
+      row.wordCursor = cursor;
+      // If we backed all the way out, clear the line stamp too.
+      if (cursor === 0 && words.every((w) => w.timeMs < 0)) {
+        row.timeMs = -1;
+      }
+      const next = rows.slice();
+      next[idx] = row;
+      return next;
+    });
+  }, [activeRow]);
+
+  // Single entry point used by the capture button + Space shortcut.
+  const captureCurrent = useCallback(() => {
+    if (granularity === "word") {
+      captureWord();
+    } else {
+      captureLine();
+    }
+  }, [granularity, captureWord, captureLine]);
+
+  // ── Keyboard shortcuts in synced mode (avoid hijacking inputs) ───
   useEffect(() => {
     if (!isOpen || mode !== "synced") return;
     const handler = (e: KeyboardEvent) => {
-      if (e.code !== "Space") return;
       const tag = (e.target as HTMLElement | null)?.tagName?.toLowerCase();
-      if (tag === "input" || tag === "textarea") return;
-      e.preventDefault();
-      captureCurrent();
+      const isInput = tag === "input" || tag === "textarea";
+      if (e.code === "Space" && !isInput) {
+        e.preventDefault();
+        captureCurrent();
+        return;
+      }
+      if (
+        granularity === "word" &&
+        !isInput &&
+        (e.code === "Enter" || e.code === "NumpadEnter")
+      ) {
+        e.preventDefault();
+        advanceLine();
+        return;
+      }
+      if (
+        granularity === "word" &&
+        !isInput &&
+        (e.code === "Backspace" || e.code === "Delete")
+      ) {
+        e.preventDefault();
+        undoLastWord();
+      }
     };
     window.addEventListener("keydown", handler);
     return () => window.removeEventListener("keydown", handler);
-  }, [isOpen, mode, captureCurrent]);
+  }, [isOpen, mode, granularity, captureCurrent, advanceLine, undoLastWord]);
 
   // ── Player nudges (compose a ±2 s seek with current position) ────
   const nudge = (deltaMs: number) => {
@@ -164,7 +349,16 @@ export function LyricsEditorModal({
   // ── Row-level helpers ────────────────────────────────────────────
   const updateRowText = (id: number, text: string) => {
     setSyncedRows((rows) =>
-      rows.map((r) => (r.id === id ? { ...r, text } : r)),
+      rows.map((r) => {
+        if (r.id !== id) return r;
+        // In word mode editing the text invalidates the captured word
+        // stamps (tokenization changes). Drop them so the user can
+        // re-capture cleanly — keep the line-level timeMs.
+        if (r.words) {
+          return { ...r, text, words: undefined, wordCursor: undefined };
+        }
+        return { ...r, text };
+      }),
     );
   };
   const removeRow = (id: number) => {
@@ -204,37 +398,86 @@ export function LyricsEditorModal({
     setError(null);
     try {
       const isSyncedMode = mode === "synced";
-      const content = isSyncedMode
-        ? serializeLrc(
-            syncedRows
-              .filter((r) => r.text.trim().length > 0 || r.timeMs >= 0)
-              // Bake the previewed global offset into every captured
-              // timestamp on save. Negative results are clamped to 0
-              // so a user who shifts past the start of the track
-              // doesn't end up with invalid LRC entries.
-              .map((r) =>
-                r.timeMs >= 0
-                  ? { ...r, timeMs: Math.max(0, r.timeMs + globalOffsetMs) }
-                  : r,
-              )
-              .sort((a, b) => {
-                if (a.timeMs < 0 && b.timeMs < 0) return 0;
-                if (a.timeMs < 0) return 1;
-                if (b.timeMs < 0) return -1;
-                return a.timeMs - b.timeMs;
-              }),
+      const isWordMode = isSyncedMode && granularity === "word";
+
+      // Bake the previewed global offset into every captured stamp on
+      // save (both line- and word-level). Negative results are clamped
+      // to 0 so a user shifting past the start of the track doesn't
+      // emit invalid stamps.
+      const shift = (ts: number): number =>
+        ts < 0 ? -1 : Math.max(0, ts + globalOffsetMs);
+
+      let content: string;
+      let saveFormat: "plain" | "lrc" | "enhanced_lrc";
+      if (!isSyncedMode) {
+        content = plainText.trim();
+        saveFormat = "plain";
+      } else if (isWordMode) {
+        // Keep every row the user typed text into, even if they
+        // haven't captured a stamp yet — line mode does the same,
+        // so saving in word mode shouldn't silently delete unstamped
+        // text. `serializeEnhancedLrc` emits `[--:--.--]` for rows
+        // with `timeMs < 0` and folds uncaptured words into the
+        // previous segment (no phantom `<00:00.00>` stamp), so half-
+        // finished work round-trips cleanly through save → reload.
+        const rowsForSave: LyricsLine[] = syncedRows
+          .filter(
+            (r) =>
+              r.text.trim().length > 0 ||
+              r.timeMs >= 0 ||
+              (r.words?.some((w) => w.timeMs >= 0) ?? false),
           )
-        : plainText.trim();
+          .map((r) => ({
+            timeMs: shift(r.timeMs),
+            endMs: -1,
+            text: r.text,
+            words: r.words?.map((w) => ({
+              timeMs: shift(w.timeMs),
+              endMs: -1,
+              text: w.text,
+            })),
+          }))
+          // Untimed rows (timeMs < 0) sort to the end so the synced
+          // body stays monotonically ordered; the user can resume
+          // capturing them on the next edit.
+          .sort((a, b) => {
+            if (a.timeMs < 0 && b.timeMs < 0) return 0;
+            if (a.timeMs < 0) return 1;
+            if (b.timeMs < 0) return -1;
+            return a.timeMs - b.timeMs;
+          });
+        content = serializeEnhancedLrc(rowsForSave);
+        saveFormat = "enhanced_lrc";
+      } else {
+        content = serializeLrc(
+          syncedRows
+            .filter((r) => r.text.trim().length > 0 || r.timeMs >= 0)
+            .map((r) => (r.timeMs >= 0 ? { ...r, timeMs: shift(r.timeMs) } : r))
+            .sort((a, b) => {
+              if (a.timeMs < 0 && b.timeMs < 0) return 0;
+              if (a.timeMs < 0) return 1;
+              if (b.timeMs < 0) return -1;
+              return a.timeMs - b.timeMs;
+            }),
+        );
+        saveFormat = "lrc";
+      }
 
       // The backend pauses playback if we're editing the currently
       // playing file, so the flag is passed through as-is.
       const next = await saveLyrics(trackId, {
         content,
-        format: isSyncedMode ? "lrc" : "plain",
+        format: saveFormat,
         write_to_file: writeToFile,
       });
       onSaved(next);
-      onClose();
+      if (next.tag_write_skipped) {
+        // Keep the modal open with a warning so the user knows the
+        // file itself wasn't touched — DB cache still updated.
+        setWarning(t("lyrics.toast.tagWriteSkipped"));
+      } else {
+        onClose();
+      }
     } catch (err) {
       console.error("[LyricsEditor] save failed", err);
       setError(String(err));
@@ -332,18 +575,51 @@ export function LyricsEditorModal({
               className="w-full h-[50vh] resize-none rounded-lg border border-zinc-200 dark:border-zinc-700 bg-zinc-50 dark:bg-zinc-800 p-4 text-sm leading-relaxed focus:outline-none focus:ring-2 focus:ring-pink-500"
             />
           ) : (
-            <SyncedEditor
-              rows={syncedRows}
-              activeRow={activeRow}
-              playingRow={playingRowIdx}
-              offsetMs={globalOffsetMs}
-              onActivate={setActiveRow}
-              onUpdateText={updateRowText}
-              onRemove={removeRow}
-              onInsertBelow={insertRowBelow}
-              onSeekTo={seekToRow}
-              onRecapture={recapture}
-            />
+            <>
+              {/* Granularity toggle. Sits above the row list so users
+                  can flip between line + word capture without losing
+                  what they've already stamped. */}
+              <div className="flex items-center gap-2 mb-3">
+                <span className="text-xs text-zinc-500 dark:text-zinc-400 mr-1">
+                  {t("lyricsEditor.granularity.label")}
+                </span>
+                <button
+                  type="button"
+                  onClick={() => setGranularity("line")}
+                  className={`px-3 py-1 rounded-full text-xs font-medium transition-colors ${
+                    granularity === "line"
+                      ? "bg-pink-500 text-white"
+                      : "bg-zinc-100 dark:bg-zinc-800 text-zinc-600 dark:text-zinc-300 hover:bg-zinc-200 dark:hover:bg-zinc-700"
+                  }`}
+                >
+                  {t("lyricsEditor.granularity.line")}
+                </button>
+                <button
+                  type="button"
+                  onClick={() => setGranularity("word")}
+                  className={`px-3 py-1 rounded-full text-xs font-medium transition-colors ${
+                    granularity === "word"
+                      ? "bg-pink-500 text-white"
+                      : "bg-zinc-100 dark:bg-zinc-800 text-zinc-600 dark:text-zinc-300 hover:bg-zinc-200 dark:hover:bg-zinc-700"
+                  }`}
+                >
+                  {t("lyricsEditor.granularity.word")}
+                </button>
+              </div>
+              <SyncedEditor
+                rows={syncedRows}
+                activeRow={activeRow}
+                playingRow={playingRowIdx}
+                offsetMs={globalOffsetMs}
+                granularity={granularity}
+                onActivate={setActiveRow}
+                onUpdateText={updateRowText}
+                onRemove={removeRow}
+                onInsertBelow={insertRowBelow}
+                onSeekTo={seekToRow}
+                onRecapture={recapture}
+              />
+            </>
           )}
         </div>
 
@@ -390,7 +666,10 @@ export function LyricsEditorModal({
               </button>
             </div>
             <p className="text-xs text-zinc-500 dark:text-zinc-400 mt-2">
-              {t("lyricsEditor.captureHint")} · {captured}/{syncedRows.length}{" "}
+              {granularity === "word"
+                ? t("lyricsEditor.captureHintWord")
+                : t("lyricsEditor.captureHint")}
+              {" "}· {captured}/{syncedRows.length}{" "}
               {t("lyricsEditor.lines")}
             </p>
 
@@ -472,6 +751,11 @@ export function LyricsEditorModal({
             {t("lyricsEditor.writeToFile")}
           </label>
           <div className="flex items-center gap-2">
+            {warning && (
+              <span className="text-xs text-amber-600 dark:text-amber-400 truncate max-w-xs">
+                {warning}
+              </span>
+            )}
             {error && (
               <span className="text-xs text-red-500 truncate max-w-xs">
                 {error}
@@ -536,6 +820,8 @@ interface SyncedEditorProps {
   playingRow: number;
   /** Global timestamp shift previewed in the timestamp buttons. */
   offsetMs: number;
+  /** Capture granularity — drives the per-word chip row. */
+  granularity: Granularity;
   onActivate: (idx: number) => void;
   onUpdateText: (id: number, text: string) => void;
   onRemove: (id: number) => void;
@@ -549,6 +835,7 @@ function SyncedEditor({
   activeRow,
   playingRow,
   offsetMs,
+  granularity,
   onActivate,
   onUpdateText,
   onRemove,
@@ -565,10 +852,12 @@ function SyncedEditor({
         const captured = row.timeMs >= 0;
         const shifted = captured && offsetMs !== 0;
         const previewMs = captured ? Math.max(0, row.timeMs + offsetMs) : -1;
+        const showWordChips =
+          granularity === "word" && isActive && (row.words?.length ?? 0) > 0;
         return (
           <li
             key={row.id}
-            className={`flex items-center gap-2 px-2 py-1.5 rounded-lg transition-colors ${
+            className={`flex flex-col gap-1 px-2 py-1.5 rounded-lg transition-colors ${
               isActive
                 ? "bg-pink-50 dark:bg-pink-950/30 ring-1 ring-pink-200 dark:ring-pink-900"
                 : isPlaying
@@ -577,6 +866,7 @@ function SyncedEditor({
             }`}
             onFocus={() => onActivate(idx)}
           >
+          <div className="flex items-center gap-2">
             <span
               aria-hidden
               className={`w-1.5 h-1.5 rounded-full shrink-0 ${
@@ -641,6 +931,35 @@ function SyncedEditor({
             >
               <Trash2 size={12} />
             </button>
+          </div>
+            {showWordChips && (
+              <div className="flex flex-wrap items-center gap-1 pl-22 pr-2 pb-1">
+                {row.words!.map((w, wi) => {
+                  const wCursor = row.wordCursor ?? 0;
+                  const wCaptured = w.timeMs >= 0;
+                  const isNext = wi === wCursor;
+                  return (
+                    <span
+                      key={wi}
+                      className={`inline-flex items-center gap-1 px-1.5 py-0.5 rounded text-[11px] font-mono transition-colors ${
+                        wCaptured
+                          ? "bg-pink-100 dark:bg-pink-900/40 text-pink-700 dark:text-pink-200"
+                          : isNext
+                            ? "bg-emerald-100 dark:bg-emerald-900/40 text-emerald-700 dark:text-emerald-200 ring-1 ring-emerald-400"
+                            : "bg-zinc-100 dark:bg-zinc-800 text-zinc-500 dark:text-zinc-400"
+                      }`}
+                      title={
+                        wCaptured
+                          ? formatLrcTimestamp(Math.max(0, w.timeMs + offsetMs))
+                          : t("lyricsEditor.notCaptured")
+                      }
+                    >
+                      <span>{w.text.trim() || "·"}</span>
+                    </span>
+                  );
+                })}
+              </div>
+            )}
           </li>
         );
       })}
diff --git a/src/components/layout/LyricsPanel.tsx b/src/components/layout/LyricsPanel.tsx
index ba67165..90de1a5 100644
--- a/src/components/layout/LyricsPanel.tsx
+++ b/src/components/layout/LyricsPanel.tsx
@@ -15,9 +15,10 @@ import {
   clearLyrics,
   fetchLyrics,
   findActiveLineIndex,
+  findActiveWordIndex,
   importLrcFile,
-  parseLrc,
-  type LrcLine,
+  parseLyrics,
+  type LyricsLine,
   type LyricsPayload,
 } from "../../lib/tauri/lyrics";
 import { FullscreenLyrics } from "../player/FullscreenLyrics";
@@ -76,13 +77,10 @@ export function LyricsPanel() {
     };
   }, [trackId]);
 
-  // ── Parse LRC once per content change ───────────────────────────
-  const lrcLines = useMemo<LrcLine[]>(() => {
+  // ── Parse lyrics once per content change ─────────────────────────
+  const lrcLines = useMemo<LyricsLine[]>(() => {
     if (!payload) return [];
-    if (payload.format !== "lrc" && payload.format !== "enhanced_lrc") {
-      return [];
-    }
-    return parseLrc(payload.content);
+    return parseLyrics(payload.content, payload.format);
   }, [payload]);
 
   const isSynced = lrcLines.length > 0;
@@ -113,11 +111,22 @@ export function LyricsPanel() {
     }
   }, [activeIndex, isLyricsOpen, isSynced]);
 
+  // Active word inside the active line — only computed when the line
+  // carries `words[]` so plain LRC stays cheap.
+  const activeLine = activeIndex >= 0 ? lrcLines[activeIndex] : undefined;
+  const activeWordIndex = useMemo(() => {
+    if (!activeLine?.words || activeLine.words.length === 0) return -1;
+    return findActiveWordIndex(activeLine.words, positionMs);
+  }, [activeLine, positionMs]);
+
   // ── Actions ─────────────────────────────────────────────────────
   const handleImport = async () => {
     if (trackId == null) return;
     try {
-      const path = await pickFile(["lrc", "txt"], t("lyrics.importTitle"));
+      const path = await pickFile(
+        ["lrc", "elrc", "ttml", "xml", "txt"],
+        t("lyrics.importTitle"),
+      );
       if (!path) return;
       const next = await importLrcFile(trackId, path);
       setPayload(next);
@@ -153,7 +162,7 @@ export function LyricsPanel() {
     }
   };
 
-  const handleSeekToLine = (line: LrcLine) => {
+  const handleSeekToLine = (line: LyricsLine) => {
     seek(line.timeMs).catch(() => {});
   };
 
@@ -226,6 +235,7 @@ export function LyricsPanel() {
               {lrcLines.map((line, index) => {
                 const isActive = index === activeIndex;
                 const isPast = index < activeIndex;
+                const hasWords = isActive && (line.words?.length ?? 0) > 0;
                 return (
                   <li
                     key={`${line.timeMs}-${index}`}
@@ -241,7 +251,35 @@ export function LyricsPanel() {
                           : "text-zinc-500 dark:text-zinc-400 hover:text-zinc-700 dark:hover:text-zinc-200"
                     }`}
                   >
-                    {line.text || " "}
+                    {hasWords ? (
+                      <span>
+                        {line.words!.map((word, wi) => (
+                          <span
+                            key={wi}
+                            className={
+                              wi === activeWordIndex
+                                ? "text-pink-500 dark:text-pink-400"
+                                : wi < activeWordIndex
+                                  ? ""
+                                  : "opacity-60"
+                            }
+                            style={{
+                              display: "inline-block",
+                              transform:
+                                wi === activeWordIndex
+                                  ? "scale(1.04)"
+                                  : "scale(1)",
+                              transition:
+                                "color 150ms ease, opacity 150ms ease, transform 150ms ease",
+                            }}
+                          >
+                            {word.text}
+                          </span>
+                        ))}
+                      </span>
+                    ) : (
+                      line.text || " "
+                    )}
                   </li>
                 );
               })}
@@ -282,8 +320,18 @@ export function LyricsPanel() {
         {/* Footer actions */}
         {currentTrack != null && (
           <div className="flex items-center justify-between p-4 border-t border-zinc-100 dark:border-zinc-800 text-xs text-zinc-500 dark:text-zinc-400">
-            <span className="truncate">
-              {payload ? sourceLabel(payload.source, t) : ""}
+            <span className="flex items-center gap-2 min-w-0">
+              <span className="truncate">
+                {payload ? sourceLabel(payload.source, t) : ""}
+              </span>
+              {payload && (payload.format === "enhanced_lrc" || payload.format === "ttml") && (
+                <span
+                  className="shrink-0 px-1.5 py-0.5 rounded text-[10px] font-medium uppercase tracking-wider bg-pink-100 dark:bg-pink-950/40 text-pink-600 dark:text-pink-300"
+                  title={t(`lyrics.format.${payload.format}`)}
+                >
+                  {payload.format === "ttml" ? "TTML" : "WORD"}
+                </span>
+              )}
             </span>
             <div className="flex items-center space-x-1 shrink-0">
               <button
diff --git a/src/components/player/FullscreenLyrics.tsx b/src/components/player/FullscreenLyrics.tsx
index 7828625..6bd854a 100644
--- a/src/components/player/FullscreenLyrics.tsx
+++ b/src/components/player/FullscreenLyrics.tsx
@@ -1,20 +1,26 @@
-import { useEffect, useRef } from "react";
+import { useEffect, useMemo, useRef } from "react";
 import { useTranslation } from "react-i18next";
 import { X, Music2 } from "lucide-react";
 import { Artwork } from "../common/Artwork";
 import type { Track } from "../../lib/tauri/track";
-import type { LrcLine, LyricsPayload } from "../../lib/tauri/lyrics";
+import {
+  findActiveWordIndex,
+  type LyricsLine,
+  type LyricsPayload,
+} from "../../lib/tauri/lyrics";
+import { usePlayer } from "../../hooks/usePlayer";
+import { useModalA11y } from "../../hooks/useModalA11y";
 
 interface FullscreenLyricsProps {
   track: Track;
   payload: LyricsPayload | null;
-  lrcLines: LrcLine[];
+  lrcLines: LyricsLine[];
   isSynced: boolean;
   activeIndex: number;
   isFetching: boolean;
   error: string | null;
   onClose: () => void;
-  onSeek: (line: LrcLine) => void;
+  onSeek: (line: LyricsLine) => void;
 }
 
 /**
@@ -39,17 +45,22 @@ export function FullscreenLyrics({
   onSeek,
 }: FullscreenLyricsProps) {
   const { t } = useTranslation();
+  const { positionMs } = usePlayer();
   const lineRefs = useRef<Array<HTMLLIElement | null>>([]);
+  // The overlay is mounted only when the side panel toggles it on, so
+  // the hook is always opened against `true` while alive — passing
+  // `true` here keeps the focus trap, Escape-close, and focus
+  // restoration consistent with the rest of the modal stack.
+  const dialogRef = useModalA11y<HTMLDivElement>(true, onClose);
 
-  // Escape to close. Mounted only while open so we don't intercept
-  // the key when the overlay isn't visible.
-  useEffect(() => {
-    const handleKey = (e: KeyboardEvent) => {
-      if (e.key === "Escape") onClose();
-    };
-    document.addEventListener("keydown", handleKey);
-    return () => document.removeEventListener("keydown", handleKey);
-  }, [onClose]);
+  // Active word index inside the current line — drives the per-word
+  // karaoke highlight. Recomputed on every position tick but only when
+  // the current line actually carries word stamps.
+  const activeLine = activeIndex >= 0 ? lrcLines[activeIndex] : undefined;
+  const activeWordIndex = useMemo(() => {
+    if (!activeLine?.words || activeLine.words.length === 0) return -1;
+    return findActiveWordIndex(activeLine.words, positionMs);
+  }, [activeLine, positionMs]);
 
   // Keep the active line vertically centered. Independent ref array
   // from the side panel so both views can scroll in parallel.
@@ -62,7 +73,13 @@ export function FullscreenLyrics({
   }, [activeIndex, isSynced]);
 
   return (
-    <div className="fixed inset-0 z-[100] animate-fade-in">
+    <div
+      ref={dialogRef}
+      role="dialog"
+      aria-modal="true"
+      aria-labelledby="fullscreen-lyrics-title"
+      className="fixed inset-0 z-[100] animate-fade-in"
+    >
       {/* Blurred artwork background — falls back to a flat dark
           gradient when the track has no cover. */}
       <div className="absolute inset-0 overflow-hidden">
@@ -98,7 +115,10 @@ export function FullscreenLyrics({
               rounded="lg"
             />
             <div className="min-w-0">
-              <div className="text-xs uppercase tracking-widest text-white/60 mb-1">
+              <div
+                id="fullscreen-lyrics-title"
+                className="text-xs uppercase tracking-widest text-white/60 mb-1"
+              >
                 {t("lyrics.title")}
               </div>
               <div className="text-lg font-bold truncate">{track.title}</div>
@@ -140,6 +160,7 @@ export function FullscreenLyrics({
                   const opacity = isActive
                     ? 1
                     : Math.max(0.18, 0.7 - distance * 0.08);
+                  const hasWords = isActive && (line.words?.length ?? 0) > 0;
                   return (
                     <li
                       key={`${line.timeMs}-${index}`}
@@ -156,7 +177,42 @@ export function FullscreenLyrics({
                             : "text-white/70 hover:text-white"
                       }`}
                     >
-                      {line.text || " "}
+                      {hasWords ? (
+                        <span>
+                          {line.words!.map((word, wi) => {
+                            const wState =
+                              wi === activeWordIndex
+                                ? "active"
+                                : wi < activeWordIndex
+                                  ? "past"
+                                  : "future";
+                            return (
+                              <span
+                                key={wi}
+                                style={{
+                                  opacity:
+                                    wState === "active"
+                                      ? 1
+                                      : wState === "past"
+                                        ? 0.8
+                                        : 0.45,
+                                  transform:
+                                    wState === "active"
+                                      ? "scale(1.04)"
+                                      : "scale(1)",
+                                  display: "inline-block",
+                                  transition:
+                                    "opacity 150ms ease, transform 150ms ease",
+                                }}
+                              >
+                                {word.text}
+                              </span>
+                            );
+                          })}
+                        </span>
+                      ) : (
+                        line.text || " "
+                      )}
                     </li>
                   );
                 })}
diff --git a/src/i18n/locales/ar.json b/src/i18n/locales/ar.json
index 9be9b34..4678c0d 100644
--- a/src/i18n/locales/ar.json
+++ b/src/i18n/locales/ar.json
@@ -907,6 +907,15 @@
       "lrc_file": "ملف .lrc مستورد",
       "api": "LRCLIB",
       "manual": "الإدخال اليدوي"
+    },
+    "format": {
+      "lrc": "متزامن",
+      "enhanced_lrc": "متزامن كلمة بكلمة",
+      "ttml": "TTML كلمة بكلمة",
+      "plain": "غير متزامن"
+    },
+    "toast": {
+      "tagWriteSkipped": "تم الاحتفاظ بـ TTML في الذاكرة المؤقتة فقط (لم تتم كتابته في وسم الصوت)"
     }
   },
   "duplicates": {
@@ -1034,7 +1043,14 @@
       "label": "إزاحة شاملة",
       "help": "تُزيح كل سطر تم التقاطه بالقيمة نفسها — مفيدة لتصحيح ملفات LRC المستوردة التي تسبق أو تتأخر بانتظام",
       "reset": "إعادة ضبط الإزاحة"
-    }
+    },
+    "granularity": {
+      "label": "الدقة:",
+      "line": "سطرًا سطرًا",
+      "word": "كلمة كلمة"
+    },
+    "captureHintWord": "مسافة = الكلمة التالية · إدخال = السطر التالي · مسح للخلف = التراجع عن آخر كلمة",
+    "notCaptured": "غير ملتقَط"
   },
   "sort": {
     "title": "العنوان",
diff --git a/src/i18n/locales/de.json b/src/i18n/locales/de.json
index 204d5d1..cac7edb 100644
--- a/src/i18n/locales/de.json
+++ b/src/i18n/locales/de.json
@@ -907,6 +907,15 @@
       "lrc_file": "Importierte .lrc-Datei",
       "api": "LRCLIB",
       "manual": "Manuelle Eingabe"
+    },
+    "format": {
+      "lrc": "Synchronisiert",
+      "enhanced_lrc": "Wort-für-Wort synchronisiert",
+      "ttml": "TTML Wort-für-Wort",
+      "plain": "Unsynchronisiert"
+    },
+    "toast": {
+      "tagWriteSkipped": "TTML nur im Cache gespeichert (nicht in das Audio-Tag geschrieben)"
     }
   },
   "duplicates": {
@@ -1034,7 +1043,14 @@
       "label": "Globaler Versatz",
       "help": "Verschiebt jede erfasste Zeile um denselben Wert — hilfreich, um importierte LRC-Dateien zu korrigieren, die gleichmäßig zu früh oder zu spät sind",
       "reset": "Versatz zurücksetzen"
-    }
+    },
+    "granularity": {
+      "label": "Granularität:",
+      "line": "Zeile für Zeile",
+      "word": "Wort für Wort"
+    },
+    "captureHintWord": "Leertaste = nächstes Wort · Eingabe = nächste Zeile · Rücktaste = letztes Wort rückgängig",
+    "notCaptured": "Nicht erfasst"
   },
   "sort": {
     "title": "Titel",
diff --git a/src/i18n/locales/en.json b/src/i18n/locales/en.json
index c65f8b3..2932054 100644
--- a/src/i18n/locales/en.json
+++ b/src/i18n/locales/en.json
@@ -916,6 +916,15 @@
       "lrc_file": "Imported .lrc file",
       "api": "LRCLIB",
       "manual": "Manual entry"
+    },
+    "format": {
+      "lrc": "Synchronized",
+      "enhanced_lrc": "Word-by-word synchronized",
+      "ttml": "TTML word-by-word",
+      "plain": "Unsynchronized"
+    },
+    "toast": {
+      "tagWriteSkipped": "TTML kept in cache only (not written to the audio tag)"
     }
   },
   "duplicates": {
@@ -1043,7 +1052,14 @@
       "label": "Global shift",
       "help": "Shifts every captured line by the same delta — useful for fixing imported LRC files that are uniformly early or late",
       "reset": "Reset shift"
-    }
+    },
+    "granularity": {
+      "label": "Granularity:",
+      "line": "Line by line",
+      "word": "Word by word"
+    },
+    "captureHintWord": "Space = next word · Enter = next line · Backspace = undo last word",
+    "notCaptured": "Not captured"
   },
   "sort": {
     "title": "Title",
diff --git a/src/i18n/locales/es.json b/src/i18n/locales/es.json
index 96dc9f8..919c15b 100644
--- a/src/i18n/locales/es.json
+++ b/src/i18n/locales/es.json
@@ -907,6 +907,15 @@
       "lrc_file": "Archivo .lrc importado",
       "api": "LRCLIB",
       "manual": "Introducción manual"
+    },
+    "format": {
+      "lrc": "Sincronizado",
+      "enhanced_lrc": "Sincronizado palabra a palabra",
+      "ttml": "TTML palabra a palabra",
+      "plain": "Sin sincronizar"
+    },
+    "toast": {
+      "tagWriteSkipped": "TTML guardado solo en caché (no escrito en la etiqueta de audio)"
     }
   },
   "duplicates": {
@@ -1034,7 +1043,14 @@
       "label": "Desplazamiento global",
       "help": "Desplaza todas las líneas capturadas por el mismo delta — útil para corregir archivos LRC importados que están adelantados o retrasados de manera uniforme",
       "reset": "Restablecer desplazamiento"
-    }
+    },
+    "granularity": {
+      "label": "Granularidad:",
+      "line": "Línea por línea",
+      "word": "Palabra por palabra"
+    },
+    "captureHintWord": "Espacio = palabra siguiente · Intro = línea siguiente · Retroceso = deshacer última palabra",
+    "notCaptured": "Sin marcar"
   },
   "sort": {
     "title": "Título",
diff --git a/src/i18n/locales/fr.json b/src/i18n/locales/fr.json
index 6650c24..0fde95f 100644
--- a/src/i18n/locales/fr.json
+++ b/src/i18n/locales/fr.json
@@ -916,6 +916,15 @@
       "lrc_file": "Fichier .lrc importé",
       "api": "LRCLIB",
       "manual": "Saisie manuelle"
+    },
+    "format": {
+      "lrc": "Synchronisé",
+      "enhanced_lrc": "Synchronisé mot-à-mot",
+      "ttml": "TTML mot-à-mot",
+      "plain": "Non synchronisé"
+    },
+    "toast": {
+      "tagWriteSkipped": "TTML conservé en base (non écrit dans le tag audio)"
     }
   },
   "smartPlaylistEditor": {
@@ -1043,7 +1052,14 @@
       "label": "Décalage global",
       "help": "Décale toutes les lignes calées du même delta — utile pour corriger un fichier LRC importé qui est uniformément en avance ou en retard",
       "reset": "Réinitialiser le décalage"
-    }
+    },
+    "granularity": {
+      "label": "Granularité :",
+      "line": "Ligne par ligne",
+      "word": "Mot par mot"
+    },
+    "captureHintWord": "Espace = mot suivant · Entrée = ligne suivante · Retour arrière = annuler le dernier mot",
+    "notCaptured": "Non calé"
   },
   "sort": {
     "title": "Titre",
diff --git a/src/i18n/locales/hi.json b/src/i18n/locales/hi.json
index c90ef5b..fcbceb6 100644
--- a/src/i18n/locales/hi.json
+++ b/src/i18n/locales/hi.json
@@ -907,6 +907,15 @@
       "lrc_file": "आयातित .lrc फ़ाइल",
       "api": "LRCLIB",
       "manual": "मैनुअल प्रविष्टि"
+    },
+    "format": {
+      "lrc": "सिंक्रनाइज़",
+      "enhanced_lrc": "शब्द-दर-शब्द सिंक्रनाइज़",
+      "ttml": "TTML शब्द-दर-शब्द",
+      "plain": "असिंक्रनाइज़"
+    },
+    "toast": {
+      "tagWriteSkipped": "TTML केवल कैश में रखा गया (ऑडियो टैग में नहीं लिखा गया)"
     }
   },
   "duplicates": {
@@ -1034,7 +1043,14 @@
       "label": "ग्लोबल ऑफ़सेट",
       "help": "हर कैप्चर की गई पंक्ति को समान डेल्टा से शिफ्ट करता है — आयात की गई LRC फ़ाइलों को ठीक करने में सहायक जो समान रूप से जल्दी या देर से हैं",
       "reset": "ऑफ़सेट रीसेट करें"
-    }
+    },
+    "granularity": {
+      "label": "ग्रैन्युलैरिटी:",
+      "line": "पंक्ति-दर-पंक्ति",
+      "word": "शब्द-दर-शब्द"
+    },
+    "captureHintWord": "स्पेस = अगला शब्द · एंटर = अगली पंक्ति · बैकस्पेस = अंतिम शब्द पूर्ववत करें",
+    "notCaptured": "अंकित नहीं"
   },
   "sort": {
     "title": "शीर्षक",
diff --git a/src/i18n/locales/id.json b/src/i18n/locales/id.json
index 6ef1945..f8bb0df 100644
--- a/src/i18n/locales/id.json
+++ b/src/i18n/locales/id.json
@@ -907,6 +907,15 @@
       "lrc_file": "Berkas .lrc yang diimpor",
       "api": "LRCLIB",
       "manual": "Pencatatan manual"
+    },
+    "format": {
+      "lrc": "Tersinkronisasi",
+      "enhanced_lrc": "Tersinkronisasi kata per kata",
+      "ttml": "TTML kata per kata",
+      "plain": "Tidak tersinkronisasi"
+    },
+    "toast": {
+      "tagWriteSkipped": "TTML disimpan hanya di cache (tidak ditulis ke tag audio)"
     }
   },
   "duplicates": {
@@ -1034,7 +1043,14 @@
       "label": "Pergeseran global",
       "help": "Menggeser setiap baris yang ditangkap dengan delta yang sama — berguna untuk memperbaiki berkas LRC impor yang seragam terlalu cepat atau lambat",
       "reset": "Setel ulang pergeseran"
-    }
+    },
+    "granularity": {
+      "label": "Granularitas:",
+      "line": "Baris per baris",
+      "word": "Kata per kata"
+    },
+    "captureHintWord": "Spasi = kata berikutnya · Enter = baris berikutnya · Backspace = batalkan kata terakhir",
+    "notCaptured": "Belum ditangkap"
   },
   "sort": {
     "title": "Judul",
diff --git a/src/i18n/locales/it.json b/src/i18n/locales/it.json
index a5296c9..ad063cd 100644
--- a/src/i18n/locales/it.json
+++ b/src/i18n/locales/it.json
@@ -907,6 +907,15 @@
       "lrc_file": "File .lrc importato",
       "api": "LRCLIB",
       "manual": "Inserimento manuale"
+    },
+    "format": {
+      "lrc": "Sincronizzato",
+      "enhanced_lrc": "Sincronizzato parola per parola",
+      "ttml": "TTML parola per parola",
+      "plain": "Non sincronizzato"
+    },
+    "toast": {
+      "tagWriteSkipped": "TTML mantenuto solo in cache (non scritto nel tag audio)"
     }
   },
   "duplicates": {
@@ -1034,7 +1043,14 @@
       "label": "Spostamento globale",
       "help": "Sposta tutte le righe catturate dello stesso delta — utile per correggere file LRC importati uniformemente in anticipo o in ritardo",
       "reset": "Ripristina spostamento"
-    }
+    },
+    "granularity": {
+      "label": "Granularità:",
+      "line": "Riga per riga",
+      "word": "Parola per parola"
+    },
+    "captureHintWord": "Spazio = parola successiva · Invio = riga successiva · Backspace = annulla ultima parola",
+    "notCaptured": "Non catturato"
   },
   "sort": {
     "title": "Titolo",
diff --git a/src/i18n/locales/ja.json b/src/i18n/locales/ja.json
index bf1cb0a..8d8375f 100644
--- a/src/i18n/locales/ja.json
+++ b/src/i18n/locales/ja.json
@@ -907,6 +907,15 @@
       "lrc_file": "インポートされた.lrcファイル",
       "api": "LRCLIB",
       "manual": "手動入力"
+    },
+    "format": {
+      "lrc": "同期済み",
+      "enhanced_lrc": "単語単位で同期",
+      "ttml": "TTML 単語単位",
+      "plain": "非同期"
+    },
+    "toast": {
+      "tagWriteSkipped": "TTML はキャッシュにのみ保存されました（音声タグには書き込まれていません）"
     }
   },
   "duplicates": {
@@ -1034,7 +1043,14 @@
       "label": "全体オフセット",
       "help": "キャプチャ済みのすべての行を同じ量だけずらします — インポートしたLRCファイルが一律に早かったり遅かったりする場合の補正に便利です",
       "reset": "オフセットをリセット"
-    }
+    },
+    "granularity": {
+      "label": "粒度：",
+      "line": "1 行ずつ",
+      "word": "1 単語ずつ"
+    },
+    "captureHintWord": "スペース = 次の単語 · Enter = 次の行 · Backspace = 最後の単語を取り消す",
+    "notCaptured": "未キャプチャ"
   },
   "sort": {
     "title": "タイトル",
diff --git a/src/i18n/locales/kr.json b/src/i18n/locales/kr.json
index 0b47006..8d0116f 100644
--- a/src/i18n/locales/kr.json
+++ b/src/i18n/locales/kr.json
@@ -907,6 +907,15 @@
       "lrc_file": ".lrc 파일 가져오기",
       "api": "LRCLIB",
       "manual": "수동 입력"
+    },
+    "format": {
+      "lrc": "동기화됨",
+      "enhanced_lrc": "단어별 동기화",
+      "ttml": "TTML 단어별",
+      "plain": "동기화 안 됨"
+    },
+    "toast": {
+      "tagWriteSkipped": "TTML은 캐시에만 저장되었습니다(오디오 태그에는 기록되지 않음)"
     }
   },
   "duplicates": {
@@ -1034,7 +1043,14 @@
       "label": "전체 오프셋",
       "help": "캡처된 모든 줄을 같은 양만큼 이동합니다 — 일정하게 빠르거나 느린 가져온 LRC 파일을 보정할 때 유용합니다",
       "reset": "오프셋 초기화"
-    }
+    },
+    "granularity": {
+      "label": "세분화 단위:",
+      "line": "한 줄씩",
+      "word": "한 단어씩"
+    },
+    "captureHintWord": "스페이스 = 다음 단어 · Enter = 다음 줄 · Backspace = 마지막 단어 취소",
+    "notCaptured": "캡처되지 않음"
   },
   "sort": {
     "title": "제목",
diff --git a/src/i18n/locales/nl.json b/src/i18n/locales/nl.json
index bb91d96..c72e06f 100644
--- a/src/i18n/locales/nl.json
+++ b/src/i18n/locales/nl.json
@@ -907,6 +907,15 @@
       "lrc_file": "Geïmporteerd .lrc-bestand",
       "api": "LRCLIB",
       "manual": "Handmatig invoeren"
+    },
+    "format": {
+      "lrc": "Gesynchroniseerd",
+      "enhanced_lrc": "Woord-voor-woord gesynchroniseerd",
+      "ttml": "TTML woord-voor-woord",
+      "plain": "Niet gesynchroniseerd"
+    },
+    "toast": {
+      "tagWriteSkipped": "TTML alleen in cache bewaard (niet geschreven naar audiotag)"
     }
   },
   "duplicates": {
@@ -1034,7 +1043,14 @@
       "label": "Globale verschuiving",
       "help": "Verschuift elke vastgelegde regel met dezelfde delta — handig om geïmporteerde LRC-bestanden te corrigeren die gelijkmatig te vroeg of te laat zijn",
       "reset": "Verschuiving resetten"
-    }
+    },
+    "granularity": {
+      "label": "Granulariteit:",
+      "line": "Regel per regel",
+      "word": "Woord per woord"
+    },
+    "captureHintWord": "Spatie = volgend woord · Enter = volgende regel · Backspace = laatste woord ongedaan maken",
+    "notCaptured": "Niet vastgelegd"
   },
   "sort": {
     "title": "Titel",
diff --git a/src/i18n/locales/pt-BR.json b/src/i18n/locales/pt-BR.json
index 4b16049..5cea733 100644
--- a/src/i18n/locales/pt-BR.json
+++ b/src/i18n/locales/pt-BR.json
@@ -907,6 +907,15 @@
       "lrc_file": "Arquivo .lrc importado",
       "api": "LRCLIB",
       "manual": "Digitação manual"
+    },
+    "format": {
+      "lrc": "Sincronizado",
+      "enhanced_lrc": "Sincronizado palavra por palavra",
+      "ttml": "TTML palavra por palavra",
+      "plain": "Não sincronizado"
+    },
+    "toast": {
+      "tagWriteSkipped": "TTML mantido apenas em cache (não gravado na tag de áudio)"
     }
   },
   "duplicates": {
@@ -1034,7 +1043,14 @@
       "label": "Deslocamento global",
       "help": "Desloca todas as linhas capturadas pelo mesmo delta — útil para corrigir arquivos LRC importados uniformemente adiantados ou atrasados",
       "reset": "Redefinir deslocamento"
-    }
+    },
+    "granularity": {
+      "label": "Granularidade:",
+      "line": "Linha por linha",
+      "word": "Palavra por palavra"
+    },
+    "captureHintWord": "Espaço = próxima palavra · Enter = próxima linha · Backspace = desfazer última palavra",
+    "notCaptured": "Não capturado"
   },
   "sort": {
     "title": "Título",
diff --git a/src/i18n/locales/pt.json b/src/i18n/locales/pt.json
index 590ecb6..e246d6a 100644
--- a/src/i18n/locales/pt.json
+++ b/src/i18n/locales/pt.json
@@ -907,6 +907,15 @@
       "lrc_file": "Ficheiro .lrc importado",
       "api": "LRCLIB",
       "manual": "Introdução manual"
+    },
+    "format": {
+      "lrc": "Sincronizado",
+      "enhanced_lrc": "Sincronizado palavra a palavra",
+      "ttml": "TTML palavra a palavra",
+      "plain": "Não sincronizado"
+    },
+    "toast": {
+      "tagWriteSkipped": "TTML mantido apenas em cache (não escrito na etiqueta de áudio)"
     }
   },
   "duplicates": {
@@ -1034,7 +1043,14 @@
       "label": "Desfasamento global",
       "help": "Desloca todas as linhas capturadas pelo mesmo delta — útil para corrigir ficheiros LRC importados uniformemente adiantados ou atrasados",
       "reset": "Repor desfasamento"
-    }
+    },
+    "granularity": {
+      "label": "Granularidade:",
+      "line": "Linha a linha",
+      "word": "Palavra a palavra"
+    },
+    "captureHintWord": "Espaço = próxima palavra · Enter = próxima linha · Retrocesso = desfazer última palavra",
+    "notCaptured": "Não capturado"
   },
   "sort": {
     "title": "Título",
diff --git a/src/i18n/locales/ru.json b/src/i18n/locales/ru.json
index a0053f1..c83209d 100644
--- a/src/i18n/locales/ru.json
+++ b/src/i18n/locales/ru.json
@@ -907,6 +907,15 @@
       "lrc_file": "Импортированный файл .lrc",
       "api": "LRCLIB",
       "manual": "Ввод вручную"
+    },
+    "format": {
+      "lrc": "Синхронизировано",
+      "enhanced_lrc": "Синхронизировано по словам",
+      "ttml": "TTML по словам",
+      "plain": "Без синхронизации"
+    },
+    "toast": {
+      "tagWriteSkipped": "TTML сохранён только в кэше (не записан в аудиотег)"
     }
   },
   "duplicates": {
@@ -1034,7 +1043,14 @@
       "label": "Общий сдвиг",
       "help": "Сдвигает все захваченные строки на одну и ту же величину — полезно для исправления импортированных LRC-файлов, которые равномерно опережают или отстают",
       "reset": "Сбросить сдвиг"
-    }
+    },
+    "granularity": {
+      "label": "Гранулярность:",
+      "line": "По строкам",
+      "word": "По словам"
+    },
+    "captureHintWord": "Пробел = следующее слово · Enter = следующая строка · Backspace = отменить последнее слово",
+    "notCaptured": "Не зафиксировано"
   },
   "sort": {
     "title": "Название",
diff --git a/src/i18n/locales/tr.json b/src/i18n/locales/tr.json
index 2fe8c63..d6f7963 100644
--- a/src/i18n/locales/tr.json
+++ b/src/i18n/locales/tr.json
@@ -907,6 +907,15 @@
       "lrc_file": "İçe aktarılan .lrc dosyası",
       "api": "LRCLIB",
       "manual": "Elle giriş"
+    },
+    "format": {
+      "lrc": "Senkronize",
+      "enhanced_lrc": "Sözcük sözcük senkronize",
+      "ttml": "TTML sözcük sözcük",
+      "plain": "Senkronsuz"
+    },
+    "toast": {
+      "tagWriteSkipped": "TTML yalnızca önbellekte tutuldu (ses etiketine yazılmadı)"
     }
   },
   "duplicates": {
@@ -1034,7 +1043,14 @@
       "label": "Genel kaydırma",
       "help": "Tüm yakalanan satırları aynı değer kadar kaydırır — yeknesak biçimde erken veya geç olan içe aktarılmış LRC dosyalarını düzeltmek için kullanışlıdır",
       "reset": "Kaydırmayı sıfırla"
-    }
+    },
+    "granularity": {
+      "label": "Ayrıntı düzeyi:",
+      "line": "Satır satır",
+      "word": "Sözcük sözcük"
+    },
+    "captureHintWord": "Boşluk = sonraki sözcük · Enter = sonraki satır · Geri = son sözcüğü geri al",
+    "notCaptured": "Yakalanmadı"
   },
   "sort": {
     "title": "Başlık",
diff --git a/src/i18n/locales/zh-CN.json b/src/i18n/locales/zh-CN.json
index 7b96a77..3551fd4 100644
--- a/src/i18n/locales/zh-CN.json
+++ b/src/i18n/locales/zh-CN.json
@@ -907,6 +907,15 @@
       "lrc_file": "已导入的 .lrc 文件",
       "api": "LRCLIB",
       "manual": "手动输入"
+    },
+    "format": {
+      "lrc": "已同步",
+      "enhanced_lrc": "逐词同步",
+      "ttml": "TTML 逐词",
+      "plain": "未同步"
+    },
+    "toast": {
+      "tagWriteSkipped": "TTML 仅保留在缓存中（未写入音频标签）"
     }
   },
   "duplicates": {
@@ -1034,7 +1043,14 @@
       "label": "整体偏移",
       "help": "将所有已捕获行整体偏移相同的时长——适用于导入的 LRC 文件整体提前或滞后的情况",
       "reset": "重置偏移"
-    }
+    },
+    "granularity": {
+      "label": "粒度：",
+      "line": "逐行",
+      "word": "逐词"
+    },
+    "captureHintWord": "空格 = 下一个词 · 回车 = 下一行 · Backspace = 撤销最后一个词",
+    "notCaptured": "未捕获"
   },
   "sort": {
     "title": "标题",
diff --git a/src/i18n/locales/zh-TW.json b/src/i18n/locales/zh-TW.json
index 7e64ef5..9ee4c18 100644
--- a/src/i18n/locales/zh-TW.json
+++ b/src/i18n/locales/zh-TW.json
@@ -907,6 +907,15 @@
       "lrc_file": "已匯入的 .lrc 檔案",
       "api": "LRCLIB",
       "manual": "手動輸入"
+    },
+    "format": {
+      "lrc": "已同步",
+      "enhanced_lrc": "逐字同步",
+      "ttml": "TTML 逐字",
+      "plain": "未同步"
+    },
+    "toast": {
+      "tagWriteSkipped": "TTML 僅保留在快取中（未寫入音訊標籤）"
     }
   },
   "duplicates": {
@@ -1034,7 +1043,14 @@
       "label": "整體偏移",
       "help": "將所有已擷取行整體偏移相同的時長——適用於匯入的 LRC 檔案整體提前或落後的情況",
       "reset": "重設偏移"
-    }
+    },
+    "granularity": {
+      "label": "粒度：",
+      "line": "逐行",
+      "word": "逐字"
+    },
+    "captureHintWord": "空格鍵 = 下一個字 · Enter = 下一行 · Backspace = 取消最後一個字",
+    "notCaptured": "未擷取"
   },
   "sort": {
     "title": "標題",
diff --git a/src/lib/tauri/lyrics.ts b/src/lib/tauri/lyrics.ts
index a335342..e9baa8c 100644
--- a/src/lib/tauri/lyrics.ts
+++ b/src/lib/tauri/lyrics.ts
@@ -1,6 +1,6 @@
 import { invoke } from "@tauri-apps/api/core";
 
-export type LyricsFormat = "plain" | "lrc" | "enhanced_lrc";
+export type LyricsFormat = "plain" | "lrc" | "enhanced_lrc" | "ttml";
 export type LyricsSource = "embedded" | "lrc_file" | "api" | "manual";
 
 export interface LyricsPayload {
@@ -8,6 +8,14 @@ export interface LyricsPayload {
   content: string;
   format: LyricsFormat;
   source: LyricsSource;
+  /**
+   * Set by `save_lyrics` when the user asked for `write_to_file` but
+   * the audio container can't carry the chosen format (currently TTML
+   * on MP3/ID3v2). The DB cache is still updated; the UI surfaces a
+   * toast so the user knows the file itself wasn't touched. Absent on
+   * every other return path.
+   */
+  tag_write_skipped?: boolean;
 }
 
 /** Cache-only lookup. Returns null when no row exists yet. */
@@ -42,10 +50,12 @@ export function clearLyrics(trackId: number): Promise<void> {
 
 export interface SaveLyricsPayload {
   content: string;
-  format: "plain" | "lrc";
+  format: "plain" | "lrc" | "enhanced_lrc" | "ttml";
   /**
    * When true, the backend also writes the lyrics into the audio
    * file's USLT/LYRICS/©lyr frame. Disabled writes are cache-only.
+   * TTML on MP3 is silently skipped (see `tag_write_skipped` on the
+   * returned payload).
    */
   write_to_file: boolean;
 }
@@ -63,10 +73,13 @@ export function saveLyrics(
 }
 
 /**
- * Format a millisecond timestamp as the LRC `[mm:ss.xx]` tag.
- * Centisecond precision matches Musicolet / LRCLIB output.
+ * Format a millisecond timestamp as `<open>mm:ss.xx<close>`.
+ * Centisecond precision matches Musicolet / LRCLIB output. Used with
+ * `[` / `]` for LRC line stamps and `<` / `>` for Enhanced LRC inline
+ * word stamps — picking the delimiters up-front avoids string-replace
+ * round-trips on a known-good output.
  */
-export function formatLrcTimestamp(timeMs: number): string {
+function formatTimestamp(timeMs: number, open: string, close: string): string {
   const safe = Math.max(0, Math.floor(timeMs));
   const minutes = Math.floor(safe / 60_000);
   const seconds = Math.floor((safe % 60_000) / 1000);
@@ -74,7 +87,15 @@ export function formatLrcTimestamp(timeMs: number): string {
   const mm = minutes.toString().padStart(2, "0");
   const ss = seconds.toString().padStart(2, "0");
   const cc = centis.toString().padStart(2, "0");
-  return `[${mm}:${ss}.${cc}]`;
+  return `${open}${mm}:${ss}.${cc}${close}`;
+}
+
+/**
+ * Format a millisecond timestamp as the LRC `[mm:ss.xx]` tag.
+ * Centisecond precision matches Musicolet / LRCLIB output.
+ */
+export function formatLrcTimestamp(timeMs: number): string {
+  return formatTimestamp(timeMs, "[", "]");
 }
 
 /**
@@ -126,49 +147,391 @@ export function cancelLyricsPrefetch(): Promise<boolean> {
   return invoke<boolean>("cancel_lyrics_prefetch");
 }
 
-// ── LRC parser ──────────────────────────────────────────────────────
+// ── Lyrics parsers (LRC + Enhanced LRC + TTML) ──────────────────────
+
+/**
+ * One karaoke word within a synchronized line. `endMs` is the
+ * timestamp at which the next word becomes active — for the last word
+ * of a line it falls back to the next line's `timeMs` (or +∞ on the
+ * very last line).
+ */
+export interface LyricsWord {
+  timeMs: number;
+  endMs: number;
+  text: string;
+}
 
-export interface LrcLine {
-  /** Timestamp in milliseconds when this line should be highlighted. */
+/**
+ * Unified line type returned by every parser. Components that don't
+ * care about word-level timing can ignore `words`; the karaoke view
+ * uses it when present to drive the per-word highlight animation.
+ *
+ * Kept structurally compatible with the legacy `LrcLine` shape so
+ * existing call sites (`findActiveLineIndex`, panel scroll, etc.)
+ * keep working without per-call casts.
+ */
+export interface LyricsLine {
   timeMs: number;
-  /** Plain text of the line (HTML-safe — no markup expected from LRC). */
+  /** End of this line in ms. -1 if unknown (e.g. last line). */
+  endMs: number;
+  /** Plain text — for word-timed lines, this is the joined word text. */
   text: string;
+  /** Per-word timestamps when the source format provides them. */
+  words?: LyricsWord[];
 }
 
-const LRC_TIMESTAMP_RE = /\[(\d{1,3}):(\d{1,2})(?:[.:](\d{1,3}))?\]/g;
+/** Backwards-compatible alias used across the panel + fullscreen views. */
+export type LrcLine = LyricsLine;
+
+const LRC_LINE_STAMP_RE = /\[(\d{1,3}):(\d{1,2})(?:[.:](\d{1,3}))?\]/g;
+const LRC_WORD_STAMP_RE = /<(\d{1,3}):(\d{1,2})(?:[.:](\d{1,3}))?>/g;
+
+/** `mm:ss(.xx|:xx)?` → ms. Pads fractions to 3 digits then truncates. */
+function lrcStampToMs(
+  minutes: string,
+  seconds: string,
+  fraction?: string,
+): number {
+  const m = Number(minutes);
+  const s = Number(seconds);
+  const fracMs = Number((fraction ?? "0").padEnd(3, "0").slice(0, 3));
+  return m * 60_000 + s * 1000 + fracMs;
+}
 
 /**
- * Parse an LRC string into time-stamped lines, sorted by ascending
- * timestamp. Lines without a timestamp (e.g. `[ar:Artist]` metadata
- * tags or stray text) are dropped. A single text line carrying
- * multiple timestamps yields multiple entries.
- *
- * Returns an empty array if no timestamps are found — the caller
- * should fall back to plain rendering in that case.
+ * Parse a plain LRC string (line-level timestamps only) into a sorted
+ * list of `LyricsLine`. Lines without a timestamp are dropped; a
+ * single text line carrying multiple timestamps yields multiple
+ * entries. Returns an empty array when no stamps are found — the
+ * caller should fall back to plain rendering.
  */
-export function parseLrc(content: string): LrcLine[] {
-  const out: LrcLine[] = [];
+export function parseLrc(content: string): LyricsLine[] {
+  const out: LyricsLine[] = [];
   for (const raw of content.split(/\r?\n/)) {
-    LRC_TIMESTAMP_RE.lastIndex = 0;
+    LRC_LINE_STAMP_RE.lastIndex = 0;
     const stamps: number[] = [];
     let match: RegExpExecArray | null;
-    while ((match = LRC_TIMESTAMP_RE.exec(raw)) !== null) {
-      const minutes = Number(match[1]);
-      const seconds = Number(match[2]);
-      const fracRaw = match[3] ?? "0";
-      // LRC fractional is hundredths of a second; .xxx is rare but
-      // valid. Pad to 3 digits then divide to get ms.
-      const fracMs = Number(fracRaw.padEnd(3, "0").slice(0, 3));
-      stamps.push(minutes * 60_000 + seconds * 1000 + fracMs);
+    while ((match = LRC_LINE_STAMP_RE.exec(raw)) !== null) {
+      stamps.push(lrcStampToMs(match[1], match[2], match[3]));
     }
     if (stamps.length === 0) continue;
-    const text = raw.replace(LRC_TIMESTAMP_RE, "").trim();
+    const text = raw.replace(LRC_LINE_STAMP_RE, "").trim();
     for (const timeMs of stamps) {
-      out.push({ timeMs, text });
+      out.push({ timeMs, endMs: -1, text });
     }
   }
   out.sort((a, b) => a.timeMs - b.timeMs);
-  return out;
+  return fillEndTimestamps(out);
+}
+
+/**
+ * Parse Enhanced LRC (`[mm:ss.xx]La <mm:ss.xx>nuit <mm:ss.xx>tombe`).
+ * Each line keeps its line-level `timeMs` and gets a `words[]` array
+ * with one entry per `<mm:ss.xx>word` token. A line with stamps but
+ * no inline word stamps gracefully degrades to the plain LRC layout
+ * (no `words` field).
+ */
+export function parseEnhancedLrc(content: string): LyricsLine[] {
+  const lines: LyricsLine[] = [];
+  for (const raw of content.split(/\r?\n/)) {
+    LRC_LINE_STAMP_RE.lastIndex = 0;
+    const lineStamps: number[] = [];
+    let m: RegExpExecArray | null;
+    while ((m = LRC_LINE_STAMP_RE.exec(raw)) !== null) {
+      lineStamps.push(lrcStampToMs(m[1], m[2], m[3]));
+    }
+    if (lineStamps.length === 0) continue;
+    const body = raw.replace(LRC_LINE_STAMP_RE, "");
+
+    LRC_WORD_STAMP_RE.lastIndex = 0;
+    const wordStamps: Array<{ at: number; timeMs: number }> = [];
+    let wm: RegExpExecArray | null;
+    while ((wm = LRC_WORD_STAMP_RE.exec(body)) !== null) {
+      wordStamps.push({
+        at: wm.index,
+        timeMs: lrcStampToMs(wm[1], wm[2], wm[3]),
+      });
+    }
+
+    if (wordStamps.length === 0) {
+      // Plain LRC line — keep the text as-is.
+      const text = body.trim();
+      for (const timeMs of lineStamps) {
+        lines.push({ timeMs, endMs: -1, text });
+      }
+      continue;
+    }
+
+    // Slice the body between consecutive word stamps to recover the
+    // word text. The slice from `wordStamps[i]` end to the next stamp
+    // start is the displayed word.
+    const built: LyricsWord[] = [];
+
+    // Any text before the first inline word stamp is sung at the
+    // line's own timestamp — common when a tool emits
+    // `[mm:ss]First <mm:ss>second`. Treat it as a virtual leading
+    // word; its timeMs is rewritten per-duplicate-line in the loop
+    // below so that `[00:01][00:30]Hello <00:31>world` doesn't make
+    // every clone inherit the same first-word time.
+    const prefix = body.slice(0, wordStamps[0].at);
+    const hasPrefix = prefix.length > 0 && prefix.trim().length > 0;
+    if (hasPrefix) {
+      built.push({
+        timeMs: -1, // placeholder, set per-line below
+        endMs: wordStamps[0].timeMs,
+        text: prefix,
+      });
+    }
+
+    for (let i = 0; i < wordStamps.length; i += 1) {
+      const start =
+        wordStamps[i].at + matchedStampLength(body, wordStamps[i].at);
+      const end = i + 1 < wordStamps.length ? wordStamps[i + 1].at : body.length;
+      built.push({
+        timeMs: wordStamps[i].timeMs,
+        endMs: i + 1 < wordStamps.length ? wordStamps[i + 1].timeMs : -1,
+        text: body.slice(start, end),
+      });
+    }
+
+    // Drop trailing empty segments without timing (artefact of a
+    // trailing space after the last stamp).
+    const words = built.filter((w) => w.text.length > 0 || w.timeMs >= 0);
+    const text = words.map((w) => w.text).join("").trim();
+
+    // Deep-clone the words array per line entry so `fillEndTimestamps`
+    // can mutate each independently. For prefix-bearing lines, the
+    // virtual first word inherits the current line stamp instead of a
+    // shared placeholder.
+    for (const timeMs of lineStamps) {
+      const clonedWords = words.map((w, idx) => ({
+        ...w,
+        timeMs: hasPrefix && idx === 0 ? timeMs : w.timeMs,
+      }));
+      lines.push({ timeMs, endMs: -1, text, words: clonedWords });
+    }
+  }
+  lines.sort((a, b) => a.timeMs - b.timeMs);
+  return fillEndTimestamps(lines);
+}
+
+/** Length of the `<mm:ss(.xx)?>` token starting at `at` in `body`. */
+function matchedStampLength(body: string, at: number): number {
+  const close = body.indexOf(">", at);
+  return close < 0 ? 0 : close - at + 1;
+}
+
+/**
+ * Parse Apple-Music-style TTML. Walks `<p>` for lines and `<span>` for
+ * words. `begin`/`end` accept `HH:MM:SS.mmm`, `MM:SS.mmm`, plain
+ * seconds (`12.5s`), or a bare number of seconds.
+ *
+ * Char-level spans (TTML lets `<span>` nest inside `<span>`) are
+ * collapsed into the outer word — we don't animate character-by-char
+ * in v1.
+ *
+ * Returns an empty array if the document has no parseable lines.
+ */
+export function parseTtml(content: string): LyricsLine[] {
+  if (typeof window === "undefined" || typeof DOMParser === "undefined") {
+    return [];
+  }
+  const doc = new DOMParser().parseFromString(content, "application/xml");
+  if (doc.querySelector("parsererror")) return [];
+
+  const out: LyricsLine[] = [];
+  const paragraphs = doc.getElementsByTagName("p");
+  for (let i = 0; i < paragraphs.length; i += 1) {
+    const p = paragraphs[i];
+    const lineBegin = parseTtmlTime(p.getAttribute("begin"));
+    if (lineBegin < 0) continue;
+    const lineEnd = parseTtmlTime(p.getAttribute("end"));
+
+    // Direct child <span>s are the words. Nested spans are folded into
+    // their parent's text so char-level timing collapses cleanly.
+    const wordEls: Element[] = [];
+    for (const child of Array.from(p.children)) {
+      if (child.tagName.toLowerCase() === "span") wordEls.push(child);
+    }
+
+    let words: LyricsWord[] | undefined;
+    let text: string;
+    if (wordEls.length > 0) {
+      words = [];
+      for (let w = 0; w < wordEls.length; w += 1) {
+        const el = wordEls[w];
+        const wBegin = parseTtmlTime(el.getAttribute("begin"));
+        const wEnd = parseTtmlTime(el.getAttribute("end"));
+        if (wBegin < 0) continue;
+        // Re-attach the trailing whitespace that TTML strips so words
+        // render with their natural spacing.
+        const raw = (el.textContent ?? "").replace(/\s+/g, " ");
+        const trailing = el.nextSibling?.nodeType === Node.TEXT_NODE ? " " : "";
+        words.push({
+          timeMs: wBegin,
+          endMs: wEnd >= 0 ? wEnd : -1,
+          text: raw + trailing,
+        });
+      }
+      if (words.length === 0) words = undefined;
+      text = (words ?? []).map((w) => w.text).join("").trim();
+    } else {
+      text = (p.textContent ?? "").replace(/\s+/g, " ").trim();
+    }
+
+    if (!text && (!words || words.length === 0)) continue;
+    out.push({
+      timeMs: lineBegin,
+      endMs: lineEnd >= 0 ? lineEnd : -1,
+      text,
+      words,
+    });
+  }
+
+  out.sort((a, b) => a.timeMs - b.timeMs);
+  return fillEndTimestamps(out);
+}
+
+/**
+ * Parse a TTML `begin`/`end` clock value into milliseconds. Accepts:
+ *   - `HH:MM:SS.mmm`
+ *   - `MM:SS.mmm` / `MM:SS`
+ *   - `123.5s` (seconds, decimal allowed)
+ *   - `1500ms`
+ *   - bare seconds (`"5"` → 5000 ms)
+ * Returns -1 for null / empty / unparseable input.
+ */
+function parseTtmlTime(value: string | null): number {
+  if (value == null) return -1;
+  const s = value.trim();
+  if (!s) return -1;
+
+  if (s.endsWith("ms")) {
+    const n = Number(s.slice(0, -2));
+    return Number.isFinite(n) ? Math.round(n) : -1;
+  }
+  if (s.endsWith("s")) {
+    const n = Number(s.slice(0, -1));
+    return Number.isFinite(n) ? Math.round(n * 1000) : -1;
+  }
+
+  if (s.includes(":")) {
+    const parts = s.split(":");
+    if (parts.length === 2) {
+      const [mm, ss] = parts;
+      const m = Number(mm);
+      const sec = Number(ss);
+      if (Number.isFinite(m) && Number.isFinite(sec)) {
+        return Math.round(m * 60_000 + sec * 1000);
+      }
+      return -1;
+    }
+    if (parts.length === 3) {
+      const [hh, mm, ss] = parts;
+      const h = Number(hh);
+      const m = Number(mm);
+      const sec = Number(ss);
+      if (
+        Number.isFinite(h) &&
+        Number.isFinite(m) &&
+        Number.isFinite(sec)
+      ) {
+        return Math.round(h * 3_600_000 + m * 60_000 + sec * 1000);
+      }
+      return -1;
+    }
+    return -1;
+  }
+
+  const n = Number(s);
+  return Number.isFinite(n) ? Math.round(n * 1000) : -1;
+}
+
+/**
+ * Fill each line's `endMs` with the next line's `timeMs` (and the last
+ * word of each line gets the line's `endMs`). Pure helper used by every
+ * parser so the karaoke view can interpolate without special-casing the
+ * last entry.
+ */
+function fillEndTimestamps(lines: LyricsLine[]): LyricsLine[] {
+  for (let i = 0; i < lines.length; i += 1) {
+    if (lines[i].endMs < 0) {
+      lines[i].endMs = i + 1 < lines.length ? lines[i + 1].timeMs : -1;
+    }
+    const words = lines[i].words;
+    if (words && words.length > 0) {
+      for (let w = 0; w < words.length; w += 1) {
+        if (words[w].endMs < 0) {
+          words[w].endMs =
+            w + 1 < words.length ? words[w + 1].timeMs : lines[i].endMs;
+        }
+      }
+    }
+  }
+  return lines;
+}
+
+/**
+ * Dispatcher consumed by every UI component. Picks the right parser
+ * for `format`. Plain text returns a single line at t=0 with no
+ * `words`. Unknown / empty content returns an empty array.
+ */
+export function parseLyrics(
+  content: string,
+  format: LyricsFormat,
+): LyricsLine[] {
+  if (!content.trim()) return [];
+  switch (format) {
+    case "lrc":
+      return parseLrc(content);
+    case "enhanced_lrc":
+      return parseEnhancedLrc(content);
+    case "ttml":
+      return parseTtml(content);
+    case "plain":
+    default:
+      return [];
+  }
+}
+
+/**
+ * Serialize a list of word-stamped lines back to Enhanced LRC text.
+ * Lines without `words` fall back to a plain `[mm:ss.xx]` entry.
+ * Used by the editor when the user saves a word-timed track — TTML
+ * round-trip isn't part of v1, so we always export to Enhanced LRC.
+ *
+ * Words with `timeMs < 0` (not yet captured) are emitted **without**
+ * an inline stamp — their text is folded into the previous word so a
+ * half-finished line doesn't ship phantom `<00:00.00>word` stamps
+ * that would mis-sync on the next load. The user can re-open the
+ * editor and finish stamping later.
+ */
+export function serializeEnhancedLrc(lines: LyricsLine[]): string {
+  return lines
+    .map((line) => {
+      const stamp =
+        line.timeMs < 0 ? "[--:--.--]" : formatLrcTimestamp(line.timeMs);
+      if (!line.words || line.words.length === 0) {
+        return `${stamp}${line.text}`;
+      }
+      const parts: string[] = [];
+      for (const w of line.words) {
+        if (w.timeMs >= 0) {
+          parts.push(`${formatTimestamp(w.timeMs, "<", ">")}${w.text}`);
+        } else {
+          // Uncaptured — append the text to the previous segment so
+          // it survives the round-trip without acquiring a fake
+          // zero-second stamp.
+          if (parts.length > 0) {
+            parts[parts.length - 1] += w.text;
+          } else {
+            parts.push(w.text);
+          }
+        }
+      }
+      return `${stamp}${parts.join("")}`;
+    })
+    .join("\n");
 }
 
 /**
@@ -180,7 +543,7 @@ export function parseLrc(content: string): LrcLine[] {
  * Returns `-1` when the position is before the first line.
  */
 export function findActiveLineIndex(
-  lines: LrcLine[],
+  lines: LyricsLine[],
   positionMs: number,
   hint = 0,
 ): number {
@@ -193,3 +556,20 @@ export function findActiveLineIndex(
   while (i + 1 < lines.length && lines[i + 1].timeMs <= positionMs) i++;
   return i;
 }
+
+/**
+ * Find the index of the active word within a line's `words` array
+ * given a playback position. Returns `-1` when the position is before
+ * the first word (so the line is highlighted but no word yet).
+ */
+export function findActiveWordIndex(
+  words: LyricsWord[],
+  positionMs: number,
+  hint = 0,
+): number {
+  if (words.length === 0 || positionMs < words[0].timeMs) return -1;
+  let i = Math.max(0, Math.min(hint, words.length - 1));
+  while (i > 0 && words[i].timeMs > positionMs) i--;
+  while (i + 1 < words.length && words[i + 1].timeMs <= positionMs) i++;
+  return i;
+}