diff --git a/.gitignore b/.gitignore
index a1822ee05..24ad425eb 100644
--- a/.gitignore
+++ b/.gitignore
@@ -132,3 +132,4 @@ workbench/fixtures/
 /aur_ci
 /aur_ci.pub
 /aur_known_hosts
+tmp_handoff.md
diff --git a/crates/compositor/src/audio.rs b/crates/compositor/src/audio.rs
index e51f0f8af..b2674b85d 100644
--- a/crates/compositor/src/audio.rs
+++ b/crates/compositor/src/audio.rs
@@ -5,7 +5,7 @@
 use crate::ffi::*;
 
 use crate::regions::SpeedSegment;
-use crate::scene::SceneAudio;
+use crate::scene::{SceneAudio, SceneAudioTrack};
 use anyhow::{bail, Result};
 use std::f32::consts::PI;
 use std::ffi::CString;
@@ -1381,6 +1381,142 @@ pub fn assemble_concatenated_pcm(
     output
 }
 
+/// Mix imported audio tracks (issue #350) over the assembled programme.
+///
+/// Each track is decoded across its trim window — already resampled to 48 kHz
+/// stereo by `decode_clip_audio`, the same path a clip's own audio takes — scaled
+/// by its per-track gain (the same `10^(dB/20)` law as `finish_audio`), and summed
+/// into the programme at `start_sec`. The programme length is NOT extended: a
+/// track that runs past the video is truncated to it, so the audio and video
+/// streams stay the same length for the muxer.
+///
+/// The decode window is capped up front at the room left in the programme after
+/// `start_sec`, and a track starting at/after the end is skipped without decoding.
+/// `decode_clip_audio` preallocates from the window, so this keeps a long track
+/// pinned near a short programme's end from buffering (and clamping away) hours of
+/// PCM. `trim_end_sec` must therefore be concrete — the renderer sends
+/// `trimEnd ?? durationSec`.
+///
+/// A track whose file has no decodable audio is skipped — the same degradation a
+/// stream-less clip gets.
+pub fn mix_external_tracks(mut programme: PlanarPcm, tracks: &[SceneAudioTrack]) -> PlanarPcm {
+    let programme_len = programme.first().map(Vec::len).unwrap_or(0);
+    if programme_len == 0 {
+        return programme;
+    }
+    for track in tracks {
+        let offset = (track.start_sec.max(0.0) * AUDIO_OUTPUT_SAMPLE_RATE as f64).round() as usize;
+        // A track that starts at or past the programme end contributes nothing —
+        // skip it before decoding anything.
+        if offset >= programme_len {
+            continue;
+        }
+        let trim_start = track.trim_start_sec.max(0.0);
+        let Some(trim_end_full) = track.trim_end_sec else {
+            // Without a concrete end there is no safe window to decode (see the doc
+            // comment); the renderer always resolves one, so this only guards a
+            // hand-written scene.
+            continue;
+        };
+        // Cap the decode window at the room left in the programme. Everything past
+        // `offset` that overflows is discarded by `overlay_track_pcm` anyway, so
+        // decoding it only wastes time and memory — a three-hour track placed at
+        // second 9 of a ten-second export must not buffer three hours of PCM.
+        let remaining_sec = (programme_len - offset) as f64 / AUDIO_OUTPUT_SAMPLE_RATE as f64;
+        let trim_end = trim_end_full.min(trim_start + remaining_sec);
+        if trim_end <= trim_start {
+            continue;
+        }
+        let decoded = match decode_clip_audio(&track.path, trim_start, trim_end) {
+            Ok(Some(pcm)) => pcm,
+            _ => continue,
+        };
+        // The app's own range is -60..+12 dB (the inspector slider); clamping at
+        // -12 here floored every quiet bed at a tenth of the attenuation asked for.
+        let gain = 10.0f32.powf(track.gain_db.clamp(-60.0, 12.0) / 20.0);
+        overlay_track_pcm(
+            &mut programme,
+            &decoded,
+            offset,
+            gain,
+            track.fade_in_sec.max(0.0),
+            track.fade_out_sec.max(0.0),
+        );
+    }
+    programme
+}
+
+/// Sum one decoded track into the programme at `offset` samples, scaled by `gain`,
+/// truncated at the programme's end. Split out of `mix_external_tracks` so the
+/// placement/gain/clamp math is testable without ffmpeg, exactly like
+/// `mix_aligned_tracks` is split from the decode above.
+fn overlay_track_pcm(
+    programme: &mut PlanarPcm,
+    decoded: &PlanarPcm,
+    offset: usize,
+    gain: f32,
+    fade_in_sec: f64,
+    fade_out_sec: f64,
+) {
+    let programme_len = programme.first().map(Vec::len).unwrap_or(0);
+    if offset >= programme_len {
+        return;
+    }
+    let room = programme_len - offset;
+    // The ramps are measured against the DECODED length, not the room left in the
+    // programme: a track running past the end is cut off there, and a fade-out
+    // timed to the cut would ramp down over audio the export never reaches.
+    let decoded_len = decoded.iter().map(Vec::len).max().unwrap_or(0);
+    let (fade_in, fade_out) = resolve_fade_samples(decoded_len, fade_in_sec, fade_out_sec);
+    for channel in 0..AUDIO_OUTPUT_CHANNELS {
+        let Some(source) = decoded.get(channel) else {
+            continue;
+        };
+        let count = source.len().min(room);
+        let dst = &mut programme[channel];
+        for k in 0..count {
+            dst[offset + k] += source[k] * gain * fade_envelope(k, decoded_len, fade_in, fade_out);
+        }
+    }
+}
+
+/// Fade lengths in samples, reduced to fit inside `len`.
+///
+/// Fades that do not fit share the window in proportion rather than being clamped
+/// independently: clamping each to the length first would turn an asymmetric pair
+/// into a symmetric one, losing the shape asked for. Kept identical to the app's
+/// `resolveFadeSecs` so the preview and the render agree.
+fn resolve_fade_samples(len: usize, fade_in_sec: f64, fade_out_sec: f64) -> (usize, usize) {
+    if len == 0 {
+        return (0, 0);
+    }
+    let rate = AUDIO_OUTPUT_SAMPLE_RATE as f64;
+    let mut fade_in = fade_in_sec.max(0.0) * rate;
+    let mut fade_out = fade_out_sec.max(0.0) * rate;
+    let total = fade_in + fade_out;
+    if total > len as f64 && total > 0.0 {
+        let scale = len as f64 / total;
+        fade_in *= scale;
+        fade_out *= scale;
+    }
+    (fade_in.round() as usize, fade_out.round() as usize)
+}
+
+/// Linear ramp factor at sample `k` of a `len`-sample track.
+fn fade_envelope(k: usize, len: usize, fade_in: usize, fade_out: usize) -> f32 {
+    let mut v = 1.0f32;
+    if fade_in > 0 && k < fade_in {
+        v = v.min(k as f32 / fade_in as f32);
+    }
+    if fade_out > 0 && len > k {
+        let remaining = len - k;
+        if remaining <= fade_out {
+            v = v.min(remaining as f32 / fade_out as f32);
+        }
+    }
+    v
+}
+
 /// Encodeur AAC attaché au muxer avant son header. Les paquets utilisent le même interleaver
 /// que la vidéo ; les pts restent en unités échantillon jusqu'au rescale vers l'AVStream.
 pub(crate) struct AacEncoder {
@@ -1692,6 +1828,68 @@ mod tests {
         assert_eq!(mixed[1], vec![0.25, -0.5, 0.75]);
     }
 
+    // Imported audio track overlay (issue #350).
+    #[test]
+    fn overlay_sums_at_offset_with_gain() {
+        let mut programme = planar(&[0.1, 0.1, 0.1, 0.1]);
+        // ×2 gain, placed at sample offset 1.
+        overlay_track_pcm(&mut programme, &planar(&[0.2, 0.2]), 1, 2.0, 0.0, 0.0);
+        assert_eq!(programme[0], vec![0.1, 0.5, 0.5, 0.1]);
+        assert_eq!(programme[1], vec![0.1, 0.5, 0.5, 0.1]);
+    }
+
+    #[test]
+    fn overlay_truncates_a_track_that_runs_past_the_programme() {
+        let mut programme = planar(&[0.0, 0.0, 0.0]);
+        // A 4-sample track placed at offset 2 has room for only 1 sample.
+        overlay_track_pcm(&mut programme, &planar(&[1.0, 1.0, 1.0, 1.0]), 2, 1.0, 0.0, 0.0);
+        assert_eq!(programme[0], vec![0.0, 0.0, 1.0]);
+    }
+
+    #[test]
+    fn overlay_past_the_end_is_a_no_op() {
+        let mut programme = planar(&[0.3, 0.3]);
+        overlay_track_pcm(&mut programme, &planar(&[1.0]), 5, 1.0, 0.0, 0.0);
+        assert_eq!(programme[0], vec![0.3, 0.3]);
+    }
+
+    #[test]
+    fn mix_external_tracks_skips_empty_windows() {
+        let programme = planar(&[0.4, 0.4]);
+        let tracks = vec![SceneAudioTrack {
+            path: "/nope.mp3".into(),
+            start_sec: 0.0,
+            gain_db: 0.0,
+            trim_start_sec: 2.0,
+            trim_end_sec: Some(1.0), // end <= start: empty window, never decoded
+            fade_in_sec: 0.0,
+            fade_out_sec: 0.0,
+        }];
+        // The empty window is skipped before any decode, so the programme is
+        // untouched even though the path does not exist.
+        let out = mix_external_tracks(programme, &tracks);
+        assert_eq!(out[0], vec![0.4, 0.4]);
+    }
+
+    #[test]
+    fn mix_external_tracks_skips_a_track_that_starts_past_the_programme() {
+        // 2 samples = ~0.00004 s of programme at 48 kHz; the track starts at 1 s, so
+        // its offset is past the end. It must be skipped before any decode is
+        // attempted (the path does not exist), never buffering its window.
+        let programme = planar(&[0.4, 0.4]);
+        let tracks = vec![SceneAudioTrack {
+            path: "/nope.mp3".into(),
+            start_sec: 1.0,
+            gain_db: 0.0,
+            trim_start_sec: 0.0,
+            trim_end_sec: Some(3600.0),
+            fade_in_sec: 0.0,
+            fade_out_sec: 0.0,
+        }];
+        let out = mix_external_tracks(programme, &tracks);
+        assert_eq!(out[0], vec![0.4, 0.4]);
+    }
+
     #[test]
     fn single_track_is_not_clamped() {
         // Promesse de non-régression : une source mono-piste ressort telle quelle, y compris
@@ -1784,6 +1982,73 @@ mod tests {
         assert!((loud[0][0] - ceiling).abs() < 1e-6);
     }
 
+    #[test]
+    fn fades_that_fit_are_left_alone() {
+        let rate = AUDIO_OUTPUT_SAMPLE_RATE as f64;
+        let (fin, fout) = resolve_fade_samples(rate as usize, 0.1, 0.2);
+        assert_eq!(fin, (0.1 * rate).round() as usize);
+        assert_eq!(fout, (0.2 * rate).round() as usize);
+    }
+
+    #[test]
+    fn fades_too_long_for_the_track_share_it_in_proportion() {
+        // 6 s + 4 s of fade on a 2 s track → 1.2 s / 0.8 s, not a clamped 1 s / 1 s.
+        // Mirrors `resolveFadeSecs` on the app side; the two must agree or the
+        // preview and the render shape the same track differently.
+        let rate = AUDIO_OUTPUT_SAMPLE_RATE as f64;
+        let len = (2.0 * rate) as usize;
+        let (fin, fout) = resolve_fade_samples(len, 6.0, 4.0);
+        assert_eq!(fin, (1.2 * rate).round() as usize);
+        assert_eq!(fout, (0.8 * rate).round() as usize);
+        assert!(fin + fout <= len + 1);
+    }
+
+    #[test]
+    fn a_fade_in_longer_than_the_track_still_reaches_full_volume() {
+        // Left unreduced this holds the gain near zero for the whole track — the
+        // layer exports silent.
+        let (fin, fout) = resolve_fade_samples(100, 10.0, 0.0);
+        assert_eq!((fin, fout), (100, 0));
+        assert!((fade_envelope(99, 100, fin, fout) - 0.99).abs() < 1e-3);
+    }
+
+    #[test]
+    fn the_envelope_ramps_at_both_edges_and_holds_between() {
+        assert_eq!(fade_envelope(0, 100, 10, 10), 0.0);
+        assert!((fade_envelope(5, 100, 10, 10) - 0.5).abs() < 1e-6);
+        assert_eq!(fade_envelope(50, 100, 10, 10), 1.0);
+        assert!((fade_envelope(95, 100, 10, 10) - 0.5).abs() < 1e-6);
+    }
+
+    #[test]
+    fn overlay_applies_the_fade_over_the_decoded_length() {
+        // The ramps are measured against the DECODED length, not the room left in
+        // the programme: a fade-out timed to the programme's end would ramp down
+        // over audio the export never reaches.
+        let mut programme = planar(&[0.0, 0.0, 0.0, 0.0]);
+        let decoded = planar(&[1.0, 1.0, 1.0, 1.0]);
+        // A 4-sample fade-in at 48 kHz is far below one sample of real time, so
+        // ask for the whole decoded length in seconds.
+        let four = 4.0 / AUDIO_OUTPUT_SAMPLE_RATE as f64;
+        overlay_track_pcm(&mut programme, &decoded, 0, 1.0, four, 0.0);
+        assert_eq!(programme[0][0], 0.0);
+        assert!(programme[0][1] > 0.0 && programme[0][1] < 1.0);
+        assert!(programme[0][3] > programme[0][1]);
+    }
+
+    #[test]
+    fn a_track_gain_below_the_output_bound_is_honoured() {
+        // The per-track gain range is the inspector's -60..+12, NOT the project
+        // output trim's ±12: clamping here at -12 floored every quiet bed at a
+        // tenth of the attenuation asked for.
+        let mut programme = planar(&[0.0]);
+        let decoded = planar(&[1.0]);
+        let gain = 10.0f32.powf(-40.0 / 20.0);
+        overlay_track_pcm(&mut programme, &decoded, 0, gain, 0.0, 0.0);
+        assert!((programme[0][0] - gain).abs() < 1e-9);
+        assert!(programme[0][0] < 10.0f32.powf(-12.0 / 20.0));
+    }
+
     #[test]
     fn output_is_clipped_to_full_scale_and_keeps_its_length() {
         // The trim can push a hot signal past full scale; the timeline must come back the
diff --git a/crates/compositor/src/pipeline_linux.rs b/crates/compositor/src/pipeline_linux.rs
index 235a32917..9a58a5443 100644
--- a/crates/compositor/src/pipeline_linux.rs
+++ b/crates/compositor/src/pipeline_linux.rs
@@ -21,7 +21,7 @@ use std::ffi::CString;
 use std::ptr;
 
 use crate::audio::{
-    assemble_concatenated_pcm, build_audio_concat_plan, finish_audio,
+    assemble_concatenated_pcm, build_audio_concat_plan, finish_audio, mix_external_tracks,
     AacEncoder, PlanarPcm,
 };
 use crate::audio_jobs::{decode_and_stretch_clip_audio, ClipAudioJobs};
@@ -459,6 +459,12 @@ pub fn run_composited_multi(
 
     let scene = comp.scene_snapshot();
     let audio_settings = scene.as_ref().map(|scene| scene.audio).unwrap_or_default();
+    // Imported audio tracks (issue #350), cloned out of the borrowed scene so the
+    // mix step below owns them. Empty for a project with no imported audio.
+    let audio_tracks = scene
+        .as_ref()
+        .map(|scene| scene.audio_tracks.clone())
+        .unwrap_or_default();
     // Ring de staging a 2 : l'export ne veut que du debit, une frame de latence
     // ne se voit pas dans un fichier. Voir `Compositor::set_readback_depth` pour
     // la raison pour laquelle la preview, elle, reste a 1.
@@ -552,7 +558,10 @@ pub fn run_composited_multi(
         let declared_audio: Vec<bool> = clips.iter().map(|c| c.has_audio).collect();
         let plan = build_audio_concat_plan(&clip_frame_counts, &declared_audio, out_fps as f64);
         audio_encoder.encode(
-            &finish_audio(assemble_concatenated_pcm(&clip_pcm, &plan), audio_settings),
+            &finish_audio(
+                mix_external_tracks(assemble_concatenated_pcm(&clip_pcm, &plan), &audio_tracks),
+                audio_settings,
+            ),
             octx,
         )?;
         crate::ffi::averr(crate::ffi::av_write_trailer(octx), "write_trailer")?;
diff --git a/crates/compositor/src/pipeline_macos.rs b/crates/compositor/src/pipeline_macos.rs
index c7cf571bc..f8afc95b5 100644
--- a/crates/compositor/src/pipeline_macos.rs
+++ b/crates/compositor/src/pipeline_macos.rs
@@ -30,7 +30,7 @@
 //! décodeurs, symétrique.
 
 use crate::audio::{
-    assemble_concatenated_pcm, build_audio_concat_plan, finish_audio,
+    assemble_concatenated_pcm, build_audio_concat_plan, finish_audio, mix_external_tracks,
     AacEncoder, PlanarPcm,
 };
 use crate::audio_jobs::{decode_and_stretch_clip_audio, ClipAudioJobs};
@@ -1078,6 +1078,11 @@ pub fn run_composited_multi(
     // raconte avoir déjà coûté une fois.
     let scene = comp.scene_snapshot();
     let audio_settings = scene.as_ref().map(|scene| scene.audio).unwrap_or_default();
+    // Imported audio tracks (issue #350), cloned out of the borrowed scene.
+    let audio_tracks = scene
+        .as_ref()
+        .map(|scene| scene.audio_tracks.clone())
+        .unwrap_or_default();
     frames = unsafe {
         crate::timeline_walk::walk_composited_timeline(
             clips,
@@ -1146,7 +1151,10 @@ pub fn run_composited_multi(
         let declared_audio: Vec<bool> = clips.iter().map(|clip| clip.has_audio).collect();
         let plan = build_audio_concat_plan(&clip_frame_counts, &declared_audio, out_fps as f64);
         audio_encoder.encode(
-            &finish_audio(assemble_concatenated_pcm(&clip_pcm, &plan), audio_settings),
+            &finish_audio(
+                mix_external_tracks(assemble_concatenated_pcm(&clip_pcm, &plan), &audio_tracks),
+                audio_settings,
+            ),
             octx,
         )?;
 
diff --git a/crates/compositor/src/pipeline_windows.rs b/crates/compositor/src/pipeline_windows.rs
index 5fff82056..a3d1a7d68 100644
--- a/crates/compositor/src/pipeline_windows.rs
+++ b/crates/compositor/src/pipeline_windows.rs
@@ -3,7 +3,7 @@
 //! tout le run, deux lectures seulement. Rien dans la boucle ne peut fausser le fps.
 
 use crate::audio::{
-    assemble_concatenated_pcm, build_audio_concat_plan, finish_audio,
+    assemble_concatenated_pcm, build_audio_concat_plan, finish_audio, mix_external_tracks,
     AacEncoder, PlanarPcm,
 };
 use crate::audio_jobs::{decode_and_stretch_clip_audio, ClipAudioJobs};
@@ -1344,6 +1344,11 @@ unsafe fn run_multi_inner(
     // fenêtrage par clip ; `walk_composited_timeline` s'en charge.
     let scene = comp.scene_snapshot();
     let audio_settings = scene.as_ref().map(|scene| scene.audio).unwrap_or_default();
+    // Imported audio tracks (issue #350), cloned out of the borrowed scene.
+    let audio_tracks = scene
+        .as_ref()
+        .map(|scene| scene.audio_tracks.clone())
+        .unwrap_or_default();
 
     // ---- encodeur (choisi à l'exécution, cf. ExportCodec::candidates) + mux ----
     // Backend CPU : pas de pool D3D11 du tout. `av_hwdevice_ctx_init(D3D11VA)` échoue sur
@@ -1477,7 +1482,7 @@ unsafe fn run_multi_inner(
         out_fps as f64,
     );
     let assembled_audio = finish_audio(
-        assemble_concatenated_pcm(&clip_pcm, &audio_plan),
+        mix_external_tracks(assemble_concatenated_pcm(&clip_pcm, &audio_plan), &audio_tracks),
         audio_settings,
     );
     audio_encoder.encode(&assembled_audio, octx)?;
diff --git a/crates/compositor/src/scene.rs b/crates/compositor/src/scene.rs
index ff300d475..7a4905a2f 100644
--- a/crates/compositor/src/scene.rs
+++ b/crates/compositor/src/scene.rs
@@ -432,6 +432,39 @@ pub struct SceneAudio {
     pub gain_db: f32,
 }
 
+/// One imported audio track (issue #350) mixed over the assembled programme —
+/// voiceover / BGM / SFX. Deliberately a SEPARATE `Scene` field rather than a
+/// member of `SceneAudio`, so `SceneAudio` stays `Copy` and the pipelines keep
+/// copying it out of a borrow unchanged.
+///
+/// `start_sec` is the track's head on the OUTPUT programme; `trim_start_sec` /
+/// `trim_end_sec` window the source file (both source seconds). The renderer
+/// resolves `start_sec` from the track's raw timeline position — equal to it when
+/// the project has no trims/speed, which is the case this first cut mixes exactly.
+#[derive(Debug, Clone, Default, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SceneAudioTrack {
+    pub path: String,
+    #[serde(default)]
+    pub start_sec: f64,
+    #[serde(default)]
+    pub gain_db: f32,
+    #[serde(default)]
+    pub trim_start_sec: f64,
+    #[serde(default)]
+    pub trim_end_sec: Option<f64>,
+    /// Ramp lengths at this entry's own edges, in seconds. The app puts them only
+    /// on the pieces that touch the track's real start and end, so a split or
+    /// looping track fades once instead of at every cut or repeat.
+    ///
+    /// `#[serde(default)]` for the usual reason: a payload from a build that
+    /// predates the field must degrade to "no fade", not fail the whole scene.
+    #[serde(default)]
+    pub fade_in_sec: f64,
+    #[serde(default)]
+    pub fade_out_sec: f64,
+}
+
 #[derive(Debug, Clone, Copy, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct SceneOutput {
@@ -500,6 +533,10 @@ pub struct Scene {
     /// Global audio finishing. Default keeps old scene payloads bit-for-bit compatible.
     #[serde(default)]
     pub audio: SceneAudio,
+    /// Imported audio tracks mixed over the programme (issue #350). `#[serde(default)]`:
+    /// absent from every scene written before this, and from a project with none.
+    #[serde(default)]
+    pub audio_tracks: Vec<SceneAudioTrack>,
     /// Crop écran par clip, dans le même ordre que `clips` (`cropByClip` côté TS).
     #[serde(default)]
     pub crop_by_clip: Vec<Option<SceneCrop>>,
diff --git a/electron/ai-edition/document-service.test.ts b/electron/ai-edition/document-service.test.ts
index 6cbdb97c9..bf3d12289 100644
--- a/electron/ai-edition/document-service.test.ts
+++ b/electron/ai-edition/document-service.test.ts
@@ -280,6 +280,63 @@ describe("DocumentService", () => {
 			expect(after.project.primaryAssetId).toBe(first.project.primaryAssetId);
 			expect(after.assets).toHaveLength(2);
 		});
+
+		// Issue #350 — external audio import (voiceover / BGM / SFX).
+		it("appends an audio asset without claiming the primary slot", async () => {
+			const doc = await service.createProject("P");
+			const updated = await service.addAsset(doc.project.id, {
+				path: "/tmp/voiceover.mp3",
+				kind: "audio",
+			});
+			expect(updated.assets).toHaveLength(1);
+			expect(updated.assets[0]?.kind).toBe("audio");
+			// An audio-only file must never become the project's primary asset, even
+			// when it is the first file added to an otherwise-empty project.
+			expect(updated.project.primaryAssetId).toBeUndefined();
+		});
+
+		it("keeps the existing video primary when an audio track is added", async () => {
+			const doc = await service.createProject("P");
+			const withVideo = await service.addAsset(doc.project.id, { path: "/tmp/screen.mp4" });
+			const primary = withVideo.project.primaryAssetId;
+			const withAudio = await service.addAsset(doc.project.id, {
+				path: "/tmp/bgm.wav",
+				kind: "audio",
+			});
+			expect(withAudio.project.primaryAssetId).toBe(primary);
+			expect(withAudio.assets).toHaveLength(2);
+		});
+
+		it("rejects unsupported audio extensions", async () => {
+			const doc = await service.createProject("P");
+			await expect(
+				service.addAsset(doc.project.id, { path: "/tmp/clip.mp4", kind: "audio" }),
+			).rejects.toBeInstanceOf(ProjectFileError);
+		});
+
+		it("accepts a recorded .webm take as audio", async () => {
+			// MediaRecorder writes a voiceover as webm/opus — the same extension a
+			// screen recording uses. The caller has already declared the kind here,
+			// so this gate must take it; only the import PICKER, which has nothing
+			// but the extension to go on, still refuses .webm as audio.
+			const doc = await service.createProject("P");
+			const next = await service.addAsset(doc.project.id, {
+				path: "/tmp/voiceover-2026.webm",
+				kind: "audio",
+			});
+			expect(next.assets.at(-1)).toMatchObject({ kind: "audio" });
+			// ...and it must not have claimed the primary (video-only) slot.
+			expect(next.project.primaryAssetId).toBeUndefined();
+		});
+
+		it("accepts a video extension under the default kind but not as audio", async () => {
+			const doc = await service.createProject("P");
+			// The same extension routing works in reverse: an .mp3 is fine as audio
+			// but rejected as video (covered above), and an .mp4 is the opposite.
+			await expect(
+				service.addAsset(doc.project.id, { path: "/tmp/a.mp3", kind: "audio" }),
+			).resolves.toBeDefined();
+		});
 	});
 
 	describe("removeAsset", () => {
@@ -363,6 +420,57 @@ describe("DocumentService", () => {
 			expect(after.project.primaryAssetId).toBe(b.assets[1]?.id);
 		});
 
+		// Issue #350 — an audio overlay can never be primary.
+		it("passes primary to the next VIDEO asset, never to an audio asset", async () => {
+			const doc = await service.createProject("P");
+			const video = await service.addAsset(doc.project.id, { path: "/tmp/screen.mp4" });
+			await service.addAsset(doc.project.id, { path: "/tmp/music.mp3", kind: "audio" });
+			const primaryId = video.project.primaryAssetId;
+			expect(primaryId).toBeTruthy();
+			// Removing the only video leaves just the audio asset; primary must clear,
+			// not fall to the audio one.
+			const after = await service.removeAsset(doc.project.id, primaryId ?? "");
+			expect(after.project.primaryAssetId).toBeUndefined();
+			expect(after.assets).toHaveLength(1);
+			expect(after.assets[0]?.kind).toBe("audio");
+		});
+
+		it("drops audioTracks that referenced a removed audio asset", async () => {
+			const doc = await service.createProject("P");
+			await service.addAsset(doc.project.id, { path: "/tmp/screen.mp4" });
+			const withAudio = await service.addAsset(doc.project.id, {
+				path: "/tmp/music.mp3",
+				kind: "audio",
+			});
+			const audioId = withAudio.assets.find((a) => a.kind === "audio")?.id ?? "";
+			expect(audioId).toBeTruthy();
+			const withTrack = await service.saveProject({
+				...withAudio,
+				audioTracks: [
+					{
+						id: "trk_1",
+						assetId: audioId,
+						kind: "music",
+						startMs: 0,
+						endMs: 10_000,
+						durationSec: 10,
+						offsetMs: 0,
+						gainDb: 0,
+						loop: false,
+						fadeInMs: 0,
+						fadeOutMs: 0,
+						muted: false,
+						label: "music",
+						origin: "user",
+					},
+				],
+			});
+			expect(withTrack.audioTracks).toHaveLength(1);
+			const after = await service.removeAsset(doc.project.id, audioId);
+			expect(after.audioTracks).toEqual([]);
+			expect(after.assets.some((a) => a.id === audioId)).toBe(false);
+		});
+
 		it("resequences other assets and rederives their anchored regions", async () => {
 			const created = await service.createProject("P");
 			const withA = await service.addAsset(created.project.id, { path: "/tmp/a.mp4" });
diff --git a/electron/ai-edition/document-service.ts b/electron/ai-edition/document-service.ts
index 3c93e3bc0..9c9b958b9 100644
--- a/electron/ai-edition/document-service.ts
+++ b/electron/ai-edition/document-service.ts
@@ -38,6 +38,9 @@ export interface ProjectSummary {
 export interface AddAssetInput {
 	path: string;
 	label?: string;
+	// "audio" imports an external voiceover / BGM / SFX file (issue #350).
+	// Defaults to "video" when omitted, so existing callers are unaffected.
+	kind?: "video" | "audio";
 }
 
 export class DocumentNotFoundError extends Error {
@@ -72,6 +75,35 @@ function isSupportedVideoPath(filePath: string): boolean {
 	return SUPPORTED_VIDEO_EXTENSIONS.has(ext);
 }
 
+// Imported audio (issue #350). Decoding is handled downstream by the same
+// WebCodecs / ffmpeg paths that read a video's audio track, so this list is the
+// container formats decodeAudioData and the compositor can open.
+// What may be filed as an AUDIO asset. Deliberately WIDER than the import
+// picker's list in `electron/ipc/handlers.ts`: this gate runs when the caller
+// has already declared `kind: "audio"`, so it only has to reject files that
+// could not carry audio at all, whereas the picker has to guess from the
+// extension alone and must not offer a video as audio.
+//
+// `.webm` is exactly that difference. An in-editor voiceover take is written by
+// MediaRecorder as webm/opus — the same extension a screen recording uses — so
+// the picker rightly refuses it while this gate must accept it.
+const SUPPORTED_AUDIO_EXTENSIONS = new Set([
+	".mp3",
+	".wav",
+	".m4a",
+	".aac",
+	".flac",
+	".ogg",
+	".oga",
+	".opus",
+	".webm",
+]);
+
+function isSupportedAudioPath(filePath: string): boolean {
+	const ext = path.extname(filePath).toLowerCase();
+	return SUPPORTED_AUDIO_EXTENSIONS.has(ext);
+}
+
 function safeProjectId(raw: string): string {
 	// ponytail: project ids are uuid-prefixed strings (e.g. "proj_<uuid>"). Reject
 	// anything that smells like path traversal before we ever touch the disk.
@@ -283,7 +315,15 @@ export class DocumentService {
 		if (!input.path) {
 			throw new ProjectFileError("Asset path is required.", projectId);
 		}
-		if (!isSupportedVideoPath(input.path)) {
+		const kind = input.kind ?? "video";
+		if (kind === "audio") {
+			if (!isSupportedAudioPath(input.path)) {
+				throw new ProjectFileError(
+					`Unsupported audio extension: ${path.extname(input.path)} (supported: ${[...SUPPORTED_AUDIO_EXTENSIONS].join(", ")})`,
+					projectId,
+				);
+			}
+		} else if (!isSupportedVideoPath(input.path)) {
 			throw new ProjectFileError(
 				`Unsupported video extension: ${path.extname(input.path)} (supported: ${[...SUPPORTED_VIDEO_EXTENSIONS].join(", ")})`,
 				projectId,
@@ -300,18 +340,24 @@ export class DocumentService {
 		}
 		const asset: AxcutAsset = {
 			id: createId("asset"),
-			kind: "video",
+			kind,
 			label: input.label?.trim() || path.basename(absolutePath),
 			originalPath: absolutePath,
 			sizeBytes,
 			cameraTrack: null,
 		};
+		// An audio import is an overlay, never the thing the timeline is built
+		// around, so it must not claim the empty primaryAssetId slot — otherwise the
+		// first file dropped into a fresh project (a BGM track) would become its
+		// primary asset and the editor would try to lay out clips from a file with
+		// no video.
+		const claimsPrimary = kind !== "audio" && !doc.project.primaryAssetId;
 		const next: AxcutDocument = {
 			...doc,
 			assets: [...doc.assets, asset],
 			project: {
 				...doc.project,
-				...(doc.project.primaryAssetId ? {} : { primaryAssetId: asset.id }),
+				...(claimsPrimary ? { primaryAssetId: asset.id } : {}),
 				updatedAt: new Date().toISOString(),
 			},
 		};
@@ -324,9 +370,13 @@ export class DocumentService {
 			throw new ProjectFileError(`Asset ${assetId} not found in project ${projectId}.`, projectId);
 		}
 		const assets = doc.assets.filter((a) => a.id !== assetId);
+		// Primary is the thing the timeline is built around, so it must fall to the
+		// next VIDEO asset — never an audio overlay (issue #350), which can't be
+		// primary (see addAsset). Falling back to `assets[0]` would hand primary to
+		// an audio asset when the removed one was the last video.
 		const primaryAssetId =
 			doc.project.primaryAssetId === assetId
-				? (assets[0]?.id ?? undefined)
+				? (assets.find((a) => a.kind !== "audio")?.id ?? undefined)
 				: doc.project.primaryAssetId;
 		const withoutAssetClips = doc.timeline.clips
 			.filter((clip) => clip.assetId === assetId)
@@ -334,6 +384,9 @@ export class DocumentService {
 		const next: AxcutDocument = {
 			...withoutAssetClips,
 			assets,
+			// Drop imported audio tracks that referenced the removed asset — they
+			// would otherwise dangle, pointing at an asset the document no longer has.
+			audioTracks: withoutAssetClips.audioTracks.filter((t) => t.assetId !== assetId),
 			timeline: {
 				...withoutAssetClips.timeline,
 				trimRanges: withoutAssetClips.timeline.trimRanges.filter((r) => r.assetId !== assetId),
diff --git a/electron/electron-env.d.ts b/electron/electron-env.d.ts
index e140a4e37..6de7a3cc4 100644
--- a/electron/electron-env.d.ts
+++ b/electron/electron-env.d.ts
@@ -289,6 +289,22 @@ interface Window {
 			name?: string;
 			canceled?: boolean;
 		}>;
+		// Import an external audio file from the timeline toolbar (issue #350).
+		openAudioFilePicker: () => Promise<{
+			success: boolean;
+			path?: string;
+			name?: string;
+			canceled?: boolean;
+			message?: string;
+		}>;
+		// Persist an in-editor voiceover take (raw MediaRecorder bytes) under the
+		// recordings dir, so it outlives the session like every other asset.
+		saveRecordedVoiceover: (data: ArrayBuffer) => Promise<{
+			success: boolean;
+			path?: string;
+			message?: string;
+			error?: string;
+		}>;
 		setCurrentVideoPath: (path: string) => Promise<{ success: boolean }>;
 		setCurrentRecordingSession: (
 			session: import("../src/lib/recordingSession").RecordingSession | null,
diff --git a/electron/ipc/handlers.ts b/electron/ipc/handlers.ts
index aa2014670..f404daa84 100644
--- a/electron/ipc/handlers.ts
+++ b/electron/ipc/handlers.ts
@@ -107,6 +107,9 @@ const ALLOWED_IMPORT_VIDEO_EXTENSIONS = new Set([
 	".ts",
 ]);
 const PREVIEW_AUDIO_DIR = path.join(app.getPath("userData"), "preview-audio");
+// See the save-recorded-voiceover handler: an upper bound on renderer-supplied
+// bytes written to disk, well past any plausible take.
+const MAX_RECORDED_VOICEOVER_BYTES = 512 * 1024 * 1024;
 const nativeMacCaptureEvents = new EventEmitter();
 
 // Enumeration walks every display and window and grabs a thumbnail of each, so it
@@ -186,6 +189,34 @@ function hasAllowedImportVideoExtension(filePath: string): boolean {
 	return ALLOWED_IMPORT_VIDEO_EXTENSIONS.has(path.extname(filePath).toLowerCase());
 }
 
+// Imported audio (issue #350). Kept separate from the video set so the two
+// pickers stay honest — an audio picker must not approve a video path and vice
+// versa. A SUBSET of SUPPORTED_AUDIO_EXTENSIONS in the document service, which
+// also accepts `.webm`: that gate is told the kind by its caller, while this one
+// only has the extension to go on and `.webm` is far more often a video.
+const ALLOWED_IMPORT_AUDIO_EXTENSIONS = new Set([
+	".mp3",
+	".wav",
+	".m4a",
+	".aac",
+	".flac",
+	".ogg",
+	".opus",
+]);
+
+function hasAllowedImportAudioExtension(filePath: string): boolean {
+	return ALLOWED_IMPORT_AUDIO_EXTENSIONS.has(path.extname(filePath).toLowerCase());
+}
+
+// Video OR audio. The type-specific pickers stay honest (see the audio set's
+// comment), but the generic media READS — peaks, binary, file-info, chunk — serve
+// whichever kind the document points at, so they must accept both. Gating them on
+// video alone dropped every imported audio path once `approvedPaths` was empty
+// (a project reopen), and the waveform was lost for good (issue #350).
+function hasAllowedImportMediaExtension(filePath: string): boolean {
+	return hasAllowedImportVideoExtension(filePath) || hasAllowedImportAudioExtension(filePath);
+}
+
 function runProcess(
 	command: string,
 	args: string[],
@@ -282,8 +313,13 @@ async function prepareSupplementalPreviewAudioTrack(videoPath: string) {
 	return { success: true, path: pathToFileURL(outputPath).toString() };
 }
 
-async function approveReadableVideoPath(
-	filePath?: string | null,
+// Shared core behind the media path approvers. `hasAllowedExtension` is the ONLY
+// thing that differs between video and audio imports, so it is the single knob:
+// an already-approved path passes regardless, otherwise the extension gate,
+// optional trusted-dir confinement, and a stat check decide whether to approve.
+async function approveReadableMediaPath(
+	filePath: string | null | undefined,
+	hasAllowedExtension: (p: string) => boolean,
 	trustedDirs?: string[],
 ): Promise<string | null> {
 	const normalizedPath = normalizeVideoSourcePath(filePath);
@@ -295,7 +331,7 @@ async function approveReadableVideoPath(
 		return normalizedPath;
 	}
 
-	if (!hasAllowedImportVideoExtension(normalizedPath)) {
+	if (!hasAllowedExtension(normalizedPath)) {
 		return null;
 	}
 
@@ -322,6 +358,29 @@ async function approveReadableVideoPath(
 	return normalizedPath;
 }
 
+function approveReadableVideoPath(
+	filePath?: string | null,
+	trustedDirs?: string[],
+): Promise<string | null> {
+	return approveReadableMediaPath(filePath, hasAllowedImportVideoExtension, trustedDirs);
+}
+
+function approveReadableAudioPath(
+	filePath?: string | null,
+	trustedDirs?: string[],
+): Promise<string | null> {
+	return approveReadableMediaPath(filePath, hasAllowedImportAudioExtension, trustedDirs);
+}
+
+// For the generic media reads that accept either kind — NOT for the pickers,
+// which must stay type-specific (see `hasAllowedImportMediaExtension`).
+function approveReadableAvPath(
+	filePath?: string | null,
+	trustedDirs?: string[],
+): Promise<string | null> {
+	return approveReadableMediaPath(filePath, hasAllowedImportMediaExtension, trustedDirs);
+}
+
 function resolveRecordingOutputPath(fileName: string): string {
 	const trimmed = fileName.trim();
 	if (!trimmed) {
@@ -3590,6 +3649,8 @@ export function registerIpcHandlers(
 		}
 	});
 
+	// The media tab imports VIDEO (it arranges clips). Audio is imported from the
+	// timeline toolbar instead (issue #350) — see `open-audio-file-picker` below.
 	ipcMain.handle("open-video-file-picker", async () => {
 		try {
 			const dialogOptions = buildDialogOptions(
@@ -3636,6 +3697,84 @@ export function registerIpcHandlers(
 		}
 	});
 
+	// Import an external audio file (voiceover / BGM / SFX) — issue #350. Driven by
+	// the timeline's "Add audio" tool: audio is a timeline overlay (like an
+	// annotation), not a media-tab clip, so it has its own audio-only picker and the
+	// renderer adds it as a kind:"audio" asset + track at the playhead.
+	ipcMain.handle("open-audio-file-picker", async () => {
+		try {
+			const dialogOptions = buildDialogOptions(
+				{
+					title: mainT("dialogs", "fileDialogs.selectAudio"),
+					defaultPath: RECORDINGS_DIR,
+					filters: [
+						{
+							name: mainT("dialogs", "fileDialogs.audioFiles"),
+							extensions: ["mp3", "wav", "m4a", "aac", "flac", "ogg", "opus"],
+						},
+						{ name: mainT("dialogs", "fileDialogs.allFiles"), extensions: ["*"] },
+					],
+					properties: ["openFile"],
+				},
+				getMainWindow(),
+			);
+			const result = await dialog.showOpenDialog(dialogOptions);
+
+			if (result.canceled || result.filePaths.length === 0) {
+				return { success: false, canceled: true };
+			}
+
+			const normalizedPath = await approveReadableAudioPath(result.filePaths[0]);
+			if (!normalizedPath) {
+				return {
+					success: false,
+					message: "Selected file is not a supported readable audio file",
+				};
+			}
+
+			return {
+				success: true,
+				path: normalizedPath,
+			};
+		} catch (error) {
+			console.error("Failed to open audio file picker:", error);
+			return {
+				success: false,
+				message: "Failed to open audio file picker",
+				error: String(error),
+			};
+		}
+	});
+
+	// In-editor voiceover recording: the renderer hands over the raw MediaRecorder
+	// blob (webm/opus) and gets back the path it landed at, under the recordings
+	// dir so it lives with the project's other media and survives relaunches.
+	ipcMain.handle("save-recorded-voiceover", async (_event, data: ArrayBuffer) => {
+		try {
+			if (!(data instanceof ArrayBuffer) || data.byteLength === 0) {
+				return { success: false, message: "Empty recording" };
+			}
+			// A cap, because this writes renderer-supplied bytes straight to disk. An
+			// hour of Opus is a few tens of MB, so 512 MB is far past any real take
+			// and still refuses a runaway or malformed payload before it is buffered.
+			if (data.byteLength > MAX_RECORDED_VOICEOVER_BYTES) {
+				return { success: false, message: "Recording too large" };
+			}
+			await fs.mkdir(RECORDINGS_DIR, { recursive: true });
+			const fileName = `voiceover-${new Date().toISOString().replace(/[:.]/g, "-")}.webm`;
+			const target = path.join(RECORDINGS_DIR, fileName);
+			await fs.writeFile(target, Buffer.from(data));
+			return { success: true, path: target };
+		} catch (error) {
+			console.error("Failed to save recorded voiceover:", error);
+			return {
+				success: false,
+				message: "Failed to save recorded voiceover",
+				error: String(error),
+			};
+		}
+	});
+
 	ipcMain.handle("reveal-in-folder", async (_, filePath: string) => {
 		try {
 			// showItemInFolder returns nothing, it throws on error
@@ -3661,7 +3800,7 @@ export function registerIpcHandlers(
 
 	ipcMain.handle("read-binary-file", async (_, filePath: string) => {
 		try {
-			const normalizedPath = await approveReadableVideoPath(filePath);
+			const normalizedPath = await approveReadableAvPath(filePath);
 			if (!normalizedPath) {
 				return {
 					success: false,
@@ -3691,7 +3830,7 @@ export function registerIpcHandlers(
 	// recording above that can never be loaded whole — see read-file-chunk).
 	ipcMain.handle("get-readable-file-info", async (_, filePath: string) => {
 		try {
-			const normalizedPath = await approveReadableVideoPath(filePath);
+			const normalizedPath = await approveReadableAvPath(filePath);
 			if (!normalizedPath) {
 				return {
 					success: false,
@@ -3727,7 +3866,7 @@ export function registerIpcHandlers(
 		async (_, filePath: string, durationSec: number): Promise<AudioPeaksResult> => {
 			try {
 				// Same approval gate as every other read of a renderer-supplied path.
-				const normalizedPath = await approveReadableVideoPath(filePath);
+				const normalizedPath = await approveReadableAvPath(filePath);
 				if (!normalizedPath) {
 					return { success: false, message: "File path is not approved" };
 				}
@@ -3751,7 +3890,7 @@ export function registerIpcHandlers(
 	// do (2 GiB cap) and a 16 GB machine cannot hold for multi-GB recordings.
 	ipcMain.handle("read-file-chunk", async (_, filePath: string, offset: number, length: number) => {
 		try {
-			const normalizedPath = await approveReadableVideoPath(filePath);
+			const normalizedPath = await approveReadableAvPath(filePath);
 			if (!normalizedPath) {
 				return {
 					success: false,
diff --git a/electron/ipc/nativeBridge.ts b/electron/ipc/nativeBridge.ts
index 5d4992c10..7b01e0b2f 100644
--- a/electron/ipc/nativeBridge.ts
+++ b/electron/ipc/nativeBridge.ts
@@ -489,6 +489,7 @@ export function registerNativeBridgeHandlers(context: NativeBridgeContext) {
 									request.payload.projectId,
 									request.payload.path,
 									request.payload.label,
+									request.payload.kind,
 								),
 							);
 						case "document.removeAsset":
diff --git a/electron/native-bridge/services/aiEditionService.ts b/electron/native-bridge/services/aiEditionService.ts
index 0fbbccc9c..90088781a 100644
--- a/electron/native-bridge/services/aiEditionService.ts
+++ b/electron/native-bridge/services/aiEditionService.ts
@@ -151,9 +151,17 @@ export class AiEditionService {
 		}
 	}
 
-	async addAsset(projectId: string, path: string, label?: string): Promise<AiEditionAssetResult> {
-		const document = await this.options.documents.addAsset(projectId, { path, label });
-		const assetId = document.project.primaryAssetId ?? document.assets.at(-1)?.id ?? "";
+	async addAsset(
+		projectId: string,
+		path: string,
+		label?: string,
+		kind?: "video" | "audio",
+	): Promise<AiEditionAssetResult> {
+		const document = await this.options.documents.addAsset(projectId, { path, label, kind });
+		// The just-added asset is always the last one; primaryAssetId is only a
+		// fallback for the video case and would point at the wrong asset for an
+		// audio import (which never claims primary), so prefer the tail.
+		const assetId = document.assets.at(-1)?.id ?? document.project.primaryAssetId ?? "";
 		return { assetId, document };
 	}
 
diff --git a/electron/preload.ts b/electron/preload.ts
index 6aff16407..7873bef90 100644
--- a/electron/preload.ts
+++ b/electron/preload.ts
@@ -276,6 +276,12 @@ contextBridge.exposeInMainWorld("electronAPI", {
 	openVideoFilePicker: () => {
 		return ipcRenderer.invoke("open-video-file-picker");
 	},
+	openAudioFilePicker: () => {
+		return ipcRenderer.invoke("open-audio-file-picker");
+	},
+	saveRecordedVoiceover: (data: ArrayBuffer) => {
+		return ipcRenderer.invoke("save-recorded-voiceover", data);
+	},
 	setCurrentVideoPath: (path: string) => {
 		return ipcRenderer.invoke("set-current-video-path", path);
 	},
diff --git a/src/components/ai-edition/EditorEmptyState.test.tsx b/src/components/ai-edition/EditorEmptyState.test.tsx
index acb513e4b..be7f130b7 100644
--- a/src/components/ai-edition/EditorEmptyState.test.tsx
+++ b/src/components/ai-edition/EditorEmptyState.test.tsx
@@ -53,6 +53,7 @@ const sampleDoc = vi.hoisted(
 		},
 		annotations: [],
 		zoomRanges: [],
+		audioTracks: [],
 		legacyEditor: null,
 	}),
 );
diff --git a/src/components/ai-edition/ExportDialog.showInFolder.test.tsx b/src/components/ai-edition/ExportDialog.showInFolder.test.tsx
index c5b45637c..52eb7b2ad 100644
--- a/src/components/ai-edition/ExportDialog.showInFolder.test.tsx
+++ b/src/components/ai-edition/ExportDialog.showInFolder.test.tsx
@@ -77,6 +77,7 @@ const DOC: AxcutDocument = {
 	},
 	annotations: [],
 	zoomRanges: [],
+	audioTracks: [],
 	legacyEditor: null,
 };
 
diff --git a/src/components/ai-edition/ExportDialog.test.ts b/src/components/ai-edition/ExportDialog.test.ts
index 3aa8d85b5..ed2f1ab1a 100644
--- a/src/components/ai-edition/ExportDialog.test.ts
+++ b/src/components/ai-edition/ExportDialog.test.ts
@@ -57,6 +57,7 @@ function doc(assets: AxcutAsset[], clips: AxcutClip[]): AxcutDocument {
 		},
 		annotations: [],
 		zoomRanges: [],
+		audioTracks: [],
 		legacyEditor: null,
 	};
 }
diff --git a/src/components/ai-edition/NewEditorShell.tsx b/src/components/ai-edition/NewEditorShell.tsx
index b371d100c..58d2ad83b 100644
--- a/src/components/ai-edition/NewEditorShell.tsx
+++ b/src/components/ai-edition/NewEditorShell.tsx
@@ -14,7 +14,7 @@ import {
 	replaceTimeline as replaceTimelineOp,
 } from "@/lib/ai-edition/document/timeline";
 import { isModalOpen } from "@/lib/ai-edition/modalGuard";
-import { type AxcutClip, documentSchema } from "@/lib/ai-edition/schema";
+import { type AxcutAudioTrack, type AxcutClip, documentSchema } from "@/lib/ai-edition/schema";
 import { useProjectStore } from "@/lib/ai-edition/store/projectStore";
 import {
 	useAssetTranscriptions,
@@ -44,6 +44,7 @@ import {
 import { Preview } from "./Preview";
 import type { TrimTarget } from "./RightPanes";
 import { importPendingRecording } from "./recordingImport";
+import { AddAudioLayerDialog } from "./v4/AddAudioLayerDialog";
 import v4 from "./v4/EditorShellV4.module.css";
 import { type EditorMode, EditorTopBar } from "./v4/EditorTopBar";
 import { type Facet, FloatingInspector } from "./v4/FloatingInspector";
@@ -73,6 +74,10 @@ interface SeekTarget {
  * handlers that need it. The store write cadence is unchanged — `currentTimeSec`
  * is still the source of truth, still updated every frame.
  */
+// Stable empty list: a fresh `[]` each render would churn the preview's audio
+// element set on every playhead tick.
+const NO_AUDIO_TRACKS: AxcutAudioTrack[] = [];
+
 function NativePlaybackSync({
 	visibleClips,
 	clips,
@@ -427,7 +432,16 @@ export function NewEditorShell() {
 	const handleDropAsset = useCallback(
 		(assetId: string) =>
 			enqueueTimelineWrite(() => {
-				const at = useProjectStore.getState().document?.timeline.clips.length ?? 0;
+				const doc = useProjectStore.getState().document;
+				// An audio asset has no video, so it must never become a clip (issue
+				// #350) — it goes on the audio lane as a track. Adding it "to the
+				// timeline" reuses its existing track if it already has one (importing
+				// already placed one) so the same file can't stack up duplicate lanes.
+				if (doc?.assets.find((a) => a.id === assetId)?.kind === "audio") {
+					if (doc.audioTracks.some((t) => t.assetId === assetId)) return Promise.resolve();
+					return tl.addAudioTrack(assetId).then(() => undefined);
+				}
+				const at = doc?.timeline.clips.length ?? 0;
 				return tl.insertClipAt(assetId, at);
 			}).catch((error) => {
 				toast.error(te("mediaStage.couldNotAddAsset"), {
@@ -770,6 +784,56 @@ export function NewEditorShell() {
 		});
 	}, []);
 
+	// Voiceover recording (the one audio gesture that is not a file import). The
+	// dialog owns the mic; the shell owns the transport and the placement.
+	const [voiceoverFlow, setVoiceoverFlow] = useState<{ maxDurationSec: number } | null>(null);
+	// The playhead as it was when RECORDING STARTED. Recording plays the video so
+	// the user can narrate what they see, which means the live playhead has moved
+	// on by the take's own length by the time the take ends — reading it then
+	// placed every voiceover one full take-length to the right of where it was
+	// spoken. Captured on the way in, used on the way out.
+	const voiceoverStartSecRef = useRef(0);
+
+	const openVoiceoverFlow = useCallback(() => {
+		const doc = useProjectStore.getState().document;
+		if (!doc) return;
+		const total = doc.timeline.clips.reduce((max, c) => Math.max(max, c.timelineEndSec), 0);
+		const playhead = useProjectStore.getState().currentTimeSec;
+		voiceoverStartSecRef.current = playhead;
+		// Recording stops itself at the end of the timeline: a take can never
+		// outlive the video it was recorded over.
+		setVoiceoverFlow({ maxDurationSec: Math.max(0.5, total - playhead) });
+	}, []);
+
+	// Silences the timeline's own audio tracks for the duration of a take — see
+	// where it is passed to the preview.
+	const [voiceoverRecording, setVoiceoverRecording] = useState(false);
+
+	const handleVoiceoverRecordingStart = useCallback(() => {
+		// Re-capture: the user may have scrubbed between opening the dialog and
+		// hitting Record, and playback starts from wherever the playhead is now.
+		voiceoverStartSecRef.current = useProjectStore.getState().currentTimeSec;
+		setVoiceoverRecording(true);
+		if (videoElement?.paused) void videoElement.play().catch(() => undefined);
+	}, [videoElement]);
+
+	const handleVoiceoverRecordingStop = useCallback(() => {
+		setVoiceoverRecording(false);
+		videoElement?.pause();
+	}, [videoElement]);
+
+	const handleVoiceoverReady = useCallback(
+		async (assetId: string, durationSec: number) => {
+			setVoiceoverFlow(null);
+			await tl.addAudioTrack(assetId, voiceoverStartSecRef.current, {
+				kind: "voiceover",
+				durationSec,
+				spanSec: durationSec,
+			});
+		},
+		[tl],
+	);
+
 	const pasteRegion = useCallback(async () => {
 		const doc = useProjectStore.getState().document;
 		if (!doc) return;
@@ -786,6 +850,21 @@ export function NewEditorShell() {
 			return;
 		}
 
+		// Validate before building anything. The clipboard outlives the project, so
+		// a track copied in one project and pasted in another would reference an
+		// asset that only exists back where it came from — a pill that plays
+		// nothing and exports nothing. Audio is the only kind carrying a reference
+		// out of the document today; the next one belongs here too, rather than in
+		// its own branch below.
+		const referencedAssetId = (snapshot.region as { assetId?: unknown }).assetId;
+		if (
+			typeof referencedAssetId === "string" &&
+			!doc.assets.some((a) => a.id === referencedAssetId)
+		) {
+			toast.error(te("regionClipboard.pasteAssetMissing"));
+			return;
+		}
+
 		const { anchorRegionsWithDerivedMs } = await import("@/lib/ai-edition/timeline/timelineMap");
 		const { createId } = await import("@/lib/ai-edition/document/ids");
 
@@ -793,6 +872,30 @@ export function NewEditorShell() {
 		const timeMs = Math.round(useProjectStore.getState().currentTimeSec * 1000);
 		const src = snapshot.region as { startMs: number; endMs: number };
 		const prefix = snapshot.kind === "annotation" ? "ann" : snapshot.kind;
+
+		// Audio re-ventilates through its own anchorer, which advances each
+		// fragment's source offset — the generic one would copy the offset into
+		// every fragment and restart the file at each cut.
+		if (snapshot.kind === "audio") {
+			const { anchorAudioTrackFragments } = await import("@/lib/ai-edition/document/audioTracks");
+			const track = {
+				...(snapshot.region as unknown as AxcutAudioTrack),
+				id: createId("audio"),
+				trackId: undefined,
+				startMs: timeMs,
+				endMs: timeMs + (Number(src.endMs) - Number(src.startMs)),
+			};
+			const fragments = anchorAudioTrackFragments(track, doc.timeline.clips, () =>
+				createId("audio"),
+			);
+			if (fragments.length === 0) return;
+			await saveDocument(
+				{ ...doc, audioTracks: [...doc.audioTracks, ...fragments] },
+				{ history: true },
+			);
+			toast.success("Region pasted");
+			return;
+		}
 		const pasted = {
 			...snapshot.region,
 			id: createId(prefix),
@@ -842,7 +945,7 @@ export function NewEditorShell() {
 		// `tl` belongs here now that the trim branch calls tl.addTrim: useTimeline
 		// returns a fresh object each render, so memoizing on saveDocument alone
 		// would paste through a callback holding a stale document.
-	}, [saveDocument, tl]);
+	}, [saveDocument, tl, te]);
 
 	// Copy the SELECTED pill. Reads the same arrays the lanes render, so what gets
 	// copied is what the user is looking at — the old version dug into the raw
@@ -870,6 +973,22 @@ export function NewEditorShell() {
 			return;
 		}
 
+		// An audio track is stored as one fragment per clip it covers; the user
+		// copied the PILL, so collapse it back before it goes on the clipboard.
+		if (sel.kind === "audio") {
+			const { collapseTracksToPills, trackGroupId } = await import(
+				"@/lib/ai-edition/document/audioTracks"
+			);
+			const [pill] = collapseTracksToPills(
+				tl.audioTracks.filter((t) => trackGroupId(t) === sel.id),
+			);
+			if (!pill) return;
+			copyRegion({ kind: "audio", region: pill as unknown as Record<string, unknown> });
+			setCopiedClipId(null);
+			toast.success("Region copied");
+			return;
+		}
+
 		const source =
 			sel.kind === "zoom"
 				? tl.zoomRegions
@@ -948,6 +1067,14 @@ export function NewEditorShell() {
 				}
 				if (tl.selection) {
 					void tl.removeRegion(tl.selection.kind, tl.selection.id);
+					return;
+				}
+				// An audio track is selected through its OWN channel, not `selection`
+				// (the two are mutually exclusive — see addAudioTrack), so it needs its
+				// own branch here or Delete does nothing on the one lane that looks
+				// exactly like every other.
+				if (tl.selectedAudioTrackId) {
+					void tl.removeAudioTrack(tl.selectedAudioTrackId);
 				}
 			};
 
@@ -1032,6 +1159,18 @@ export function NewEditorShell() {
 				void tl.addAnnotation(newRegionDurationSec());
 				return;
 			}
+			// Unlike its neighbours this opens a file picker rather than dropping a region at
+			// the playhead — there is nothing to size, so it takes no duration (issue #350).
+			if (matchesShortcut(e, shortcuts.addAudio, isMac)) {
+				e.preventDefault();
+				void tl.addAudio();
+				return;
+			}
+			if (matchesShortcut(e, shortcuts.addVoiceover, isMac)) {
+				e.preventDefault();
+				openVoiceoverFlow();
+				return;
+			}
 			if (matchesShortcut(e, shortcuts.addSpeed, isMac)) {
 				e.preventDefault();
 				void tl.addSpeed(newRegionDurationSec());
@@ -1235,6 +1374,16 @@ export function NewEditorShell() {
 									hasProject={hasProject}
 									hasAsset={hasAsset}
 									videoSources={videoSources}
+									// Imported audio tracks (issue #350). `videoSources` already
+									// resolves a URL for every asset (audio included), so it doubles as
+									// the audio source list; VirtualPreview looks each track up by assetId.
+									// Nothing already on the timeline plays while a take is being
+									// recorded. On speakers it bleeds straight into the microphone
+									// and lands in the new take; even on headphones, narrating over
+									// an earlier voiceover is not what the button offers. The video
+									// itself keeps playing — that is what the user is narrating to.
+									audioTracks={voiceoverRecording ? NO_AUDIO_TRACKS : tl.audioTracks}
+									audioSources={videoSources}
 									clips={clips}
 									zoomRegions={tl.zoomRegions}
 									speedRegions={tl.speedRegions}
@@ -1324,6 +1473,7 @@ export function NewEditorShell() {
 						onTogglePlay={togglePlay}
 						onPrevClip={handlePrevClip}
 						onNextClip={handleNextClip}
+						onAddVoiceover={openVoiceoverFlow}
 						onEditClip={setEditClipTarget}
 					/>
 				</div>
@@ -1383,6 +1533,21 @@ export function NewEditorShell() {
 				onChoose={handleConfirmUnsaved}
 			/>
 			<ExportDialog open={exportOpen} onClose={() => setExportOpen(false)} document={document} />
+			<AddAudioLayerDialog
+				open={voiceoverFlow !== null}
+				maxDurationSec={voiceoverFlow?.maxDurationSec ?? 0}
+				onClose={() => {
+					// Belt and braces: the recorder's own stop handler clears this, but a
+					// flow that ends any other way must not leave the timeline muted.
+					setVoiceoverRecording(false);
+					setVoiceoverFlow(null);
+				}}
+				onComplete={(assetId, durationSec) => {
+					void handleVoiceoverReady(assetId, durationSec);
+				}}
+				onRecordingStart={handleVoiceoverRecordingStart}
+				onRecordingStop={handleVoiceoverRecordingStop}
+			/>
 		</div>
 	);
 }
diff --git a/src/components/ai-edition/Preview.tsx b/src/components/ai-edition/Preview.tsx
index aaf04f2db..cd6868e75 100644
--- a/src/components/ai-edition/Preview.tsx
+++ b/src/components/ai-edition/Preview.tsx
@@ -3,6 +3,7 @@ import type { CameraFullscreenRegion, ZoomFocus } from "@/components/video-edito
 import { useScopedT } from "@/contexts/I18nContext";
 import type {
 	AxcutAnnotationRegion,
+	AxcutAudioTrack,
 	AxcutClip,
 	AxcutTrimRange,
 	AxcutZoomRegion,
@@ -21,6 +22,12 @@ interface PreviewProps {
 	hasProject: boolean;
 	hasAsset: boolean;
 	videoSources: VideoSource[];
+	/** Imported audio tracks and the (unfiltered) asset URLs they resolve to
+	 *  (issue #350). Passed straight through to VirtualPreview — unlike the video
+	 *  `previewSources` below, these are NOT narrowed to clip-referenced assets,
+	 *  since an audio track has no clip. */
+	audioTracks?: AxcutAudioTrack[];
+	audioSources?: VideoSource[];
 	clips: AxcutClip[];
 	zoomRegions?: AxcutZoomRegion[];
 	speedRegions?: SpeedRegion[];
@@ -52,6 +59,8 @@ export function Preview({
 	hasProject,
 	hasAsset,
 	videoSources,
+	audioTracks = [],
+	audioSources = [],
 	clips,
 	zoomRegions,
 	speedRegions,
@@ -178,6 +187,8 @@ export function Preview({
 				<>
 					<PreviewCanvas
 						videoSources={previewSources}
+						audioTracks={audioTracks}
+						audioSources={audioSources}
 						clips={clips}
 						zoomRegions={zoomRegions}
 						speedRegions={speedRegions}
diff --git a/src/components/ai-edition/PreviewCanvas.tsx b/src/components/ai-edition/PreviewCanvas.tsx
index 6f59e066f..150012b95 100644
--- a/src/components/ai-edition/PreviewCanvas.tsx
+++ b/src/components/ai-edition/PreviewCanvas.tsx
@@ -34,6 +34,7 @@ import { useScopedT } from "@/contexts/I18nContext";
 import { resolveAspectRatioValue } from "@/lib/ai-edition/document/outputFormat";
 import type {
 	AxcutAnnotationRegion,
+	AxcutAudioTrack,
 	AxcutClip,
 	AxcutTrimRange,
 	AxcutZoomRegion,
@@ -65,6 +66,10 @@ type BlurData = NonNullable<AxcutAnnotationRegion["blurData"]>;
 
 interface PreviewCanvasProps {
 	videoSources: VideoSource[];
+	/** Imported audio tracks + their asset URLs (issue #350), forwarded to
+	 *  VirtualPreview. */
+	audioTracks?: AxcutAudioTrack[];
+	audioSources?: VideoSource[];
 	clips: AxcutClip[];
 	zoomRegions?: AxcutZoomRegion[];
 	speedRegions?: SpeedRegion[];
diff --git a/src/components/ai-edition/RightPanes.tsx b/src/components/ai-edition/RightPanes.tsx
index 2e15f7b12..19946e085 100644
--- a/src/components/ai-edition/RightPanes.tsx
+++ b/src/components/ai-edition/RightPanes.tsx
@@ -13,6 +13,7 @@ import {
 	Layout as LayoutIcon,
 	Loader2,
 	MousePointerClick,
+	Music,
 	Sliders,
 	Trash2,
 } from "lucide-react";
@@ -38,6 +39,7 @@ import defaultCursorPreviewUrl from "@/assets/cursors/Cursor=Default.svg";
 import GradientEditor, { type GradientEditorState } from "@/components/ui/gradient-editor";
 import { Popover, PopoverContent, PopoverTrigger } from "@/components/ui/popover";
 import { useI18n, useScopedT } from "@/contexts/I18nContext";
+import { collapseTracksToPills, trackGroupId } from "@/lib/ai-edition/document/audioTracks";
 import { collectNativeFormats } from "@/lib/ai-edition/document/outputFormat";
 import type {
 	AxcutAsset,
@@ -52,6 +54,7 @@ import {
 } from "@/lib/ai-edition/store/editorSettings";
 import { useProjectStore } from "@/lib/ai-edition/store/projectStore";
 import { useEditorSettings } from "@/lib/ai-edition/store/useEditorSettings";
+import type { useTimeline } from "@/lib/ai-edition/store/useTimeline";
 import {
 	buildAggregatedSections,
 	type ClipSection,
@@ -2303,6 +2306,166 @@ export function AudioPane() {
 	);
 }
 
+type TimelineApi = ReturnType<typeof useTimeline>;
+
+// Per-track controls for the selected imported audio track (issue #350). Shown by
+// the inspector in place of the facet when an audio track is selected (see
+// FloatingInspector). The header is the generic "Audio track"; the body leads
+// with the file name, then the volume (a local live value during the drag,
+// committed as one undo step on release), then a delete button styled like the
+// region panes' (position and mute are edited on the lane itself).
+// Longest fade the inspector offers. Past a few seconds a fade stops reading as
+// a fade and starts reading as a level change, and the track's own span caps it
+// anyway (`resolveFadeSecs` reduces one that does not fit).
+const FADE_MAX_MS = 5000;
+
+export function AudioTrackPane({ tl }: { tl: TimelineApi }) {
+	const ts = useScopedT("settings");
+	const trackId = tl.selectedAudioTrackId;
+	// The document stores one clip-anchored fragment per clip the track covers;
+	// the inspector edits the user-visible TRACK, so collapse first. Editing a
+	// single fragment would let the halves of a split take disagree.
+	const track = trackId
+		? collapseTracksToPills(tl.audioTracks.filter((t) => trackGroupId(t) === trackId))[0]
+		: undefined;
+	const asset = track ? tl.assets.find((a) => a.id === track.assetId) : undefined;
+	// Live-drag values; null means "show the committed value".
+	const [liveGain, setLiveGain] = useState<number | null>(null);
+	const [liveFadeIn, setLiveFadeIn] = useState<number | null>(null);
+	const [liveFadeOut, setLiveFadeOut] = useState<number | null>(null);
+	// Drop the live value when the selected track changes: a drag released outside
+	// the input never fires onCommit, so without this an uncommitted -10 dB from
+	// track A would show as track B's gain the moment B is selected.
+	// biome-ignore lint/correctness/useExhaustiveDependencies: trackId is the trigger, not a read — the body only resets the live value.
+	useEffect(() => {
+		setLiveGain(null);
+		setLiveFadeIn(null);
+		setLiveFadeOut(null);
+	}, [trackId]);
+	if (!track) return null;
+	const fileName = track.label || asset?.label || asset?.originalPath?.split(/[\\/]/).pop() || "";
+
+	// Match the region panes' danger-outlined delete button (see SelectionPane).
+	const deleteBtnStyle: CSSProperties = {
+		display: "flex",
+		width: "100%",
+		alignItems: "center",
+		justifyContent: "center",
+		gap: 7,
+		padding: "9px 14px",
+		borderRadius: 10,
+		border: "1px solid var(--danger)",
+		background: "var(--danger-soft)",
+		color: "var(--danger)",
+		font: "600 13px var(--font-display)",
+		cursor: "pointer",
+	};
+
+	return (
+		<Pane
+			title={ts("audioTrack.defaultLabel")}
+			icon={<Music size={14} />}
+			helpText={ts("audioTrack.help")}
+		>
+			<div
+				title={fileName}
+				style={{
+					fontSize: 13,
+					fontWeight: 600,
+					color: "var(--fg)",
+					overflow: "hidden",
+					textOverflow: "ellipsis",
+					whiteSpace: "nowrap",
+					margin: "0 0 10px",
+				}}
+			>
+				{fileName}
+			</div>
+			<div className={styles.sliderGrid}>
+				<SliderCell
+					label={ts("audio.outputGain")}
+					value={liveGain ?? track.gainDb}
+					min={-AUDIO_GAIN_DB_LIMIT}
+					max={AUDIO_GAIN_DB_LIMIT}
+					step={0.5}
+					decimals={1}
+					suffix=" dB"
+					onChange={(value) => setLiveGain(value)}
+					onCommit={() => {
+						if (liveGain !== null) void tl.setAudioTrackGain(track.id, liveGain);
+						setLiveGain(null);
+					}}
+				/>
+				<SliderCell
+					label={ts("audioTrack.fadeIn")}
+					value={liveFadeIn ?? track.fadeInMs}
+					min={0}
+					max={FADE_MAX_MS}
+					step={50}
+					decimals={0}
+					suffix=" ms"
+					onChange={setLiveFadeIn}
+					onCommit={() => {
+						if (liveFadeIn !== null) void tl.updateAudioTrack(track.id, { fadeInMs: liveFadeIn });
+						setLiveFadeIn(null);
+					}}
+				/>
+				<SliderCell
+					label={ts("audioTrack.fadeOut")}
+					value={liveFadeOut ?? track.fadeOutMs}
+					min={0}
+					max={FADE_MAX_MS}
+					step={50}
+					decimals={0}
+					suffix=" ms"
+					onChange={setLiveFadeOut}
+					onCommit={() => {
+						if (liveFadeOut !== null)
+							void tl.updateAudioTrack(track.id, { fadeOutMs: liveFadeOut });
+						setLiveFadeOut(null);
+					}}
+				/>
+			</div>
+			<div className={styles.paneRow}>
+				<span className={styles.label}>{ts("audioTrack.mute")}</span>
+				<Toggle
+					checked={track.muted}
+					ariaLabel={ts("audioTrack.mute")}
+					onChange={(v) => void tl.updateAudioTrack(track.id, { muted: v })}
+				/>
+			</div>
+			<div className={styles.paneRow}>
+				<span className={styles.label}>{ts("audioTrack.loop")}</span>
+				<Toggle
+					checked={track.loop}
+					ariaLabel={ts("audioTrack.loop")}
+					// Fills the rest of the programme on the way on — see
+					// setAudioTrackLoop for why the toggle moves the edge for you.
+					onChange={(v) => void tl.setAudioTrackLoop(track.id, v)}
+				/>
+			</div>
+			<button
+				type="button"
+				className={styles.secondaryBtn}
+				onClick={() => {
+					setLiveGain(null);
+					void tl.setAudioTrackGain(track.id, 0);
+				}}
+			>
+				{ts("audio.reset")}
+			</button>
+			<button
+				type="button"
+				onClick={() => void tl.removeAudioTrack(track.id)}
+				style={deleteBtnStyle}
+			>
+				<Trash2 size={14} />
+				{ts("audioTrack.remove")}
+			</button>
+		</Pane>
+	);
+}
+
 // ─── Cursor ───────────────────────────────────────────────────────
 
 function safeAssetUrl(relativePath: string): string {
diff --git a/src/components/ai-edition/VirtualPreview.audio.test.ts b/src/components/ai-edition/VirtualPreview.audio.test.ts
index 208bf05a2..e1d6fec6d 100644
--- a/src/components/ai-edition/VirtualPreview.audio.test.ts
+++ b/src/components/ai-edition/VirtualPreview.audio.test.ts
@@ -1,8 +1,12 @@
 import { describe, expect, it } from "vitest";
+import { projectRawTimelineSecToPlayback } from "@/lib/ai-edition/document/timeline";
+import type { AxcutAudioTrack, AxcutClip, AxcutTrimRange } from "@/lib/ai-edition/schema";
 import {
 	applyPreviewAudioSettings,
 	type PreviewAudioGraph,
 	resolveAudioTrackPlayback,
+	resolveTimelineAudioPlayback,
+	timelineAudioFadeAt,
 } from "./VirtualPreview";
 
 /** Minimal stand-in: the function only ever touches `gain.gain.value`. */
@@ -80,3 +84,227 @@ describe("applyPreviewAudioSettings", () => {
 		expect(graph.gain.gain.value).toBeCloseTo(0.5, 4);
 	});
 });
+
+describe("resolveTimelineAudioPlayback", () => {
+	// A 6s track placed 10s into the RAW timeline, playing the source from 2s in.
+	const track: AxcutAudioTrack = {
+		id: "t1",
+		assetId: "a1",
+		kind: "music",
+		startMs: 10_000,
+		endMs: 16_000,
+		durationSec: 20,
+		offsetMs: 2000,
+		gainDb: 0,
+		loop: false,
+		fadeInMs: 0,
+		fadeOutMs: 0,
+		muted: false,
+		label: "",
+		origin: "user",
+	};
+	const spanSec = (t: AxcutAudioTrack) => (t.endMs - t.startMs) / 1000;
+
+	// Second arg is the track head projected to output seconds; with no trims it is
+	// just the raw head (10), so these read the same as before the output-space
+	// change — the projection is exercised separately below.
+	it("maps the playhead to a source position offset by the track offset", () => {
+		// 3s into the track's span → 2 (offset) + 3 = 5s of source.
+		expect(resolveTimelineAudioPlayback(13, 10, track, spanSec(track))).toEqual({
+			targetTimeSec: 5,
+			shouldPlay: true,
+		});
+	});
+
+	it("does not play before the track starts, parked at the in-point", () => {
+		expect(resolveTimelineAudioPlayback(9, 10, track, spanSec(track))).toEqual({
+			targetTimeSec: 2,
+			shouldPlay: false,
+		});
+	});
+
+	it("does not play past the end of its span, parked at the out-point", () => {
+		expect(resolveTimelineAudioPlayback(16, 10, track, spanSec(track))).toEqual({
+			targetTimeSec: 8,
+			shouldPlay: false,
+		});
+	});
+
+	it("goes silent when the file runs out before the span does", () => {
+		// A 5s file under a 10s span: at 6s in there is no source left, and the
+		// element holds at the end rather than restarting.
+		const short = { ...track, endMs: 20_000, offsetMs: 0, durationSec: 5 };
+		expect(resolveTimelineAudioPlayback(14, 10, short, spanSec(short))).toEqual({
+			targetTimeSec: 4,
+			shouldPlay: true,
+		});
+		expect(resolveTimelineAudioPlayback(16, 10, short, spanSec(short)).shouldPlay).toBe(false);
+	});
+
+	it("folds a looping track back into its window, in phase with the export", () => {
+		// 4s of source (offset 0, 4s file) under a 10s span.
+		const looped = { ...track, endMs: 20_000, offsetMs: 0, durationSec: 4, loop: true };
+		const span = spanSec(looped);
+		expect(resolveTimelineAudioPlayback(13, 10, looped, span).targetTimeSec).toBeCloseTo(3, 6);
+		// 5s in is 1s into the second repeat — the export's second mix entry agrees.
+		expect(resolveTimelineAudioPlayback(15, 10, looped, span).targetTimeSec).toBeCloseTo(1, 6);
+		expect(resolveTimelineAudioPlayback(15, 10, looped, span).shouldPlay).toBe(true);
+		// Past the span it stops, however much file is left.
+		expect(resolveTimelineAudioPlayback(21, 10, looped, span).shouldPlay).toBe(false);
+	});
+
+	// The regression: an interior trim must NOT skip the track's own content, so the
+	// preview stays byte-for-byte with `audio::mix_external_tracks`, which overlays the
+	// decoded window contiguously. Same scenario as Etienne's review and the projection's
+	// own test: a 10s clip with raw 2..4 cut, background track at raw head 0 spanning 0..10.
+	it("plays contiguously across an interior trim, matching the export", () => {
+		const clip: AxcutClip = {
+			id: "clip_1",
+			assetId: "asset_1",
+			sourceStartSec: 0,
+			sourceEndSec: 10,
+			timelineStartSec: 0,
+			timelineEndSec: 10,
+			wordRefs: [],
+			origin: "user",
+			reason: "",
+		};
+		const trim: AxcutTrimRange = {
+			id: "trim_1",
+			assetId: "asset_1",
+			startSec: 2,
+			endSec: 4,
+			origin: "user",
+			reason: "",
+		};
+		const bgm: AxcutAudioTrack = {
+			...track,
+			id: "bgm",
+			assetId: "a2",
+			startMs: 0,
+			endMs: 10_000,
+			durationSec: 10,
+			offsetMs: 0,
+		};
+		const project = (rawSec: number) => projectRawTimelineSecToPlayback([clip], [trim], rawSec);
+		const outputStart = project(bgm.startMs / 1000); // 0
+
+		// Raw playhead 5 sits 1s past the 2s cut → output 3. The track is a contiguous
+		// block, so it must be at source 3 — NOT source 5, which the old raw-space
+		// `local` produced (the 2s desync).
+		expect(resolveTimelineAudioPlayback(project(5), outputStart, bgm, spanSec(bgm))).toEqual({
+			targetTimeSec: 3,
+			shouldPlay: true,
+		});
+		// Just before the cut is unaffected: raw 1 → output 1 → source 1.
+		expect(
+			resolveTimelineAudioPlayback(project(1), outputStart, bgm, spanSec(bgm)).targetTimeSec,
+		).toBeCloseTo(1, 6);
+	});
+});
+
+describe("resolveTimelineAudioPlayback under a trim", () => {
+	const clip: AxcutClip = {
+		id: "clip_1",
+		assetId: "asset_1",
+		sourceStartSec: 0,
+		sourceEndSec: 20,
+		timelineStartSec: 0,
+		timelineEndSec: 20,
+		wordRefs: [],
+		origin: "user",
+		reason: "",
+	};
+	const trim: AxcutTrimRange = {
+		id: "trim_1",
+		assetId: "asset_1",
+		startSec: 4,
+		endSec: 8,
+		origin: "user",
+		reason: "",
+	};
+	const project = (rawSec: number) => projectRawTimelineSecToPlayback([clip], [trim], rawSec);
+
+	const buried: AxcutAudioTrack = {
+		id: "buried",
+		assetId: "a1",
+		kind: "music",
+		startMs: 5000,
+		endMs: 7000,
+		durationSec: 30,
+		offsetMs: 0,
+		gainDb: 0,
+		loop: false,
+		fadeInMs: 0,
+		fadeOutMs: 0,
+		muted: false,
+		label: "",
+		origin: "user",
+	};
+
+	it("never plays a track buried inside the trim", () => {
+		// Both ends project onto the cut, so the track's OUTPUT span is zero. Read
+		// off the raw span instead it stayed 2s long and played at the boundary,
+		// with nothing on screen to explain the sound.
+		const outStart = project(buried.startMs / 1000);
+		const outSpan = project(buried.endMs / 1000) - outStart;
+		expect(outSpan).toBeCloseTo(0, 6);
+		for (const raw of [3, 5, 6, 9, 12]) {
+			expect(resolveTimelineAudioPlayback(project(raw), outStart, buried, outSpan).shouldPlay).toBe(
+				false,
+			);
+		}
+	});
+
+	it("plays a track that merely crosses the trim, for the length that survives", () => {
+		const crossing = { ...buried, id: "crossing", startMs: 2000, endMs: 12_000 };
+		const outStart = project(crossing.startMs / 1000);
+		const outSpan = project(crossing.endMs / 1000) - outStart;
+		// Raw 2..12 with raw 4..8 cut leaves 6s of programme.
+		expect(outSpan).toBeCloseTo(6, 6);
+		expect(resolveTimelineAudioPlayback(project(3), outStart, crossing, outSpan).shouldPlay).toBe(
+			true,
+		);
+		// Just past the end of what survives.
+		expect(
+			resolveTimelineAudioPlayback(outStart + 6.1, outStart, crossing, outSpan).shouldPlay,
+		).toBe(false);
+	});
+});
+
+describe("timelineAudioFadeAt", () => {
+	const track: AxcutAudioTrack = {
+		id: "t1",
+		assetId: "a1",
+		kind: "music",
+		startMs: 0,
+		endMs: 10_000,
+		durationSec: 20,
+		offsetMs: 0,
+		gainDb: 0,
+		loop: false,
+		fadeInMs: 1000,
+		fadeOutMs: 2000,
+		muted: false,
+		label: "",
+		origin: "user",
+	};
+
+	it("ramps in and out over the track's own edges", () => {
+		expect(timelineAudioFadeAt(track, 0, 10)).toBe(0);
+		expect(timelineAudioFadeAt(track, 0.5, 10)).toBeCloseTo(0.5, 6);
+		expect(timelineAudioFadeAt(track, 5, 10)).toBe(1);
+		expect(timelineAudioFadeAt(track, 9, 10)).toBeCloseTo(0.5, 6);
+		expect(timelineAudioFadeAt(track, 10, 10)).toBe(0);
+	});
+
+	it("is silent when muted", () => {
+		expect(timelineAudioFadeAt({ ...track, muted: true }, 5, 10)).toBe(0);
+	});
+
+	it("still reaches full volume when a fade is longer than the span", () => {
+		// Unreduced, the ramp never completes and the track plays near-silent.
+		const long = { ...track, fadeInMs: 20_000, fadeOutMs: 0 };
+		expect(timelineAudioFadeAt(long, 2, 2)).toBe(1);
+	});
+});
diff --git a/src/components/ai-edition/VirtualPreview.playback.test.tsx b/src/components/ai-edition/VirtualPreview.playback.test.tsx
index f0389fe2a..f4ffe88a0 100644
--- a/src/components/ai-edition/VirtualPreview.playback.test.tsx
+++ b/src/components/ai-edition/VirtualPreview.playback.test.tsx
@@ -207,3 +207,176 @@ describe("VirtualPreview playback across a clip boundary", () => {
 		expect(video.pauseCalls).toHaveLength(0);
 	});
 });
+
+// Issue #350 — imported audio tracks follow the RAW virtual playhead. The
+// decision math is unit-tested in VirtualPreview.audio.test.ts; here we prove the
+// rAF loop applies it to the mounted <audio> element (seek + play/pause).
+function driveAudioEl(el: HTMLAudioElement) {
+	let currentTime = 0;
+	let paused = true;
+	Object.defineProperty(el, "currentTime", {
+		configurable: true,
+		get: () => currentTime,
+		set: (next: number) => {
+			currentTime = next;
+		},
+	});
+	Object.defineProperty(el, "paused", { configurable: true, get: () => paused });
+	Object.defineProperty(el, "duration", { configurable: true, get: () => 10 });
+	el.play = vi.fn(() => {
+		paused = false;
+		return Promise.resolve();
+	});
+	el.pause = vi.fn(() => {
+		paused = true;
+	});
+	return {
+		get currentTime() {
+			return currentTime;
+		},
+	};
+}
+
+describe("VirtualPreview imported audio tracks", () => {
+	// A 2s span at raw 2..4, playing the source from 1s in → source 1..3.
+	const track = {
+		id: "trk",
+		assetId: "aud",
+		kind: "music" as const,
+		startMs: 2000,
+		endMs: 4000,
+		durationSec: 10,
+		offsetMs: 1000,
+		gainDb: 0,
+		loop: false,
+		fadeInMs: 0,
+		fadeOutMs: 0,
+		muted: false,
+		label: "",
+		origin: "user" as const,
+	};
+
+	function mountWithAudio() {
+		const sources: VideoSource[] = [{ id: "a1", src: "file:///tmp/a1.mp4", label: "a1" }];
+		const audioSources: VideoSource[] = [{ id: "aud", src: "file:///tmp/vo.mp3", label: "vo" }];
+		const { container } = render(
+			<VirtualPreview
+				videoSources={sources}
+				audioTracks={[track]}
+				audioSources={audioSources}
+				clips={[clip("c1", "a1", 0, 10, 0)]}
+				onTimeChange={vi.fn()}
+			/>,
+		);
+		const videoEl = container.querySelector("video");
+		if (!videoEl) throw new Error("no <video>");
+		const video = driveVideo(videoEl as HTMLVideoElement);
+		act(() => fireEvent.loadedMetadata(videoEl));
+		const audioEl = container.querySelector<HTMLAudioElement>(
+			'[data-testid="preview-audio-track-trk"]',
+		);
+		if (!audioEl) throw new Error("no track <audio>");
+		return { video, audioEl, audio: driveAudioEl(audioEl) };
+	}
+
+	it("mounts one <audio> per track with the asset's URL", () => {
+		const { audioEl } = mountWithAudio();
+		expect(audioEl.getAttribute("src")).toBe("file:///tmp/vo.mp3");
+	});
+
+	it("plays inside the window at the trim-offset source time, pauses outside", () => {
+		const { video, audioEl, audio } = mountWithAudio();
+		video.play();
+		// virtualTime lands one tick after the video seek, and the audio loop reads
+		// last frame's virtualTime, so two ticks settle the decision.
+		video.seekTo(3); // virtual 3 → 1s into the 2..4 span
+		tick();
+		tick();
+		expect(audioEl.play).toHaveBeenCalled();
+		expect(audio.currentTime).toBeCloseTo(2, 1); // trimStart 1 + 1s in
+
+		video.seekTo(5); // virtual 5 → past the window end (4)
+		tick();
+		tick();
+		expect(audioEl.pause).toHaveBeenCalled();
+	});
+});
+
+// Issue #350 — a track boosted past 0 dB must sound boosted in the preview too, not just
+// in the export. `element.volume` caps at 1, so the boost has to ride a WebAudio gain node.
+// jsdom has no WebAudio, so install a minimal fake context and watch the nodes it mints.
+class FakeAudioNode {
+	connect = vi.fn();
+	disconnect = vi.fn();
+}
+class FakeGainNode extends FakeAudioNode {
+	gain = { value: 1 };
+}
+let createdGains: FakeGainNode[] = [];
+class FakeAudioContext {
+	state = "running";
+	destination = new FakeAudioNode();
+	resume = vi.fn(() => Promise.resolve());
+	close = vi.fn(() => Promise.resolve());
+	createMediaElementSource = vi.fn(() => new FakeAudioNode());
+	createGain = vi.fn(() => {
+		const node = new FakeGainNode();
+		createdGains.push(node);
+		return node;
+	});
+}
+
+describe("VirtualPreview imported audio track boost", () => {
+	beforeEach(() => {
+		createdGains = [];
+		vi.stubGlobal("AudioContext", FakeAudioContext);
+	});
+
+	// +6.0206 dB is exactly ×2 in linear gain — a boost `element.volume` (max 1) could never
+	// reach. The graph mints the output gain first, then one gain per track, so the track's
+	// node is the last one created.
+	const boosted = {
+		id: "trk",
+		assetId: "aud",
+		kind: "music" as const,
+		startMs: 2000,
+		endMs: 4000,
+		durationSec: 10,
+		offsetMs: 1000,
+		gainDb: 6.0206,
+		loop: false,
+		fadeInMs: 0,
+		fadeOutMs: 0,
+		muted: false,
+		label: "",
+		origin: "user" as const,
+	};
+
+	it("drives a per-track gain node past unity instead of capping element.volume", () => {
+		const sources: VideoSource[] = [{ id: "a1", src: "file:///tmp/a1.mp4", label: "a1" }];
+		const audioSources: VideoSource[] = [{ id: "aud", src: "file:///tmp/vo.mp3", label: "vo" }];
+		const { container } = render(
+			<VirtualPreview
+				videoSources={sources}
+				audioTracks={[boosted]}
+				audioSources={audioSources}
+				clips={[clip("c1", "a1", 0, 10, 0)]}
+				onTimeChange={vi.fn()}
+			/>,
+		);
+		const videoEl = container.querySelector("video");
+		if (!videoEl) throw new Error("no <video>");
+		driveVideo(videoEl as HTMLVideoElement);
+		act(() => fireEvent.loadedMetadata(videoEl));
+		const audioEl = container.querySelector<HTMLAudioElement>(
+			'[data-testid="preview-audio-track-trk"]',
+		);
+		if (!audioEl) throw new Error("no track <audio>");
+		driveAudioEl(audioEl);
+
+		tick(); // let the rAF stamp the live gain onto the node
+		const trackGain = createdGains.at(-1);
+		expect(trackGain?.gain.value).toBeCloseTo(2, 3); // boosted, NOT clamped to 1
+		expect(audioEl.volume).toBe(1); // volume left at unity so it doesn't double-attenuate
+	});
+});
diff --git a/src/components/ai-edition/VirtualPreview.tsx b/src/components/ai-edition/VirtualPreview.tsx
index 804cfa5a5..326bbd642 100644
--- a/src/components/ai-edition/VirtualPreview.tsx
+++ b/src/components/ai-edition/VirtualPreview.tsx
@@ -4,8 +4,17 @@ import {
 	DEFAULT_CROP_REGION,
 	MAX_NATIVE_PLAYBACK_RATE,
 } from "@/components/video-editor/types";
-import { resolvePlaybackSegments } from "@/lib/ai-edition/document/timeline";
-import type { AxcutClip, AxcutTrimRange, AxcutZoomRegion } from "@/lib/ai-edition/schema";
+import { resolveFadeSecs } from "@/lib/ai-edition/document/audioTracks";
+import {
+	projectRawTimelineSecToPlayback,
+	resolvePlaybackSegments,
+} from "@/lib/ai-edition/document/timeline";
+import type {
+	AxcutAudioTrack,
+	AxcutClip,
+	AxcutTrimRange,
+	AxcutZoomRegion,
+} from "@/lib/ai-edition/schema";
 import { audioGainScalar } from "@/lib/ai-edition/store/editorSettings";
 import { useEditorSettings } from "@/lib/ai-edition/store/useEditorSettings";
 import type { PlaybackClockRef } from "@/lib/ai-edition/timeline/playback-clock";
@@ -65,6 +74,77 @@ export function resolveAudioTrackPlayback(
 	};
 }
 
+/**
+ * Where an imported audio track (issue #350) should sit against the playback
+ * clock, and whether it should be playing there. Both arguments are in
+ * trim-compressed OUTPUT-programme seconds: `outputTimeSec` is the playhead and
+ * `outputStartSec` is the track's head, each already projected from raw through
+ * the trims by `projectRawTimelineSecToPlayback` in the caller.
+ *
+ * The track plays as one CONTIGUOUS block: `[outputStartSec, outputStartSec +
+ * (trimEnd - trimStart)]`, its source position `trimStart` plus how far the
+ * playhead is past the head. Outside that span it parks at the nearer trim edge
+ * and stays paused, the same discipline `resolveAudioTrackPlayback` uses so the
+ * rAF never seeks an element into nothing.
+ *
+ * Working in output space is what keeps the preview identical to the export: the
+ * native `audio::mix_external_tracks` overlays the decoded window
+ * `[trimStart, trimEnd]` contiguously at its projected offset, so an interior
+ * trim shortens the programme UNDER the track without cutting the track's own
+ * content. Deriving `local` from the RAW playhead instead (which jumps across a
+ * cut) made the element skip that much source and end early — the preview/export
+ * desync this fixes.
+ */
+export function resolveTimelineAudioPlayback(
+	outputTimeSec: number,
+	outputStartSec: number,
+	track: AxcutAudioTrack,
+	/** The fragment's own span in seconds — how long it plays on the timeline,
+	 *  which is independent of how much file is left after the offset. */
+	spanSec: number,
+) {
+	const offset = Math.max(0, track.offsetMs / 1000);
+	const sourceEnd = track.durationSec > 0 ? track.durationSec : offset + spanSec;
+	// The window the file has left after the offset; the fragment stops at
+	// whichever runs out first, its span or the file.
+	const windowLen = Math.max(0, sourceEnd - offset);
+	const local = outputTimeSec - outputStartSec;
+	const active = local >= 0 && local < spanSec;
+	if (track.loop && windowLen > 0) {
+		// Fold into the repeating window, exactly as the export's per-repeat mix
+		// entries do, so preview and render stay in phase.
+		return {
+			targetTimeSec: offset + (local > 0 ? local % windowLen : 0),
+			shouldPlay: active,
+		};
+	}
+	return {
+		targetTimeSec: Math.min(Math.max(offset, offset + local), sourceEnd),
+		// A file shorter than its span goes silent at the end rather than
+		// restarting: seeking a finished element back would stutter it every frame.
+		shouldPlay: active && local < windowLen,
+	};
+}
+
+/** Fraction 0..1 of a track's volume `localSec` into its span, applying the
+ *  ramps. Shares `resolveFadeSecs` with the export so a fade too long for its
+ *  span is reduced the same way on both sides. */
+export function timelineAudioFadeAt(
+	track: AxcutAudioTrack,
+	localSec: number,
+	spanSec: number,
+): number {
+	if (track.muted) return 0;
+	const { fadeInSec, fadeOutSec } = resolveFadeSecs(track.fadeInMs, track.fadeOutMs, spanSec);
+	let v = 1;
+	if (fadeInSec > 0 && localSec < fadeInSec) v = Math.min(v, Math.max(0, localSec / fadeInSec));
+	if (fadeOutSec > 0) {
+		const remaining = spanSec - localSec;
+		if (remaining < fadeOutSec) v = Math.min(v, Math.max(0, remaining / fadeOutSec));
+	}
+	return v;
+}
+
 export interface PreviewAudioGraph {
 	context: AudioContext;
 	gain: GainNode;
@@ -112,6 +192,11 @@ function findNextClipByTimelineOrder(
 
 interface VirtualPreviewProps {
 	videoSources: VideoSource[];
+	/** Imported audio tracks to mix over the video (issue #350), and the file URLs
+	 *  their assets resolve to (keyed by assetId in `id`). Both default to empty, so
+	 *  a project with no imported audio behaves exactly as before. */
+	audioTracks?: AxcutAudioTrack[];
+	audioSources?: VideoSource[];
 	clips: AxcutClip[];
 	zoomRegions?: AxcutZoomRegion[];
 	speedRegions?: SpeedRegion[];
@@ -156,6 +241,8 @@ interface VirtualPreviewProps {
 
 export function VirtualPreview({
 	videoSources,
+	audioTracks = [],
+	audioSources = [],
 	clips,
 	zoomRegions = [],
 	speedRegions = [],
@@ -206,6 +293,11 @@ export function VirtualPreview({
 	const audioContextRef = useRef<AudioContext | null>(null);
 	const audioContextCloseTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
 	const audioSourceNodesRef = useRef(new WeakMap<HTMLAudioElement, MediaElementAudioSourceNode>());
+	// Per-track gain nodes for imported audio (issue #350). Keyed by track id so the rAF
+	// can set each track's level live (a boost past 0 dB, which `element.volume` can't do —
+	// same reason the primary/supplemental sum through a gain node). The graph effect owns
+	// their lifecycle; the map is cleared and rebuilt whenever the routing is torn down.
+	const audioTrackGainNodesRef = useRef<Map<string, GainNode>>(new Map());
 	const audioGraphRef = useRef<PreviewAudioGraph | null>(null);
 	const videoFrameRef = useRef<HTMLDivElement | null>(null);
 
@@ -272,10 +364,21 @@ export function VirtualPreview({
 		};
 	}, [activeSource?.filePath]);
 
+	// Which imported-track elements are actually mounted (a track is rendered only once its
+	// asset URL resolves — see the JSX). Re-routing the graph is keyed on this set, NOT on the
+	// tracks' gains: a level change is applied live on the existing node by the rAF, so it must
+	// not tear the graph down. Joined ids change only on a real mount/unmount.
+	const mountedAudioTrackKey = audioTracks
+		.filter((track) => audioSources.some((source) => source.id === track.assetId))
+		.map((track) => track.id)
+		.join(",");
+
 	// Sum the audio elements into one gain node so the output trim can boost past 0 dB,
 	// which `element.volume` cannot do. The primary media element carries track 1; on macOS
 	// the existing IPC helper extracts track 2 (normally the microphone) so both are audible
-	// instead of Chromium silently choosing one.
+	// instead of Chromium silently choosing one. Imported tracks (issue #350) join the same
+	// graph through a per-track gain node so their boost survives the preview too.
+	// biome-ignore lint/correctness/useExhaustiveDependencies: mountedAudioTrackKey is the trigger for re-routing tracks; the elements are read from the ref.
 	useEffect(() => {
 		if (!primaryAudioEl || !audioProbeComplete) return;
 		if (supplementalAudioSrc && !supplementalAudioEl) return;
@@ -322,14 +425,48 @@ export function VirtualPreview({
 				// preview outright rather than degrade it.
 			}
 		}
+		// Imported tracks (issue #350): each mounted element gets source → per-track gain →
+		// the output gain, so the effective level is trackGain × outputGain — the same order
+		// the exporter mixes in (mix_external_tracks applies the track gain, finish_audio the
+		// output gain). The rAF sets each node's value; created here at unity as a safe default.
+		const trackGainNodes: GainNode[] = [];
+		audioTrackGainNodesRef.current = new Map();
+		for (const [trackId, element] of audioTrackElsRef.current) {
+			try {
+				let source = audioSourceNodesRef.current.get(element);
+				if (!source) {
+					source = graph.context.createMediaElementSource(element);
+					audioSourceNodesRef.current.set(element, source);
+				}
+				source.disconnect();
+				const trackGain = graph.context.createGain();
+				source.connect(trackGain);
+				trackGain.connect(graph.gain);
+				audioTrackGainNodesRef.current.set(trackId, trackGain);
+				connectedSources.push(source);
+				trackGainNodes.push(trackGain);
+			} catch {
+				// Same rationale as the primary/supplemental loop: routing THIS track failed, so
+				// leave the rest connected. The rAF falls back to `element.volume` for a track
+				// with no gain node (capped at 0 dB, but audible).
+			}
+		}
 		audioGraphRef.current = graph;
 		applyPreviewAudioSettings(graph, elements, audioGainDbRef.current);
 		return () => {
 			audioGraphRef.current = null;
 			for (const source of connectedSources) source.disconnect();
+			for (const trackGain of trackGainNodes) trackGain.disconnect();
+			audioTrackGainNodesRef.current = new Map();
 			graph.gain.disconnect();
 		};
-	}, [primaryAudioEl, supplementalAudioEl, supplementalAudioSrc, audioProbeComplete]);
+	}, [
+		primaryAudioEl,
+		supplementalAudioEl,
+		supplementalAudioSrc,
+		audioProbeComplete,
+		mountedAudioTrackKey,
+	]);
 
 	// Keep one AudioContext for the component. Closing and recreating it on an effect rerun
 	// permanently silences an HTMLAudioElement because createMediaElementSource may only be
@@ -352,6 +489,7 @@ export function VirtualPreview({
 				const context = audioContextRef.current;
 				audioContextRef.current = null;
 				audioSourceNodesRef.current = new WeakMap();
+				audioTrackGainNodesRef.current = new Map();
 				if (context) void context.close();
 			}, 0);
 		};
@@ -400,6 +538,11 @@ export function VirtualPreview({
 	// mutation.
 	const clipsRef = useRef(clips);
 	clipsRef.current = clips;
+	// Same reason as `clipsRef`: the rAF projects the playhead and each imported
+	// audio track's head raw→output every frame (see the audio-track loop), and
+	// must see the live trims, not the set captured when the loop was created.
+	const trimRangesRef = useRef(trimRanges);
+	trimRangesRef.current = trimRanges;
 	// Trim-narrowed (`resolvePlaybackSegments`) — used ONLY to detect "has the <video>'s own
 	// currentTime drifted into a trim" and where to jump it back out to. Everything ELSE in
 	// this component (`clips`/`clipsRef` above, virtualTimeSec, zoom/speed region lookups,
@@ -426,6 +569,17 @@ export function VirtualPreview({
 	virtualDurationSecRef.current = virtualDurationSec;
 	const speedRegionsRef = useRef(speedRegions);
 	speedRegionsRef.current = speedRegions;
+	// Imported audio tracks (issue #350): the rAF reads these through refs, same as
+	// everything else it touches, so a track added/edited mid-playback is picked up
+	// without re-creating the loop. `audioTrackElsRef` maps a track id to its mounted
+	// <audio> element (registered by the ref callback on render).
+	const audioTracksRef = useRef(audioTracks);
+	audioTracksRef.current = audioTracks;
+	const audioTrackElsRef = useRef<Map<string, HTMLAudioElement>>(new Map());
+	const registerAudioTrackEl = useCallback((trackId: string, element: HTMLAudioElement | null) => {
+		if (element) audioTrackElsRef.current.set(trackId, element);
+		else audioTrackElsRef.current.delete(trackId);
+	}, []);
 	// Same reasoning as `clipsRef` above, for the one thing the rAF calls rather than reads:
 	// `seekToVirtualTime` is a `useCallback` whose deps include `clips`, so it takes a new
 	// identity on every clip mutation — a REORDER included. The rAF below is deliberately
@@ -471,6 +625,105 @@ export function VirtualPreview({
 					audio.pause();
 				}
 			}
+			// Imported audio tracks (issue #350): project the playhead raw→output
+			// once, then position each track as a contiguous block against that
+			// output clock (see `resolveTimelineAudioPlayback`) so an interior trim
+			// shortens the programme without cutting the track — identical to the
+			// export's `mix_external_tracks`. Play it only inside its window, and set
+			// its level from the track gain. When the WebAudio graph is up the level
+			// rides a per-track gain node (which CAN boost past 0 dB, and the output node
+			// applies the global gain on top, matching the export); the `.volume` path is
+			// the fallback for when the graph is unavailable — there a boost caps at 0 dB.
+			const globalGain = audioGainScalar(audioGainDbRef.current);
+			// Speed-aware: under a 2x region the raw playhead races, and a projection
+			// blind to speed raced the audio's target position with it — the track
+			// was never given a faster `playbackRate`, but seeking it twice as fast
+			// amounts to the same thing. Dividing raw time by the rate turns that
+			// back into 1x wall-clock, which is what the render does too.
+			const outputTimeSec = projectRawTimelineSecToPlayback(
+				clipsRef.current,
+				trimRangesRef.current,
+				virtualTimeSecRef.current,
+				speedRegionsRef.current,
+			);
+			for (const track of audioTracksRef.current) {
+				const el = audioTrackElsRef.current.get(track.id);
+				if (!el) continue;
+				const outputStartSec = projectRawTimelineSecToPlayback(
+					clipsRef.current,
+					trimRangesRef.current,
+					track.startMs / 1000,
+					speedRegionsRef.current,
+				);
+				// Length is measured WITHOUT speed, position WITH it. A trim REMOVES
+				// timeline — a track buried in one has zero length and stays silent,
+				// rather than playing its full raw length parked at the cut. A speed
+				// region only COMPRESSES: the track still holds all its audio and
+				// still plays at 1x, so it must not be cut short because the video
+				// under it was sped up.
+				const spanSec = Math.max(
+					0,
+					projectRawTimelineSecToPlayback(
+						clipsRef.current,
+						trimRangesRef.current,
+						track.endMs / 1000,
+					) -
+						projectRawTimelineSecToPlayback(
+							clipsRef.current,
+							trimRangesRef.current,
+							track.startMs / 1000,
+						),
+				);
+				const trackTarget = resolveTimelineAudioPlayback(
+					outputTimeSec,
+					outputStartSec,
+					track,
+					spanSec,
+				);
+				const fade = timelineAudioFadeAt(track, outputTimeSec - outputStartSec, spanSec);
+				// Imported audio plays at its natural 1× rate, NOT the video's. The export
+				// sums it into the programme at 1× — speed regions stretch clip PCM only,
+				// never the imported track — so following `v.playbackRate` would pitch a
+				// voiceover up under a 2× region and finish it early, diverging from export.
+				if (el.playbackRate !== 1) el.playbackRate = 1;
+				const trackGainNode = audioTrackGainNodesRef.current.get(track.id);
+				if (trackGainNode) {
+					trackGainNode.gain.value = audioGainScalar(track.gainDb) * fade;
+					if (el.volume !== 1) el.volume = 1;
+				} else {
+					el.volume = Math.min(1, audioGainScalar(track.gainDb) * globalGain * fade);
+				}
+				// Only re-seek on a real discontinuity (a scrub, a trim jump, a first
+				// play), NOT on the sub-frame drift of normal playback. The primary audio
+				// can afford a 25 ms leash because it syncs to the <video>'s own
+				// authoritative clock; an imported track syncs to `virtualTimeSec`, which is
+				// DERIVED from that clock each frame and so is slightly noisy — at a 25 ms
+				// leash it re-seeks most frames, and each seek briefly stalls the element:
+				// the jitter. A started element already plays at the right rate from the
+				// right offset, so it free-runs in sync; this wide leash just catches the
+				// jumps. BGM/voiceover tolerates it; frame-tight sync is the video's job.
+				const leashSec = !el.paused && trackTarget.shouldPlay ? 0.3 : 0.025;
+				if (Math.abs(el.currentTime - trackTarget.targetTimeSec) > leashSec) {
+					try {
+						el.currentTime = trackTarget.targetTimeSec;
+					} catch {
+						// media metadata not ready yet
+					}
+				}
+				if (!v.paused && trackTarget.shouldPlay && el.paused) {
+					// Resume a context suspended by autoplay policy, exactly as the primary
+					// loop does above — otherwise a track that starts while the primary
+					// element is silent (its span is over, or a recording with no separate
+					// audio element) routes into a suspended context and plays nothing.
+					if (audioGraphRef.current?.context.state === "suspended") {
+						void audioGraphRef.current.context.resume();
+					}
+					const playback = el.play();
+					if (playback) void playback.catch(() => undefined);
+				} else if ((v.paused || !trackTarget.shouldPlay) && !el.paused) {
+					el.pause();
+				}
+			}
 			// Publish this frame's live position/rate for other media elements
 			// (webcam) to read directly — see playback-clock.ts for why this
 			// bypasses React state entirely.
@@ -1146,6 +1399,23 @@ export function VirtualPreview({
 								data-testid="preview-audio-supplemental"
 							/>
 						) : null}
+						{/* Imported audio tracks (issue #350). One element per track, kept in
+						    sync by the rAF loop above via audioTrackElsRef. A track whose asset
+						    URL isn't resolved yet is skipped rather than mounted src-less. */}
+						{audioTracks.map((track) => {
+							const src = audioSources.find((s) => s.id === track.assetId)?.src;
+							if (!src) return null;
+							return (
+								<audio
+									key={`audio-track:${track.id}`}
+									ref={(element) => registerAudioTrackEl(track.id, element)}
+									src={src}
+									preload="metadata"
+									aria-hidden="true"
+									data-testid={`preview-audio-track-${track.id}`}
+								/>
+							);
+						})}
 						{/* Plus d'overlay ici du tout. « Loading preview… » reflétait l'état du
 						    <video> CACHÉ (source horloge/audio), pas la preview RÉELLE — le canvas
 						    natif, qui montre déjà une image valide pendant que le <video> re-seek.
diff --git a/src/components/ai-edition/WebcamOverlay.test.tsx b/src/components/ai-edition/WebcamOverlay.test.tsx
index 16da96666..0e5575b6a 100644
--- a/src/components/ai-edition/WebcamOverlay.test.tsx
+++ b/src/components/ai-edition/WebcamOverlay.test.tsx
@@ -74,6 +74,7 @@ function makeDocument(): AxcutDocument {
 		},
 		annotations: [],
 		zoomRanges: [],
+		audioTracks: [],
 		legacyEditor: null,
 	};
 }
diff --git a/src/components/ai-edition/v4/AddAudioLayerDialog.test.tsx b/src/components/ai-edition/v4/AddAudioLayerDialog.test.tsx
new file mode 100644
index 000000000..696452ed6
--- /dev/null
+++ b/src/components/ai-edition/v4/AddAudioLayerDialog.test.tsx
@@ -0,0 +1,130 @@
+// @vitest-environment jsdom
+import "@testing-library/jest-dom";
+import { fireEvent, render, screen } from "@testing-library/react";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { AddAudioLayerDialog } from "./AddAudioLayerDialog";
+
+vi.mock("@/contexts/I18nContext", () => ({
+	useScopedT: () => (key: string) => key,
+	useI18n: () => ({ locale: "en", setLocale: () => undefined }),
+}));
+
+const addAudioAsset = vi.fn();
+vi.mock("@/lib/ai-edition/store/projectStore", () => ({
+	useProjectStore: {
+		getState: () => ({ document: { assets: [] }, addAudioAsset }),
+	},
+}));
+
+vi.mock("@/lib/ai-edition/timeline/duration", () => ({
+	probeAudioDuration: vi.fn(async () => 3),
+}));
+
+/** A MediaRecorder stand-in that records whether it was ever stopped. */
+class FakeRecorder {
+	static instances: FakeRecorder[] = [];
+	state: "inactive" | "recording" = "inactive";
+	stopped = false;
+	ondataavailable: ((e: { data: Blob }) => void) | null = null;
+	onstop: (() => void) | null = null;
+	mimeType = "audio/webm";
+	constructor() {
+		FakeRecorder.instances.push(this);
+	}
+	static isTypeSupported() {
+		return true;
+	}
+	start() {
+		this.state = "recording";
+	}
+	stop() {
+		this.stopped = true;
+		this.state = "inactive";
+		this.onstop?.();
+	}
+}
+
+const stopTrack = vi.fn();
+
+beforeEach(() => {
+	FakeRecorder.instances = [];
+	stopTrack.mockClear();
+	addAudioAsset.mockReset();
+	vi.stubGlobal("MediaRecorder", FakeRecorder);
+	Object.defineProperty(navigator, "mediaDevices", {
+		configurable: true,
+		value: { getUserMedia: vi.fn(async () => ({ getTracks: () => [{ stop: stopTrack }] })) },
+	});
+});
+
+afterEach(() => {
+	vi.unstubAllGlobals();
+});
+
+function renderDialog(over: Partial<Parameters<typeof AddAudioLayerDialog>[0]> = {}) {
+	const props = {
+		open: true,
+		maxDurationSec: 60,
+		onClose: vi.fn(),
+		onComplete: vi.fn(),
+		onRecordingStart: vi.fn(),
+		onRecordingStop: vi.fn(),
+		...over,
+	};
+	const view = render(<AddAudioLayerDialog {...props} />);
+	return { ...view, props };
+}
+
+describe("AddAudioLayerDialog", () => {
+	it("tells the shell when a take starts, so it can capture the playhead", async () => {
+		// The shell reads the playhead HERE, not when the take ends: recording
+		// plays the video, so by the end the live playhead has advanced by the
+		// take's own length. Every voiceover used to land that far to the right.
+		const { props } = renderDialog();
+		fireEvent.click(screen.getByText("audio.record"));
+		await vi.waitFor(() => expect(props.onRecordingStart).toHaveBeenCalledTimes(1));
+	});
+
+	it("does not cover the video it is recording against", () => {
+		// It used to be a modal over a dimmed backdrop, which hid the one thing a
+		// voiceover needs you to watch. It is a docked bar now: no backdrop, and
+		// nothing claiming to be a modal dialog.
+		const { container } = renderDialog();
+		expect(container.querySelector('[aria-modal="true"]')).toBeNull();
+		expect(container.querySelector('[class*="Backdrop"]')).toBeNull();
+		expect(screen.getByText("audio.record")).toBeTruthy();
+	});
+
+	it("reports the end of a take, which is what un-mutes the timeline", async () => {
+		// The shell silences the existing audio tracks between these two callbacks,
+		// so a stop that never reported would leave the timeline mute for good.
+		const { props } = renderDialog();
+		fireEvent.click(screen.getByText("audio.record"));
+		await vi.waitFor(() => expect(FakeRecorder.instances).toHaveLength(1));
+		fireEvent.click(screen.getByText("audio.stop"));
+		expect(props.onRecordingStop).toHaveBeenCalledTimes(1);
+	});
+
+	it("stops the recorder when the dialog is torn down mid-take", async () => {
+		const { unmount, props } = renderDialog();
+		fireEvent.click(screen.getByText("audio.record"));
+		await vi.waitFor(() => expect(FakeRecorder.instances).toHaveLength(1));
+
+		unmount();
+
+		// Without this the take was never flushed, `onRecordingStop` never fired,
+		// and the video element was left playing after the shell went away.
+		expect(FakeRecorder.instances[0].stopped).toBe(true);
+		expect(props.onRecordingStop).toHaveBeenCalled();
+		// The microphone is released too.
+		expect(stopTrack).toHaveBeenCalled();
+	});
+
+	it("does not import a take that was discarded by the teardown", async () => {
+		const { unmount } = renderDialog();
+		fireEvent.click(screen.getByText("audio.record"));
+		await vi.waitFor(() => expect(FakeRecorder.instances).toHaveLength(1));
+		unmount();
+		expect(addAudioAsset).not.toHaveBeenCalled();
+	});
+});
diff --git a/src/components/ai-edition/v4/AddAudioLayerDialog.tsx b/src/components/ai-edition/v4/AddAudioLayerDialog.tsx
new file mode 100644
index 000000000..d10edf08d
--- /dev/null
+++ b/src/components/ai-edition/v4/AddAudioLayerDialog.tsx
@@ -0,0 +1,333 @@
+// Voiceover dialog: record a narration take against the timeline, live from the
+// microphone (MediaRecorder → webm/opus, written to the recordings dir by the
+// main process), or import a file if the user already has one.
+//
+// Music and other imports do NOT come through here — they are a plain file
+// import on the timeline toolbar (`tl.addAudio`). Recording is the only audio
+// gesture that needs a dialog, because it has a live state to show.
+//
+// The dialog resolves the AUDIO ASSET and its duration, then reports back via
+// `onComplete` — placing the track on the timeline (span, anchor, inspector
+// selection) is the caller's job, exactly like the other add* flows.
+
+import { Mic, StopCircle, Upload } from "lucide-react";
+import { useCallback, useEffect, useRef, useState } from "react";
+import { toast } from "sonner";
+import { toFileUrl } from "@/components/video-editor/projectPersistence";
+import { useScopedT } from "@/contexts/I18nContext";
+import type { AxcutAsset } from "@/lib/ai-edition/schema";
+import { useProjectStore } from "@/lib/ai-edition/store/projectStore";
+import { probeAudioDuration } from "@/lib/ai-edition/timeline/duration";
+import styles from "./EditorShellV4.module.css";
+
+const RECORDER_MIME_PREFERENCES = ["audio/webm;codecs=opus", "audio/webm", "audio/mp4"];
+
+function pickRecorderMimeType(): string {
+	if (typeof MediaRecorder === "undefined") return "";
+	for (const mime of RECORDER_MIME_PREFERENCES) {
+		if (MediaRecorder.isTypeSupported(mime)) return mime;
+	}
+	return "";
+}
+
+/** Reuse an already-imported asset over importing the same file twice. */
+function findExistingAsset(path: string): AxcutAsset | null {
+	const doc = useProjectStore.getState().document;
+	if (!doc) return null;
+	return (
+		doc.assets.find((a) => a.kind === "audio" && a.originalPath === path) ??
+		doc.assets.find((a) => a.originalPath === path) ??
+		null
+	);
+}
+
+export function AddAudioLayerDialog({
+	open,
+	/** Timeline length in seconds — recording stops by itself when reached. */
+	maxDurationSec,
+	onClose,
+	onComplete,
+	onRecordingStart,
+	onRecordingStop,
+}: {
+	open: boolean;
+	maxDurationSec: number;
+	onClose: () => void;
+	onComplete: (assetId: string, durationSec: number) => void;
+	onRecordingStart: () => void;
+	onRecordingStop: () => void;
+}) {
+	const t = useScopedT("timeline");
+	const tc = useScopedT("common");
+	const [busy, setBusy] = useState(false);
+	const [recording, setRecording] = useState(false);
+	const [elapsedSec, setElapsedSec] = useState(0);
+	const recorderRef = useRef<MediaRecorder | null>(null);
+	const streamRef = useRef<MediaStream | null>(null);
+	const chunksRef = useRef<Blob[]>([]);
+	const startedAtRef = useRef(0);
+	const timerRef = useRef<ReturnType<typeof setInterval> | null>(null);
+	// Set when the user cancels (closes the dialog mid-take) — the stop handler
+	// then discards the blob instead of importing it as a layer.
+	const discardRef = useRef(false);
+	// Read by the Escape handler, which must not re-subscribe every time the
+	// elapsed-time state ticks.
+	const recordingRef = useRef(false);
+
+	// Reset whenever the dialog opens again — a cancelled recording must not
+	// leak its stream or timer into the next session.
+	useEffect(() => {
+		if (open) {
+			setBusy(false);
+			setRecording(false);
+			recordingRef.current = false;
+			setElapsedSec(0);
+		}
+		return () => {
+			if (timerRef.current) clearInterval(timerRef.current);
+			timerRef.current = null;
+			// Stop the RECORDER, not just the stream. Tearing the dialog down
+			// mid-take (a project close, a shell unmount) used to drop the take on
+			// the floor: `onstop` never fired, so the blob was never flushed and
+			// `onRecordingStop` never ran — leaving the video element playing.
+			// Discard rather than import: nobody is left to place the layer.
+			const recorder = recorderRef.current;
+			if (recorder && recorder.state !== "inactive") {
+				discardRef.current = true;
+				try {
+					recorder.stop();
+				} catch {
+					// already torn down by the browser
+				}
+			}
+			for (const track of streamRef.current?.getTracks() ?? []) track.stop();
+			streamRef.current = null;
+			recorderRef.current = null;
+		};
+	}, [open]);
+
+	const stopRecording = useCallback(() => {
+		if (timerRef.current) {
+			clearInterval(timerRef.current);
+			timerRef.current = null;
+		}
+		const recorder = recorderRef.current;
+		// `recorder.onstop` (registered at start) owns the save path.
+		if (recorder && recorder.state !== "inactive") {
+			recorder.stop();
+		}
+		for (const track of streamRef.current?.getTracks() ?? []) track.stop();
+		streamRef.current = null;
+	}, []);
+
+	const cancelRecording = useCallback(() => {
+		discardRef.current = true;
+		stopRecording();
+		onRecordingStop();
+		setRecording(false);
+		recordingRef.current = false;
+		setElapsedSec(0);
+	}, [stopRecording, onRecordingStop]);
+
+	const finishWithPath = useCallback(
+		async (path: string, durationSec: number) => {
+			setBusy(true);
+			try {
+				const existing = findExistingAsset(path);
+				// `addAudioAsset` files it as audio explicitly: a recorded voiceover
+				// lands as `.webm`, the same extension as a screen recording, so
+				// extension guessing would import it as a video asset.
+				const asset = existing ?? (await useProjectStore.getState().addAudioAsset(path));
+				if (!asset) {
+					toast.error(t("audio.importFailed"));
+					return;
+				}
+				onComplete(asset.id, durationSec);
+			} catch (err) {
+				toast.error(t("audio.importFailed"), {
+					description: err instanceof Error ? err.message : String(err),
+				});
+			} finally {
+				setBusy(false);
+			}
+		},
+		[onComplete, t],
+	);
+
+	const startRecording = useCallback(async () => {
+		if (typeof navigator === "undefined" || !navigator.mediaDevices?.getUserMedia) {
+			toast.error(t("audio.recordingUnavailable"));
+			return;
+		}
+		try {
+			const stream = await navigator.mediaDevices.getUserMedia({
+				audio: { echoCancellation: true, noiseSuppression: true },
+			});
+			streamRef.current = stream;
+			const mimeType = pickRecorderMimeType();
+			const recorder = mimeType
+				? new MediaRecorder(stream, { mimeType })
+				: new MediaRecorder(stream);
+			recorderRef.current = recorder;
+			chunksRef.current = [];
+			recorder.ondataavailable = (event) => {
+				if (event.data.size > 0) chunksRef.current.push(event.data);
+			};
+			recorder.onstop = () => {
+				const blob = new Blob(chunksRef.current, {
+					type: recorder.mimeType || "audio/webm",
+				});
+				const duration = (performance.now() - startedAtRef.current) / 1000;
+				const discarded = discardRef.current;
+				discardRef.current = false;
+				setRecording(false);
+				recordingRef.current = false;
+				setElapsedSec(0);
+				onRecordingStop();
+				if (discarded) return;
+				void (async () => {
+					try {
+						const data = await blob.arrayBuffer();
+						const saved = window.electronAPI?.saveRecordedVoiceover
+							? await window.electronAPI.saveRecordedVoiceover(data)
+							: { success: false as const };
+						if (saved.success && saved.path) {
+							await finishWithPath(saved.path, duration);
+						} else {
+							// Browser-mode fallback: no main process to persist the
+							// blob, so the layer references the in-memory blob URL —
+							// good for the session, gone on reload.
+							const url = URL.createObjectURL(blob);
+							await finishWithPath(url, duration);
+						}
+					} catch (err) {
+						toast.error(t("audio.saveFailed"), {
+							description: err instanceof Error ? err.message : String(err),
+						});
+					}
+				})();
+			};
+			startedAtRef.current = performance.now();
+			discardRef.current = false;
+			recorder.start(250);
+			setRecording(true);
+			recordingRef.current = true;
+			setElapsedSec(0);
+			onRecordingStart();
+			timerRef.current = setInterval(() => {
+				setElapsedSec((performance.now() - startedAtRef.current) / 1000);
+			}, 200);
+		} catch {
+			toast.error(t("audio.micDenied"));
+		}
+	}, [finishWithPath, onRecordingStart, onRecordingStop, t]);
+
+	// Stop by itself at the end of the timeline so a layer can never outlive
+	// the video it was recorded over.
+	useEffect(() => {
+		if (!recording || !Number.isFinite(maxDurationSec) || maxDurationSec <= 0) return;
+		if (elapsedSec >= maxDurationSec) {
+			stopRecording();
+			// `onRecordingStop` fires from the recorder's stop handler.
+		}
+	}, [recording, elapsedSec, maxDurationSec, stopRecording]);
+
+	// Re-entrancy guard: the shell passes an inline `onComplete` and re-renders on
+	// every playhead tick during playback, so a dialog left open while the video
+	// plays re-creates this callback constantly. Without the guard a second click
+	// (or any caller that fires on re-render) would stack `showOpenDialog` calls.
+	const pickerOpenRef = useRef(false);
+
+	const importFile = useCallback(async () => {
+		if (pickerOpenRef.current) return;
+		pickerOpenRef.current = true;
+		try {
+			const picker = await window.electronAPI?.openAudioFilePicker?.();
+			if (!picker?.success || !picker.path) return;
+			const url = toFileUrl(picker.path);
+			// The probe needs the real duration to size the layer; when it fails the
+			// caller falls back to the default span.
+			const duration = (await probeAudioDuration(url)) ?? 0;
+			await finishWithPath(picker.path, duration);
+		} finally {
+			pickerOpenRef.current = false;
+		}
+	}, [finishWithPath]);
+
+	// Escape closes, the way it did when this was a modal — cancelling a take in
+	// progress rather than saving a half-recorded one.
+	useEffect(() => {
+		if (!open) return;
+		const onKey = (e: KeyboardEvent) => {
+			if (e.key !== "Escape") return;
+			e.preventDefault();
+			if (recordingRef.current) cancelRecording();
+			onClose();
+		};
+		window.addEventListener("keydown", onKey);
+		return () => window.removeEventListener("keydown", onKey);
+	}, [open, cancelRecording, onClose]);
+
+	if (!open) return null;
+
+	return (
+		// A toolbar, not a dialog: no backdrop, nothing dimmed, and the preview
+		// keeps playing behind it. `aria-live` so a screen reader hears the take
+		// start and stop without the focus trap a modal would impose.
+		<div className={styles.voiceoverBar} role="group" aria-label={t("audio.addVoiceover")}>
+			<span className={styles.voiceoverBarTitle}>
+				<strong>{t("audio.addVoiceover")}</strong>
+				<span>{recording ? t("audio.recordingHint") : t("audio.subtitle")}</span>
+			</span>
+			{recording ? (
+				<>
+					<span className={styles.voiceoverBarLive} aria-live="polite">
+						<span className={`${styles.voiceoverBarDot} animate-pulse`} />
+						{t("audio.recording")} {elapsedSec.toFixed(1)}s
+					</span>
+					<button
+						type="button"
+						onClick={stopRecording}
+						className={`${styles.voiceoverBarBtn} ${styles.voiceoverBarBtnDanger}`}
+					>
+						<StopCircle size={16} />
+						{t("audio.stop")}
+					</button>
+					<button
+						type="button"
+						onClick={() => {
+							cancelRecording();
+							onClose();
+						}}
+						className={styles.voiceoverBarBtn}
+					>
+						{tc("actions.cancel")}
+					</button>
+				</>
+			) : (
+				<>
+					<button
+						type="button"
+						onClick={() => void startRecording()}
+						className={styles.voiceoverBarBtn}
+					>
+						<Mic size={16} />
+						{t("audio.record")}
+					</button>
+					<button
+						type="button"
+						onClick={() => void importFile()}
+						disabled={busy}
+						className={styles.voiceoverBarBtn}
+					>
+						<Upload size={16} />
+						{t("audio.importFile")}
+					</button>
+					<button type="button" onClick={onClose} className={styles.voiceoverBarBtn}>
+						{tc("actions.close")}
+					</button>
+				</>
+			)}
+		</div>
+	);
+}
diff --git a/src/components/ai-edition/v4/EditorShellV4.module.css b/src/components/ai-edition/v4/EditorShellV4.module.css
index 1e313e34c..1ec4dd715 100644
--- a/src/components/ai-edition/v4/EditorShellV4.module.css
+++ b/src/components/ai-edition/v4/EditorShellV4.module.css
@@ -966,6 +966,21 @@
 	cursor: pointer;
 	text-align: left;
 }
+/* The key that does the same thing, parked at the end of a menu row. Teaches
+   the shortcut at the moment the user is reaching for the slow way to do it. */
+.recMenuKey {
+	margin-left: auto;
+	flex-shrink: 0;
+	padding: 2px 6px;
+	border-radius: 5px;
+	border: 1px solid var(--border-soft);
+	background: var(--surface-2);
+	color: var(--muted);
+	font-size: 10.5px;
+	font-weight: 600;
+	line-height: 1.4;
+}
+
 .recMenuRow:hover:not(:disabled) {
 	background: var(--surface-2);
 }
@@ -1496,6 +1511,48 @@
 	border-color: #a855f7;
 	background: rgba(168, 85, 247, 0.14);
 }
+/* Imported audio tracks (issue #350). A distinct teal so a BGM/voiceover track
+   reads apart from the effect pills, and taller than a lane pill so the waveform
+   inside it is legible. */
+.laneAudio {
+	border-color: #14b8a6;
+	background: rgba(20, 184, 166, 0.16);
+	height: 30px;
+	top: 1px;
+	cursor: pointer;
+}
+.laneAudio:active {
+	cursor: pointer;
+}
+/* The label rides above the waveform (which is inset:0 behind it). */
+/* Where a looping track starts its file over. A hairline rather than a full
+   divider: it has to be legible against the waveform without reading as a cut,
+   which is what a solid line on a timeline means everywhere else. */
+.laneLoopMark {
+	position: absolute;
+	top: 0;
+	bottom: 0;
+	width: 1px;
+	z-index: 1;
+	pointer-events: none;
+	background: color-mix(in srgb, var(--fg) 45%, transparent);
+}
+
+.laneAudioLabel {
+	position: relative;
+	z-index: 1;
+	overflow: hidden;
+	text-overflow: ellipsis;
+	display: inline-flex;
+	align-items: center;
+	gap: 5px;
+}
+/* The audio lane is taller than the effect lanes to give the waveform room. */
+/* Height is set inline from the row count — the lane grows only as far as the
+   tracks actually overlap. This is the single-row floor. */
+.tlLaneAudio {
+	height: 32px;
+}
 .tlClips {
 	position: relative;
 	/* NOT a flex row. Clips are absolutely positioned by percentage of the
@@ -1756,3 +1813,83 @@
 	pointer-events: none;
 	z-index: 14;
 }
+
+/* ── Voiceover recorder ──────────────────────────────────────────────────
+   Deliberately NOT a modal. The whole point of a voiceover is narrating to
+   the video that is playing, so a centred dialog over a dimmed backdrop hides
+   the one thing the user needs to watch. This docks at the bottom instead:
+   no backdrop, nothing covered but a strip of the timeline, and the preview
+   stays lit and playing behind it. */
+.voiceoverBar {
+	position: fixed;
+	left: 50%;
+	bottom: 24px;
+	transform: translateX(-50%);
+	z-index: 60;
+	display: flex;
+	align-items: center;
+	gap: 14px;
+	padding: 12px 16px;
+	border-radius: 14px;
+	border: 1px solid var(--border);
+	background: var(--surface-1);
+	box-shadow: 0 18px 40px rgb(0 0 0 / 38%);
+}
+
+.voiceoverBarTitle {
+	display: flex;
+	flex-direction: column;
+	gap: 2px;
+	margin-right: 4px;
+}
+.voiceoverBarTitle strong {
+	font: 600 13px var(--font-display);
+	color: var(--fg);
+}
+.voiceoverBarTitle span {
+	font-size: 11px;
+	color: var(--muted);
+}
+
+.voiceoverBarBtn {
+	display: inline-flex;
+	align-items: center;
+	justify-content: center;
+	gap: 7px;
+	padding: 9px 14px;
+	border-radius: 10px;
+	border: 1px solid var(--border);
+	background: var(--bg-2, var(--surface-2));
+	color: var(--fg-1, var(--fg));
+	font: 600 13px var(--font-display);
+	cursor: pointer;
+	white-space: nowrap;
+}
+.voiceoverBarBtn:hover:not(:disabled) {
+	background: var(--surface-3);
+}
+.voiceoverBarBtn:disabled {
+	opacity: 0.55;
+	cursor: not-allowed;
+}
+.voiceoverBarBtnDanger {
+	border-color: var(--danger);
+	color: var(--danger);
+}
+
+/* The live take: a pulsing dot and the running length, so the user can see it
+   is actually capturing without looking away from the video. */
+.voiceoverBarLive {
+	display: inline-flex;
+	align-items: center;
+	gap: 8px;
+	color: var(--danger);
+	font: 600 13px var(--font-display);
+	font-variant-numeric: tabular-nums;
+}
+.voiceoverBarDot {
+	width: 10px;
+	height: 10px;
+	border-radius: 999px;
+	background: var(--danger);
+}
diff --git a/src/components/ai-edition/v4/FloatingInspector.tsx b/src/components/ai-edition/v4/FloatingInspector.tsx
index ac162d322..c39495ca6 100644
--- a/src/components/ai-edition/v4/FloatingInspector.tsx
+++ b/src/components/ai-edition/v4/FloatingInspector.tsx
@@ -43,6 +43,7 @@ import { CaptionsPane } from "../CaptionsPane";
 import { ColorField } from "../ColorField";
 import {
 	AudioPane,
+	AudioTrackPane,
 	CursorPane,
 	LayoutPane,
 	SliderCell,
@@ -113,13 +114,18 @@ export function FloatingInspector({
 		return () => document.removeEventListener("mousedown", onDocMouseDown);
 	}, [clipPickerOpen]);
 	const selection = tl.selection;
-	const effectiveOpen = open || selection !== null;
+	// An imported audio track is selected (issue #350) — like a region selection it
+	// takes over the inspector body with its own pane (see AudioTrackPane).
+	const audioTrackSelected = tl.selectedAudioTrackId !== null;
+	const effectiveOpen = open || selection !== null || audioTrackSelected;
 	return (
 		<div className={styles.inspectorWrap}>
 			{effectiveOpen ? (
 				<div className={styles.inspector}>
 					{selection ? (
 						<SelectionPane tl={tl} onClose={() => tl.clearSelection()} />
+					) : audioTrackSelected ? (
+						<AudioTrackPane tl={tl} />
 					) : (
 						<FacetBody facet={facet} onCollapse={onToggleOpen} transcriptProps={transcriptProps} />
 					)}
@@ -132,11 +138,11 @@ export function FloatingInspector({
 						type="button"
 						title={ts(labelKey)}
 						aria-label={ts(labelKey)}
-						aria-pressed={!selection && open && facet === id}
+						aria-pressed={!selection && !audioTrackSelected && open && facet === id}
 						onClick={() => {
 							// Switching facets while an element is selected should show
 							// the facet, not leave the selection pane on top of it.
-							if (selection) tl.clearSelection();
+							if (selection || audioTrackSelected) tl.clearSelection();
 							if (facet === id && open) {
 								onToggleOpen();
 							} else {
diff --git a/src/components/ai-edition/v4/MediaStage.tsx b/src/components/ai-edition/v4/MediaStage.tsx
index a7af81acb..695a3cd35 100644
--- a/src/components/ai-edition/v4/MediaStage.tsx
+++ b/src/components/ai-edition/v4/MediaStage.tsx
@@ -73,7 +73,10 @@ export function MediaStage({
 		[locale, t],
 	);
 
-	const assets = document?.assets ?? [];
+	// Video only — this stage arranges clips. Imported audio (issue #350) is a
+	// timeline overlay added from the timeline toolbar, not a clip, so it never
+	// appears in this list.
+	const assets = (document?.assets ?? []).filter((a) => a.kind !== "audio");
 	const filtered = useMemo(
 		() =>
 			assets.filter((a) => {
diff --git a/src/components/ai-edition/v4/V4Timeline.geometry.test.tsx b/src/components/ai-edition/v4/V4Timeline.geometry.test.tsx
index 8e515568c..4fa2d7684 100644
--- a/src/components/ai-edition/v4/V4Timeline.geometry.test.tsx
+++ b/src/components/ai-edition/v4/V4Timeline.geometry.test.tsx
@@ -13,8 +13,12 @@ vi.mock("@/contexts/I18nContext", () => ({
 	useScopedT: () => (key: string) => key,
 }));
 vi.mock("sonner", () => ({ toast: { error: vi.fn(), info: vi.fn(), success: vi.fn() } }));
+// The audio lane's pill renders a ClipWaveform; no decode in this geometry suite.
+vi.mock("@/hooks/useAudioPeaks", () => ({ useAudioPeaks: () => null }));
 
+import { ShortcutsProvider } from "@/contexts/ShortcutsContext";
 import type { useTimeline } from "@/lib/ai-edition/store/useTimeline";
+import { DEFAULT_SHORTCUTS, formatBinding } from "@/lib/shortcuts";
 import { V4Timeline } from "./V4Timeline";
 
 beforeAll(() => {
@@ -84,6 +88,9 @@ function renderTimeline(
 		selection: null,
 		multiSelection: [],
 		clipSelection: null,
+		audioTracks: [],
+		selectedAudioTrackId: null,
+		selectAudioTrack: vi.fn(),
 		clearSelection: vi.fn(),
 		selectRegion: vi.fn(),
 		selectClip: vi.fn(),
@@ -95,17 +102,20 @@ function renderTimeline(
 		}),
 	};
 	render(
-		<V4Timeline
-			// Only the members the lanes and the clip row read are mocked; the prop
-			// stays typed as the real API rather than widened to `any` (AGENTS.md).
-			tl={tl as unknown as ReturnType<typeof useTimeline>}
-			setCurrentTime={vi.fn()}
-			playing={false}
-			onTogglePlay={vi.fn()}
-			onPrevClip={vi.fn()}
-			onNextClip={vi.fn()}
-			onEditClip={vi.fn()}
-		/>,
+		<ShortcutsProvider>
+			<V4Timeline
+				// Only the members the lanes and the clip row read are mocked; the prop
+				// stays typed as the real API rather than widened to `any` (AGENTS.md).
+				tl={tl as unknown as ReturnType<typeof useTimeline>}
+				setCurrentTime={vi.fn()}
+				playing={false}
+				onTogglePlay={vi.fn()}
+				onPrevClip={vi.fn()}
+				onNextClip={vi.fn()}
+				onEditClip={vi.fn()}
+				onAddVoiceover={vi.fn()}
+			/>
+		</ShortcutsProvider>,
 	);
 	return {
 		pill: screen.getByTitle("toolbar.newAnnotation"),
@@ -205,14 +215,14 @@ describe("V4Timeline create-from-toolbar", () => {
 
 	it("scales the new region's duration with the zoom", () => {
 		const { tl } = renderTimeline();
-		fireEvent.click(screen.getByTitle("buttons.addZoom"));
+		fireEvent.click(screen.getByLabelText("buttons.addZoom"));
 		// 900px viewport / 1800 s = 0.5 px per second, so a 96px pill is 192 s.
 		expect(durationOf(tl)).toBeCloseTo(192, 3);
 
 		// Zoomed to the 50x ceiling the same 96px is worth 3.84 s: same pill on
 		// screen, a region 50x shorter.
 		zoomIn(40);
-		fireEvent.click(screen.getByTitle("buttons.addZoom"));
+		fireEvent.click(screen.getByLabelText("buttons.addZoom"));
 		expect(durationOf(tl)).toBeCloseTo(3.84, 3);
 	});
 
@@ -224,7 +234,7 @@ describe("V4Timeline create-from-toolbar", () => {
 		const { tl } = renderTimeline();
 		const ruler = document.querySelector("[class*=tlRulerRow]") as HTMLElement;
 		wheelZoomOn(ruler, 40);
-		fireEvent.click(screen.getByTitle("buttons.addZoom"));
+		fireEvent.click(screen.getByLabelText("buttons.addZoom"));
 		expect(durationOf(tl)).toBeCloseTo(3.84, 3);
 	});
 
@@ -247,7 +257,7 @@ describe("V4Timeline create-from-toolbar", () => {
 		// second; the region would be born unusable, so the duration floors.
 		const { tl } = renderTimeline([clip(0, 3)]);
 		zoomIn(40);
-		fireEvent.click(screen.getByTitle("buttons.addZoom"));
+		fireEvent.click(screen.getByLabelText("buttons.addZoom"));
 		expect(durationOf(tl)).toBeCloseTo(0.25, 3);
 	});
 
@@ -257,7 +267,7 @@ describe("V4Timeline create-from-toolbar", () => {
 	// so before it is clicked instead of looking like it worked.
 	it("disables Add Full Camera when no clip on the timeline has a camera", () => {
 		renderTimeline();
-		expect(screen.getByTitle("buttons.addCameraFullscreen")).toBeDisabled();
+		expect(screen.getByLabelText("buttons.addCameraFullscreen")).toBeDisabled();
 	});
 
 	it("enables Add Full Camera as soon as a clip's asset carries one", () => {
@@ -267,7 +277,7 @@ describe("V4Timeline create-from-toolbar", () => {
 				cameraTrack: { sourcePath: "/tmp/cam.webm", startMs: 0, offsetMs: 0, visible: true },
 			},
 		]);
-		expect(screen.getByTitle("buttons.addCameraFullscreen")).toBeEnabled();
+		expect(screen.getByLabelText("buttons.addCameraFullscreen")).toBeEnabled();
 	});
 
 	// The disabled button is only half the promise: an empty lane advertises the shortcut
@@ -338,3 +348,238 @@ describe("V4Timeline clip row", () => {
 		}
 	});
 });
+
+// Issue #350 — dragging an imported audio track on its lane. The pixel→second
+// math and the single-write commit are what these pin; the clamp/guard math is
+// covered by document/audioTracks.test.ts.
+describe("V4Timeline audio lane drag", () => {
+	const AUDIO_ASSET = { id: "aud", label: "voiceover", originalPath: "/vo.mp3", durationSec: 60 };
+	// A 60s track whose head sits at raw 100s.
+	const makeTrack = () => ({
+		id: "trk1",
+		assetId: "aud",
+		kind: "music" as const,
+		startMs: 100_000,
+		endMs: 160_000,
+		durationSec: 60,
+		offsetMs: 0,
+		gainDb: 0,
+		loop: false,
+		fadeInMs: 0,
+		fadeOutMs: 0,
+		muted: false,
+		label: "vo",
+		origin: "user" as const,
+	});
+
+	function renderAudioTracks(tracks: Array<ReturnType<typeof makeTrack>>) {
+		return renderAudio({}, {}, tracks);
+	}
+
+	function renderAudio(
+		trackOverrides: Partial<ReturnType<typeof makeTrack>> = {},
+		props: { onAddVoiceover?: () => void } = {},
+		tracks?: Array<ReturnType<typeof makeTrack>>,
+	) {
+		const placeAudioTrack = vi.fn(
+			async (_id: string, _span: { startMs: number; endMs: number; offsetMs?: number }) => {
+				/* the drag only awaits it */
+			},
+		);
+		const selectAudioTrack = vi.fn();
+		const tl = {
+			clips: [clip(0, TOTAL_SEC)],
+			assets: [AUDIO_ASSET],
+			annotationRegions: [],
+			speedRegions: [],
+			cameraFullscreenRegions: [],
+			zoomRegions: [],
+			trimRanges: [],
+			selection: null,
+			multiSelection: [],
+			clipSelection: null,
+			audioTracks: tracks ?? [{ ...makeTrack(), ...trackOverrides }],
+			selectedAudioTrackId: null,
+			selectAudioTrack,
+			placeAudioTrack,
+			clearSelection: vi.fn(),
+			selectRegion: vi.fn(),
+			selectClip: vi.fn(),
+			updateAnnotationSpan: vi.fn(async () => undefined),
+			addZoom: vi.fn(async () => undefined),
+		};
+		const { container } = render(
+			<ShortcutsProvider>
+				<V4Timeline
+					tl={tl as unknown as ReturnType<typeof useTimeline>}
+					setCurrentTime={vi.fn()}
+					playing={false}
+					onTogglePlay={vi.fn()}
+					onPrevClip={vi.fn()}
+					onNextClip={vi.fn()}
+					onEditClip={vi.fn()}
+					onAddVoiceover={props.onAddVoiceover ?? vi.fn()}
+				/>
+			</ShortcutsProvider>,
+		);
+		// `pill` is a getter: the multi-track cases render no "vo" pill, and an
+		// eager lookup would throw before their own assertions ran.
+		return {
+			get pill() {
+				return screen.getByTitle("vo");
+			},
+			container,
+			placeAudioTrack,
+			selectAudioTrack,
+		};
+	}
+
+	// 900px / 1800s = 0.5 px per second, so +90px is +180s.
+	const secForPx = (px: number) => (px / VIEWPORT_PX) * TOTAL_SEC;
+
+	it("offers both audio paths behind one toolbar button", () => {
+		// A mic and a music note side by side both just said "audio"; one button
+		// with a named menu is what tells a first-time user the two paths apart.
+		const onAddVoiceover = vi.fn();
+		renderAudio({}, { onAddVoiceover });
+		fireEvent.click(screen.getByLabelText("toolbar.addAudioTooltip"));
+		fireEvent.click(screen.getByText("audio.addVoiceover"));
+		expect(onAddVoiceover).toHaveBeenCalledTimes(1);
+	});
+
+	it("teaches the key that does the same thing", () => {
+		// Read off the live bindings rather than hardcoded here, so a rebind in the
+		// shortcuts dialog moves the menu with it instead of teaching a stale key.
+		renderAudio();
+		fireEvent.click(screen.getByLabelText("toolbar.addAudioTooltip"));
+		const keys = Array.from(document.querySelectorAll("kbd"), (k) => k.textContent);
+		expect(keys).toEqual([
+			formatBinding(DEFAULT_SHORTCUTS.addVoiceover, false),
+			formatBinding(DEFAULT_SHORTCUTS.addAudio, false),
+		]);
+	});
+
+	it("marks where a looping track starts its file over", () => {
+		// A 60s file under a 180s span repeats twice more after the first pass, so
+		// there are two boundaries to show — at a third and two thirds.
+		const { pill } = renderAudio({ loop: true, endMs: 100_000 + 180_000 });
+		expect(pill.querySelectorAll('[data-testid="audio-loop-mark"]')).toHaveLength(2);
+	});
+
+	it("draws no loop marks when the track fits inside its source", () => {
+		const { pill } = renderAudio({ loop: true });
+		expect(pill.querySelectorAll('[data-testid="audio-loop-mark"]')).toHaveLength(0);
+	});
+
+	it("stacks overlapping tracks on separate rows", () => {
+		// Three takes over the same stretch used to draw at the same height, one
+		// hiding the next — you could not tell which pill you were about to drag.
+		const { container } = renderAudioTracks([
+			{ ...makeTrack(), id: "a", label: "a", startMs: 0, endMs: 60_000 },
+			{ ...makeTrack(), id: "b", label: "b", startMs: 10_000, endMs: 70_000 },
+			{ ...makeTrack(), id: "c", label: "c", startMs: 20_000, endMs: 80_000 },
+		]);
+		const tops = ["a", "b", "c"].map((l) => (screen.getByTitle(l) as HTMLElement).style.top);
+		expect(new Set(tops).size).toBe(3);
+		// ...and the lane grew to hold them rather than clipping.
+		const lane = container.querySelector('[class*="tlLaneAudio"]') as HTMLElement;
+		expect(Number.parseInt(lane.style.height, 10)).toBeGreaterThan(60);
+	});
+
+	it("keeps non-overlapping tracks on one row", () => {
+		renderAudioTracks([
+			{ ...makeTrack(), id: "a", label: "a", startMs: 0, endMs: 10_000 },
+			{ ...makeTrack(), id: "b", label: "b", startMs: 20_000, endMs: 30_000 },
+		]);
+		const tops = ["a", "b"].map((l) => (screen.getByTitle(l) as HTMLElement).style.top);
+		expect(new Set(tops).size).toBe(1);
+	});
+
+	it("selects the track on pointer-down before any movement", () => {
+		const { pill, selectAudioTrack } = renderAudio();
+		fireEvent.pointerDown(pill, { clientX: 0 });
+		window.dispatchEvent(new MouseEvent("pointerup", { clientX: 0 }));
+		expect(selectAudioTrack).toHaveBeenCalledWith("trk1");
+	});
+
+	it("body drag slides the head and commits once, trims untouched", () => {
+		const { pill, placeAudioTrack } = renderAudio();
+		fireEvent.pointerDown(pill, { clientX: 0 });
+		window.dispatchEvent(new MouseEvent("pointermove", { clientX: 90 }));
+		window.dispatchEvent(new MouseEvent("pointerup", { clientX: 90 }));
+		expect(placeAudioTrack).toHaveBeenCalledTimes(1);
+		const [id, placement] = placeAudioTrack.mock.calls[0];
+		expect(id).toBe("trk1");
+		// The span slides whole: head moves, length is unchanged.
+		expect(placement.startMs / 1000).toBeCloseTo(100 + secForPx(90), 3);
+		expect((placement.endMs - placement.startMs) / 1000).toBeCloseTo(60, 3);
+	});
+
+	it("left-handle drag trims into the source instead of sliding the audio", () => {
+		// A left-edge drag is a trim IN: the head moves right by N seconds and the
+		// same N is skipped in the file, so what plays under the pill stays put.
+		// Committing the span alone left `offsetMs` untouched, which just slid the
+		// whole track along — the "my music starts five seconds late" symptom.
+		const { pill, placeAudioTrack } = renderAudio();
+		const handle = pill.firstElementChild as Element;
+		fireEvent.pointerDown(handle, { clientX: 0 });
+		window.dispatchEvent(new MouseEvent("pointermove", { clientX: 15 }));
+		window.dispatchEvent(new MouseEvent("pointerup", { clientX: 15 }));
+		expect(placeAudioTrack).toHaveBeenCalledTimes(1);
+		const [, placement] = placeAudioTrack.mock.calls[0];
+		const movedSec = placement.startMs / 1000 - 100;
+		expect(movedSec).toBeGreaterThan(0);
+		// The head moved and the source in-point advanced by the same amount.
+		expect((placement.offsetMs ?? 0) / 1000).toBeCloseTo(movedSec, 3);
+		// The tail is untouched, so the span shortens by exactly what was trimmed.
+		expect((placement.endMs - placement.startMs) / 1000).toBeCloseTo(60 - movedSec, 3);
+	});
+
+	it("a plain move leaves the source in-point alone", () => {
+		const { pill, placeAudioTrack } = renderAudio();
+		fireEvent.pointerDown(pill, { clientX: 0 });
+		window.dispatchEvent(new MouseEvent("pointermove", { clientX: 90 }));
+		window.dispatchEvent(new MouseEvent("pointerup", { clientX: 90 }));
+		const [, placement] = placeAudioTrack.mock.calls[0];
+		expect(placement.offsetMs).toBe(0);
+	});
+
+	it("caps the out-point at the source length when the track does not loop", () => {
+		// A non-looping track has nothing to play past the end of its file, so the
+		// right edge stops there however far the pointer goes.
+		const { pill, placeAudioTrack } = renderAudio();
+		const handle = pill.lastElementChild as Element;
+		fireEvent.pointerDown(handle, { clientX: 0 });
+		window.dispatchEvent(new MouseEvent("pointermove", { clientX: 400 }));
+		window.dispatchEvent(new MouseEvent("pointerup", { clientX: 400 }));
+		const [, placement] = placeAudioTrack.mock.calls[0];
+		expect((placement.endMs - placement.startMs) / 1000).toBeCloseTo(60, 3);
+	});
+
+	it("lets a looping track be pulled out past the end of its file", () => {
+		// This is what makes the loop toggle mean anything: the span has to be able
+		// to EXCEED the source, or the audio always plays exactly once and turning
+		// loop on does nothing at all.
+		const { pill, placeAudioTrack } = renderAudio({ loop: true });
+		const handle = pill.lastElementChild as Element;
+		fireEvent.pointerDown(handle, { clientX: 0 });
+		window.dispatchEvent(new MouseEvent("pointermove", { clientX: 400 }));
+		window.dispatchEvent(new MouseEvent("pointerup", { clientX: 400 }));
+		const [, placement] = placeAudioTrack.mock.calls[0];
+		expect((placement.endMs - placement.startMs) / 1000).toBeGreaterThan(60);
+	});
+
+	it("right-handle drag pulls the out-point in, head fixed", () => {
+		const { pill, placeAudioTrack } = renderAudio();
+		// The right resize handle is the last child of the pill.
+		const handle = pill.lastElementChild as Element;
+		fireEvent.pointerDown(handle, { clientX: 0 });
+		window.dispatchEvent(new MouseEvent("pointermove", { clientX: -30 }));
+		window.dispatchEvent(new MouseEvent("pointerup", { clientX: -30 }));
+		expect(placeAudioTrack).toHaveBeenCalledTimes(1);
+		const [, placement] = placeAudioTrack.mock.calls[0];
+		// The head is pinned; only the tail comes in, so the span gets shorter.
+		expect(placement.startMs).toBe(100_000);
+		expect(placement.endMs - placement.startMs).toBeLessThan(60_000);
+	});
+});
diff --git a/src/components/ai-edition/v4/V4Timeline.tsx b/src/components/ai-edition/v4/V4Timeline.tsx
index f6c94e2ca..d0f43c32e 100644
--- a/src/components/ai-edition/v4/V4Timeline.tsx
+++ b/src/components/ai-edition/v4/V4Timeline.tsx
@@ -1,9 +1,12 @@
 import {
+	AudioLines,
 	Clock,
 	Crosshair,
 	Loader2,
 	Maximize2,
 	MessageSquare,
+	Mic,
+	Music,
 	Pencil,
 	Scissors,
 	Sparkles,
@@ -13,6 +16,7 @@ import {
 	ZoomIn,
 } from "lucide-react";
 import {
+	Fragment,
 	memo,
 	type PointerEvent as ReactPointerEvent,
 	useCallback,
@@ -23,13 +27,16 @@ import {
 } from "react";
 import { toast } from "sonner";
 import { Popover, PopoverContent, PopoverTrigger } from "@/components/ui/popover";
-import { fromFileUrl } from "@/components/video-editor/projectPersistence";
+import { Tooltip, TooltipProvider } from "@/components/ui/tooltip";
+import { fromFileUrl, toFileUrl } from "@/components/video-editor/projectPersistence";
 import { ZOOM_DEPTH_SCALES } from "@/components/video-editor/types";
 import { useScopedT } from "@/contexts/I18nContext";
+import { useShortcuts } from "@/contexts/ShortcutsContext";
 import { useAudioPeaks } from "@/hooks/useAudioPeaks";
+import { collapseTracksToPills, packAudioTrackRows } from "@/lib/ai-edition/document/audioTracks";
 import { createId } from "@/lib/ai-edition/document/ids";
 import { setUiProbeScrubbing } from "@/lib/ai-edition/perf/uiFrameProbe";
-import type { AxcutClip } from "@/lib/ai-edition/schema";
+import type { AxcutAudioTrack, AxcutClip } from "@/lib/ai-edition/schema";
 import { audioGainScalar } from "@/lib/ai-edition/store/editorSettings";
 import { useProjectStore } from "@/lib/ai-edition/store/projectStore";
 import { useTimelineTranscriptGate } from "@/lib/ai-edition/store/transcriptionStore";
@@ -53,6 +60,7 @@ import {
 	type AutoZoomSuggestion,
 	buildAutoZoomSuggestionsForClips,
 } from "@/lib/ai-edition/timeline/zoom-suggestions";
+import { formatBinding } from "@/lib/shortcuts";
 import { nativeBridgeClient } from "@/native/client";
 import { TransportBar } from "../TransportBar";
 import type { VideoSource } from "../VirtualPreview";
@@ -127,6 +135,14 @@ const PILL_HANDLE_OUT_PX = PILL_HANDLE_PX + PILL_MOVE_GAP_PX;
 const PILL_CONTENT_MIN_PX = 34;
 /** Edge-snap radius while dragging a pill, in screen px. */
 const PILL_SNAP_PX = 8;
+// One audio pill's height, and the vertical step between stacked rows. The lane
+// grows by a row for each track that overlaps one already placed — see
+// `packAudioTrackRows`.
+const AUDIO_ROW_HEIGHT_PX = 26;
+const AUDIO_ROW_GAP_PX = 3;
+// Breathing room above the first row and below the last, so a pill never sits
+// flush against the lane's rounded edge.
+const AUDIO_LANE_PAD_PX = 3;
 // The size a newly created pill aims for (PILL_CREATE_PX) lives in
 // timeline/newRegionDuration, because the keyboard shortcuts create regions too
 // and they are handled in NewEditorShell, outside this component.
@@ -335,6 +351,122 @@ const ClipWaveform = memo(function ClipWaveform({
 	);
 });
 
+// One imported audio track on its lane (issue #350). Grab the body to move it,
+// the edge handles to trim (left = in-point, which moves the head too; right =
+// out-point). The waveform reuses ClipWaveform (its `.tlWave` is inset:0, so it
+// paints behind the label here just as it does inside a clip), windowed to the
+// track's trim and scaled by the track's own gain. `leftPct`/`widthPct` are
+// precomputed by the parent — during a drag they carry the live preview geometry
+// — so this stays memoisable: a doc edit that doesn't touch this track, and a
+// drag on another one, won't re-render it.
+const AudioLanePill = memo(function AudioLanePill({
+	track,
+	url,
+	assetDurationSec,
+	leftPct,
+	widthPct,
+	sourceStartSec,
+	sourceEndSec,
+	spanSec,
+	loopWindowSec,
+	row,
+	rowHeight,
+	selected,
+	onStartDrag,
+	onSelect,
+	label,
+	outputGain,
+}: {
+	track: AxcutAudioTrack;
+	url: string | undefined;
+	assetDurationSec: number | undefined;
+	leftPct: number;
+	widthPct: number;
+	/** The slice of the source the pill is showing — the track's offset and its
+	 *  span, or the live window while an edge is being dragged. */
+	sourceStartSec: number;
+	sourceEndSec: number;
+	/** The pill's own length in seconds, and how much source one repeat plays —
+	 *  together they say where the loop boundaries fall. */
+	spanSec: number;
+	loopWindowSec: number;
+	/** Which row of the audio lane this pill occupies, and how tall a row is —
+	 *  overlapping tracks are stacked rather than drawn on top of each other. */
+	row: number;
+	rowHeight: number;
+	selected: boolean;
+	onStartDrag: (e: ReactPointerEvent, track: AxcutAudioTrack, mode: "move" | "l" | "r") => void;
+	onSelect: (id: string) => void;
+	label: string;
+	/** Linear project output gain, applied on top of the track gain — the mixer
+	 *  applies both, so the bars must too or they under-read the exported level. */
+	outputGain: number;
+}) {
+	const duration = assetDurationSec ?? track.durationSec;
+	return (
+		<div
+			role="button"
+			tabIndex={0}
+			className={`${styles.lanePill} ${styles.laneAudio}${
+				selected ? ` ${styles.lanePillSel}` : ""
+			}`}
+			style={{
+				left: `${leftPct}%`,
+				width: `${widthPct}%`,
+				minWidth: 3,
+				top: AUDIO_LANE_PAD_PX + row * rowHeight,
+				height: AUDIO_ROW_HEIGHT_PX,
+			}}
+			// Body drag moves the track; it also selects and stops the .tlTracks scrub.
+			onPointerDown={(e) => onStartDrag(e, track, "move")}
+			onKeyDown={(e) => {
+				if (e.key === "Enter" || e.key === " ") {
+					e.preventDefault();
+					onSelect(track.id);
+				}
+			}}
+			title={label}
+		>
+			<span
+				className={styles.lanePillHandle}
+				style={{ left: 0 }}
+				onPointerDown={(e) => onStartDrag(e, track, "l")}
+			/>
+			<ClipWaveform
+				videoUrl={url}
+				assetDurationSec={duration}
+				sourceStartSec={sourceStartSec}
+				sourceEndSec={sourceEndSec}
+				// Track gain AND the project output gain — `finish_audio` applies both and
+				// clamps, so scaling by the track gain alone under-read a boosted output.
+				gain={audioGainScalar(track.gainDb) * outputGain}
+			/>
+			{/* Where the file starts over, so a looping bed reads as one deliberate
+			    repeat rather than a mystery. Only drawn when the pill actually
+			    outruns its source — otherwise there is nothing to repeat. */}
+			{track.loop && loopWindowSec > 0
+				? Array.from({ length: Math.min(200, Math.ceil(spanSec / loopWindowSec) - 1) }, (_, i) => (
+						<span
+							key={`loop-${i + 1}`}
+							data-testid="audio-loop-mark"
+							className={styles.laneLoopMark}
+							style={{ left: `${(((i + 1) * loopWindowSec) / spanSec) * 100}%` }}
+						/>
+					))
+				: null}
+			<span className={styles.laneAudioLabel}>
+				<Music size={11} />
+				{label}
+			</span>
+			<span
+				className={styles.lanePillHandle}
+				style={{ right: 0 }}
+				onPointerDown={(e) => onStartDrag(e, track, "r")}
+			/>
+		</div>
+	);
+});
+
 interface LanePill {
 	id: string;
 	kind: "annotation" | "speed" | "trim" | "zoom" | "cameraFullscreen";
@@ -356,6 +488,7 @@ export function V4Timeline({
 	onPrevClip,
 	onNextClip,
 	onEditClip,
+	onAddVoiceover,
 }: {
 	tl: TimelineApi;
 	setCurrentTime: (sec: number) => void;
@@ -369,8 +502,14 @@ export function V4Timeline({
 	/** Opens the (now single, shell-level) EditClipModal for this clip —
 	 * trim in/out and crop both live there per-clip. */
 	onEditClip: (clip: AxcutClip) => void;
+	/** Opens the voiceover recorder. Shell-level like the clip editor: the
+	 *  dialog owns the microphone and the shell owns the transport. */
+	onAddVoiceover: () => void;
 }) {
 	const t = useScopedT("timeline");
+	// The live bindings, not the defaults: these keys are remappable, and a menu
+	// that taught the wrong one would be worse than teaching none.
+	const { shortcuts, isMac } = useShortcuts();
 	// The camera lane borrows the Layout pane's "No Webcam" wording when there is no
 	// camera to grow, so the two surfaces say the same thing about the same project.
 	const ts = useScopedT("settings");
@@ -412,6 +551,7 @@ export function V4Timeline({
 	const { settings, set: setSettings } = useEditorSettings();
 
 	const [autoEnhanceOpen, setAutoEnhanceOpen] = useState(false);
+	const [audioMenuOpen, setAudioMenuOpen] = useState(false);
 	const [autoBusy, setAutoBusy] = useState(false);
 	// The AI cut pass reads the transcript, and the transcript is produced in the
 	// background (see transcriptionStore). Until it is there, the entry says why
@@ -779,6 +919,150 @@ export function V4Timeline({
 		[tl, total, clips, pxPerSec],
 	);
 
+	// Live preview geometry for an audio track being dragged (issue #350), the
+	// audio-lane counterpart of activePillDrag — see startAudioDrag. Times are
+	// output-timeline (start) and source (trimStart/trimEnd) seconds.
+	const [audioDrag, setAudioDrag] = useState<{
+		id: string;
+		start: number;
+		trimStart: number;
+		trimEnd: number;
+	} | null>(null);
+	const audioDragRef = useRef<typeof audioDrag>(null);
+	// The user-visible tracks and their lane rows. Packed from the STORED spans,
+	// not the live drag geometry: a pill that changed rows halfway through a drag
+	// would jump out from under the pointer.
+	const audioPills = useMemo(() => collapseTracksToPills(tl.audioTracks), [tl.audioTracks]);
+	const audioRows = useMemo(() => packAudioTrackRows(audioPills), [audioPills]);
+
+	// Drag an audio track: "move" slides the head (both edges together), "l"/"r"
+	// trim the in/out points. The left edge moves the head AND the in-point so the
+	// right edge stays put — hence the single placeAudioTrack commit on release.
+	// Like the region pills, the preview is local state and the document is written
+	// once, on pointerup.
+	const startAudioDrag = useCallback(
+		(e: ReactPointerEvent, track: AxcutAudioTrack, mode: "move" | "l" | "r") => {
+			e.preventDefault();
+			e.stopPropagation();
+			tl.selectAudioTrack(track.id);
+			// Start clean: a previous drag's commit may still be in flight (its ref is
+			// cleared only when `placeAudioTrack` resolves). Without this, a plain
+			// select-click that never moves would let `up` read that stale value and
+			// re-commit the old drag — a redundant write and an extra undo step.
+			audioDragRef.current = null;
+			const el = canvasRef.current;
+			if (!el) return;
+			const r = el.getBoundingClientRect();
+			const startX = e.clientX;
+			const asset = tl.assets.find((a) => a.id === track.assetId);
+			// The source length caps the out-point; fall back to the current window when
+			// the file hasn't been probed (durationSec 0), so a drag can't extend past it.
+			const spanSec = Math.max(0, (track.endMs - track.startMs) / 1000);
+			const sourceLen = asset?.durationSec || track.durationSec || spanSec;
+			const origStart = track.startMs / 1000;
+			const origTrimStart = track.offsetMs / 1000;
+			const origTrimEnd = origTrimStart + spanSec;
+			// A looping track may be pulled out PAST the end of its file — that is
+			// the whole point of looping, and capping at the source length is what
+			// made the loop toggle do nothing: the span could never exceed the
+			// window loop repeats, so it always played exactly once. Only the
+			// programme end bounds it (applied below).
+			const maxEnd = track.loop
+				? Number.POSITIVE_INFINITY
+				: sourceLen > 0
+					? sourceLen
+					: origTrimEnd;
+			// Snap the moving edge to clip boundaries and the timeline ends, same PILL_SNAP_PX
+			// magnet the region pills use.
+			const snapTargets = [
+				0,
+				total,
+				...clips.map((c) => c.timelineStartSec),
+				...clips.map((c) => c.timelineEndSec),
+			];
+			const snapThresh = pxPerSec > 0 ? PILL_SNAP_PX / pxPerSec : 0;
+			const snap = (v: number): number => {
+				let best = v;
+				let bestD = snapThresh;
+				for (const target of snapTargets) {
+					const d = Math.abs(target - v);
+					if (d < bestD) {
+						bestD = d;
+						best = target;
+					}
+				}
+				setSnapPct(best === v ? null : (best / total) * 100);
+				return best;
+			};
+			const move = (ev: PointerEvent) => {
+				const dxSec = ((ev.clientX - startX) / r.width) * total;
+				let ns = origStart;
+				let nts = origTrimStart;
+				let nte = origTrimEnd;
+				if (mode === "move") {
+					// Cap so the whole track lands by `total`: no pill past 100%, and the
+					// export (which truncates at the programme end) matches what's shown.
+					const upper = Math.max(0, total - (origTrimEnd - origTrimStart));
+					ns = Math.min(Math.max(0, snap(origStart + dxSec)), upper);
+				} else if (mode === "l") {
+					// The left edge can't cross the right one, and can't reveal more head
+					// than the source has (trimStart floors at 0 → head floors at
+					// origStart - origTrimStart).
+					const rightEdge = origStart + (origTrimEnd - origTrimStart);
+					const lowerLeft = Math.max(0, origStart - origTrimStart);
+					let newLeft = snap(origStart + dxSec);
+					newLeft = Math.min(Math.max(newLeft, lowerLeft), rightEdge - MIN_REGION_SEC);
+					ns = newLeft;
+					nts = origTrimStart + (newLeft - origStart);
+					nte = origTrimEnd;
+				} else {
+					// Right edge: move the out-point, head fixed. Snap on the timeline
+					// position of the edge, then map back to a source out-point.
+					const snappedRight = snap(origStart + (origTrimEnd - origTrimStart) + dxSec);
+					const newTrimEnd = origTrimStart + (snappedRight - origStart);
+					// Cap the out-point at the source length AND the programme end (`total`).
+					nte = Math.min(
+						Math.max(newTrimEnd, origTrimStart + MIN_REGION_SEC),
+						maxEnd,
+						origTrimStart + Math.max(0, total - origStart),
+					);
+				}
+				const next = { id: track.id, start: ns, trimStart: nts, trimEnd: nte };
+				audioDragRef.current = next;
+				setAudioDrag(next);
+			};
+			const up = () => {
+				setSnapPct(null);
+				window.removeEventListener("pointermove", move);
+				window.removeEventListener("pointerup", up);
+				const fin = audioDragRef.current;
+				if (fin) {
+					void tl
+						.placeAudioTrack(fin.id, {
+							startMs: Math.round(fin.start * 1000),
+							endMs: Math.round((fin.start + Math.max(0, fin.trimEnd - fin.trimStart)) * 1000),
+							// Carries the left-edge trim: without it the head moved but the
+							// source kept playing from the same point, so dragging the edge
+							// in just slid the audio along instead of cutting its head off.
+							offsetMs: Math.round(fin.trimStart * 1000),
+						})
+						.finally(() => {
+							if (audioDragRef.current === fin) {
+								audioDragRef.current = null;
+								setAudioDrag(null);
+							}
+						});
+				} else {
+					audioDragRef.current = null;
+					setAudioDrag(null);
+				}
+			};
+			window.addEventListener("pointermove", move);
+			window.addEventListener("pointerup", up);
+		},
+		[tl, total, clips, pxPerSec],
+	);
+
 	const startNavDrag = useCallback(
 		(mode: "left" | "right" | "pan", e: ReactPointerEvent) => {
 			e.preventDefault();
@@ -1271,118 +1555,211 @@ export function V4Timeline({
 		<div className={styles.tl} ref={panelRef}>
 			<div className={styles.tlToolbar}>
 				{showLanes ? (
-					<div className={styles.tlTools} role="toolbar" aria-label={t("toolbar.timelineTools")}>
-						<Popover open={autoEnhanceOpen} onOpenChange={setAutoEnhanceOpen}>
-							<PopoverTrigger asChild>
+					// Its own provider rather than leaning on the app root's: the toolbar
+					// is the only thing here that needs one, and every test that renders
+					// a timeline (directly or through the shell) would otherwise have to
+					// know to supply it. Nesting under the root provider is harmless.
+					<TooltipProvider>
+						<div className={styles.tlTools} role="toolbar" aria-label={t("toolbar.timelineTools")}>
+							<Popover open={autoEnhanceOpen} onOpenChange={setAutoEnhanceOpen}>
+								<Tooltip content={t("toolbar.autoEnhance")}>
+									<PopoverTrigger asChild>
+										<button
+											type="button"
+											className={styles.tlToolBtn}
+											aria-label={t("toolbar.autoEnhance")}
+											disabled={autoBusy}
+										>
+											{autoBusy ? (
+												<Loader2 className="animate-spin" size={15} />
+											) : (
+												<Wand2 size={15} />
+											)}
+										</button>
+									</PopoverTrigger>
+								</Tooltip>
+								<PopoverContent
+									align="start"
+									sideOffset={6}
+									animated={false}
+									className="w-auto border-0 bg-transparent p-0 shadow-none"
+								>
+									<div
+										className={styles.recMenu}
+										style={{ position: "relative", bottom: "auto", width: 244 }}
+									>
+										<button
+											type="button"
+											className={styles.recMenuRow}
+											onClick={() => void runAutoZooms()}
+										>
+											<ZoomIn size={15} style={{ flexShrink: 0 }} />
+											<span style={{ display: "flex", flexDirection: "column", gap: 1 }}>
+												<span style={{ fontWeight: 600 }}>{t("toolbar.automaticZooms")}</span>
+												<span style={{ fontSize: 11, color: "var(--muted)" }}>
+													{t("toolbar.automaticZoomsHint")}
+												</span>
+											</span>
+										</button>
+										<button
+											type="button"
+											className={styles.recMenuRow}
+											onClick={runAiEnhance}
+											disabled={smartCutsBlocked}
+											title={
+												transcriptGate.reason === "failed" ? transcriptGate.message : undefined
+											}
+											style={
+												smartCutsBlocked ? { opacity: 0.55, cursor: "not-allowed" } : undefined
+											}
+										>
+											{transcriptGate.state === "pending" ? (
+												<Loader2 size={15} className="animate-spin" style={{ flexShrink: 0 }} />
+											) : (
+												<Sparkles size={15} style={{ flexShrink: 0 }} />
+											)}
+											<span style={{ display: "flex", flexDirection: "column", gap: 1 }}>
+												<span style={{ fontWeight: 600 }}>{t("toolbar.smartZoomsAndCuts")}</span>
+												<span style={{ fontSize: 11, color: "var(--muted)" }}>{smartCutsHint}</span>
+											</span>
+										</button>
+									</div>
+								</PopoverContent>
+							</Popover>
+							<span className={styles.tlToolSep} aria-hidden />
+							{tools.map((tool) => (
+								<Fragment key={tool.id}>
+									<Tooltip content={tool.label}>
+										<button
+											type="button"
+											className={styles.tlToolBtn}
+											aria-label={tool.label}
+											onClick={() => {
+												// Read at CLICK time: a render-time value would be one zoom
+												// notch stale when the user zooms and immediately creates.
+												const dur = newRegionDurationSec();
+												if (tool.id === "speed") void tl.addSpeed(dur);
+												if (tool.id === "comment") void tl.addAnnotation(dur);
+												if (tool.id === "cut") void tl.addTrim(dur);
+											}}
+										>
+											{tool.icon}
+										</button>
+									</Tooltip>
+									{/* Add audio sits right after Add annotation (issue #350). */}
+									{/* One audio button, two ways in. A mic and a music note side by
+								    side both just said "audio" and left the user to guess which
+								    was which; a waveform is neutral between them, and the menu
+								    names the two paths outright. Mirrors the auto-enhance
+								    button's menu right next to it. */}
+									{tool.id === "comment" ? (
+										<Popover open={audioMenuOpen} onOpenChange={setAudioMenuOpen}>
+											<Tooltip content={t("toolbar.addAudioTooltip")}>
+												<PopoverTrigger asChild>
+													<button
+														type="button"
+														className={styles.tlToolBtn}
+														aria-label={t("toolbar.addAudioTooltip")}
+													>
+														<AudioLines size={15} />
+													</button>
+												</PopoverTrigger>
+											</Tooltip>
+											<PopoverContent
+												align="start"
+												sideOffset={6}
+												animated={false}
+												className="w-auto border-0 bg-transparent p-0 shadow-none"
+											>
+												<div
+													className={styles.recMenu}
+													style={{ position: "relative", bottom: "auto", width: 244 }}
+												>
+													<button
+														type="button"
+														className={styles.recMenuRow}
+														onClick={() => {
+															setAudioMenuOpen(false);
+															onAddVoiceover();
+														}}
+													>
+														<Mic size={15} style={{ flexShrink: 0 }} />
+														<span style={{ display: "flex", flexDirection: "column", gap: 1 }}>
+															<span style={{ fontWeight: 600 }}>{t("audio.addVoiceover")}</span>
+															<span style={{ fontSize: 11, color: "var(--muted)" }}>
+																{t("audio.addVoiceoverHint")}
+															</span>
+														</span>
+														<kbd className={styles.recMenuKey}>
+															{formatBinding(shortcuts.addVoiceover, isMac)}
+														</kbd>
+													</button>
+													<button
+														type="button"
+														className={styles.recMenuRow}
+														onClick={() => {
+															setAudioMenuOpen(false);
+															void tl.addAudio();
+														}}
+													>
+														<Music size={15} style={{ flexShrink: 0 }} />
+														<span style={{ display: "flex", flexDirection: "column", gap: 1 }}>
+															<span style={{ fontWeight: 600 }}>{ts("audioTrack.add")}</span>
+															<span style={{ fontSize: 11, color: "var(--muted)" }}>
+																{t("audio.importFileHint")}
+															</span>
+														</span>
+														<kbd className={styles.recMenuKey}>
+															{formatBinding(shortcuts.addAudio, isMac)}
+														</kbd>
+													</button>
+												</div>
+											</PopoverContent>
+										</Popover>
+									) : null}
+								</Fragment>
+							))}
+							<Tooltip content={t("buttons.addZoom")}>
 								<button
 									type="button"
 									className={styles.tlToolBtn}
-									title={t("toolbar.autoEnhance")}
-									aria-label={t("toolbar.autoEnhance")}
-									disabled={autoBusy}
+									aria-label={t("buttons.addZoom")}
+									onClick={() => void tl.addZoom(newRegionDurationSec())}
 								>
-									{autoBusy ? <Loader2 className="animate-spin" size={15} /> : <Wand2 size={15} />}
+									<ZoomIn size={15} />
 								</button>
-							</PopoverTrigger>
-							<PopoverContent
-								align="start"
-								sideOffset={6}
-								animated={false}
-								className="w-auto border-0 bg-transparent p-0 shadow-none"
+							</Tooltip>
+							<Tooltip
+								content={t(
+									settings.autoFocusAll ? "buttons.autoFocusAllOn" : "buttons.autoFocusAllOff",
+								)}
 							>
-								<div
-									className={styles.recMenu}
-									style={{ position: "relative", bottom: "auto", width: 244 }}
+								<button
+									type="button"
+									className={styles.tlToolBtn}
+									aria-pressed={settings.autoFocusAll}
+									aria-label={t(
+										settings.autoFocusAll ? "buttons.autoFocusAllOn" : "buttons.autoFocusAllOff",
+									)}
+									onClick={() => void setSettings({ autoFocusAll: !settings.autoFocusAll })}
 								>
-									<button
-										type="button"
-										className={styles.recMenuRow}
-										onClick={() => void runAutoZooms()}
-									>
-										<ZoomIn size={15} style={{ flexShrink: 0 }} />
-										<span style={{ display: "flex", flexDirection: "column", gap: 1 }}>
-											<span style={{ fontWeight: 600 }}>{t("toolbar.automaticZooms")}</span>
-											<span style={{ fontSize: 11, color: "var(--muted)" }}>
-												{t("toolbar.automaticZoomsHint")}
-											</span>
-										</span>
-									</button>
-									<button
-										type="button"
-										className={styles.recMenuRow}
-										onClick={runAiEnhance}
-										disabled={smartCutsBlocked}
-										title={transcriptGate.reason === "failed" ? transcriptGate.message : undefined}
-										style={smartCutsBlocked ? { opacity: 0.55, cursor: "not-allowed" } : undefined}
-									>
-										{transcriptGate.state === "pending" ? (
-											<Loader2 size={15} className="animate-spin" style={{ flexShrink: 0 }} />
-										) : (
-											<Sparkles size={15} style={{ flexShrink: 0 }} />
-										)}
-										<span style={{ display: "flex", flexDirection: "column", gap: 1 }}>
-											<span style={{ fontWeight: 600 }}>{t("toolbar.smartZoomsAndCuts")}</span>
-											<span style={{ fontSize: 11, color: "var(--muted)" }}>{smartCutsHint}</span>
-										</span>
-									</button>
-								</div>
-							</PopoverContent>
-						</Popover>
-						<span className={styles.tlToolSep} aria-hidden />
-						{tools.map((tool) => (
-							<button
-								type="button"
-								key={tool.id}
-								className={styles.tlToolBtn}
-								title={tool.label}
-								aria-label={tool.label}
-								onClick={() => {
-									// Read at CLICK time: a render-time value would be one zoom
-									// notch stale when the user zooms and immediately creates.
-									const dur = newRegionDurationSec();
-									if (tool.id === "speed") void tl.addSpeed(dur);
-									if (tool.id === "comment") void tl.addAnnotation(dur);
-									if (tool.id === "cut") void tl.addTrim(dur);
-								}}
-							>
-								{tool.icon}
-							</button>
-						))}
-						<button
-							type="button"
-							className={styles.tlToolBtn}
-							title={t("buttons.addZoom")}
-							aria-label={t("buttons.addZoom")}
-							onClick={() => void tl.addZoom(newRegionDurationSec())}
-						>
-							<ZoomIn size={15} />
-						</button>
-						<button
-							type="button"
-							className={styles.tlToolBtn}
-							aria-pressed={settings.autoFocusAll}
-							title={t(
-								settings.autoFocusAll ? "buttons.autoFocusAllOn" : "buttons.autoFocusAllOff",
-							)}
-							aria-label={t(
-								settings.autoFocusAll ? "buttons.autoFocusAllOn" : "buttons.autoFocusAllOff",
-							)}
-							onClick={() => void setSettings({ autoFocusAll: !settings.autoFocusAll })}
-						>
-							<Crosshair size={15} />
-						</button>
-						<button
-							type="button"
-							className={styles.tlToolBtn}
-							title={t("buttons.addCameraFullscreen")}
-							aria-label={t("buttons.addCameraFullscreen")}
-							disabled={!hasAnyCamera}
-							style={!hasAnyCamera ? { opacity: 0.55, cursor: "not-allowed" } : undefined}
-							onClick={() => void tl.addCameraFullscreen(newRegionDurationSec())}
-						>
-							<Maximize2 size={15} />
-						</button>
-					</div>
+									<Crosshair size={15} />
+								</button>
+							</Tooltip>
+							<Tooltip content={t("buttons.addCameraFullscreen")}>
+								<button
+									type="button"
+									className={styles.tlToolBtn}
+									aria-label={t("buttons.addCameraFullscreen")}
+									disabled={!hasAnyCamera}
+									style={!hasAnyCamera ? { opacity: 0.55, cursor: "not-allowed" } : undefined}
+									onClick={() => void tl.addCameraFullscreen(newRegionDurationSec())}
+								>
+									<Maximize2 size={15} />
+								</button>
+							</Tooltip>
+						</div>
+					</TooltipProvider>
 				) : (
 					// Media is an ARRANGING surface: add, remove, reorder. Nothing here
 					// plays or edits, so the transport, the scroll hints, the zoom nav and
@@ -1482,6 +1859,73 @@ export function V4Timeline({
 										hasAnyCamera ? t("hints.pressCameraFullscreen") : ts("layout.noWebcam"),
 									)}
 								</div>
+								{/* Imported audio tracks (issue #350). Always shown, like every other
+								    lane — "Add audio" is a toolbar peer of the region tools now (and
+								    has a keyboard shortcut), so an empty lane advertises the shortcut
+								    that fills it rather than hiding until the first import. */}
+								<div
+									className={`${styles.tlLane} ${styles.tlLaneAudio}`}
+									// Grows a row per overlapping track, so three voiceovers over
+									// the same stretch are three legible pills rather than one
+									// pile nobody can aim at.
+									style={{
+										height:
+											audioRows.rowCount * AUDIO_ROW_HEIGHT_PX +
+											(audioRows.rowCount - 1) * AUDIO_ROW_GAP_PX +
+											AUDIO_LANE_PAD_PX * 2,
+									}}
+								>
+									{tl.audioTracks.length === 0 ? (
+										<span
+											className={styles.laneEmpty}
+											style={{ left: `${nav.start * 100}%`, width: `${navSpan * 100}%` }}
+										>
+											{t("hints.pressAudio")}
+										</span>
+									) : (
+										// One pill per user-visible track: the document stores one
+										// clip-anchored fragment per clip the track covers, and the
+										// lane must not show a split take as two pills.
+										audioPills.map((track) => {
+											const asset = tl.assets.find((a) => a.id === track.assetId);
+											const duration = asset?.durationSec ?? track.durationSec;
+											// While this track is being dragged, lay it out from the live
+											// preview geometry instead of the not-yet-written document.
+											const drag = audioDrag?.id === track.id ? audioDrag : null;
+											const start = drag ? drag.start : track.startMs / 1000;
+											// A drag carries its span as the trim window it is dragging
+											// the edges of; the pill's width is that window.
+											const widthSec = drag
+												? Math.max(0, drag.trimEnd - drag.trimStart)
+												: Math.max(0, (track.endMs - track.startMs) / 1000);
+											const trimStart = drag ? drag.trimStart : track.offsetMs / 1000;
+											const trimEnd = trimStart + widthSec;
+											return (
+												<AudioLanePill
+													key={track.id}
+													track={track}
+													url={asset ? toFileUrl(asset.originalPath) : undefined}
+													assetDurationSec={duration}
+													leftPct={pctOf(start)}
+													widthPct={pctOf(widthSec)}
+													row={audioRows.rowOf.get(track.id) ?? 0}
+													rowHeight={AUDIO_ROW_HEIGHT_PX + AUDIO_ROW_GAP_PX}
+													spanSec={widthSec}
+													loopWindowSec={Math.max(0, (duration || 0) - trimStart)}
+													sourceStartSec={trimStart}
+													// A looping pill can outrun its file; the waveform draws
+													// the source it actually has.
+													sourceEndSec={duration > 0 ? Math.min(trimEnd, duration) : trimEnd}
+													selected={tl.selectedAudioTrackId === track.id}
+													onStartDrag={startAudioDrag}
+													onSelect={tl.selectAudioTrack}
+													label={track.label || asset?.label || ts("audioTrack.defaultLabel")}
+													outputGain={audioGainScalar(settings.audioGainDb)}
+												/>
+											);
+										})
+									)}
+								</div>
 							</>
 						) : null}
 
diff --git a/src/components/ai-edition/v4/V4Timeline.waveform.test.tsx b/src/components/ai-edition/v4/V4Timeline.waveform.test.tsx
index b5b2d9949..c29f5f84d 100644
--- a/src/components/ai-edition/v4/V4Timeline.waveform.test.tsx
+++ b/src/components/ai-edition/v4/V4Timeline.waveform.test.tsx
@@ -54,6 +54,7 @@ vi.mock("@/lib/ai-edition/store/useEditorSettings", () => ({
 	}),
 }));
 
+import { ShortcutsProvider } from "@/contexts/ShortcutsContext";
 import type { useTimeline } from "@/lib/ai-edition/store/useTimeline";
 import { V4Timeline } from "./V4Timeline";
 
@@ -115,6 +116,9 @@ function renderBars(atGainDb: number): string[] {
 		selection: null,
 		multiSelection: [],
 		clipSelection: null,
+		audioTracks: [],
+		selectedAudioTrackId: null,
+		selectAudioTrack: vi.fn(),
 		clearSelection: vi.fn(),
 		selectRegion: vi.fn(),
 		selectClip: vi.fn(),
@@ -122,16 +126,19 @@ function renderBars(atGainDb: number): string[] {
 		addZoom: vi.fn(async () => undefined),
 	};
 	const view = render(
-		<V4Timeline
-			tl={tl as unknown as ReturnType<typeof useTimeline>}
-			videoSources={[{ id: "a1", src: "file:///tmp/rec.mp4", label: "rec" }]}
-			setCurrentTime={vi.fn()}
-			playing={false}
-			onTogglePlay={vi.fn()}
-			onPrevClip={vi.fn()}
-			onNextClip={vi.fn()}
-			onEditClip={vi.fn()}
-		/>,
+		<ShortcutsProvider>
+			<V4Timeline
+				tl={tl as unknown as ReturnType<typeof useTimeline>}
+				videoSources={[{ id: "a1", src: "file:///tmp/rec.mp4", label: "rec" }]}
+				setCurrentTime={vi.fn()}
+				playing={false}
+				onTogglePlay={vi.fn()}
+				onPrevClip={vi.fn()}
+				onNextClip={vi.fn()}
+				onEditClip={vi.fn()}
+				onAddVoiceover={vi.fn()}
+			/>
+		</ShortcutsProvider>,
 	);
 	const bars = Array.from(
 		document.querySelectorAll<HTMLElement>('[class*="tlWave"] span'),
diff --git a/src/components/ui/popover.tsx b/src/components/ui/popover.tsx
index 9341c8d3e..807481b6d 100644
--- a/src/components/ui/popover.tsx
+++ b/src/components/ui/popover.tsx
@@ -9,9 +9,18 @@ function Popover({ ...props }: React.ComponentProps<typeof PopoverPrimitive.Root
 	return <PopoverPrimitive.Root data-slot="popover" {...props} />;
 }
 
-function PopoverTrigger({ ...props }: React.ComponentProps<typeof PopoverPrimitive.Trigger>) {
-	return <PopoverPrimitive.Trigger data-slot="popover-trigger" {...props} />;
-}
+// forwardRef, like the Dialog parts: on React 18 a plain function component
+// cannot receive a ref, so anything that wraps this trigger with its own
+// `asChild` — a Tooltip around a popover button, say — fails to anchor and
+// warns. The primitive underneath has always forwarded; only this wrapper
+// swallowed it.
+const PopoverTrigger = React.forwardRef<
+	React.ComponentRef<typeof PopoverPrimitive.Trigger>,
+	React.ComponentProps<typeof PopoverPrimitive.Trigger>
+>(({ ...props }, ref) => (
+	<PopoverPrimitive.Trigger ref={ref} data-slot="popover-trigger" {...props} />
+));
+PopoverTrigger.displayName = "PopoverTrigger";
 
 function PopoverContent({
 	className,
diff --git a/src/components/ui/tooltip.tsx b/src/components/ui/tooltip.tsx
index c5dfc12b5..823b3f9b5 100644
--- a/src/components/ui/tooltip.tsx
+++ b/src/components/ui/tooltip.tsx
@@ -46,25 +46,27 @@ function TooltipContent({
 	);
 }
 
-function Tooltip({
-	children,
-	content,
-	side,
-	className,
-}: {
-	children: React.ReactNode;
-	content: React.ReactNode;
-	side?: "top" | "right" | "bottom" | "left";
-	className?: string;
-}) {
-	return (
-		<TooltipRoot>
-			<TooltipTrigger asChild>{children}</TooltipTrigger>
-			<TooltipContent side={side} className={className}>
-				{content}
-			</TooltipContent>
-		</TooltipRoot>
-	);
-}
+// forwardRef for the same reason as PopoverTrigger above: this is a convenience
+// wrapper people nest inside other `asChild` triggers, and on React 18 a plain
+// function component silently drops the ref it is handed.
+const Tooltip = React.forwardRef<
+	React.ComponentRef<typeof TooltipTrigger>,
+	{
+		children: React.ReactNode;
+		content: React.ReactNode;
+		side?: "top" | "right" | "bottom" | "left";
+		className?: string;
+	}
+>(({ children, content, side, className }, ref) => (
+	<TooltipRoot>
+		<TooltipTrigger ref={ref} asChild>
+			{children}
+		</TooltipTrigger>
+		<TooltipContent side={side} className={className}>
+			{content}
+		</TooltipContent>
+	</TooltipRoot>
+));
+Tooltip.displayName = "Tooltip";
 
 export { Tooltip, TooltipContent, TooltipProvider, TooltipRoot, TooltipTrigger };
diff --git a/src/contexts/ShortcutsContext.tsx b/src/contexts/ShortcutsContext.tsx
index 91bd7f8d3..6f5e13731 100644
--- a/src/contexts/ShortcutsContext.tsx
+++ b/src/contexts/ShortcutsContext.tsx
@@ -39,9 +39,14 @@ export function ShortcutsProvider({ children }: { children: ReactNode }) {
 	useEffect(() => {
 		setIsMac(getIsMac());
 
+		// Guard `electronAPI` itself, not just the method on it — that is what the
+		// note above is after. Without preload (browser mode, and any test that
+		// renders a consumer) the bare property read threw and took the whole
+		// subtree with it, rather than falling back to the defaults already in
+		// state.
 		window.electronAPI
-			.getShortcuts?.()
-			.then((saved) => {
+			?.getShortcuts?.()
+			?.then((saved) => {
 				if (saved) {
 					setShortcuts(mergeWithDefaults(saved as Partial<ShortcutsConfig>));
 				}
@@ -54,9 +59,9 @@ export function ShortcutsProvider({ children }: { children: ReactNode }) {
 	const persistShortcuts = useCallback(
 		async (config?: ShortcutsConfig) => {
 			const configToSave = config ?? shortcuts;
-			await window.electronAPI.saveShortcuts?.(configToSave);
+			await window.electronAPI?.saveShortcuts?.(configToSave);
 
-			const result = await window.electronAPI.updateGlobalShortcut?.(configToSave.openApp);
+			const result = await window.electronAPI?.updateGlobalShortcut?.(configToSave.openApp);
 			return result ? result.success : true;
 		},
 		[shortcuts],
diff --git a/src/i18n/locales/ar/dialogs.json b/src/i18n/locales/ar/dialogs.json
index 43caf5938..cf7c6f554 100644
--- a/src/i18n/locales/ar/dialogs.json
+++ b/src/i18n/locales/ar/dialogs.json
@@ -79,11 +79,13 @@
 		"saveGif": "حفظ GIF المصدر",
 		"saveVideo": "حفظ الفيديو المصدر",
 		"selectVideo": "حدد ملف فيديو",
+		"selectAudio": "اختر ملف صوت",
 		"saveProject": "حفظ مشروع OpenScreen",
 		"openProject": "فتح مشروع OpenScreen",
 		"gifImage": "صورة GIF",
 		"mp4Video": "فيديو MP4",
 		"videoFiles": "ملفات فيديو",
+		"audioFiles": "ملفات الصوت",
 		"openscreenProject": "مشروع OpenScreen",
 		"allFiles": "جميع الملفات"
 	}
diff --git a/src/i18n/locales/ar/editor.json b/src/i18n/locales/ar/editor.json
index 39860c0da..a479f0127 100644
--- a/src/i18n/locales/ar/editor.json
+++ b/src/i18n/locales/ar/editor.json
@@ -71,6 +71,7 @@
 		"pasted": "تم لصق سمات {{region}}",
 		"nothingToCopy": "حدد منطقة لنسخ سماتها",
 		"nothingToPaste": "لم يتم نسخ أي سمات بعد",
+		"pasteAssetMissing": "ملف هذا المسار الصوتي غير موجود في هذا المشروع",
 		"kinds": {
 			"zoom": "تكبير",
 			"speed": "سرعة",
diff --git a/src/i18n/locales/ar/settings.json b/src/i18n/locales/ar/settings.json
index 5fc1ac58c..793eb609f 100644
--- a/src/i18n/locales/ar/settings.json
+++ b/src/i18n/locales/ar/settings.json
@@ -327,5 +327,16 @@
 		"outputGain": "ضبط مستوى الإخراج",
 		"reset": "إعادة ضبط الصوت",
 		"help": "اضبط مستوى إخراج الصوت. يُطبَّق بالطريقة نفسها في المعاينة وعند التصدير."
+	},
+	"audioTrack": {
+		"add": "إضافة مسار صوتي",
+		"importFailed": "تعذّر إضافة الصوت",
+		"defaultLabel": "مسار صوتي",
+		"help": "مستوى الصوت والتلاشي والتكرار لهذا المسار الصوتي. يُمزج فوق التسجيل في المعاينة والتصدير. اسحب المسار على المخطط الزمني لتحريكه أو تغيير حجمه.",
+		"fadeIn": "تلاشٍ للداخل",
+		"fadeOut": "تلاشٍ للخارج",
+		"mute": "كتم",
+		"loop": "تكرار",
+		"remove": "حذف المسار"
 	}
 }
diff --git a/src/i18n/locales/ar/shortcuts.json b/src/i18n/locales/ar/shortcuts.json
index d8c063784..137a0186e 100644
--- a/src/i18n/locales/ar/shortcuts.json
+++ b/src/i18n/locales/ar/shortcuts.json
@@ -20,6 +20,8 @@
 		"addTrim": "إضافة قص",
 		"addSpeed": "إضافة سرعة",
 		"addAnnotation": "إضافة شرح",
+		"addAudio": "إضافة صوت",
+		"addVoiceover": "تسجيل تعليق صوتي",
 		"addKeyframe": "إضافة إطار رئيسي",
 		"addCameraFullscreen": "إضافة كاميرا كاملة الشاشة",
 		"deleteSelected": "حذف المحدد",
diff --git a/src/i18n/locales/ar/timeline.json b/src/i18n/locales/ar/timeline.json
index 4412a0a0b..e0e263b43 100644
--- a/src/i18n/locales/ar/timeline.json
+++ b/src/i18n/locales/ar/timeline.json
@@ -15,6 +15,7 @@
 		"pressZoom": "اضغط Z لإضافة تكبير",
 		"pressTrim": "اضغط T لإضافة قص",
 		"pressAnnotation": "اضغط A لإضافة شرح",
+		"pressAudio": "اضغط M لإضافة صوت، وV لتسجيل تعليق صوتي",
 		"pressSpeed": "اضغط S لإضافة سرعة",
 		"pressCameraFullscreen": "اضغط C لإضافة مقطع كاميرا كاملة الشاشة"
 	},
@@ -85,6 +86,22 @@
 		"smartCutsNeedsTranscript": "يتطلب نصًا منسوخًا",
 		"smartCutsNoAudio": "لا يحتوي هذا الملف على صوت",
 		"smartCutsNoSpeech": "لم يتم اكتشاف كلام",
-		"smartCutsFailed": "فشل النسخ — أعد المحاولة من قسم الوسائط"
+		"smartCutsFailed": "فشل النسخ — أعد المحاولة من قسم الوسائط",
+		"addAudioTooltip": "إضافة صوت"
+	},
+	"audio": {
+		"addVoiceover": "إضافة تعليق صوتي",
+		"addVoiceoverHint": "سجّل تعليقًا صوتيًا فوق الفيديو",
+		"subtitle": "ضع تعليقًا صوتيًا أو موسيقى خلفية على المخطط الزمني",
+		"record": "تسجيل تعليق صوتي",
+		"importFile": "استيراد ملف صوتي",
+		"importFileHint": "أدرج موسيقى أو ملفًا صوتيًا",
+		"recording": "جارٍ التسجيل",
+		"recordingHint": "علّق صوتيًا مع الفيديو — يعمل أثناء التسجيل",
+		"stop": "إيقاف",
+		"micDenied": "تم رفض الوصول إلى الميكروفون",
+		"recordingUnavailable": "التسجيل غير متاح هنا",
+		"saveFailed": "تعذر حفظ التسجيل",
+		"importFailed": "تعذر استيراد الملف الصوتي"
 	}
 }
diff --git a/src/i18n/locales/en/dialogs.json b/src/i18n/locales/en/dialogs.json
index 90599af16..9ce8e3ded 100644
--- a/src/i18n/locales/en/dialogs.json
+++ b/src/i18n/locales/en/dialogs.json
@@ -42,7 +42,6 @@
 		"step1Title": "1. Add Trim",
 		"step1DescriptionBefore": "Press ",
 		"step1DescriptionAfter": " or click the scissors icon to mark a section for removal.",
-
 		"step2Title": "2. Adjust",
 		"step2Description": "Drag the edges of the red region to cover exactly what you want to cut out."
 	},
@@ -80,11 +79,13 @@
 		"saveGif": "Save Exported GIF",
 		"saveVideo": "Save Exported Video",
 		"selectVideo": "Select Video File",
+		"selectAudio": "Select Audio File",
 		"saveProject": "Save OpenScreen Project",
 		"openProject": "Open OpenScreen Project",
 		"gifImage": "GIF Image",
 		"mp4Video": "MP4 Video",
 		"videoFiles": "Video Files",
+		"audioFiles": "Audio Files",
 		"openscreenProject": "OpenScreen Project",
 		"allFiles": "All Files"
 	}
diff --git a/src/i18n/locales/en/editor.json b/src/i18n/locales/en/editor.json
index 7aa5954ce..efc37eb98 100644
--- a/src/i18n/locales/en/editor.json
+++ b/src/i18n/locales/en/editor.json
@@ -71,6 +71,7 @@
 		"pasted": "{{region}} attributes pasted",
 		"nothingToCopy": "Select a region to copy its attributes",
 		"nothingToPaste": "No attributes copied yet",
+		"pasteAssetMissing": "That audio track's file isn't in this project",
 		"kinds": {
 			"zoom": "Zoom",
 			"speed": "Speed",
diff --git a/src/i18n/locales/en/settings.json b/src/i18n/locales/en/settings.json
index b291460d7..c7b7aaa33 100644
--- a/src/i18n/locales/en/settings.json
+++ b/src/i18n/locales/en/settings.json
@@ -79,6 +79,17 @@
 		"outputGain": "Output level",
 		"reset": "Reset audio"
 	},
+	"audioTrack": {
+		"add": "Add audio track",
+		"importFailed": "Could not add audio",
+		"defaultLabel": "Audio track",
+		"help": "Volume, fades and looping for this audio track. It mixes over the recording in the preview and the export. Drag the track on the timeline to move or resize it.",
+		"fadeIn": "Fade in",
+		"fadeOut": "Fade out",
+		"mute": "Mute",
+		"loop": "Loop",
+		"remove": "Delete track"
+	},
 	"effects": {
 		"title": "Composition",
 		"blurBg": "Blur BG",
diff --git a/src/i18n/locales/en/shortcuts.json b/src/i18n/locales/en/shortcuts.json
index 081aceada..99f3ce90a 100644
--- a/src/i18n/locales/en/shortcuts.json
+++ b/src/i18n/locales/en/shortcuts.json
@@ -20,6 +20,8 @@
 		"addTrim": "Add Trim",
 		"addSpeed": "Add Speed",
 		"addAnnotation": "Add Annotation",
+		"addAudio": "Add Audio",
+		"addVoiceover": "Record Voiceover",
 		"addKeyframe": "Add Keyframe",
 		"addCameraFullscreen": "Add Full Camera",
 		"deleteSelected": "Delete Selected",
diff --git a/src/i18n/locales/en/timeline.json b/src/i18n/locales/en/timeline.json
index c41966115..886e8ce7a 100644
--- a/src/i18n/locales/en/timeline.json
+++ b/src/i18n/locales/en/timeline.json
@@ -15,6 +15,7 @@
 		"pressZoom": "Press Z to add zoom",
 		"pressTrim": "Press T to add trim",
 		"pressAnnotation": "Press A to add annotation",
+		"pressAudio": "Press M to add audio, V to record a voiceover",
 		"pressSpeed": "Press S to add speed",
 		"pressCameraFullscreen": "Press C to add a Full Camera segment"
 	},
@@ -85,6 +86,22 @@
 		"smartCutsNeedsTranscript": "Needs a transcript",
 		"smartCutsNoAudio": "This media has no audio",
 		"smartCutsNoSpeech": "No speech detected",
-		"smartCutsFailed": "Transcription failed — retry it from Media"
+		"smartCutsFailed": "Transcription failed — retry it from Media",
+		"addAudioTooltip": "Add audio"
+	},
+	"audio": {
+		"addVoiceover": "Add Voiceover",
+		"addVoiceoverHint": "Record narration over your video",
+		"subtitle": "Place a voiceover or background music layer on the timeline",
+		"record": "Record voiceover",
+		"importFile": "Import audio file",
+		"importFileHint": "Bring in music or an audio file",
+		"recording": "Recording",
+		"recordingHint": "Narrate along with the video — it plays while you record",
+		"stop": "Stop",
+		"micDenied": "Microphone access was denied",
+		"recordingUnavailable": "Recording is not available here",
+		"saveFailed": "Could not save the recording",
+		"importFailed": "Could not import the audio file"
 	}
 }
diff --git a/src/i18n/locales/es/dialogs.json b/src/i18n/locales/es/dialogs.json
index 954121938..8f26a3aff 100644
--- a/src/i18n/locales/es/dialogs.json
+++ b/src/i18n/locales/es/dialogs.json
@@ -79,11 +79,13 @@
 		"saveGif": "Guardar GIF exportado",
 		"saveVideo": "Guardar video exportado",
 		"selectVideo": "Seleccionar archivo de video",
+		"selectAudio": "Seleccionar archivo de audio",
 		"saveProject": "Guardar proyecto OpenScreen",
 		"openProject": "Abrir proyecto OpenScreen",
 		"gifImage": "Imagen GIF",
 		"mp4Video": "Video MP4",
 		"videoFiles": "Archivos de video",
+		"audioFiles": "Archivos de audio",
 		"openscreenProject": "Proyecto OpenScreen",
 		"allFiles": "Todos los archivos"
 	}
diff --git a/src/i18n/locales/es/editor.json b/src/i18n/locales/es/editor.json
index 4d10b36a6..5aa7ada51 100644
--- a/src/i18n/locales/es/editor.json
+++ b/src/i18n/locales/es/editor.json
@@ -71,6 +71,7 @@
 		"pasted": "Atributos de {{region}} pegados",
 		"nothingToCopy": "Selecciona una región para copiar sus atributos",
 		"nothingToPaste": "Aún no se han copiado atributos",
+		"pasteAssetMissing": "El archivo de esa pista de audio no está en este proyecto",
 		"kinds": {
 			"zoom": "Zoom",
 			"speed": "Velocidad",
diff --git a/src/i18n/locales/es/settings.json b/src/i18n/locales/es/settings.json
index bb9ee27a2..441150694 100644
--- a/src/i18n/locales/es/settings.json
+++ b/src/i18n/locales/es/settings.json
@@ -327,5 +327,16 @@
 		"outputGain": "Ajuste de salida",
 		"reset": "Restablecer audio",
 		"help": "Ajusta el nivel de salida del audio. Se aplica igual en la vista previa y en la exportación."
+	},
+	"audioTrack": {
+		"add": "Añadir pista de audio",
+		"importFailed": "No se pudo añadir el audio",
+		"defaultLabel": "Pista de audio",
+		"help": "Volumen, fundidos y bucle de esta pista de audio. Se mezcla sobre la grabación en la vista previa y la exportación. Arrastra la pista en la línea de tiempo para moverla o redimensionarla.",
+		"fadeIn": "Aparición",
+		"fadeOut": "Desvanecido",
+		"mute": "Silenciar",
+		"loop": "Bucle",
+		"remove": "Eliminar pista"
 	}
 }
diff --git a/src/i18n/locales/es/shortcuts.json b/src/i18n/locales/es/shortcuts.json
index 970c52306..688f218f0 100644
--- a/src/i18n/locales/es/shortcuts.json
+++ b/src/i18n/locales/es/shortcuts.json
@@ -20,6 +20,8 @@
 		"addTrim": "Agregar recorte",
 		"addSpeed": "Agregar velocidad",
 		"addAnnotation": "Agregar anotación",
+		"addAudio": "Añadir audio",
+		"addVoiceover": "Grabar voz en off",
 		"addKeyframe": "Agregar fotograma clave",
 		"addCameraFullscreen": "Agregar cámara a pantalla completa",
 		"deleteSelected": "Eliminar seleccionado",
diff --git a/src/i18n/locales/es/timeline.json b/src/i18n/locales/es/timeline.json
index 989289e00..8d6f3974b 100644
--- a/src/i18n/locales/es/timeline.json
+++ b/src/i18n/locales/es/timeline.json
@@ -15,6 +15,7 @@
 		"pressZoom": "Presiona Z para agregar zoom",
 		"pressTrim": "Presiona T para agregar recorte",
 		"pressAnnotation": "Presiona A para agregar anotación",
+		"pressAudio": "Pulsa M para añadir audio, V para grabar una voz en off",
 		"pressSpeed": "Presiona S para agregar velocidad",
 		"pressCameraFullscreen": "Presiona C para agregar un segmento de cámara a pantalla completa"
 	},
@@ -85,6 +86,22 @@
 		"smartCutsNeedsTranscript": "Requiere una transcripción",
 		"smartCutsNoAudio": "Este medio no tiene audio",
 		"smartCutsNoSpeech": "No se detectó voz",
-		"smartCutsFailed": "La transcripción falló: reinténtala desde Medios"
+		"smartCutsFailed": "La transcripción falló: reinténtala desde Medios",
+		"addAudioTooltip": "Añadir audio"
+	},
+	"audio": {
+		"addVoiceover": "Añadir voz en off",
+		"addVoiceoverHint": "Graba una narración sobre tu vídeo",
+		"subtitle": "Coloca una capa de voz en off o de música de fondo en la línea de tiempo",
+		"record": "Grabar voz en off",
+		"importFile": "Importar archivo de audio",
+		"importFileHint": "Importa música o un archivo de audio",
+		"recording": "Grabando",
+		"recordingHint": "Narra junto al vídeo: se reproduce mientras grabas",
+		"stop": "Detener",
+		"micDenied": "Se denegó el acceso al micrófono",
+		"recordingUnavailable": "La grabación no está disponible aquí",
+		"saveFailed": "No se pudo guardar la grabación",
+		"importFailed": "No se pudo importar el archivo de audio"
 	}
 }
diff --git a/src/i18n/locales/fr/dialogs.json b/src/i18n/locales/fr/dialogs.json
index 82fc95dcb..ad5b4edf6 100644
--- a/src/i18n/locales/fr/dialogs.json
+++ b/src/i18n/locales/fr/dialogs.json
@@ -79,11 +79,13 @@
 		"saveGif": "Enregistrer le GIF exporté",
 		"saveVideo": "Enregistrer la vidéo exportée",
 		"selectVideo": "Sélectionner un fichier vidéo",
+		"selectAudio": "Sélectionner un fichier audio",
 		"saveProject": "Enregistrer le projet OpenScreen",
 		"openProject": "Ouvrir un projet OpenScreen",
 		"gifImage": "Image GIF",
 		"mp4Video": "Vidéo MP4",
 		"videoFiles": "Fichiers vidéo",
+		"audioFiles": "Fichiers audio",
 		"openscreenProject": "Projet OpenScreen",
 		"allFiles": "Tous les fichiers"
 	}
diff --git a/src/i18n/locales/fr/editor.json b/src/i18n/locales/fr/editor.json
index 7a719ade2..2942cdc95 100644
--- a/src/i18n/locales/fr/editor.json
+++ b/src/i18n/locales/fr/editor.json
@@ -71,6 +71,7 @@
 		"pasted": "Attributs de {{region}} collés",
 		"nothingToCopy": "Sélectionnez une région pour copier ses attributs",
 		"nothingToPaste": "Aucun attribut copié pour l'instant",
+		"pasteAssetMissing": "Le fichier de cette piste audio n'est pas dans ce projet",
 		"kinds": {
 			"zoom": "Zoom",
 			"speed": "Vitesse",
diff --git a/src/i18n/locales/fr/settings.json b/src/i18n/locales/fr/settings.json
index 23dd573f0..0e696d74c 100644
--- a/src/i18n/locales/fr/settings.json
+++ b/src/i18n/locales/fr/settings.json
@@ -327,5 +327,16 @@
 		"outputGain": "Niveau de sortie",
 		"reset": "Réinitialiser l’audio",
 		"help": "Ajustez le niveau de sortie audio. Il s’applique à l’identique dans l’aperçu et à l’export."
+	},
+	"audioTrack": {
+		"add": "Ajouter une piste audio",
+		"importFailed": "Impossible d’ajouter l’audio",
+		"defaultLabel": "Piste audio",
+		"help": "Volume, fondus et boucle de cette piste audio. Elle se mixe par-dessus l'enregistrement dans l'aperçu et à l'export. Faites glisser la piste sur la timeline pour la déplacer ou la redimensionner.",
+		"fadeIn": "Fondu d'entrée",
+		"fadeOut": "Fondu de sortie",
+		"mute": "Muet",
+		"loop": "Boucle",
+		"remove": "Supprimer la piste"
 	}
 }
diff --git a/src/i18n/locales/fr/shortcuts.json b/src/i18n/locales/fr/shortcuts.json
index 659ef13b8..3b28fca17 100644
--- a/src/i18n/locales/fr/shortcuts.json
+++ b/src/i18n/locales/fr/shortcuts.json
@@ -20,6 +20,8 @@
 		"addTrim": "Ajouter une coupe",
 		"addSpeed": "Ajouter une vitesse",
 		"addAnnotation": "Ajouter une annotation",
+		"addAudio": "Ajouter un audio",
+		"addVoiceover": "Enregistrer une voix off",
 		"addKeyframe": "Ajouter une image-clé",
 		"addCameraFullscreen": "Ajouter une caméra en plein écran",
 		"deleteSelected": "Supprimer la sélection",
diff --git a/src/i18n/locales/fr/timeline.json b/src/i18n/locales/fr/timeline.json
index a35b8858a..52de88c6c 100644
--- a/src/i18n/locales/fr/timeline.json
+++ b/src/i18n/locales/fr/timeline.json
@@ -15,6 +15,7 @@
 		"pressZoom": "Appuyez sur Z pour ajouter un zoom",
 		"pressTrim": "Appuyez sur T pour ajouter une coupe",
 		"pressAnnotation": "Appuyez sur A pour ajouter une annotation",
+		"pressAudio": "Appuyez sur M pour ajouter un audio, V pour enregistrer une voix off",
 		"pressSpeed": "Appuyez sur S pour ajouter une vitesse",
 		"pressCameraFullscreen": "Appuyez sur C pour ajouter un segment Caméra plein écran"
 	},
@@ -85,6 +86,22 @@
 		"smartCutsNeedsTranscript": "Nécessite une transcription",
 		"smartCutsNoAudio": "Ce média n'a pas d'audio",
 		"smartCutsNoSpeech": "Aucune parole détectée",
-		"smartCutsFailed": "Échec de la transcription — relancez-la depuis Médias"
+		"smartCutsFailed": "Échec de la transcription — relancez-la depuis Médias",
+		"addAudioTooltip": "Ajouter un audio"
+	},
+	"audio": {
+		"addVoiceover": "Ajouter une voix off",
+		"addVoiceoverHint": "Enregistrez une narration par-dessus votre vidéo",
+		"subtitle": "Placez une couche de voix off ou de musique de fond sur la timeline",
+		"record": "Enregistrer une voix off",
+		"importFile": "Importer un fichier audio",
+		"importFileHint": "Importez une musique ou un fichier audio",
+		"recording": "Enregistrement",
+		"recordingHint": "Commentez en même temps que la vidéo — elle joue pendant l'enregistrement",
+		"stop": "Arrêter",
+		"micDenied": "L'accès au micro a été refusé",
+		"recordingUnavailable": "L'enregistrement n'est pas disponible ici",
+		"saveFailed": "Impossible d'enregistrer la capture",
+		"importFailed": "Impossible d'importer le fichier audio"
 	}
 }
diff --git a/src/i18n/locales/it/dialogs.json b/src/i18n/locales/it/dialogs.json
index 0fad7d36e..e8e326c91 100644
--- a/src/i18n/locales/it/dialogs.json
+++ b/src/i18n/locales/it/dialogs.json
@@ -79,11 +79,13 @@
 		"saveGif": "Salva GIF esportata",
 		"saveVideo": "Salva video esportato",
 		"selectVideo": "Seleziona file video",
+		"selectAudio": "Seleziona file audio",
 		"saveProject": "Salva progetto OpenScreen",
 		"openProject": "Apri progetto OpenScreen",
 		"gifImage": "Immagine GIF",
 		"mp4Video": "Video MP4",
 		"videoFiles": "File video",
+		"audioFiles": "File audio",
 		"openscreenProject": "Progetto OpenScreen",
 		"allFiles": "Tutti i file"
 	}
diff --git a/src/i18n/locales/it/editor.json b/src/i18n/locales/it/editor.json
index 70a680a7a..467729547 100644
--- a/src/i18n/locales/it/editor.json
+++ b/src/i18n/locales/it/editor.json
@@ -71,6 +71,7 @@
 		"pasted": "Attributi di {{region}} incollati",
 		"nothingToCopy": "Seleziona una regione per copiarne gli attributi",
 		"nothingToPaste": "Nessun attributo copiato",
+		"pasteAssetMissing": "Il file di questa traccia audio non è in questo progetto",
 		"kinds": {
 			"zoom": "Zoom",
 			"speed": "Velocità",
diff --git a/src/i18n/locales/it/settings.json b/src/i18n/locales/it/settings.json
index e10828765..1e1426fb7 100644
--- a/src/i18n/locales/it/settings.json
+++ b/src/i18n/locales/it/settings.json
@@ -327,5 +327,16 @@
 		"outputGain": "Livello di uscita",
 		"reset": "Reimposta audio",
 		"help": "Regola il livello di uscita audio. Si applica allo stesso modo nell’anteprima e nell’esportazione."
+	},
+	"audioTrack": {
+		"add": "Aggiungi traccia audio",
+		"importFailed": "Impossibile aggiungere l’audio",
+		"defaultLabel": "Traccia audio",
+		"help": "Volume, dissolvenze e ripetizione di questa traccia audio. Si mixa sopra la registrazione nell'anteprima e nell'esportazione. Trascina la traccia sulla timeline per spostarla o ridimensionarla.",
+		"fadeIn": "Dissolvenza in entrata",
+		"fadeOut": "Dissolvenza in uscita",
+		"mute": "Muto",
+		"loop": "Ripeti",
+		"remove": "Elimina traccia"
 	}
 }
diff --git a/src/i18n/locales/it/shortcuts.json b/src/i18n/locales/it/shortcuts.json
index 6a2da2208..0940258b2 100644
--- a/src/i18n/locales/it/shortcuts.json
+++ b/src/i18n/locales/it/shortcuts.json
@@ -20,6 +20,8 @@
 		"addTrim": "Aggiungi taglio",
 		"addSpeed": "Aggiungi velocità",
 		"addAnnotation": "Aggiungi annotazione",
+		"addAudio": "Aggiungi audio",
+		"addVoiceover": "Registra voce fuori campo",
 		"addKeyframe": "Aggiungi fotogramma chiave",
 		"addCameraFullscreen": "Aggiungi Camera a schermo intero",
 		"deleteSelected": "Elimina selezionato",
diff --git a/src/i18n/locales/it/timeline.json b/src/i18n/locales/it/timeline.json
index 09bb116ee..014041e4b 100644
--- a/src/i18n/locales/it/timeline.json
+++ b/src/i18n/locales/it/timeline.json
@@ -15,6 +15,7 @@
 		"pressZoom": "Premi Z per aggiungere zoom",
 		"pressTrim": "Premi T per aggiungere taglio",
 		"pressAnnotation": "Premi A per aggiungere annotazione",
+		"pressAudio": "Premi M per aggiungere audio, V per registrare una voce fuori campo",
 		"pressSpeed": "Premi S per aggiungere velocità",
 		"pressCameraFullscreen": "Premi C per aggiungere un segmento Camera a schermo intero"
 	},
@@ -85,6 +86,22 @@
 		"smartCutsNeedsTranscript": "Richiede una trascrizione",
 		"smartCutsNoAudio": "Questo contenuto non ha audio",
 		"smartCutsNoSpeech": "Nessun parlato rilevato",
-		"smartCutsFailed": "Trascrizione non riuscita: riprova da Contenuti multimediali"
+		"smartCutsFailed": "Trascrizione non riuscita: riprova da Contenuti multimediali",
+		"addAudioTooltip": "Aggiungi audio"
+	},
+	"audio": {
+		"addVoiceover": "Aggiungi voce fuori campo",
+		"addVoiceoverHint": "Registra una narrazione sopra il video",
+		"subtitle": "Posiziona un livello di voce fuori campo o di musica di sottofondo sulla timeline",
+		"record": "Registra voce fuori campo",
+		"importFile": "Importa file audio",
+		"importFileHint": "Importa musica o un file audio",
+		"recording": "Registrazione",
+		"recordingHint": "Racconta insieme al video: continua a riprodursi mentre registri",
+		"stop": "Ferma",
+		"micDenied": "Accesso al microfono negato",
+		"recordingUnavailable": "La registrazione non è disponibile qui",
+		"saveFailed": "Impossibile salvare la registrazione",
+		"importFailed": "Impossibile importare il file audio"
 	}
 }
diff --git a/src/i18n/locales/ja-JP/dialogs.json b/src/i18n/locales/ja-JP/dialogs.json
index 7ee976a77..c0c00ad80 100644
--- a/src/i18n/locales/ja-JP/dialogs.json
+++ b/src/i18n/locales/ja-JP/dialogs.json
@@ -79,11 +79,13 @@
 		"saveGif": "エクスポートしたGIFを保存",
 		"saveVideo": "エクスポートした動画を保存",
 		"selectVideo": "動画ファイルを選択",
+		"selectAudio": "オーディオファイルを選択",
 		"saveProject": "OpenScreen プロジェクトを保存",
 		"openProject": "OpenScreen プロジェクトを開く",
 		"gifImage": "GIF 画像",
 		"mp4Video": "MP4 動画",
 		"videoFiles": "動画ファイル",
+		"audioFiles": "オーディオファイル",
 		"openscreenProject": "OpenScreen プロジェクト",
 		"allFiles": "すべてのファイル"
 	}
diff --git a/src/i18n/locales/ja-JP/editor.json b/src/i18n/locales/ja-JP/editor.json
index bcbc57164..f65e0b454 100644
--- a/src/i18n/locales/ja-JP/editor.json
+++ b/src/i18n/locales/ja-JP/editor.json
@@ -71,6 +71,7 @@
 		"pasted": "{{region}}の属性を貼り付けました",
 		"nothingToCopy": "属性をコピーする領域を選択してください",
 		"nothingToPaste": "コピーされた属性がありません",
+		"pasteAssetMissing": "このオーディオトラックのファイルはこのプロジェクトにありません",
 		"kinds": {
 			"zoom": "ズーム",
 			"speed": "速度",
diff --git a/src/i18n/locales/ja-JP/settings.json b/src/i18n/locales/ja-JP/settings.json
index ead358d48..fff7c1f01 100644
--- a/src/i18n/locales/ja-JP/settings.json
+++ b/src/i18n/locales/ja-JP/settings.json
@@ -327,5 +327,16 @@
 		"outputGain": "出力レベル",
 		"reset": "オーディオをリセット",
 		"help": "音声の出力レベルを調整します。プレビューと書き出しで同じように適用されます。"
+	},
+	"audioTrack": {
+		"add": "オーディオトラックを追加",
+		"importFailed": "オーディオを追加できませんでした",
+		"defaultLabel": "オーディオトラック",
+		"help": "このオーディオトラックの音量、フェード、ループ。プレビューと書き出しの両方で録画にミックスされます。タイムライン上でドラッグすると移動やサイズ変更ができます。",
+		"fadeIn": "フェードイン",
+		"fadeOut": "フェードアウト",
+		"mute": "ミュート",
+		"loop": "ループ",
+		"remove": "トラックを削除"
 	}
 }
diff --git a/src/i18n/locales/ja-JP/shortcuts.json b/src/i18n/locales/ja-JP/shortcuts.json
index 173355c66..82f1c2291 100644
--- a/src/i18n/locales/ja-JP/shortcuts.json
+++ b/src/i18n/locales/ja-JP/shortcuts.json
@@ -20,6 +20,8 @@
 		"addTrim": "トリムを追加",
 		"addSpeed": "速度を追加",
 		"addAnnotation": "注釈を追加",
+		"addAudio": "音声を追加",
+		"addVoiceover": "ナレーションを録音",
 		"addKeyframe": "キーフレームを追加",
 		"addCameraFullscreen": "フルスクリーンカメラを追加",
 		"deleteSelected": "選択を削除",
diff --git a/src/i18n/locales/ja-JP/timeline.json b/src/i18n/locales/ja-JP/timeline.json
index 68911ba91..bf21fd025 100644
--- a/src/i18n/locales/ja-JP/timeline.json
+++ b/src/i18n/locales/ja-JP/timeline.json
@@ -15,6 +15,7 @@
 		"pressZoom": "Zキーを押してズームを追加",
 		"pressTrim": "Tキーを押してトリムを追加",
 		"pressAnnotation": "Aキーを押して注釈を追加",
+		"pressAudio": "M キーで音声を追加、V キーでナレーションを録音",
 		"pressSpeed": "Sキーを押して再生速度を追加",
 		"pressCameraFullscreen": "Cキーを押してフルスクリーンカメラのセグメントを追加"
 	},
@@ -85,6 +86,22 @@
 		"smartCutsNeedsTranscript": "文字起こしが必要です",
 		"smartCutsNoAudio": "このメディアには音声がありません",
 		"smartCutsNoSpeech": "音声が検出されませんでした",
-		"smartCutsFailed": "文字起こしに失敗しました — メディアから再試行してください"
+		"smartCutsFailed": "文字起こしに失敗しました — メディアから再試行してください",
+		"addAudioTooltip": "音声を追加"
+	},
+	"audio": {
+		"addVoiceover": "ナレーションを追加",
+		"addVoiceoverHint": "動画にナレーションを録音",
+		"subtitle": "タイムラインにナレーションまたは BGM のレイヤーを配置します",
+		"record": "ナレーションを録音",
+		"importFile": "音声ファイルを読み込む",
+		"importFileHint": "音楽やオーディオファイルを読み込む",
+		"recording": "録音中",
+		"recordingHint": "動画に合わせて話してください — 録音中も再生されます",
+		"stop": "停止",
+		"micDenied": "マイクへのアクセスが拒否されました",
+		"recordingUnavailable": "ここでは録音できません",
+		"saveFailed": "録音を保存できませんでした",
+		"importFailed": "音声ファイルを読み込めませんでした"
 	}
 }
diff --git a/src/i18n/locales/ko-KR/dialogs.json b/src/i18n/locales/ko-KR/dialogs.json
index 5891f44c1..2b64240ae 100644
--- a/src/i18n/locales/ko-KR/dialogs.json
+++ b/src/i18n/locales/ko-KR/dialogs.json
@@ -79,11 +79,13 @@
 		"saveGif": "내보낸 GIF 저장",
 		"saveVideo": "내보낸 비디오 저장",
 		"selectVideo": "비디오 파일 선택",
+		"selectAudio": "오디오 파일 선택",
 		"saveProject": "OpenScreen 프로젝트 저장",
 		"openProject": "OpenScreen 프로젝트 열기",
 		"gifImage": "GIF 이미지",
 		"mp4Video": "MP4 비디오",
 		"videoFiles": "비디오 파일",
+		"audioFiles": "오디오 파일",
 		"openscreenProject": "OpenScreen 프로젝트",
 		"allFiles": "모든 파일"
 	}
diff --git a/src/i18n/locales/ko-KR/editor.json b/src/i18n/locales/ko-KR/editor.json
index 96e6c5339..8efddbf6b 100644
--- a/src/i18n/locales/ko-KR/editor.json
+++ b/src/i18n/locales/ko-KR/editor.json
@@ -71,6 +71,7 @@
 		"pasted": "{{region}} 속성을 붙여넣었습니다",
 		"nothingToCopy": "속성을 복사할 영역을 선택하세요",
 		"nothingToPaste": "복사된 속성이 없습니다",
+		"pasteAssetMissing": "이 오디오 트랙의 파일이 이 프로젝트에 없습니다",
 		"kinds": {
 			"zoom": "줌",
 			"speed": "속도",
diff --git a/src/i18n/locales/ko-KR/settings.json b/src/i18n/locales/ko-KR/settings.json
index 631189192..ae96030db 100644
--- a/src/i18n/locales/ko-KR/settings.json
+++ b/src/i18n/locales/ko-KR/settings.json
@@ -327,5 +327,16 @@
 		"outputGain": "출력 레벨",
 		"reset": "오디오 재설정",
 		"help": "오디오 출력 레벨을 조정합니다. 미리보기와 내보내기에 동일하게 적용됩니다."
+	},
+	"audioTrack": {
+		"add": "오디오 트랙 추가",
+		"importFailed": "오디오를 추가할 수 없습니다",
+		"defaultLabel": "오디오 트랙",
+		"help": "이 오디오 트랙의 볼륨, 페이드, 반복입니다. 미리보기와 내보내기에서 녹화 위에 믹스됩니다. 타임라인에서 트랙을 끌어 이동하거나 크기를 조절하세요.",
+		"fadeIn": "페이드 인",
+		"fadeOut": "페이드 아웃",
+		"mute": "음소거",
+		"loop": "반복",
+		"remove": "트랙 삭제"
 	}
 }
diff --git a/src/i18n/locales/ko-KR/shortcuts.json b/src/i18n/locales/ko-KR/shortcuts.json
index 00e8f689d..86f0693ea 100644
--- a/src/i18n/locales/ko-KR/shortcuts.json
+++ b/src/i18n/locales/ko-KR/shortcuts.json
@@ -20,6 +20,8 @@
 		"addTrim": "트림 추가",
 		"addSpeed": "속도 추가",
 		"addAnnotation": "주석 추가",
+		"addAudio": "오디오 추가",
+		"addVoiceover": "보이스오버 녹음",
 		"addKeyframe": "키프레임 추가",
 		"addCameraFullscreen": "전체 화면 카메라 추가",
 		"deleteSelected": "선택 항목 삭제",
diff --git a/src/i18n/locales/ko-KR/timeline.json b/src/i18n/locales/ko-KR/timeline.json
index 8a100ee6d..1a0242f10 100644
--- a/src/i18n/locales/ko-KR/timeline.json
+++ b/src/i18n/locales/ko-KR/timeline.json
@@ -15,6 +15,7 @@
 		"pressZoom": "Z를 눌러 줌 추가",
 		"pressTrim": "T를 눌러 트림 추가",
 		"pressAnnotation": "A를 눌러 주석 추가",
+		"pressAudio": "M 키로 오디오 추가, V 키로 보이스오버 녹음",
 		"pressSpeed": "S를 눌러 속도 추가",
 		"pressCameraFullscreen": "C를 눌러 전체 화면 카메라 구간을 추가하세요"
 	},
@@ -85,6 +86,22 @@
 		"smartCutsNeedsTranscript": "받아쓰기가 필요합니다",
 		"smartCutsNoAudio": "이 미디어에는 오디오가 없습니다",
 		"smartCutsNoSpeech": "음성이 감지되지 않음",
-		"smartCutsFailed": "받아쓰기에 실패했습니다 — 미디어에서 다시 시도하세요"
+		"smartCutsFailed": "받아쓰기에 실패했습니다 — 미디어에서 다시 시도하세요",
+		"addAudioTooltip": "오디오 추가"
+	},
+	"audio": {
+		"addVoiceover": "내레이션 추가",
+		"addVoiceoverHint": "영상 위에 내레이션을 녹음",
+		"subtitle": "타임라인에 내레이션 또는 배경 음악 레이어를 배치합니다",
+		"record": "내레이션 녹음",
+		"importFile": "오디오 파일 가져오기",
+		"importFileHint": "음악이나 오디오 파일 가져오기",
+		"recording": "녹음 중",
+		"recordingHint": "영상에 맞춰 말하세요 — 녹음하는 동안 재생됩니다",
+		"stop": "중지",
+		"micDenied": "마이크 접근이 거부되었습니다",
+		"recordingUnavailable": "여기에서는 녹음할 수 없습니다",
+		"saveFailed": "녹음을 저장하지 못했습니다",
+		"importFailed": "오디오 파일을 가져오지 못했습니다"
 	}
 }
diff --git a/src/i18n/locales/pt-BR/dialogs.json b/src/i18n/locales/pt-BR/dialogs.json
index ba77d90a9..88f163d99 100644
--- a/src/i18n/locales/pt-BR/dialogs.json
+++ b/src/i18n/locales/pt-BR/dialogs.json
@@ -79,11 +79,13 @@
 		"saveGif": "Salvar GIF Exportado",
 		"saveVideo": "Salvar Vídeo Exportado",
 		"selectVideo": "Selecionar Arquivo de Vídeo",
+		"selectAudio": "Selecionar arquivo de áudio",
 		"saveProject": "Salvar Projeto OpenScreen",
 		"openProject": "Abrir Projeto OpenScreen",
 		"gifImage": "Imagem GIF",
 		"mp4Video": "Vídeo MP4",
 		"videoFiles": "Arquivos de Vídeo",
+		"audioFiles": "Arquivos de áudio",
 		"openscreenProject": "Projeto OpenScreen",
 		"allFiles": "Todos os Arquivos"
 	}
diff --git a/src/i18n/locales/pt-BR/editor.json b/src/i18n/locales/pt-BR/editor.json
index e5f828d3c..7a92ad9eb 100644
--- a/src/i18n/locales/pt-BR/editor.json
+++ b/src/i18n/locales/pt-BR/editor.json
@@ -71,6 +71,7 @@
 		"pasted": "Atributos de {{region}} colados",
 		"nothingToCopy": "Selecione uma região para copiar seus atributos",
 		"nothingToPaste": "Nenhum atributo copiado ainda",
+		"pasteAssetMissing": "O arquivo dessa faixa de áudio não está neste projeto",
 		"kinds": {
 			"zoom": "Zoom",
 			"speed": "Velocidade",
diff --git a/src/i18n/locales/pt-BR/settings.json b/src/i18n/locales/pt-BR/settings.json
index de22724be..6a201627d 100644
--- a/src/i18n/locales/pt-BR/settings.json
+++ b/src/i18n/locales/pt-BR/settings.json
@@ -327,5 +327,16 @@
 		"outputGain": "Nível de saída",
 		"reset": "Redefinir áudio",
 		"help": "Ajuste o nível de saída do áudio. Ele se aplica da mesma forma na prévia e na exportação."
+	},
+	"audioTrack": {
+		"add": "Adicionar faixa de áudio",
+		"importFailed": "Não foi possível adicionar o áudio",
+		"defaultLabel": "Faixa de áudio",
+		"help": "Volume, fades e repetição desta faixa de áudio. Ela é mixada sobre a gravação na prévia e na exportação. Arraste a faixa na linha do tempo para movê-la ou redimensioná-la.",
+		"fadeIn": "Fade in",
+		"fadeOut": "Fade out",
+		"mute": "Silenciar",
+		"loop": "Repetir",
+		"remove": "Excluir faixa"
 	}
 }
diff --git a/src/i18n/locales/pt-BR/shortcuts.json b/src/i18n/locales/pt-BR/shortcuts.json
index a21fe7bed..5f5506aec 100644
--- a/src/i18n/locales/pt-BR/shortcuts.json
+++ b/src/i18n/locales/pt-BR/shortcuts.json
@@ -20,6 +20,8 @@
 		"addTrim": "Adicionar Recorte",
 		"addSpeed": "Adicionar Velocidade",
 		"addAnnotation": "Adicionar Anotação",
+		"addAudio": "Adicionar áudio",
+		"addVoiceover": "Gravar narração",
 		"addKeyframe": "Adicionar Quadro-chave",
 		"addCameraFullscreen": "Adicionar Câmera em Tela Cheia",
 		"deleteSelected": "Excluir Selecionado",
diff --git a/src/i18n/locales/pt-BR/timeline.json b/src/i18n/locales/pt-BR/timeline.json
index 5359feba9..c1e6d3c27 100644
--- a/src/i18n/locales/pt-BR/timeline.json
+++ b/src/i18n/locales/pt-BR/timeline.json
@@ -15,6 +15,7 @@
 		"pressZoom": "Pressione Z para adicionar zoom",
 		"pressTrim": "Pressione T para adicionar recorte",
 		"pressAnnotation": "Pressione A para adicionar anotação",
+		"pressAudio": "Pressione M para adicionar áudio, V para gravar uma narração",
 		"pressSpeed": "Pressione S para adicionar velocidade",
 		"pressCameraFullscreen": "Pressione C para adicionar um segmento de Câmera em Tela Cheia"
 	},
@@ -85,6 +86,22 @@
 		"smartCutsNeedsTranscript": "Requer uma transcrição",
 		"smartCutsNoAudio": "Esta mídia não tem áudio",
 		"smartCutsNoSpeech": "Nenhuma fala detectada",
-		"smartCutsFailed": "Falha na transcrição — tente de novo em Mídia"
+		"smartCutsFailed": "Falha na transcrição — tente de novo em Mídia",
+		"addAudioTooltip": "Adicionar áudio"
+	},
+	"audio": {
+		"addVoiceover": "Adicionar narração",
+		"addVoiceoverHint": "Grave uma narração sobre o seu vídeo",
+		"subtitle": "Coloque uma camada de narração ou de música de fundo na linha do tempo",
+		"record": "Gravar narração",
+		"importFile": "Importar arquivo de áudio",
+		"importFileHint": "Importe música ou um arquivo de áudio",
+		"recording": "Gravando",
+		"recordingHint": "Narre junto com o vídeo — ele continua tocando enquanto você grava",
+		"stop": "Parar",
+		"micDenied": "Acesso ao microfone negado",
+		"recordingUnavailable": "A gravação não está disponível aqui",
+		"saveFailed": "Não foi possível salvar a gravação",
+		"importFailed": "Não foi possível importar o arquivo de áudio"
 	}
 }
diff --git a/src/i18n/locales/ru/dialogs.json b/src/i18n/locales/ru/dialogs.json
index a821771e9..1f46a14fc 100644
--- a/src/i18n/locales/ru/dialogs.json
+++ b/src/i18n/locales/ru/dialogs.json
@@ -79,11 +79,13 @@
 		"saveGif": "Сохранить экспортированный GIF",
 		"saveVideo": "Сохранить экспортированное видео",
 		"selectVideo": "Выбрать видеофайл",
+		"selectAudio": "Выбрать аудиофайл",
 		"saveProject": "Сохранить проект OpenScreen",
 		"openProject": "Открыть проект OpenScreen",
 		"gifImage": "GIF изображение",
 		"mp4Video": "MP4 видео",
 		"videoFiles": "Видеофайлы",
+		"audioFiles": "Аудиофайлы",
 		"openscreenProject": "Проект OpenScreen",
 		"allFiles": "Все файлы"
 	}
diff --git a/src/i18n/locales/ru/editor.json b/src/i18n/locales/ru/editor.json
index 4abdc63f3..a3cfb108a 100644
--- a/src/i18n/locales/ru/editor.json
+++ b/src/i18n/locales/ru/editor.json
@@ -71,6 +71,7 @@
 		"pasted": "Атрибуты «{{region}}» вставлены",
 		"nothingToCopy": "Выберите регион, чтобы скопировать его атрибуты",
 		"nothingToPaste": "Атрибуты ещё не скопированы",
+		"pasteAssetMissing": "Файл этой аудиодорожки отсутствует в проекте",
 		"kinds": {
 			"zoom": "Масштаб",
 			"speed": "Скорость",
diff --git a/src/i18n/locales/ru/settings.json b/src/i18n/locales/ru/settings.json
index ca193c6d8..680374442 100644
--- a/src/i18n/locales/ru/settings.json
+++ b/src/i18n/locales/ru/settings.json
@@ -327,5 +327,16 @@
 		"outputGain": "Уровень выхода",
 		"reset": "Сбросить аудио",
 		"help": "Настройте уровень звука на выходе. Он одинаково применяется в предпросмотре и при экспорте."
+	},
+	"audioTrack": {
+		"add": "Добавить аудиодорожку",
+		"importFailed": "Не удалось добавить аудио",
+		"defaultLabel": "Аудиодорожка",
+		"help": "Громкость, затухания и повтор этой аудиодорожки. Она подмешивается к записи в предпросмотре и при экспорте. Перетащите дорожку на таймлайне, чтобы переместить или изменить её размер.",
+		"fadeIn": "Нарастание",
+		"fadeOut": "Затухание",
+		"mute": "Без звука",
+		"loop": "Повтор",
+		"remove": "Удалить дорожку"
 	}
 }
diff --git a/src/i18n/locales/ru/shortcuts.json b/src/i18n/locales/ru/shortcuts.json
index dabb06801..eb94af5fc 100644
--- a/src/i18n/locales/ru/shortcuts.json
+++ b/src/i18n/locales/ru/shortcuts.json
@@ -20,6 +20,8 @@
 		"addTrim": "Добавить обрезку",
 		"addSpeed": "Изменить скорость",
 		"addAnnotation": "Добавить аннотацию",
+		"addAudio": "Добавить аудио",
+		"addVoiceover": "Записать закадровый голос",
 		"addKeyframe": "Добавить ключевой кадр",
 		"addCameraFullscreen": "Добавить камеру на весь экран",
 		"deleteSelected": "Удалить выбранное",
diff --git a/src/i18n/locales/ru/timeline.json b/src/i18n/locales/ru/timeline.json
index 387086953..7a89391c4 100644
--- a/src/i18n/locales/ru/timeline.json
+++ b/src/i18n/locales/ru/timeline.json
@@ -15,6 +15,7 @@
 		"pressZoom": "Нажмите Z для добавления масштабирования",
 		"pressTrim": "Нажмите T для добавления обрезки",
 		"pressAnnotation": "Нажмите A для добавления аннотации",
+		"pressAudio": "Нажмите M, чтобы добавить аудио, V — чтобы записать закадровый голос",
 		"pressSpeed": "Нажмите S для изменения скорости",
 		"pressCameraFullscreen": "Нажмите C, чтобы добавить сегмент камеры на весь экран"
 	},
@@ -85,6 +86,22 @@
 		"smartCutsNeedsTranscript": "Нужна расшифровка",
 		"smartCutsNoAudio": "В этом медиафайле нет звука",
 		"smartCutsNoSpeech": "Речь не обнаружена",
-		"smartCutsFailed": "Не удалось расшифровать — повторите из раздела «Медиа»"
+		"smartCutsFailed": "Не удалось расшифровать — повторите из раздела «Медиа»",
+		"addAudioTooltip": "Добавить аудио"
+	},
+	"audio": {
+		"addVoiceover": "Добавить озвучку",
+		"addVoiceoverHint": "Запишите закадровый голос поверх видео",
+		"subtitle": "Разместите слой озвучки или фоновой музыки на таймлайне",
+		"record": "Записать озвучку",
+		"importFile": "Импортировать аудиофайл",
+		"importFileHint": "Импортируйте музыку или аудиофайл",
+		"recording": "Запись",
+		"recordingHint": "Говорите под видео — оно продолжает играть во время записи",
+		"stop": "Остановить",
+		"micDenied": "Доступ к микрофону запрещён",
+		"recordingUnavailable": "Запись здесь недоступна",
+		"saveFailed": "Не удалось сохранить запись",
+		"importFailed": "Не удалось импортировать аудиофайл"
 	}
 }
diff --git a/src/i18n/locales/tr/dialogs.json b/src/i18n/locales/tr/dialogs.json
index 196807fd3..6b01da744 100644
--- a/src/i18n/locales/tr/dialogs.json
+++ b/src/i18n/locales/tr/dialogs.json
@@ -79,11 +79,13 @@
 		"saveGif": "Dışa Aktarılan GIF'i Kaydet",
 		"saveVideo": "Dışa Aktarılan Videoyu Kaydet",
 		"selectVideo": "Video Dosyası Seç",
+		"selectAudio": "Ses dosyası seç",
 		"saveProject": "OpenScreen Projesini Kaydet",
 		"openProject": "OpenScreen Projesini Aç",
 		"gifImage": "GIF Görüntüsü",
 		"mp4Video": "MP4 Video",
 		"videoFiles": "Video Dosyaları",
+		"audioFiles": "Ses dosyaları",
 		"openscreenProject": "OpenScreen Projesi",
 		"allFiles": "Tüm Dosyalar"
 	}
diff --git a/src/i18n/locales/tr/editor.json b/src/i18n/locales/tr/editor.json
index d4bb46a10..b79b30806 100644
--- a/src/i18n/locales/tr/editor.json
+++ b/src/i18n/locales/tr/editor.json
@@ -71,6 +71,7 @@
 		"pasted": "{{region}} öznitelikleri yapıştırıldı",
 		"nothingToCopy": "Özniteliklerini kopyalamak için bir bölge seçin",
 		"nothingToPaste": "Henüz öznitelik kopyalanmadı",
+		"pasteAssetMissing": "Bu ses parçasının dosyası bu projede yok",
 		"kinds": {
 			"zoom": "Yakınlaştırma",
 			"speed": "Hız",
diff --git a/src/i18n/locales/tr/settings.json b/src/i18n/locales/tr/settings.json
index 485666d42..02df3d644 100644
--- a/src/i18n/locales/tr/settings.json
+++ b/src/i18n/locales/tr/settings.json
@@ -327,5 +327,16 @@
 		"outputGain": "Çıkış seviyesi",
 		"reset": "Sesi sıfırla",
 		"help": "Ses çıkış seviyesini ayarlayın. Önizlemede ve dışa aktarmada aynı şekilde uygulanır."
+	},
+	"audioTrack": {
+		"add": "Ses parçası ekle",
+		"importFailed": "Ses eklenemedi",
+		"defaultLabel": "Ses parçası",
+		"help": "Bu ses parçasının seviyesi, geçişleri ve döngüsü. Önizlemede ve dışa aktarmada kaydın üzerine miksleniyor. Parçayı zaman çizelgesinde sürükleyerek taşıyın veya yeniden boyutlandırın.",
+		"fadeIn": "Açılma",
+		"fadeOut": "Kararma",
+		"mute": "Sessiz",
+		"loop": "Döngü",
+		"remove": "Parçayı sil"
 	}
 }
diff --git a/src/i18n/locales/tr/shortcuts.json b/src/i18n/locales/tr/shortcuts.json
index 6b1db110d..2da862f01 100644
--- a/src/i18n/locales/tr/shortcuts.json
+++ b/src/i18n/locales/tr/shortcuts.json
@@ -20,6 +20,8 @@
 		"addTrim": "Kırpma Ekle",
 		"addSpeed": "Hız Ekle",
 		"addAnnotation": "Açıklama Ekle",
+		"addAudio": "Ses ekle",
+		"addVoiceover": "Seslendirme kaydet",
 		"addKeyframe": "Anahtar Kare Ekle",
 		"addCameraFullscreen": "Tam Ekran Kamera Ekle",
 		"deleteSelected": "Seçileni Sil",
diff --git a/src/i18n/locales/tr/timeline.json b/src/i18n/locales/tr/timeline.json
index d5a531f3e..9f3d70d36 100644
--- a/src/i18n/locales/tr/timeline.json
+++ b/src/i18n/locales/tr/timeline.json
@@ -15,6 +15,7 @@
 		"pressZoom": "Yakınlaştırma eklemek için Z tuşuna basın",
 		"pressTrim": "Kırpma eklemek için T tuşuna basın",
 		"pressAnnotation": "Açıklama eklemek için A tuşuna basın",
+		"pressAudio": "Ses eklemek için M, seslendirme kaydetmek için V tuşuna basın",
 		"pressSpeed": "Hız eklemek için S tuşuna basın",
 		"pressCameraFullscreen": "Tam Ekran Kamera bölümü eklemek için C tuşuna basın"
 	},
@@ -85,6 +86,22 @@
 		"smartCutsNeedsTranscript": "Bir döküm gerekiyor",
 		"smartCutsNoAudio": "Bu medyada ses yok",
 		"smartCutsNoSpeech": "Konuşma algılanmadı",
-		"smartCutsFailed": "Metne dökme başarısız — Medya bölümünden yeniden deneyin"
+		"smartCutsFailed": "Metne dökme başarısız — Medya bölümünden yeniden deneyin",
+		"addAudioTooltip": "Ses ekle"
+	},
+	"audio": {
+		"addVoiceover": "Seslendirme ekle",
+		"addVoiceoverHint": "Videonuzun üzerine anlatım kaydedin",
+		"subtitle": "Zaman çizelgesine seslendirme veya fon müziği katmanı yerleştirin",
+		"record": "Seslendirme kaydet",
+		"importFile": "Ses dosyası içe aktar",
+		"importFileHint": "Müzik veya ses dosyası içe aktarın",
+		"recording": "Kaydediliyor",
+		"recordingHint": "Videoyla birlikte anlatın — kayıt sırasında oynamaya devam eder",
+		"stop": "Durdur",
+		"micDenied": "Mikrofon erişimi reddedildi",
+		"recordingUnavailable": "Burada kayıt kullanılamıyor",
+		"saveFailed": "Kayıt kaydedilemedi",
+		"importFailed": "Ses dosyası içe aktarılamadı"
 	}
 }
diff --git a/src/i18n/locales/vi/dialogs.json b/src/i18n/locales/vi/dialogs.json
index 644d2ba02..452e80e2f 100644
--- a/src/i18n/locales/vi/dialogs.json
+++ b/src/i18n/locales/vi/dialogs.json
@@ -79,11 +79,13 @@
 		"saveGif": "Lưu GIF đã xuất",
 		"saveVideo": "Lưu Video đã xuất",
 		"selectVideo": "Chọn tệp video",
+		"selectAudio": "Chọn tệp âm thanh",
 		"saveProject": "Lưu dự án OpenScreen",
 		"openProject": "Mở dự án OpenScreen",
 		"gifImage": "Hình ảnh GIF",
 		"mp4Video": "Video MP4",
 		"videoFiles": "Tệp Video",
+		"audioFiles": "Tệp âm thanh",
 		"openscreenProject": "Dự án OpenScreen",
 		"allFiles": "Tất cả các tệp"
 	}
diff --git a/src/i18n/locales/vi/editor.json b/src/i18n/locales/vi/editor.json
index 6f55d77a5..2f365aa35 100644
--- a/src/i18n/locales/vi/editor.json
+++ b/src/i18n/locales/vi/editor.json
@@ -71,6 +71,7 @@
 		"pasted": "Đã dán thuộc tính {{region}}",
 		"nothingToCopy": "Chọn một vùng để sao chép thuộc tính của nó",
 		"nothingToPaste": "Chưa sao chép thuộc tính nào",
+		"pasteAssetMissing": "Tệp của bản âm thanh này không có trong dự án",
 		"kinds": {
 			"zoom": "Thu phóng",
 			"speed": "Tốc độ",
diff --git a/src/i18n/locales/vi/settings.json b/src/i18n/locales/vi/settings.json
index a2af00397..d000aee0b 100644
--- a/src/i18n/locales/vi/settings.json
+++ b/src/i18n/locales/vi/settings.json
@@ -327,5 +327,16 @@
 		"outputGain": "Mức đầu ra",
 		"reset": "Đặt lại âm thanh",
 		"help": "Điều chỉnh mức đầu ra của âm thanh. Nó được áp dụng giống hệt nhau trong bản xem trước và khi xuất."
+	},
+	"audioTrack": {
+		"add": "Thêm bản âm thanh",
+		"importFailed": "Không thể thêm âm thanh",
+		"defaultLabel": "Bản âm thanh",
+		"help": "Âm lượng, hiệu ứng mờ và lặp cho bản âm thanh này. Nó được trộn lên trên bản ghi ở cả xem trước và xuất. Kéo bản trên dòng thời gian để di chuyển hoặc đổi kích thước.",
+		"fadeIn": "Mờ vào",
+		"fadeOut": "Mờ ra",
+		"mute": "Tắt tiếng",
+		"loop": "Lặp",
+		"remove": "Xóa bản nhạc"
 	}
 }
diff --git a/src/i18n/locales/vi/shortcuts.json b/src/i18n/locales/vi/shortcuts.json
index cf49f2526..448de3cfe 100644
--- a/src/i18n/locales/vi/shortcuts.json
+++ b/src/i18n/locales/vi/shortcuts.json
@@ -20,6 +20,8 @@
 		"addTrim": "Thêm Cắt",
 		"addSpeed": "Thêm Tốc độ",
 		"addAnnotation": "Thêm Chú thích",
+		"addAudio": "Thêm âm thanh",
+		"addVoiceover": "Ghi âm lời thuyết minh",
 		"addKeyframe": "Thêm Khung hình chính",
 		"addCameraFullscreen": "Thêm Camera Toàn màn hình",
 		"deleteSelected": "Xóa mục đã chọn",
diff --git a/src/i18n/locales/vi/timeline.json b/src/i18n/locales/vi/timeline.json
index 1d963e585..e585a7dce 100644
--- a/src/i18n/locales/vi/timeline.json
+++ b/src/i18n/locales/vi/timeline.json
@@ -15,6 +15,7 @@
 		"pressZoom": "Nhấn Z để thêm thu phóng",
 		"pressTrim": "Nhấn T để thêm cắt",
 		"pressAnnotation": "Nhấn A để thêm chú thích",
+		"pressAudio": "Nhấn M để thêm âm thanh, V để ghi âm lời thuyết minh",
 		"pressSpeed": "Nhấn S để thêm tốc độ",
 		"pressCameraFullscreen": "Nhấn C để thêm một đoạn Camera Toàn màn hình"
 	},
@@ -85,6 +86,22 @@
 		"smartCutsNeedsTranscript": "Cần có bản phiên âm",
 		"smartCutsNoAudio": "Media này không có âm thanh",
 		"smartCutsNoSpeech": "Không phát hiện giọng nói",
-		"smartCutsFailed": "Phiên âm thất bại — thử lại trong Media"
+		"smartCutsFailed": "Phiên âm thất bại — thử lại trong Media",
+		"addAudioTooltip": "Thêm âm thanh"
+	},
+	"audio": {
+		"addVoiceover": "Thêm thuyết minh",
+		"addVoiceoverHint": "Ghi âm lời thuyết minh trên video của bạn",
+		"subtitle": "Đặt lớp thuyết minh hoặc nhạc nền lên dòng thời gian",
+		"record": "Ghi âm thuyết minh",
+		"importFile": "Nhập tệp âm thanh",
+		"importFileHint": "Nhập nhạc hoặc tệp âm thanh",
+		"recording": "Đang ghi",
+		"recordingHint": "Thuyết minh cùng video — video vẫn phát trong khi bạn ghi âm",
+		"stop": "Dừng",
+		"micDenied": "Quyền truy cập micrô bị từ chối",
+		"recordingUnavailable": "Không thể ghi âm ở đây",
+		"saveFailed": "Không thể lưu bản ghi",
+		"importFailed": "Không thể nhập tệp âm thanh"
 	}
 }
diff --git a/src/i18n/locales/zh-CN/dialogs.json b/src/i18n/locales/zh-CN/dialogs.json
index 645ebf9d8..db4f12730 100644
--- a/src/i18n/locales/zh-CN/dialogs.json
+++ b/src/i18n/locales/zh-CN/dialogs.json
@@ -79,11 +79,13 @@
 		"saveGif": "保存导出的 GIF",
 		"saveVideo": "保存导出的视频",
 		"selectVideo": "选择视频文件",
+		"selectAudio": "选择音频文件",
 		"saveProject": "保存 OpenScreen 项目",
 		"openProject": "打开 OpenScreen 项目",
 		"gifImage": "GIF 图片",
 		"mp4Video": "MP4 视频",
 		"videoFiles": "视频文件",
+		"audioFiles": "音频文件",
 		"openscreenProject": "OpenScreen 项目",
 		"allFiles": "所有文件"
 	}
diff --git a/src/i18n/locales/zh-CN/editor.json b/src/i18n/locales/zh-CN/editor.json
index dcfeb282b..c47a5ffee 100644
--- a/src/i18n/locales/zh-CN/editor.json
+++ b/src/i18n/locales/zh-CN/editor.json
@@ -71,6 +71,7 @@
 		"pasted": "已粘贴{{region}}属性",
 		"nothingToCopy": "选择一个区域以复制其属性",
 		"nothingToPaste": "尚未复制任何属性",
+		"pasteAssetMissing": "该音频轨道的文件不在此项目中",
 		"kinds": {
 			"zoom": "缩放",
 			"speed": "速度",
diff --git a/src/i18n/locales/zh-CN/settings.json b/src/i18n/locales/zh-CN/settings.json
index bd13392a1..e92436d1c 100644
--- a/src/i18n/locales/zh-CN/settings.json
+++ b/src/i18n/locales/zh-CN/settings.json
@@ -327,5 +327,16 @@
 		"outputGain": "输出电平",
 		"reset": "重置音频",
 		"help": "调整音频输出电平。它在预览和导出中的效果完全一致。"
+	},
+	"audioTrack": {
+		"add": "添加音频轨道",
+		"importFailed": "无法添加音频",
+		"defaultLabel": "音频轨道",
+		"help": "该音频轨道的音量、淡入淡出和循环。它会在预览和导出时混合到录制内容之上。在时间轴上拖动轨道可移动或调整大小。",
+		"fadeIn": "淡入",
+		"fadeOut": "淡出",
+		"mute": "静音",
+		"loop": "循环",
+		"remove": "删除轨道"
 	}
 }
diff --git a/src/i18n/locales/zh-CN/shortcuts.json b/src/i18n/locales/zh-CN/shortcuts.json
index 95ec1c07e..033f80e7d 100644
--- a/src/i18n/locales/zh-CN/shortcuts.json
+++ b/src/i18n/locales/zh-CN/shortcuts.json
@@ -20,6 +20,8 @@
 		"addTrim": "添加剪辑",
 		"addSpeed": "添加速度",
 		"addAnnotation": "添加标注",
+		"addAudio": "添加音频",
+		"addVoiceover": "录制配音",
 		"addKeyframe": "添加关键帧",
 		"addCameraFullscreen": "添加全屏摄像头",
 		"deleteSelected": "删除所选",
diff --git a/src/i18n/locales/zh-CN/timeline.json b/src/i18n/locales/zh-CN/timeline.json
index 1451e6d31..1513e4f39 100644
--- a/src/i18n/locales/zh-CN/timeline.json
+++ b/src/i18n/locales/zh-CN/timeline.json
@@ -15,6 +15,7 @@
 		"pressZoom": "按 Z 添加缩放",
 		"pressTrim": "按 T 添加剪辑",
 		"pressAnnotation": "按 A 添加标注",
+		"pressAudio": "按 M 添加音频，按 V 录制配音",
 		"pressSpeed": "按 S 添加速度",
 		"pressCameraFullscreen": "按 C 添加一个全屏摄像头片段"
 	},
@@ -85,6 +86,22 @@
 		"smartCutsNeedsTranscript": "需要转录文本",
 		"smartCutsNoAudio": "此媒体没有音频",
 		"smartCutsNoSpeech": "未检测到语音",
-		"smartCutsFailed": "转录失败 — 请在“媒体”中重试"
+		"smartCutsFailed": "转录失败 — 请在“媒体”中重试",
+		"addAudioTooltip": "添加音频"
+	},
+	"audio": {
+		"addVoiceover": "添加配音",
+		"addVoiceoverHint": "为视频录制旁白",
+		"subtitle": "在时间轴上放置配音或背景音乐图层",
+		"record": "录制配音",
+		"importFile": "导入音频文件",
+		"importFileHint": "导入音乐或音频文件",
+		"recording": "正在录制",
+		"recordingHint": "跟着视频讲解 — 录制时视频会继续播放",
+		"stop": "停止",
+		"micDenied": "麦克风访问被拒绝",
+		"recordingUnavailable": "此处无法录音",
+		"saveFailed": "无法保存录音",
+		"importFailed": "无法导入音频文件"
 	}
 }
diff --git a/src/i18n/locales/zh-TW/dialogs.json b/src/i18n/locales/zh-TW/dialogs.json
index 14fc364a0..f4830a611 100644
--- a/src/i18n/locales/zh-TW/dialogs.json
+++ b/src/i18n/locales/zh-TW/dialogs.json
@@ -79,11 +79,13 @@
 		"saveGif": "儲存匯出的 GIF",
 		"saveVideo": "儲存匯出的影片",
 		"selectVideo": "選擇影片檔案",
+		"selectAudio": "選擇音訊檔案",
 		"saveProject": "儲存 OpenScreen 專案",
 		"openProject": "開啟 OpenScreen 專案",
 		"gifImage": "GIF 圖片",
 		"mp4Video": "MP4 影片",
 		"videoFiles": "影片檔案",
+		"audioFiles": "音訊檔案",
 		"openscreenProject": "OpenScreen 專案",
 		"allFiles": "所有檔案"
 	}
diff --git a/src/i18n/locales/zh-TW/editor.json b/src/i18n/locales/zh-TW/editor.json
index 4893e4caf..e0c87ee77 100644
--- a/src/i18n/locales/zh-TW/editor.json
+++ b/src/i18n/locales/zh-TW/editor.json
@@ -71,6 +71,7 @@
 		"pasted": "已貼上{{region}}屬性",
 		"nothingToCopy": "選擇一個區域以複製其屬性",
 		"nothingToPaste": "尚未複製任何屬性",
+		"pasteAssetMissing": "該音訊軌道的檔案不在此專案中",
 		"kinds": {
 			"zoom": "縮放",
 			"speed": "速度",
diff --git a/src/i18n/locales/zh-TW/settings.json b/src/i18n/locales/zh-TW/settings.json
index f9328155d..e8d9a8ed8 100644
--- a/src/i18n/locales/zh-TW/settings.json
+++ b/src/i18n/locales/zh-TW/settings.json
@@ -328,5 +328,16 @@
 		"outputGain": "輸出音量",
 		"reset": "重設音訊",
 		"help": "調整音訊輸出電平。它在預覽與匯出中的效果完全一致。"
+	},
+	"audioTrack": {
+		"add": "新增音訊軌道",
+		"importFailed": "無法新增音訊",
+		"defaultLabel": "音訊軌道",
+		"help": "該音訊軌道的音量、淡入淡出與循環。它會在預覽與匯出時混合到錄製內容之上。在時間軸上拖曳軌道可移動或調整大小。",
+		"fadeIn": "淡入",
+		"fadeOut": "淡出",
+		"mute": "靜音",
+		"loop": "循環",
+		"remove": "刪除軌道"
 	}
 }
diff --git a/src/i18n/locales/zh-TW/shortcuts.json b/src/i18n/locales/zh-TW/shortcuts.json
index fd8c6434b..2daf7eb6d 100644
--- a/src/i18n/locales/zh-TW/shortcuts.json
+++ b/src/i18n/locales/zh-TW/shortcuts.json
@@ -20,6 +20,8 @@
 		"addTrim": "新增剪輯",
 		"addSpeed": "新增速度",
 		"addAnnotation": "新增標註",
+		"addAudio": "新增音訊",
+		"addVoiceover": "錄製配音",
 		"addKeyframe": "新增關鍵影格",
 		"addCameraFullscreen": "新增全螢幕攝影機",
 		"deleteSelected": "刪除所選",
diff --git a/src/i18n/locales/zh-TW/timeline.json b/src/i18n/locales/zh-TW/timeline.json
index 7f4ba9874..e5e5f8d25 100644
--- a/src/i18n/locales/zh-TW/timeline.json
+++ b/src/i18n/locales/zh-TW/timeline.json
@@ -15,6 +15,7 @@
 		"pressZoom": "按 Z 新增縮放",
 		"pressTrim": "按 T 新增剪輯",
 		"pressAnnotation": "按 A 新增標註",
+		"pressAudio": "按 M 新增音訊，按 V 錄製配音",
 		"pressSpeed": "按 S 新增速度",
 		"pressCameraFullscreen": "按 C 新增一個全螢幕攝影機片段"
 	},
@@ -85,6 +86,22 @@
 		"smartCutsNeedsTranscript": "需要轉錄文字",
 		"smartCutsNoAudio": "此媒體沒有音訊",
 		"smartCutsNoSpeech": "未偵測到語音",
-		"smartCutsFailed": "轉錄失敗 — 請在「媒體」中重試"
+		"smartCutsFailed": "轉錄失敗 — 請在「媒體」中重試",
+		"addAudioTooltip": "新增音訊"
+	},
+	"audio": {
+		"addVoiceover": "新增旁白",
+		"addVoiceoverHint": "為影片錄製旁白",
+		"subtitle": "在時間軸上放置旁白或背景音樂圖層",
+		"record": "錄製旁白",
+		"importFile": "匯入音訊檔案",
+		"importFileHint": "匯入音樂或音訊檔案",
+		"recording": "錄製中",
+		"recordingHint": "跟著影片講解 — 錄製時影片會繼續播放",
+		"stop": "停止",
+		"micDenied": "麥克風存取遭拒絕",
+		"recordingUnavailable": "此處無法錄音",
+		"saveFailed": "無法儲存錄音",
+		"importFailed": "無法匯入音訊檔案"
 	}
 }
diff --git a/src/lib/ai-edition/document/audioTracks.test.ts b/src/lib/ai-edition/document/audioTracks.test.ts
new file mode 100644
index 000000000..49b061d6e
--- /dev/null
+++ b/src/lib/ai-edition/document/audioTracks.test.ts
@@ -0,0 +1,279 @@
+import { describe, expect, it } from "vitest";
+import { type AxcutAsset, type AxcutClip, createAudioTrack, createEmptyDocument } from "../schema";
+import {
+	anchorAudioTrackFragments,
+	collapseTracksToPills,
+	packAudioTrackRows,
+	patchAudioTrack,
+	removeAudioTrack,
+	resolveFadeSecs,
+	trackGroupId,
+} from "./audioTracks";
+
+const emptyDoc = () => createEmptyDocument({ projectId: "p", title: "t" });
+
+function clip(id: string, timelineStartSec: number, lengthSec: number): AxcutClip {
+	return {
+		id,
+		assetId: "video_1",
+		sourceStartSec: 0,
+		sourceEndSec: lengthSec,
+		timelineStartSec,
+		timelineEndSec: timelineStartSec + lengthSec,
+		wordRefs: [],
+		origin: "user",
+		reason: "",
+	};
+}
+
+// Two 10s clips back to back: a track crossing second 10 is ventilated in two.
+const twoClips = [clip("c1", 0, 10), clip("c2", 10, 10)];
+
+let seq = 0;
+const makeId = () => `frag_${++seq}`;
+
+const track = (over: Partial<ReturnType<typeof createAudioTrack>> = {}) => ({
+	...createAudioTrack({ assetId: "asset_1", durationSec: 30, timelineStartSec: 5, spanSec: 10 }),
+	...over,
+});
+
+const audioAsset: AxcutAsset = {
+	id: "asset_1",
+	kind: "audio",
+	label: "BGM",
+	originalPath: "/bgm.mp3",
+	cameraTrack: null,
+};
+
+describe("anchorAudioTrackFragments", () => {
+	it("leaves a track that fits inside one clip as a single fragment", () => {
+		const frags = anchorAudioTrackFragments(
+			track({ startMs: 1000, endMs: 6000 }),
+			twoClips,
+			makeId,
+		);
+		expect(frags).toHaveLength(1);
+		expect(frags[0].clipId).toBe("c1");
+		expect(frags[0].offsetMs).toBe(0);
+	});
+
+	it("advances each fragment's source offset by the time its predecessors played", () => {
+		// 5s..15s spans the c1/c2 boundary at 10s: 5s of source, then the next 5s.
+		const frags = anchorAudioTrackFragments(
+			track({ startMs: 5000, endMs: 15_000, offsetMs: 2000 }),
+			twoClips,
+			makeId,
+		);
+		expect(frags).toHaveLength(2);
+		expect(frags.map((f) => f.clipId)).toEqual(["c1", "c2"]);
+		// Fragment 1 starts the file at the track's own offset...
+		expect(frags[0].offsetMs).toBe(2000);
+		// ...and fragment 2 picks up where it left off, rather than restarting
+		// there — that restart is what made a bed audibly repeat at every cut.
+		expect(frags[1].offsetMs).toBe(7000);
+	});
+
+	it("keeps the fades on the outer edges only", () => {
+		const frags = anchorAudioTrackFragments(
+			track({ startMs: 5000, endMs: 15_000, fadeInMs: 500, fadeOutMs: 800 }),
+			twoClips,
+			makeId,
+		);
+		expect(frags.map((f) => [f.fadeInMs, f.fadeOutMs])).toEqual([
+			[500, 0],
+			[0, 800],
+		]);
+	});
+
+	it("does not advance the offset of a looping track", () => {
+		// Looping folds within `duration - offset`, which every fragment shares;
+		// an advanced offset would shorten the window and drift out of phase.
+		const frags = anchorAudioTrackFragments(
+			track({ startMs: 5000, endMs: 15_000, offsetMs: 1000, loop: true }),
+			twoClips,
+			makeId,
+		);
+		expect(frags.map((f) => f.offsetMs)).toEqual([1000, 1000]);
+	});
+
+	it("ties every fragment to one group id", () => {
+		const frags = anchorAudioTrackFragments(
+			track({ startMs: 5000, endMs: 15_000 }),
+			twoClips,
+			makeId,
+		);
+		const groups = new Set(frags.map(trackGroupId));
+		expect(groups.size).toBe(1);
+	});
+
+	it("returns the track unanchored when no clip is under it", () => {
+		const frags = anchorAudioTrackFragments(track({ startMs: 5000, endMs: 15_000 }), [], makeId);
+		expect(frags).toHaveLength(1);
+		expect(frags[0].clipId).toBeUndefined();
+	});
+});
+
+describe("collapseTracksToPills", () => {
+	it("folds a ventilated track back into one span with its real offset", () => {
+		const frags = anchorAudioTrackFragments(
+			track({ startMs: 5000, endMs: 15_000, offsetMs: 2000, fadeInMs: 400, fadeOutMs: 600 }),
+			twoClips,
+			makeId,
+		);
+		const [pill] = collapseTracksToPills(frags);
+		expect(pill.startMs).toBe(5000);
+		expect(pill.endMs).toBe(15_000);
+		// The FIRST fragment's offset is the track's own; the later ones hold
+		// advanced copies that must not leak back into the pill.
+		expect(pill.offsetMs).toBe(2000);
+		expect([pill.fadeInMs, pill.fadeOutMs]).toEqual([400, 600]);
+		expect(pill.clipId).toBeUndefined();
+	});
+
+	it("round-trips through anchoring unchanged", () => {
+		const original = track({ startMs: 5000, endMs: 15_000, offsetMs: 2000 });
+		const once = anchorAudioTrackFragments(original, twoClips, makeId);
+		const twice = anchorAudioTrackFragments(collapseTracksToPills(once)[0], twoClips, makeId);
+		expect(twice.map((f) => [f.startMs, f.endMs, f.offsetMs])).toEqual(
+			once.map((f) => [f.startMs, f.endMs, f.offsetMs]),
+		);
+	});
+});
+
+describe("removeAudioTrack", () => {
+	it("drops every fragment of the track and is a no-op for unknown ids", () => {
+		const frags = anchorAudioTrackFragments(
+			track({ startMs: 5000, endMs: 15_000 }),
+			twoClips,
+			makeId,
+		);
+		const doc = { ...emptyDoc(), audioTracks: frags };
+		expect(removeAudioTrack(doc, trackGroupId(frags[0])).audioTracks).toEqual([]);
+		expect(removeAudioTrack(doc, "nope").audioTracks).toEqual(frags);
+	});
+
+	it("also drops the track's asset when nothing else references it", () => {
+		const t = track();
+		const doc = { ...emptyDoc(), audioTracks: [t], assets: [audioAsset] };
+		const next = removeAudioTrack(doc, t.id);
+		expect(next.audioTracks).toEqual([]);
+		expect(next.assets).toEqual([]);
+	});
+
+	it("keeps the asset when another track still references it", () => {
+		const t1 = track();
+		const t2 = track({ id: "audio_other" });
+		const doc = { ...emptyDoc(), audioTracks: [t1, t2], assets: [audioAsset] };
+		expect(removeAudioTrack(doc, t1.id).assets).toEqual([audioAsset]);
+	});
+});
+
+describe("patchAudioTrack", () => {
+	it("applies a payload edit to every fragment", () => {
+		const frags = anchorAudioTrackFragments(
+			track({ startMs: 5000, endMs: 15_000 }),
+			twoClips,
+			makeId,
+		);
+		const doc = { ...emptyDoc(), audioTracks: frags };
+		const next = patchAudioTrack(doc, trackGroupId(frags[0]), { gainDb: -6, muted: true });
+		expect(next.audioTracks.map((t) => t.gainDb)).toEqual([-6, -6]);
+		expect(next.audioTracks.every((t) => t.muted)).toBe(true);
+	});
+
+	it("keeps fades on the outer edges when they are edited", () => {
+		const frags = anchorAudioTrackFragments(
+			track({ startMs: 5000, endMs: 15_000 }),
+			twoClips,
+			makeId,
+		);
+		const doc = { ...emptyDoc(), audioTracks: frags };
+		const next = patchAudioTrack(doc, trackGroupId(frags[0]), { fadeInMs: 300, fadeOutMs: 400 });
+		expect(next.audioTracks.map((t) => [t.fadeInMs, t.fadeOutMs])).toEqual([
+			[300, 0],
+			[0, 400],
+		]);
+	});
+
+	it("shifts the whole track by the offset delta, preserving each advance", () => {
+		const frags = anchorAudioTrackFragments(
+			track({ startMs: 5000, endMs: 15_000, offsetMs: 2000 }),
+			twoClips,
+			makeId,
+		);
+		const doc = { ...emptyDoc(), audioTracks: frags };
+		// 2000 → 3000 is +1000 everywhere; fragment 2 keeps its 5000ms advance.
+		const next = patchAudioTrack(doc, trackGroupId(frags[0]), { offsetMs: 3000 });
+		expect(next.audioTracks.map((t) => t.offsetMs)).toEqual([3000, 8000]);
+	});
+
+	it("leaves other tracks untouched", () => {
+		const a = track({ id: "audio_a" });
+		const b = track({ id: "audio_b" });
+		const doc = { ...emptyDoc(), audioTracks: [a, b] };
+		const next = patchAudioTrack(doc, "audio_b", { gainDb: -6 });
+		expect(next.audioTracks[0]).toEqual(a);
+		expect(next.audioTracks[1]?.gainDb).toBe(-6);
+	});
+});
+
+describe("resolveFadeSecs", () => {
+	it("passes fades that fit through untouched", () => {
+		expect(resolveFadeSecs(1000, 2000, 10)).toEqual({ fadeInSec: 1, fadeOutSec: 2 });
+	});
+
+	it("shrinks a fade-in longer than the span to the span", () => {
+		// Unreduced this holds the gain at zero for the whole track.
+		expect(resolveFadeSecs(5000, 0, 2)).toEqual({ fadeInSec: 2, fadeOutSec: 0 });
+	});
+
+	it("shares the span in proportion when both fades overflow", () => {
+		const { fadeInSec, fadeOutSec } = resolveFadeSecs(6000, 4000, 2);
+		expect(fadeInSec).toBeCloseTo(1.2);
+		expect(fadeOutSec).toBeCloseTo(0.8);
+	});
+});
+
+describe("packAudioTrackRows", () => {
+	const t = (id: string, startMs: number, endMs: number) => ({ id, startMs, endMs });
+
+	it("keeps tracks that never overlap on one row", () => {
+		// The common case stays a single-line lane.
+		const { rowOf, rowCount } = packAudioTrackRows([
+			t("a", 0, 1000),
+			t("b", 1000, 2000),
+			t("c", 5000, 6000),
+		]);
+		expect(rowCount).toBe(1);
+		expect([rowOf.get("a"), rowOf.get("b"), rowOf.get("c")]).toEqual([0, 0, 0]);
+	});
+
+	it("stacks tracks that overlap, so neither hides the other", () => {
+		const { rowOf, rowCount } = packAudioTrackRows([t("a", 0, 5000), t("b", 1000, 2000)]);
+		expect(rowCount).toBe(2);
+		expect(rowOf.get("a")).toBe(0);
+		expect(rowOf.get("b")).toBe(1);
+	});
+
+	it("reuses a row as soon as it frees up", () => {
+		// b overlaps a and goes to row 1; c starts after a ends, so it drops back
+		// to row 0 rather than opening a third row.
+		const { rowOf, rowCount } = packAudioTrackRows([
+			t("a", 0, 3000),
+			t("b", 1000, 9000),
+			t("c", 4000, 5000),
+		]);
+		expect(rowCount).toBe(2);
+		expect(rowOf.get("c")).toBe(0);
+	});
+
+	it("treats touching tracks as non-overlapping", () => {
+		// One ending exactly where the next begins is a sequence, not a pile.
+		const { rowCount } = packAudioTrackRows([t("a", 0, 1000), t("b", 1000, 2000)]);
+		expect(rowCount).toBe(1);
+	});
+
+	it("always reports at least one row, even with nothing to place", () => {
+		expect(packAudioTrackRows([]).rowCount).toBe(1);
+	});
+});
diff --git a/src/lib/ai-edition/document/audioTracks.ts b/src/lib/ai-edition/document/audioTracks.ts
new file mode 100644
index 000000000..73c23866c
--- /dev/null
+++ b/src/lib/ai-edition/document/audioTracks.ts
@@ -0,0 +1,238 @@
+// Placement and payload edits for timeline audio tracks (issue #350).
+//
+// Audio tracks are CLIP-ANCHORED, so unlike the array-only ops this module used
+// to hold, placement goes through the shared pill helpers in
+// `timeline/timelineMap.ts` — the same machinery zoom, annotation, speed and
+// camera-fullscreen regions already use. One user-visible track is one PILL;
+// underneath it is one anchored fragment per clip it covers.
+//
+// The one thing audio needs that no other region kind does is `offsetMs`
+// advancement. `anchorRawRegionsToClips` copies a region's payload verbatim
+// into every fragment, which is right for value-per-span effects (both halves
+// of a split zoom are still "depth 3") and wrong for continuous media: two
+// fragments each carrying `offsetMs: 2000` would both restart the file two
+// seconds in, so a bed spanning a cut audibly restarts at the boundary, and
+// each fragment would re-run the layer's fades. `anchorAudioTrackFragments`
+// fixes the payload up afterwards: every fragment's `offsetMs` is advanced by
+// the source time its predecessors consumed, and the fades are kept on the
+// outer edges only.
+
+import type { AxcutAudioTrack, AxcutClip, AxcutDocument } from "../schema";
+import { anchorRegionsWithDerivedMs, coalesceRegionsForRuler } from "../timeline/timelineMap";
+
+/** Every fragment of one user-visible track shares this key. */
+export function trackGroupId(track: AxcutAudioTrack): string {
+	return track.trackId ?? track.id;
+}
+
+/**
+ * Anchor a track's raw span to the clips it covers, then repair the payload so
+ * the fragments play as ONE continuous take:
+ *
+ *  - `offsetMs` advances by the elapsed source time, so fragment 2 picks up the
+ *    file where fragment 1 left off instead of restarting at the track offset.
+ *  - `fadeInMs` stays on the first fragment and `fadeOutMs` on the last, so a
+ *    split track fades once at each real edge rather than at every cut.
+ *  - `trackId` ties the fragments together for the lane, the inspector and
+ *    delete.
+ *
+ * A track that overlaps no clip is returned unanchored (one fragment, the input
+ * span), matching how `anchorRegionsWithDerivedMs` treats every other kind.
+ */
+export function anchorAudioTrackFragments(
+	track: AxcutAudioTrack,
+	clips: AxcutClip[],
+	makeId: () => string,
+): AxcutAudioTrack[] {
+	const groupId = trackGroupId(track);
+	const anchored = anchorRegionsWithDerivedMs([track], clips, makeId) as AxcutAudioTrack[];
+	if (anchored.length === 0) return [];
+	// Fragments come back in clip order, which is the order they play.
+	let elapsedMs = 0;
+	const last = anchored.length - 1;
+	return anchored.map((fragment, index) => {
+		const spanMs = Math.max(0, fragment.endMs - fragment.startMs);
+		const next: AxcutAudioTrack = {
+			...fragment,
+			trackId: groupId,
+			// Looping restarts the window on its own, so an advanced offset would
+			// double-count the fold; the mixer and the preview both wrap within
+			// `durationSec - offsetMs`, which every fragment shares.
+			offsetMs: track.loop ? track.offsetMs : track.offsetMs + elapsedMs,
+			fadeInMs: index === 0 ? track.fadeInMs : 0,
+			fadeOutMs: index === last ? track.fadeOutMs : 0,
+		};
+		elapsedMs += spanMs;
+		return next;
+	});
+}
+
+/** Re-anchor every track in the document — used after a structural clip edit
+ *  reshuffles what each fragment sits over. */
+export function reanchorAudioTracks(
+	tracks: AxcutAudioTrack[],
+	clips: AxcutClip[],
+	makeId: () => string,
+): AxcutAudioTrack[] {
+	// Coalesce back to one raw span per track FIRST: re-anchoring the stored
+	// fragments individually would re-ventilate each one and multiply them.
+	return collapseTracksToPills(tracks).flatMap((track) =>
+		anchorAudioTrackFragments(track, clips, makeId),
+	);
+}
+
+/**
+ * The user-visible tracks: fragments folded back into one span per `trackId`,
+ * carrying the FIRST fragment's payload (its `offsetMs` is the track's real
+ * offset — later fragments hold advanced copies) and the outer fades.
+ */
+export function collapseTracksToPills(tracks: AxcutAudioTrack[]): AxcutAudioTrack[] {
+	const groups = new Map<string, AxcutAudioTrack[]>();
+	for (const track of tracks) {
+		const key = trackGroupId(track);
+		const bucket = groups.get(key);
+		if (bucket) bucket.push(track);
+		else groups.set(key, [track]);
+	}
+	return [...groups.values()].map((fragments) => {
+		const ordered = [...fragments].sort((a, b) => a.startMs - b.startMs);
+		const head = ordered[0];
+		const tail = ordered[ordered.length - 1];
+		return {
+			...head,
+			id: trackGroupId(head),
+			trackId: undefined,
+			clipId: undefined,
+			sourceStartSec: undefined,
+			sourceEndSec: undefined,
+			startMs: head.startMs,
+			endMs: tail.endMs,
+			fadeInMs: head.fadeInMs,
+			fadeOutMs: tail.fadeOutMs,
+		};
+	});
+}
+
+/** Lane pills for the ruler, one per user-visible track. */
+export function audioTrackPills(tracks: AxcutAudioTrack[]) {
+	return coalesceRegionsForRuler(collapseTracksToPills(tracks));
+}
+
+/** Drop every fragment of a track, and its asset when nothing else needs it.
+ *
+ *  An imported audio asset is only ever reachable through its track — audio is
+ *  filtered out of the clip lists, so it never becomes a clip — so a deleted
+ *  track orphans it, and it would otherwise linger in the document forever,
+ *  invisible in every asset list (issue #350). */
+export function removeAudioTrack(doc: AxcutDocument, trackId: string): AxcutDocument {
+	const doomed = doc.audioTracks.filter((t) => trackGroupId(t) === trackId);
+	if (doomed.length === 0) return doc;
+	const audioTracks = doc.audioTracks.filter((t) => trackGroupId(t) !== trackId);
+	const assetId = doomed[0].assetId;
+	const stillReferenced =
+		audioTracks.some((t) => t.assetId === assetId) ||
+		doc.timeline.clips.some((c) => c.assetId === assetId);
+	const assets = stillReferenced ? doc.assets : doc.assets.filter((a) => a.id !== assetId);
+	return { ...doc, audioTracks, assets };
+}
+
+/** Patch the shared payload of every fragment of one track. Payload edits (gain,
+ *  mute, loop, offset) must hit ALL fragments or the halves of a split track
+ *  disagree; `offsetMs` keeps its per-fragment advance. */
+export function patchAudioTrack(
+	doc: AxcutDocument,
+	trackId: string,
+	patch: Partial<Pick<AxcutAudioTrack, "gainDb" | "muted" | "loop" | "fadeInMs" | "fadeOutMs">> & {
+		offsetMs?: number;
+	},
+): AxcutDocument {
+	const fragments = doc.audioTracks.filter((t) => trackGroupId(t) === trackId);
+	if (fragments.length === 0) return doc;
+	const ordered = [...fragments].sort((a, b) => a.startMs - b.startMs);
+	const baseOffset = ordered[0].offsetMs;
+	const last = ordered[ordered.length - 1].id;
+	return {
+		...doc,
+		audioTracks: doc.audioTracks.map((t) => {
+			if (trackGroupId(t) !== trackId) return t;
+			const isFirst = t.id === ordered[0].id;
+			const isLast = t.id === last;
+			return {
+				...t,
+				...(patch.gainDb === undefined ? {} : { gainDb: patch.gainDb }),
+				...(patch.muted === undefined ? {} : { muted: patch.muted }),
+				...(patch.loop === undefined ? {} : { loop: patch.loop }),
+				// Fades live on the outer edges; an interior fragment keeps none.
+				...(patch.fadeInMs === undefined ? {} : { fadeInMs: isFirst ? patch.fadeInMs : 0 }),
+				...(patch.fadeOutMs === undefined ? {} : { fadeOutMs: isLast ? patch.fadeOutMs : 0 }),
+				// Shift the whole track by the delta so each fragment keeps the
+				// advance that makes it continuous with its predecessor.
+				...(patch.offsetMs === undefined
+					? {}
+					: { offsetMs: Math.max(0, t.offsetMs + (patch.offsetMs - baseOffset)) }),
+			};
+		}),
+	};
+}
+
+/**
+ * Fade lengths in seconds, reduced to fit inside `spanSec`.
+ *
+ * Fades that do not fit share the span in proportion rather than being clamped
+ * independently: clamping each to the span first would turn an asymmetric pair
+ * into a symmetric one, losing the shape the user asked for. An unreduced
+ * fade-in longer than the span is worse than cosmetic — it holds the gain at
+ * zero for the whole track.
+ *
+ * Mirrored by `resolve_fade_samples` in `crates/compositor/src/audio.rs`; the
+ * preview reads this one, the render reads that one, and they must agree.
+ */
+export function resolveFadeSecs(
+	fadeInMs: number,
+	fadeOutMs: number,
+	spanSec: number,
+): { fadeInSec: number; fadeOutSec: number } {
+	const fadeInSec = Math.max(0, fadeInMs / 1000);
+	const fadeOutSec = Math.max(0, fadeOutMs / 1000);
+	const total = fadeInSec + fadeOutSec;
+	if (total <= spanSec) return { fadeInSec, fadeOutSec };
+	const scale = Math.max(0, spanSec) / total;
+	return { fadeInSec: fadeInSec * scale, fadeOutSec: fadeOutSec * scale };
+}
+
+/**
+ * Assign each track a ROW in the audio lane, so two tracks that overlap in time
+ * never sit on top of each other.
+ *
+ * Greedy first-fit over tracks in start order: a track takes the topmost row
+ * whose last occupant has already finished, and opens a new row only when every
+ * existing one is still busy. Tracks that do not overlap therefore keep sharing
+ * one row — the lane stays a single line for the common case, and grows only as
+ * far as the actual overlap demands.
+ *
+ * Stacking is the whole point: a lane that draws every track at the same height
+ * turns three voiceovers into one illegible pile where the user cannot tell
+ * which pill they are about to drag.
+ *
+ * Returns the row index per track id, plus how many rows the lane needs.
+ */
+export function packAudioTrackRows(tracks: Array<{ id: string; startMs: number; endMs: number }>): {
+	rowOf: Map<string, number>;
+	rowCount: number;
+} {
+	const ordered = [...tracks].sort((a, b) => a.startMs - b.startMs || a.endMs - b.endMs);
+	// The end of the last track placed in each row, in the same index order.
+	const rowEnds: number[] = [];
+	const rowOf = new Map<string, number>();
+	for (const track of ordered) {
+		let row = rowEnds.findIndex((end) => end <= track.startMs);
+		if (row === -1) {
+			row = rowEnds.length;
+			rowEnds.push(track.endMs);
+		} else {
+			rowEnds[row] = track.endMs;
+		}
+		rowOf.set(track.id, row);
+	}
+	return { rowOf, rowCount: Math.max(1, rowEnds.length) };
+}
diff --git a/src/lib/ai-edition/document/outputFormat.test.ts b/src/lib/ai-edition/document/outputFormat.test.ts
index 4ceac442f..c7e75ab40 100644
--- a/src/lib/ai-edition/document/outputFormat.test.ts
+++ b/src/lib/ai-edition/document/outputFormat.test.ts
@@ -67,6 +67,7 @@ function doc(assets: AxcutAsset[], clips: AxcutClip[]): AxcutDocument {
 		},
 		annotations: [],
 		zoomRanges: [],
+		audioTracks: [],
 		legacyEditor: null,
 	};
 }
diff --git a/src/lib/ai-edition/document/timeline.test.ts b/src/lib/ai-edition/document/timeline.test.ts
index a561dd2f9..06f83943d 100644
--- a/src/lib/ai-edition/document/timeline.test.ts
+++ b/src/lib/ai-edition/document/timeline.test.ts
@@ -13,6 +13,7 @@ import {
 	normalizeIntervals,
 	planTimelineReplacement,
 	primaryAssetDuration,
+	projectRawTimelineSecToPlayback,
 	rederiveRegionMs,
 	removeClip,
 	removeRegion,
@@ -57,6 +58,7 @@ function makeDoc(overrides: Partial<AxcutDocument> = {}): AxcutDocument {
 		},
 		annotations: [],
 		zoomRanges: [],
+		audioTracks: [],
 		legacyEditor: null,
 		...overrides,
 	};
@@ -840,6 +842,90 @@ describe("resolvePlaybackSegments", () => {
 	});
 });
 
+describe("projectRawTimelineSecToPlayback (issue #350 audio-track/trim sync)", () => {
+	// One 10s clip, an interior trim removing raw 2..4 (2s). Output programme is 8s long.
+	const clip = makeClip({
+		sourceStartSec: 0,
+		sourceEndSec: 10,
+		timelineStartSec: 0,
+		timelineEndSec: 10,
+	});
+	const trim = makeTrim({ startSec: 2, endSec: 4 });
+
+	it("is the identity when there are no trims", () => {
+		expect(projectRawTimelineSecToPlayback([clip], [], 6)).toBeCloseTo(6, 6);
+	});
+
+	it("pulls a raw position after a cut earlier by the removed duration", () => {
+		// Raw 6 sits 2s past the 2s cut → output 4. This is the exact bug: the track was
+		// landing at 6 (delayed by the trim) instead of 4.
+		expect(projectRawTimelineSecToPlayback([clip], [trim], 6)).toBeCloseTo(4, 6);
+	});
+
+	it("is unaffected for a position before the cut", () => {
+		expect(projectRawTimelineSecToPlayback([clip], [trim], 1)).toBeCloseTo(1, 6);
+	});
+
+	it("collapses a position inside the trimmed gap to the end of the kept content before it", () => {
+		// Raw 3 is inside the removed 2..4 span → the next audible sample is at output 2.
+		expect(projectRawTimelineSecToPlayback([clip], [trim], 3)).toBeCloseTo(2, 6);
+	});
+
+	it("counts overlapping trims once (union, not sum)", () => {
+		// Trims [2,5] and [3,4] — the second nested in the first — remove 3s total, not 4.
+		// Raw 6 → output 3. The old per-trim accumulation double-counted and returned 2.
+		const trims = [
+			makeTrim({ id: "t1", startSec: 2, endSec: 5 }),
+			makeTrim({ id: "t2", startSec: 3, endSec: 4 }),
+		];
+		expect(projectRawTimelineSecToPlayback([clip], trims, 6)).toBeCloseTo(3, 6);
+	});
+
+	it("removes a raw gap between clips (concatenated, like the programme)", () => {
+		// Clip A ends at raw 10; clip B starts at raw 15 — a 5s gap with no content. The
+		// programme concatenates B straight after A, so raw 20 (5s into B) → output 15, NOT 20.
+		const clipA = makeClip({
+			id: "clip_a",
+			sourceStartSec: 0,
+			sourceEndSec: 10,
+			timelineStartSec: 0,
+			timelineEndSec: 10,
+		});
+		const clipB = makeClip({
+			id: "clip_b",
+			sourceStartSec: 0,
+			sourceEndSec: 10,
+			timelineStartSec: 15,
+			timelineEndSec: 25,
+		});
+		expect(projectRawTimelineSecToPlayback([clipA, clipB], [], 20)).toBeCloseTo(15, 6);
+	});
+
+	it("sums cuts across multiple clips", () => {
+		const clipA = makeClip({
+			id: "clip_a",
+			sourceStartSec: 0,
+			sourceEndSec: 10,
+			timelineStartSec: 0,
+			timelineEndSec: 10,
+		});
+		const clipB = makeClip({
+			id: "clip_b",
+			sourceStartSec: 10,
+			sourceEndSec: 20,
+			timelineStartSec: 10,
+			timelineEndSec: 20,
+		});
+		// Remove 1s from clip A (raw 5..6) and 2s from clip B (raw 12..14) → 3s total.
+		const trims = [
+			makeTrim({ id: "t1", startSec: 5, endSec: 6 }),
+			makeTrim({ id: "t2", startSec: 12, endSec: 14 }),
+		];
+		// Raw 18 is past both cuts (3s removed) → output 15.
+		expect(projectRawTimelineSecToPlayback([clipA, clipB], trims, 18)).toBeCloseTo(15, 6);
+	});
+});
+
 describe("duplicateClip / moveClip", () => {
 	it("duplicateClip gives the copy a fresh, collision-free id even when called repeatedly", () => {
 		// Regression test: this used to id the copy as `clip_${clips.length + 1}_copy`,
@@ -1597,3 +1683,56 @@ describe("a malformed legacyEditor envelope", () => {
 		expect(next.legacyEditor).toEqual({ speedRegions: null, cameraFullscreenRegions: 42 });
 	});
 });
+
+describe("projectRawTimelineSecToPlayback with speed regions", () => {
+	const clip: AxcutClip = {
+		id: "c1",
+		assetId: "a1",
+		sourceStartSec: 0,
+		sourceEndSec: 20,
+		timelineStartSec: 0,
+		timelineEndSec: 20,
+		wordRefs: [],
+		origin: "user",
+		reason: "",
+	};
+
+	it("is the identity when nothing is sped up", () => {
+		expect(projectRawTimelineSecToPlayback([clip], [], 8, [])).toBeCloseTo(8, 6);
+	});
+
+	it("halves the time a 2x stretch takes to play", () => {
+		// Raw 4..8 at 2x plays in 2s, so raw 8 lands at output 6.
+		const speed = [{ startMs: 4000, endMs: 8000, speed: 2 }];
+		expect(projectRawTimelineSecToPlayback([clip], [], 4, speed)).toBeCloseTo(4, 6);
+		expect(projectRawTimelineSecToPlayback([clip], [], 6, speed)).toBeCloseTo(5, 6);
+		expect(projectRawTimelineSecToPlayback([clip], [], 8, speed)).toBeCloseTo(6, 6);
+		// Everything after carries the compression with it.
+		expect(projectRawTimelineSecToPlayback([clip], [], 12, speed)).toBeCloseTo(10, 6);
+	});
+
+	it("stretches a slow-motion region instead", () => {
+		const speed = [{ startMs: 0, endMs: 4000, speed: 0.5 }];
+		expect(projectRawTimelineSecToPlayback([clip], [], 4, speed)).toBeCloseTo(8, 6);
+	});
+
+	it("composes with trims", () => {
+		// Raw 2..4 cut, then raw 6..10 at 2x. Raw 12 = 2 kept + 2 kept + 2 (4s at 2x)
+		// + 2 = output 8.
+		const trim: AxcutTrimRange = {
+			id: "t1",
+			assetId: "a1",
+			startSec: 2,
+			endSec: 4,
+			origin: "user",
+			reason: "",
+		};
+		const speed = [{ startMs: 6000, endMs: 10_000, speed: 2 }];
+		expect(projectRawTimelineSecToPlayback([clip], [trim], 12, speed)).toBeCloseTo(8, 6);
+	});
+
+	it("ignores a nonsense rate rather than dividing by it", () => {
+		const speed = [{ startMs: 0, endMs: 4000, speed: 0 }];
+		expect(projectRawTimelineSecToPlayback([clip], [], 4, speed)).toBeCloseTo(4, 6);
+	});
+});
diff --git a/src/lib/ai-edition/document/timeline.ts b/src/lib/ai-edition/document/timeline.ts
index 232bcb6ee..987e91dc2 100644
--- a/src/lib/ai-edition/document/timeline.ts
+++ b/src/lib/ai-edition/document/timeline.ts
@@ -11,13 +11,14 @@ import {
 	hasCompleteClipAnchor,
 } from "../timeline/timelineMap";
 import { dropTrimPillsByIds, trimAppliesToClip } from "../timeline/trim-mapping";
+import { removeAudioTrack } from "./audioTracks";
 import { createId } from "./ids";
 
 /** The region families a delete can target by id. Shared with the store so "which kinds
  *  exist" has exactly one definition. `trim` is a source-time cut; the rest are pill-merged
  *  effects (zoom / speed / annotation / camera-fullscreen). Clips are removed via
  *  {@link removeClip}, not here — deleting a clip reflows the whole timeline. */
-export type RegionKind = "zoom" | "trim" | "annotation" | "speed" | "cameraFullscreen";
+export type RegionKind = "zoom" | "trim" | "annotation" | "speed" | "cameraFullscreen" | "audio";
 
 /** Length a clip is given before its media has been probed. Lives here, in the pure
  *  document layer, because that layer decides which clips are still waiting for a real
@@ -202,6 +203,131 @@ export function resolvePlaybackSegments(
 	return result;
 }
 
+/**
+ * Project a RAW/document-timeline second (the ruler where trims still occupy their space)
+ * onto the trim-COMPRESSED output programme — the concatenation of the kept segments that
+ * {@link resolvePlaybackSegments} produces and that `audio::mix_external_tracks` overlays on.
+ *
+ * Built from the SAME kept intervals as `resolvePlaybackSegments` (trims subtracted per clip
+ * via `subtractInterval`, then concatenated with a shared output cursor), so it agrees with the
+ * assembled programme in the two cases a naïve "raw − Σ trimmed-before" got wrong: OVERLAPPING
+ * trims (set subtraction counts the union once, not each trim) and RAW GAPS between clips (the
+ * cursor only advances on kept content, so a gap is removed just as the programme removes it).
+ *
+ * `output(T)` = how much kept content precedes `T`. A `T` inside a trimmed span (or an inter-clip
+ * gap) collapses to the output edge of the kept content just before it; a `T` past the last kept
+ * frame carries its raw overhang through unchanged, so a project with no clips is the identity and
+ * a track parked past the programme stays past it (the mixer then skips it). EXACT for trims; like
+ * the rest of the audio-track export path it does not model speed regions, which stay an approximation.
+ *
+ * Issue #350: imported audio tracks store their head in RAW seconds (seeded from the playhead),
+ * but the export mixes onto the compressed programme — passing the raw head through verbatim
+ * delayed every track by the total trim duration ahead of it. The preview already lands them
+ * correctly because its playhead jumps across trims; this makes the render agree.
+ */
+export interface PlaybackSpeedRegion {
+	startMs: number;
+	endMs: number;
+	speed: number;
+}
+
+/**
+ * Output seconds a raw interval `[fromSec, toSec)` occupies once the speed
+ * regions covering it are applied: a 2x stretch of raw time takes half as long
+ * to play, so it contributes half its raw length to the programme.
+ *
+ * Subdivides at every speed boundary the interval crosses and integrates
+ * `1 / speed` piecewise. Regions are matched on the raw ruler, the same
+ * coordinate their pills are drawn in.
+ */
+function outputDurationOfRawSpan(
+	fromSec: number,
+	toSec: number,
+	speedRegions: PlaybackSpeedRegion[],
+): number {
+	if (toSec <= fromSec) return 0;
+	if (speedRegions.length === 0) return toSec - fromSec;
+	// Every boundary inside the span, so each piece has one constant speed.
+	const cuts = new Set<number>([fromSec, toSec]);
+	for (const region of speedRegions) {
+		for (const edge of [region.startMs / 1000, region.endMs / 1000]) {
+			if (edge > fromSec && edge < toSec) cuts.add(edge);
+		}
+	}
+	const edges = [...cuts].sort((a, b) => a - b);
+	let out = 0;
+	for (let i = 0; i < edges.length - 1; i++) {
+		const start = edges[i];
+		const end = edges[i + 1];
+		const mid = (start + end) / 2;
+		const region = speedRegions.find(
+			(r) => mid >= r.startMs / 1000 && mid < r.endMs / 1000 && r.speed > 0,
+		);
+		out += (end - start) / (region?.speed ?? 1);
+	}
+	return out;
+}
+
+export function projectRawTimelineSecToPlayback(
+	clips: AxcutClip[],
+	trimRanges: AxcutTrimRange[],
+	rawSec: number,
+	/**
+	 * Speed regions on the raw ruler. Supplied by the AUDIO paths, which overlay
+	 * a 1x track onto the finished programme and so need its real, speed-adjusted
+	 * clock; omitted by callers that only care about trims. Left out, the
+	 * projection behaves exactly as it did before speed was modelled.
+	 */
+	speedRegions: PlaybackSpeedRegion[] = [],
+): number {
+	const ordered = [...clips].sort((a, b) => a.timelineStartSec - b.timelineStartSec);
+	let outCursor = 0; // output length of the kept content walked so far
+	let lastRawEnd = 0; // raw end of the last kept segment, for the trailing overhang
+	let landed: number | null = null; // output(rawSec), once it falls in/before a kept segment
+
+	// Each kept segment as a raw extent `{ rawStart, dur }`. Trims only REMOVE, so a kept
+	// segment's raw length survives here; how long it takes to PLAY is a separate question
+	// that `outputDurationOfRawSpan` answers, because a speed region scales it.
+	const keptSegments = (clip: AxcutClip): Array<{ rawStart: number; dur: number }> => {
+		const sourceEnd = clip.sourceEndSec ?? clip.sourceStartSec;
+		if (sourceEnd <= clip.sourceStartSec) {
+			// Duration not probed yet — the whole raw clip passes through unnarrowed, matching
+			// `resolvePlaybackSegments`' own pass-through branch.
+			return [
+				{ rawStart: clip.timelineStartSec, dur: clip.timelineEndSec - clip.timelineStartSec },
+			];
+		}
+		let ivs: Interval[] = [{ startSec: clip.sourceStartSec, endSec: sourceEnd }];
+		for (const trim of trimRanges) {
+			if (!trimAppliesToClip(trim, clip)) continue;
+			ivs = subtractInterval(ivs, { startSec: trim.startSec, endSec: trim.endSec });
+		}
+		// Source time `s` sits at `timelineStartSec + (s − sourceStartSec)` on the raw ruler.
+		return ivs.map((iv) => ({
+			rawStart: clip.timelineStartSec + (iv.startSec - clip.sourceStartSec),
+			dur: iv.endSec - iv.startSec,
+		}));
+	};
+
+	for (const clip of ordered) {
+		for (const seg of keptSegments(clip)) {
+			if (seg.dur <= 0) continue;
+			const rawEnd = seg.rawStart + seg.dur;
+			if (landed === null && rawSec < rawEnd) {
+				// `rawSec` is inside this segment, or before it in a trimmed/gap region (then
+				// the span clamps to nothing → the output edge just before the gap).
+				const within = Math.min(Math.max(rawSec, seg.rawStart), rawEnd);
+				landed = outCursor + outputDurationOfRawSpan(seg.rawStart, within, speedRegions);
+			}
+			outCursor += outputDurationOfRawSpan(seg.rawStart, rawEnd, speedRegions);
+			lastRawEnd = rawEnd;
+		}
+	}
+	// Past every kept frame: programme end plus whatever raw time hangs off the end (identity when
+	// there are no clips at all). A value ≥ programme length just means the mixer skips the track.
+	return landed ?? outCursor + Math.max(0, rawSec - lastRawEnd);
+}
+
 export function invertIntervals(intervals: Interval[], durationSec: number): Interval[] {
 	const cuts: Interval[] = [];
 	let cursor = 0;
@@ -259,6 +385,10 @@ function mapAllRegionCollections(
 			document.annotations as unknown as StoredRegion[],
 			"ann",
 		) as unknown as AxcutDocument["annotations"],
+		audioTracks: fn(
+			document.audioTracks as unknown as StoredRegion[],
+			"audio",
+		) as unknown as AxcutDocument["audioTracks"],
 		legacyEditor:
 			legacy && (speedRegions || cameraFullscreenRegions)
 				? {
@@ -879,6 +1009,11 @@ export function removeRegion(document: AxcutDocument, kind: RegionKind, id: stri
 			};
 		case "annotation":
 			return { ...document, annotations: dropPillById(document.annotations, id) };
+		case "audio":
+			// Not `dropPillById`: an audio track's fragments are grouped by
+			// `trackId`, and deleting the pill has to take the asset with it when
+			// nothing else references it.
+			return removeAudioTrack(document, id);
 		case "trim":
 			return {
 				...document,
diff --git a/src/lib/ai-edition/document/transcribe.test.ts b/src/lib/ai-edition/document/transcribe.test.ts
index 034abf212..1d5f67d80 100644
--- a/src/lib/ai-edition/document/transcribe.test.ts
+++ b/src/lib/ai-edition/document/transcribe.test.ts
@@ -49,6 +49,7 @@ function makeDoc(): AxcutDocument {
 		},
 		annotations: [],
 		zoomRanges: [],
+		audioTracks: [],
 		legacyEditor: null,
 	};
 }
diff --git a/src/lib/ai-edition/schema/index.test.ts b/src/lib/ai-edition/schema/index.test.ts
index bbba94fd8..c53bfae9f 100644
--- a/src/lib/ai-edition/schema/index.test.ts
+++ b/src/lib/ai-edition/schema/index.test.ts
@@ -3,8 +3,10 @@ import { migrateRawDocumentToCurrent } from "../document/migrate";
 import {
 	annotationRegionSchema,
 	assetSchema,
+	audioTrackSchema,
 	axcutSchemaVersion,
 	clipSchema,
+	createAudioTrack,
 	createEmptyDocument,
 	documentSchema,
 	ensureDocument,
@@ -40,6 +42,7 @@ describe("axcut-schema v7", () => {
 		expect(doc.timeline.captionRanges).toEqual([]);
 		expect(doc.annotations).toEqual([]);
 		expect(doc.zoomRanges).toEqual([]);
+		expect(doc.audioTracks).toEqual([]);
 		expect(doc.transcripts).toEqual([]);
 		expect(doc.legacyEditor).toBeNull();
 	});
@@ -73,14 +76,22 @@ describe("axcut-schema v7", () => {
 		).toThrow();
 	});
 
-	it("assetSchema requires kind = 'video'", () => {
+	it("assetSchema accepts kind 'video' and 'audio', defaulting to 'video'", () => {
+		// Widened from a literal when external-audio import landed (issue #350).
+		const video = assetSchema.parse({ id: "a1", label: "x", originalPath: "/x.mp4" });
+		expect(video.kind).toBe("video");
+		const audio = assetSchema.parse({
+			id: "a2",
+			kind: "audio",
+			label: "bgm",
+			originalPath: "/bgm.mp3",
+		});
+		expect(audio.kind).toBe("audio");
+	});
+
+	it("assetSchema rejects an unknown kind", () => {
 		expect(() =>
-			assetSchema.parse({
-				id: "asset_1",
-				kind: "audio",
-				label: "x",
-				originalPath: "/x.mp4",
-			}),
+			assetSchema.parse({ id: "a1", kind: "image", label: "x", originalPath: "/x.png" }),
 		).toThrow();
 	});
 
@@ -962,3 +973,110 @@ describe("v6 -> v7 trim clip-anchor migration", () => {
 		]);
 	});
 });
+
+describe("audio tracks (issue #350)", () => {
+	it("applies defaults for kind, gain, offset, fades and label", () => {
+		const track = audioTrackSchema.parse({
+			id: "audio_1",
+			assetId: "asset_1",
+			durationSec: 42,
+			startMs: 0,
+			endMs: 42_000,
+		});
+		expect(track.kind).toBe("music");
+		expect(track.offsetMs).toBe(0);
+		expect(track.gainDb).toBe(0);
+		expect(track.loop).toBe(false);
+		expect(track.fadeInMs).toBe(0);
+		expect(track.fadeOutMs).toBe(0);
+		expect(track.muted).toBe(false);
+		expect(track.label).toBe("");
+		// Unanchored until a caller places it — same contract as every other
+		// clip-anchored region kind.
+		expect(track.clipId).toBeUndefined();
+	});
+
+	it("rejects a span whose end precedes its start", () => {
+		expect(() =>
+			audioTrackSchema.parse({
+				id: "audio_1",
+				assetId: "asset_1",
+				durationSec: 10,
+				startMs: 5000,
+				endMs: 2000,
+			}),
+		).toThrow();
+	});
+
+	it("rejects a negative head", () => {
+		expect(() =>
+			audioTrackSchema.parse({
+				id: "audio_1",
+				assetId: "asset_1",
+				durationSec: 10,
+				startMs: -1,
+				endMs: 1000,
+			}),
+		).toThrow();
+	});
+
+	it("createAudioTrack builds a schema-valid track with a prefixed id", () => {
+		const track = createAudioTrack({
+			assetId: "asset_1",
+			durationSec: 12.5,
+			timelineStartSec: 3,
+			label: "voiceover.mp3",
+		});
+		expect(track.id).toMatch(/^audio_/);
+		expect(track.assetId).toBe("asset_1");
+		expect(track.durationSec).toBe(12.5);
+		// The span runs from the head for the source duration by default.
+		expect(track.startMs).toBe(3000);
+		expect(track.endMs).toBe(15_500);
+		expect(track.label).toBe("voiceover.mp3");
+		// The factory output must itself round-trip through the schema.
+		expect(() => audioTrackSchema.parse(track)).not.toThrow();
+	});
+
+	it("createAudioTrack takes a shorter span than the source when asked", () => {
+		// A voiceover recorded over a 4s tail of the timeline should not lay a
+		// 30s pill down just because its file is 30s long.
+		const track = createAudioTrack({
+			assetId: "asset_1",
+			durationSec: 30,
+			kind: "voiceover",
+			timelineStartSec: 2,
+			spanSec: 4,
+		});
+		expect(track.kind).toBe("voiceover");
+		expect(track.startMs).toBe(2000);
+		expect(track.endMs).toBe(6000);
+	});
+
+	it("createAudioTrack still gives a grabbable span to a zero-duration source", () => {
+		const track = createAudioTrack({ assetId: "asset_1", durationSec: 0 });
+		expect(track.endMs).toBeGreaterThan(track.startMs);
+	});
+
+	it("defaults audioTracks to [] when a stored document omits the key", () => {
+		// A document written before issue #350 has no `audioTracks`; the defaulted
+		// array must fill in so older files load unchanged (no schemaVersion bump).
+		const { audioTracks: _drop, ...withoutAudio } = createEmptyDocument({
+			projectId: "p",
+			title: "t",
+		});
+		expect("audioTracks" in withoutAudio).toBe(false);
+		const parsed = documentSchema.parse(withoutAudio);
+		expect(parsed.audioTracks).toEqual([]);
+	});
+
+	it("round-trips a document carrying an audio track", () => {
+		const track = createAudioTrack({ assetId: "asset_1", durationSec: 8 });
+		const doc = {
+			...createEmptyDocument({ projectId: "p", title: "t" }),
+			audioTracks: [track],
+		};
+		const parsed = documentSchema.parse(doc);
+		expect(parsed.audioTracks).toEqual([track]);
+	});
+});
diff --git a/src/lib/ai-edition/schema/index.ts b/src/lib/ai-edition/schema/index.ts
index 00c429de5..4f32d52bc 100644
--- a/src/lib/ai-edition/schema/index.ts
+++ b/src/lib/ai-edition/schema/index.ts
@@ -150,7 +150,12 @@ export const assetTranscriptionFailureSchema = z.object({
 
 export const assetSchema = z.object({
 	id: z.string().min(1),
-	kind: z.literal("video"),
+	// Widened from a `"video"` literal when external-audio import landed (issue
+	// #350). An imported voiceover / BGM / SFX file carries no video stream, so it
+	// needs its own kind; every document written before this only ever held
+	// `"video"`, which still validates, so the widening is additive (no
+	// schemaVersion bump — same rule as `transcriptionFailure` below).
+	kind: z.enum(["video", "audio"]).default("video"),
 	label: z.string().min(1),
 	originalPath: z.string().min(1),
 	proxyPath: z.string().optional(),
@@ -471,6 +476,73 @@ export const zoomRegionSchema = endGteStart(
 	"startMs",
 );
 
+// External audio import (issue #350) — voiceover / BGM / SFX layered over the
+// programme. Unlike zoom/speed/annotation/trim, an audio track is NOT
+// clip-anchored: it floats over the whole timeline, addressed in RAW/document
+// timeline seconds — the same clock the ruler, playhead and clip
+// `timelineStartSec`/`timelineEndSec` use, and the one `addAudioTrack` seeds from
+// the playhead. The preview positions the track on exactly this clock (see
+// `resolveTimelineAudioPlayback` in VirtualPreview). The export's OUTPUT programme
+// is trim-compressed, so the renderer maps this position to output time when
+// building the scene — an identity map when the project has no trims/speed (the
+// common case), an accepted approximation otherwise, the same way the preview
+// approximates trims by re-seeking. See `SceneAudioTrack` (sceneDescription.ts,
+// audio.rs).
+//
+// `assetId` points at an asset with `kind: "audio"`. `timelineStartSec` places
+// the track's head; `trimStartSec`/`trimEndSec` window the source file (both in
+// source seconds); `gainDb` sets its level.
+// An imported or recorded audio track (voiceover / BGM / SFX) placed on the
+// timeline (issue #350).
+//
+// CLIP-ANCHORED, on the same v5 contract as zoom/annotation: `{clipId,
+// sourceStartSec, sourceEndSec}` is the source of truth and `startMs`/`endMs`
+// is a derived ruler cache, so a track travels with the content it was placed
+// over instead of sitting still while a reorder or trim slides the programme
+// underneath it. Positions are RAW ruler ms; the export projects them onto the
+// trim-compressed programme (`projectRawTimelineSecToPlayback`).
+//
+// `offsetMs` skips INTO the source file — start the music at its chorus. It
+// replaces #502's `trimStartSec`/`trimEndSec` pair: the track's own span
+// (`startMs`..`endMs`) is where it plays, so the tail trim is implied by the
+// span and does not need storing twice. A file longer than its span is cut off
+// at the span unless `loop` is set, in which case it repeats.
+//
+// The anchor ventilates one user-visible track into one fragment PER CLIP it
+// covers. Fragments of the same track share `trackId`, and each carries its own
+// `offsetMs` advanced by the source time its predecessors consumed — see
+// `anchorAudioTrackFragments`. Without that every fragment would restart the
+// file at the same offset and re-run the fades, so a bed spanning a cut would
+// audibly restart at the boundary.
+export const audioTrackSchema = endGteStart(
+	z.object({
+		id: z.string().min(1),
+		// Shared by every fragment of one user-visible track: what the lane draws
+		// as a single pill, what the inspector edits, and what delete removes.
+		// Absent on tracks written before ventilation existed — they are their own
+		// single fragment, so `trackId ?? id` is always the group key.
+		trackId: z.string().min(1).optional(),
+		startMs: z.number().nonnegative(),
+		endMs: z.number().nonnegative(),
+		...clipAnchorShape,
+		assetId: z.string().min(1),
+		kind: z.enum(["voiceover", "music"]).default("music"),
+		// Full source duration of the underlying file, cached here so the timeline
+		// can lay out the pill before the asset is re-probed on load.
+		durationSec: z.number().nonnegative().default(0),
+		offsetMs: z.number().int().nonnegative().default(0),
+		gainDb: z.number().min(-60).max(12).default(0),
+		loop: z.boolean().default(false),
+		fadeInMs: z.number().int().nonnegative().default(0),
+		fadeOutMs: z.number().int().nonnegative().default(0),
+		muted: z.boolean().default(false),
+		label: z.string().default(""),
+		origin: z.enum(["system", "agent", "user"]).default("user"),
+	}),
+	"endMs",
+	"startMs",
+);
+
 // Legacy OpenScreen appearance / export settings that the v3 schema doesn't
 // normalize into the timeline / assets model. They are applied at export time
 // by the existing pipeline (see technical-documentation/architecture/document-model.md).
@@ -503,6 +575,9 @@ const documentSchemaShape = z.object({
 	}),
 	annotations: z.array(annotationRegionSchema).default([]),
 	zoomRanges: z.array(zoomRegionSchema).default([]),
+	// Imported audio tracks (issue #350). Defaulted so every document written
+	// before this loads unchanged; an older build simply strips the key on save.
+	audioTracks: z.array(audioTrackSchema).default([]),
 	legacyEditor: legacyEditorSchema.nullable().default(null),
 });
 
@@ -803,6 +878,10 @@ export const createProjectInputSchema = z.object({
 export const addAssetInputSchema = z.object({
 	path: z.string().trim().min(1),
 	label: z.string().trim().optional(),
+	// "audio" imports an external voiceover / BGM / SFX file (issue #350); it has
+	// no video stream and never becomes the project's primary asset. Defaults to
+	// "video" so every existing caller keeps its current behaviour.
+	kind: z.enum(["video", "audio"]).default("video"),
 	autoTranscribe: z.boolean().default(true),
 });
 
@@ -942,6 +1021,7 @@ export type AxcutTimelineOperation = z.infer<typeof timelineOperationSchema>;
 export type AxcutAnnotationRegion = z.infer<typeof annotationRegionSchema>;
 export type AxcutZoomRegion = z.infer<typeof zoomRegionSchema>;
 export type AxcutCameraTrack = z.infer<typeof cameraTrackSchema>;
+export type AxcutAudioTrack = z.infer<typeof audioTrackSchema>;
 export type AxcutLegacyEditor = z.infer<typeof legacyEditorSchema>;
 export type AxcutDocument = z.infer<typeof documentSchema>;
 export type AxcutDocumentInput = z.input<typeof documentSchema>;
@@ -977,6 +1057,7 @@ export function createEmptyDocument(
 		},
 		annotations: [],
 		zoomRanges: [],
+		audioTracks: [],
 		legacyEditor: null,
 	});
 }
@@ -984,3 +1065,40 @@ export function createEmptyDocument(
 export function ensureDocument(value: unknown): AxcutDocument {
 	return documentSchema.parse(value);
 }
+
+/**
+ * Build a timeline audio track for an imported or recorded audio asset
+ * (issue #350). The head is placed at `timelineStartSec` (RAW/document timeline
+ * seconds — the same clock the ruler, playhead and clip `timelineStartSec` use,
+ * NOT the trim-compressed output programme; the export projects it with
+ * `projectRawTimelineSecToPlayback`) and the track spans the whole source file
+ * unless the caller asks for a shorter `spanSec`. Parsed through the schema so
+ * every default (gain, fades, loop) is applied in one place.
+ *
+ * The result is UNANCHORED — `clipId` is absent. Callers place it through
+ * `anchorAudioTrackFragments`, which ventilates it across the clips it covers.
+ */
+export function createAudioTrack(input: {
+	assetId: string;
+	durationSec: number;
+	kind?: "voiceover" | "music";
+	/** Raw ruler head. The span runs from here for `durationSec`, or for
+	 *  `spanSec` when the caller wants a shorter placement than the file. */
+	timelineStartSec?: number;
+	spanSec?: number;
+	label?: string;
+}): AxcutAudioTrack {
+	const startMs = Math.round(Math.max(0, input.timelineStartSec ?? 0) * 1000);
+	// A track with no measurable source still needs a visible span, or the pill
+	// is zero-width and cannot be grabbed to fix.
+	const spanMs = Math.max(1, Math.round((input.spanSec ?? input.durationSec) * 1000));
+	return audioTrackSchema.parse({
+		id: createId("audio"),
+		assetId: input.assetId,
+		kind: input.kind ?? "music",
+		durationSec: input.durationSec,
+		startMs,
+		endMs: startMs + spanMs,
+		label: input.label ?? "",
+	});
+}
diff --git a/src/lib/ai-edition/store/documentWriteAudit.test.ts b/src/lib/ai-edition/store/documentWriteAudit.test.ts
index 6a76e8013..6af03cd04 100644
--- a/src/lib/ai-edition/store/documentWriteAudit.test.ts
+++ b/src/lib/ai-edition/store/documentWriteAudit.test.ts
@@ -134,7 +134,8 @@ const DECLARED: WritePath[] = [
 	// "Save" chosen on the way out of Ctrl+N and Ctrl+O.
 	w("src/components/ai-edition/NewEditorShell.tsx", "onKey", "save", "gesture"),
 	w("src/components/ai-edition/NewEditorShell.tsx", "onKey", "save", "gesture"),
-	// Ctrl+V of a copied region: zoom, annotation, or a legacy span.
+	// Ctrl+V of a copied region: an audio track, zoom, annotation, or a legacy span.
+	w("src/components/ai-edition/NewEditorShell.tsx", "pasteRegion", "save", "gesture"),
 	w("src/components/ai-edition/NewEditorShell.tsx", "pasteRegion", "save", "gesture"),
 	w("src/components/ai-edition/NewEditorShell.tsx", "pasteRegion", "save", "gesture"),
 	w("src/components/ai-edition/NewEditorShell.tsx", "pasteRegion", "save", "gesture"),
@@ -168,6 +169,12 @@ const DECLARED: WritePath[] = [
 	// Linking the camera track found next to a newly added asset. Part of the
 	// import, not an edit of its own.
 	w("src/lib/ai-edition/store/projectStore.ts", "addAsset", "save", "automatic"),
+	// Folding an imported audio file's probed duration onto its asset (issue #350).
+	// Part of the import, like the camera link above — not an edit of its own.
+	w("src/lib/ai-edition/store/projectStore.ts", "addAudioAsset", "save", "automatic"),
+	// Placing an imported audio track on the timeline. The user asked for it, via the
+	// media panel's "Import audio" or the timeline.
+	w("src/lib/ai-edition/store/projectStore.ts", "addAudioTrack", "save", "gesture"),
 	// THE round-3 fix. This is the shape that defeated round 2: a store action that
 	// writes on someone else's behalf. It forwards now, so its callers decide.
 	w("src/lib/ai-edition/store/projectStore.ts", "replaceTimeline", "save", "forwarded"),
@@ -234,6 +241,18 @@ const DECLARED: WritePath[] = [
 	w("src/lib/ai-edition/store/useTimeline.ts", "duplicateClip", "save", "gesture"),
 	w("src/lib/ai-edition/store/useTimeline.ts", "insertClipAt", "save", "gesture"),
 	w("src/lib/ai-edition/store/useTimeline.ts", "moveClip", "save", "gesture"),
+	// Timeline audio tracks (issue #350). Each is a direct user edit — drag or resize
+	// the track (placeAudioTrack), change its payload (updateAudioTrack, which
+	// setAudioTrackGain routes through), or delete it — one undo step apiece.
+	w("src/lib/ai-edition/store/useTimeline.ts", "placeAudioTrack", "save", "gesture"),
+	w("src/lib/ai-edition/store/useTimeline.ts", "removeAudioTrack", "save", "gesture"),
+	// Three exits, one gesture: the toggle writes the flag alone when there is
+	// nothing to fill, and the flag plus the filled span when there is. Either
+	// way it is one undo step (see setAudioTrackLoop).
+	w("src/lib/ai-edition/store/useTimeline.ts", "setAudioTrackLoop", "save", "gesture"),
+	w("src/lib/ai-edition/store/useTimeline.ts", "setAudioTrackLoop", "save", "gesture"),
+	w("src/lib/ai-edition/store/useTimeline.ts", "setAudioTrackLoop", "save", "gesture"),
+	w("src/lib/ai-edition/store/useTimeline.ts", "updateAudioTrack", "save", "gesture"),
 	// The round-2 defect: a background duration probe every freshly imported asset
 	// fires, because `addAsset` never populates `durationSec`.
 	w("src/lib/ai-edition/store/useTimeline.ts", "probeAndCorrectClip", "save", "automatic"),
@@ -256,6 +275,9 @@ const DECLARED: WritePath[] = [
 	// Source-dimension backfill for assets a migration left unprobed. On load, for
 	// every project, whether or not the user touches anything.
 	w("src/lib/ai-edition/store/useTimeline.ts", "useTimeline", "save", "automatic"),
+	// Audio-duration backfill (issue #350) — the same on-load, un-asked-for probe
+	// for imported audio assets whose duration didn't stamp at import.
+	w("src/lib/ai-edition/store/useTimeline.ts", "useTimeline", "save", "automatic"),
 ];
 
 function w(
diff --git a/src/lib/ai-edition/store/editorSettings.test.ts b/src/lib/ai-edition/store/editorSettings.test.ts
index d7cfdfcf4..ec37d7176 100644
--- a/src/lib/ai-edition/store/editorSettings.test.ts
+++ b/src/lib/ai-edition/store/editorSettings.test.ts
@@ -29,6 +29,7 @@ const baseDoc: AxcutDocument = {
 	},
 	annotations: [],
 	zoomRanges: [],
+	audioTracks: [],
 	transcripts: [],
 	transcript: null,
 	legacyEditor: null,
diff --git a/src/lib/ai-edition/store/projectStore.test.ts b/src/lib/ai-edition/store/projectStore.test.ts
index a46a6b535..2b75f0a04 100644
--- a/src/lib/ai-edition/store/projectStore.test.ts
+++ b/src/lib/ai-edition/store/projectStore.test.ts
@@ -16,6 +16,17 @@ const toastMocks = vi.hoisted(() => ({
 	error: vi.fn(),
 }));
 
+// Stub only the audio duration probe (issue #350): mounting a real <audio> in
+// jsdom never fires loadedmetadata, so an unmocked probe would block on its
+// timeout. Everything else in the module (probeVideoDimensions) stays real so
+// the video-import tests above are untouched.
+const durationMocks = vi.hoisted(() => ({ probeAudioDuration: vi.fn() }));
+
+vi.mock("../timeline/duration", async (importOriginal) => ({
+	...(await importOriginal<typeof import("../timeline/duration")>()),
+	probeAudioDuration: durationMocks.probeAudioDuration,
+}));
+
 vi.mock("@/native/client", () => ({
 	nativeBridgeClient: {
 		aiEdition: {
@@ -62,6 +73,7 @@ const sampleDoc = {
 	},
 	annotations: [],
 	zoomRanges: [],
+	audioTracks: [],
 	legacyEditor: null,
 };
 
@@ -72,6 +84,7 @@ describe("useProjectStore", () => {
 			mock.mockReset();
 		}
 		toastMocks.error.mockReset();
+		durationMocks.probeAudioDuration.mockReset();
 		// biome-ignore lint/suspicious/noExplicitAny: test-only stub of the legacy contextBridge surface
 		(window as any).electronAPI = { findRecordingCamera: vi.fn() };
 	});
@@ -298,6 +311,147 @@ describe("useProjectStore", () => {
 		expect(toastMocks.error.mock.calls[0][0]).toContain("video.mp4");
 	});
 
+	// Issue #350 — external audio import.
+	it("addAudioAsset passes kind 'audio', skips the camera lookup, and returns the asset", async () => {
+		useProjectStore.setState({
+			projectId: "proj_test",
+			document: sampleDoc,
+			revision: 1,
+			status: "ready",
+			error: null,
+		});
+		durationMocks.probeAudioDuration.mockResolvedValue(null);
+		const audioDoc = {
+			...sampleDoc,
+			assets: [
+				{ id: "audio_asset", kind: "audio", label: "voiceover.mp3", originalPath: "/tmp/vo.mp3" },
+			],
+		};
+		bridgeMocks.addAsset.mockResolvedValue({ assetId: "audio_asset", document: audioDoc });
+
+		const asset = await useProjectStore.getState().addAudioAsset("/tmp/vo.mp3");
+
+		expect(asset?.id).toBe("audio_asset");
+		expect(asset?.kind).toBe("audio");
+		// The bridge must be told this is an audio import (4th arg).
+		expect(bridgeMocks.addAsset).toHaveBeenCalledWith(
+			"proj_test",
+			"/tmp/vo.mp3",
+			undefined,
+			"audio",
+		);
+		// Audio has no camera sidecar — the lookup that addAsset does must not run.
+		expect(vi.mocked(window.electronAPI.findRecordingCamera)).not.toHaveBeenCalled();
+		// Probe returned null, so nothing to stamp: no extra save.
+		expect(bridgeMocks.save).not.toHaveBeenCalled();
+	});
+
+	it("addAudioAsset stamps the probed duration onto the asset", async () => {
+		useProjectStore.setState({
+			projectId: "proj_test",
+			document: sampleDoc,
+			revision: 1,
+			status: "ready",
+			error: null,
+		});
+		durationMocks.probeAudioDuration.mockResolvedValue(8.25);
+		const audioDoc = {
+			...sampleDoc,
+			assets: [
+				{ id: "audio_asset", kind: "audio", label: "bgm.wav", originalPath: "/tmp/bgm.wav" },
+			],
+		};
+		bridgeMocks.addAsset.mockResolvedValue({ assetId: "audio_asset", document: audioDoc });
+		bridgeMocks.save.mockImplementation((document: unknown) =>
+			Promise.resolve({ success: true, document }),
+		);
+
+		const asset = await useProjectStore.getState().addAudioAsset("/tmp/bgm.wav");
+
+		expect(asset?.durationSec).toBe(8.25);
+		expect(bridgeMocks.save).toHaveBeenCalledTimes(1);
+		expect(useProjectStore.getState().document?.assets[0]?.durationSec).toBe(8.25);
+	});
+
+	// Placement + selection for imported audio tracks (issue #350).
+	const audioAsset = {
+		id: "audio_1",
+		kind: "audio" as const,
+		label: "voiceover.mp3",
+		originalPath: "/tmp/vo.mp3",
+		durationSec: 12,
+		cameraTrack: null,
+	};
+
+	it("addAudioTrack places a track at the playhead for an audio asset and selects it", async () => {
+		useProjectStore.setState({
+			projectId: "proj_test",
+			document: { ...sampleDoc, assets: [audioAsset] },
+			revision: 1,
+			status: "ready",
+			error: null,
+			currentTimeSec: 5,
+		});
+		bridgeMocks.save.mockImplementation((document: unknown) =>
+			Promise.resolve({ success: true, document }),
+		);
+
+		const id = await useProjectStore.getState().addAudioTrack("audio_1");
+
+		const tracks = useProjectStore.getState().document?.audioTracks ?? [];
+		expect(tracks).toHaveLength(1);
+		// Head at the playhead (5s), in raw ruler ms.
+		expect(tracks[0]).toMatchObject({ assetId: "audio_1", startMs: 5000, durationSec: 12 });
+		expect(id).toBe(tracks[0]?.id);
+		// Placing a track selects it so the inspector opens on its controls.
+		expect(useProjectStore.getState().selectedAudioTrackId).toBe(id);
+	});
+
+	it("addAudioTrack refuses a non-audio (or unknown) asset and selects nothing", async () => {
+		useProjectStore.setState({
+			projectId: "proj_test",
+			document: sampleDoc, // its only asset, if any, is not audio
+			revision: 1,
+			status: "ready",
+			error: null,
+		});
+		expect(await useProjectStore.getState().addAudioTrack("nope")).toBeNull();
+		expect(useProjectStore.getState().selectedAudioTrackId).toBeNull();
+	});
+
+	it("importAudioAsset adds the asset then places and selects a track in one action", async () => {
+		useProjectStore.setState({
+			projectId: "proj_test",
+			document: sampleDoc,
+			revision: 1,
+			status: "ready",
+			error: null,
+			currentTimeSec: 0,
+		});
+		durationMocks.probeAudioDuration.mockResolvedValue(12);
+		bridgeMocks.addAsset.mockResolvedValue({
+			assetId: "audio_1",
+			document: { ...sampleDoc, assets: [audioAsset] },
+		});
+		bridgeMocks.save.mockImplementation((document: unknown) =>
+			Promise.resolve({ success: true, document }),
+		);
+
+		const asset = await useProjectStore.getState().importAudioAsset("/tmp/vo.mp3");
+
+		expect(asset?.id).toBe("audio_1");
+		const tracks = useProjectStore.getState().document?.audioTracks ?? [];
+		expect(tracks).toHaveLength(1);
+		expect(tracks[0]?.assetId).toBe("audio_1");
+		expect(useProjectStore.getState().selectedAudioTrackId).toBe(tracks[0]?.id);
+	});
+
+	it("clear() resets the audio-track selection", () => {
+		useProjectStore.setState({ selectedAudioTrackId: "audio_x" });
+		useProjectStore.getState().clear();
+		expect(useProjectStore.getState().selectedAudioTrackId).toBeNull();
+	});
+
 	// The save boundary. Every write in the app funnels through `saveDocument`, and
 	// almost every caller `void`s it from a click handler, so what this function does
 	// with a failure IS what the user sees.
diff --git a/src/lib/ai-edition/store/projectStore.ts b/src/lib/ai-edition/store/projectStore.ts
index 48dad73e2..cd2b0e91e 100644
--- a/src/lib/ai-edition/store/projectStore.ts
+++ b/src/lib/ai-edition/store/projectStore.ts
@@ -3,9 +3,11 @@ import { create } from "zustand";
 import { toFileUrl } from "@/components/video-editor/projectPersistence";
 import { toastText } from "@/i18n/toastText";
 import { nativeBridgeClient } from "@/native/client";
+import { anchorAudioTrackFragments } from "../document/audioTracks";
+import { createId } from "../document/ids";
 import { type Interval, replaceTimeline as replaceTimelineOp } from "../document/timeline";
-import { type AxcutAsset, type AxcutDocument, documentSchema } from "../schema";
-import { probeVideoDimensions } from "../timeline/duration";
+import { type AxcutAsset, type AxcutDocument, createAudioTrack, documentSchema } from "../schema";
+import { probeAudioDuration, probeVideoDimensions } from "../timeline/duration";
 import { clearHistory, currentWriteEpoch, pushHistory } from "./undoStack";
 
 // ponytail: thin Zustand wrapper over the native-bridge client. Keeps the
@@ -58,6 +60,11 @@ export interface ProjectState {
 	error: string | null;
 	sourceDurationSec: number;
 	currentTimeSec: number;
+	/** The selected imported audio track (issue #350), or null. In the store — not
+	 *  `useTimeline`'s local selection — because the media panel (which imports the
+	 *  file) and the inspector (which edits it) sit in different component subtrees
+	 *  and both need to read/set it; the region/clip selection stays hook-local. */
+	selectedAudioTrackId: string | null;
 	/** Single source of truth for "is the timeline transport playing?" — previously
 	 *  duplicated as separate local state in NewEditorShell AND VirtualPreview, each
 	 *  independently wired to the same raw <video> DOM events, which let one advance
@@ -72,6 +79,37 @@ export interface ProjectState {
 	createProject: (title: string) => Promise<AxcutDocument>;
 	refresh: () => Promise<void>;
 	addAsset: (path: string, label?: string) => Promise<AxcutAsset | null>;
+	/**
+	 * Import an external audio file (voiceover / BGM / SFX) as a `kind: "audio"`
+	 * asset — issue #350. Unlike {@link addAsset} it never looks for a camera
+	 * sidecar, and it probes the file's duration up front so the timeline can lay
+	 * out its track (added separately, see the timeline store). Returns the added
+	 * asset, or null if the write was superseded.
+	 */
+	addAudioAsset: (path: string, label?: string) => Promise<AxcutAsset | null>;
+	/**
+	 * One-shot "Import audio" for the media panel (issue #350): {@link addAudioAsset}
+	 * then place a track for it at the current playhead and select it, so the file
+	 * lands visibly on the timeline in a single user action. Returns the asset (or
+	 * null if the import was superseded). The timeline's own {@link addAudioTrack}
+	 * covers placing an already-imported asset.
+	 */
+	importAudioAsset: (path: string, label?: string) => Promise<AxcutAsset | null>;
+	/** Place a track for an already-imported audio asset at `timelineStartSec`
+	 *  (default: the playhead) and select it. Returns the new track id, or null. */
+	addAudioTrack: (
+		assetId: string,
+		timelineStartSec?: number,
+		options?: {
+			kind?: "voiceover" | "music";
+			/** Real source duration, when the caller measured it (a fresh recording
+			 *  knows its own length before the asset is probed). */
+			durationSec?: number;
+			/** Timeline span, when it should differ from the source duration. */
+			spanSec?: number;
+		},
+	) => Promise<string | null>;
+	setSelectedAudioTrackId: (id: string | null) => void;
 	removeAsset: (assetId: string) => Promise<void>;
 	/**
 	 * Write the document to disk. Resolves `true` when it took effect, `false` when it
@@ -159,6 +197,7 @@ export const useProjectStore = create<ProjectState>((set, get) => ({
 	error: null,
 	sourceDurationSec: 0,
 	currentTimeSec: 0,
+	selectedAudioTrackId: null,
 	playing: false,
 	dirty: false,
 	lastSavedAt: null,
@@ -179,6 +218,7 @@ export const useProjectStore = create<ProjectState>((set, get) => ({
 				error: null,
 				dirty: false,
 				lastSavedAt: new Date(),
+				selectedAudioTrackId: null,
 			});
 			clearHistory();
 		} catch (error) {
@@ -325,6 +365,97 @@ export const useProjectStore = create<ProjectState>((set, get) => ({
 		return addedAsset;
 	},
 
+	async addAudioAsset(path, label) {
+		const { projectId } = get();
+		if (!projectId) throw new Error("No project loaded");
+		// Same superseded guard as addAsset: the native add, a duration probe and a
+		// save all await, and a project switch / clear can land in between.
+		const epoch = currentWriteEpoch();
+		const superseded = () => get().projectId !== projectId || currentWriteEpoch() !== epoch;
+		const result = await nativeBridgeClient.aiEdition.addAsset(projectId, path, label, "audio");
+		if (superseded()) return null;
+		let document = parseDocument(result.document);
+		const addedAsset =
+			document.assets.find(
+				(a) => a.kind === "audio" && a.originalPath === path && (label ? a.label === label : true),
+			) ??
+			document.assets.at(-1) ??
+			null;
+		if (!addedAsset) return null;
+
+		// Probe the real length so the timeline can size the track pill immediately
+		// on add. Non-fatal: an unreadable file just leaves durationSec unset and the
+		// track store falls back to a placeholder. No camera lookup — audio has none.
+		const durationSec = await probeAudioDuration(toFileUrl(addedAsset.originalPath)).catch(
+			() => null,
+		);
+		if (superseded()) return null;
+		if (durationSec != null) {
+			const next: AxcutDocument = {
+				...document,
+				assets: document.assets.map((a) => (a.id === addedAsset.id ? { ...a, durationSec } : a)),
+			};
+			// history: false — probing a duration is part of the import, not an edit
+			// of its own, so it must not become the thing the next Ctrl+Z reverses.
+			if (await get().saveDocument(next, { history: false })) document = parseDocument(next);
+		}
+
+		if (superseded()) return null;
+		set({
+			document,
+			revision: get().revision + 1,
+			dirty: false,
+			lastSavedAt: new Date(),
+		});
+		return document.assets.find((a) => a.id === addedAsset.id) ?? addedAsset;
+	},
+
+	setSelectedAudioTrackId(id) {
+		set({ selectedAudioTrackId: id });
+	},
+
+	async addAudioTrack(assetId, timelineStartSec, options) {
+		const document = get().document;
+		if (!document) return null;
+		const asset = document.assets.find((a) => a.id === assetId);
+		if (!asset || asset.kind !== "audio") return null;
+		const track = createAudioTrack({
+			assetId,
+			durationSec: options?.durationSec ?? asset.durationSec ?? 0,
+			kind: options?.kind,
+			spanSec: options?.spanSec,
+			// Default to the playhead (RAW/document timeline seconds — the clock the
+			// ruler and playhead use, NOT the trim-compressed output programme),
+			// matching the timeline hook's placement. A voiceover passes the playhead
+			// captured when RECORDING STARTED — by the time the take ends the live
+			// playhead has run on by the take's own length.
+			timelineStartSec: timelineStartSec ?? get().currentTimeSec,
+			label: asset.label,
+		});
+		// Anchor before saving: the track becomes one fragment per clip it covers,
+		// each picking the source up where the previous one left off.
+		const fragments = anchorAudioTrackFragments(track, document.timeline.clips, () =>
+			createId("audio"),
+		);
+		if (fragments.length === 0) return null;
+		const next = { ...document, audioTracks: [...document.audioTracks, ...fragments] };
+		if (!(await get().saveDocument(next, { history: true }))) return null;
+		set({ selectedAudioTrackId: track.id });
+		return track.id;
+	},
+
+	async importAudioAsset(path, label) {
+		const asset = await get().addAudioAsset(path, label);
+		if (!asset) return null;
+		// addAudioAsset already committed the asset (with its probed duration), so
+		// the current document is the one to place the track on. If the placement
+		// write fails or is superseded, the import did NOT succeed as a one-shot —
+		// report failure rather than claim success with an asset but no track.
+		const trackId = await get().addAudioTrack(asset.id);
+		if (!trackId) return null;
+		return asset;
+	},
+
 	async removeAsset(assetId) {
 		const { projectId } = get();
 		if (!projectId) throw new Error("No project loaded");
@@ -451,6 +582,7 @@ export const useProjectStore = create<ProjectState>((set, get) => ({
 			error: null,
 			sourceDurationSec: 0,
 			currentTimeSec: 0,
+			selectedAudioTrackId: null,
 			playing: false,
 			dirty: false,
 			lastSavedAt: null,
diff --git a/src/lib/ai-edition/store/regionClipboard.ts b/src/lib/ai-edition/store/regionClipboard.ts
index ef1116ff8..f0d6d7d10 100644
--- a/src/lib/ai-edition/store/regionClipboard.ts
+++ b/src/lib/ai-edition/store/regionClipboard.ts
@@ -11,6 +11,10 @@ export type RegionSnapshot =
 	| { kind: "annotation"; region: Record<string, unknown> }
 	| { kind: "speed"; region: Record<string, unknown> }
 	| { kind: "cameraFullscreen"; region: Record<string, unknown> }
+	// An audio track copies its whole payload (asset, gain, fades, loop) so a
+	// paste is a second placement of the same audio, like every other kind. The
+	// snapshot is the COLLAPSED pill, never a stored fragment.
+	| { kind: "audio"; region: Record<string, unknown> }
 	// A trim carries no user-visible properties, so all there is to copy is how
 	// LONG it was — `{ durationSec }`. That is not a special case so much as the
 	// general one made obvious: every paste keeps the copied properties and takes
diff --git a/src/lib/ai-edition/store/undo.modalGuard.test.tsx b/src/lib/ai-edition/store/undo.modalGuard.test.tsx
index f54b12389..46e083b0b 100644
--- a/src/lib/ai-edition/store/undo.modalGuard.test.tsx
+++ b/src/lib/ai-edition/store/undo.modalGuard.test.tsx
@@ -35,6 +35,7 @@ function doc(title: string): AxcutDocument {
 		},
 		annotations: [],
 		zoomRanges: [],
+		audioTracks: [],
 		legacyEditor: null,
 	};
 }
diff --git a/src/lib/ai-edition/store/useCaptions.test.ts b/src/lib/ai-edition/store/useCaptions.test.ts
index b4063d68c..0cd641328 100644
--- a/src/lib/ai-edition/store/useCaptions.test.ts
+++ b/src/lib/ai-edition/store/useCaptions.test.ts
@@ -71,6 +71,7 @@ const docA: AxcutDocument = {
 	},
 	annotations: [],
 	zoomRanges: [],
+	audioTracks: [],
 	legacyEditor: null,
 };
 
diff --git a/src/lib/ai-edition/store/useEditorSettings.test.ts b/src/lib/ai-edition/store/useEditorSettings.test.ts
index bd47cb452..4122c05bf 100644
--- a/src/lib/ai-edition/store/useEditorSettings.test.ts
+++ b/src/lib/ai-edition/store/useEditorSettings.test.ts
@@ -74,6 +74,7 @@ const docA: AxcutDocument = {
 	},
 	annotations: [],
 	zoomRanges: [],
+	audioTracks: [],
 	legacyEditor: null,
 };
 
diff --git a/src/lib/ai-edition/store/useTimeline.test.ts b/src/lib/ai-edition/store/useTimeline.test.ts
index 78854e817..7b77e9c46 100644
--- a/src/lib/ai-edition/store/useTimeline.test.ts
+++ b/src/lib/ai-edition/store/useTimeline.test.ts
@@ -20,6 +20,7 @@ const probeVideoDurationMock = vi.hoisted(() => vi.fn());
 const probeVideoDimensionsMock = vi.hoisted(() =>
 	vi.fn().mockResolvedValue({ width: 1920, height: 1080 }),
 );
+const probeAudioDurationMock = vi.hoisted(() => vi.fn().mockResolvedValue(null));
 const toastErrorMock = vi.hoisted(() => vi.fn());
 
 vi.mock("sonner", () => ({ toast: { error: toastErrorMock } }));
@@ -30,6 +31,7 @@ vi.mock("../timeline/duration", async (importOriginal) => {
 		...actual,
 		probeVideoDuration: probeVideoDurationMock,
 		probeVideoDimensions: probeVideoDimensionsMock,
+		probeAudioDuration: probeAudioDurationMock,
 	};
 });
 
@@ -110,6 +112,7 @@ const sampleDoc: AxcutDocument = {
 	},
 	annotations: [],
 	zoomRanges: [],
+	audioTracks: [],
 	legacyEditor: null,
 };
 
@@ -1285,3 +1288,308 @@ describe("useTimeline drag snapshots", () => {
 		expect(useProjectStore.getState().document?.annotations[0].content).toBe("before");
 	});
 });
+
+// Issue #350 — imported audio tracks. The hook wraps the pure ops in
+// document/audioTracks.ts (unit-tested separately); these cover the wiring:
+// asset lookup, playhead placement, the save, and undo.
+describe("useTimeline audio tracks", () => {
+	const audioDoc: AxcutDocument = {
+		...sampleDoc,
+		assets: [
+			...sampleDoc.assets,
+			{
+				id: "audio_1",
+				kind: "audio",
+				label: "voiceover.mp3",
+				originalPath: "/tmp/vo.mp3",
+				durationSec: 30,
+				cameraTrack: null,
+			},
+		],
+	};
+
+	beforeEach(() => {
+		useProjectStore.getState().clear();
+		clearHistory();
+		for (const mock of Object.values(bridgeMocks)) mock.mockReset();
+		probeAudioDurationMock.mockReset();
+		probeAudioDurationMock.mockResolvedValue(null);
+		bridgeMocks.save.mockImplementation(async (doc: typeof sampleDoc) => ({
+			success: true,
+			document: doc,
+		}));
+		useProjectStore.setState({
+			projectId: "proj_test",
+			document: audioDoc,
+			revision: 1,
+			status: "ready",
+			error: null,
+			currentTimeSec: 4,
+		});
+	});
+
+	afterEach(() => {
+		vi.clearAllMocks();
+	});
+
+	it("addAudioTrack places a track for the asset at the playhead and returns its id", async () => {
+		const { result } = renderTimeline();
+		let id: string | null = null;
+		await act(async () => {
+			id = await result.current.addAudioTrack("audio_1");
+		});
+		const tracks = useProjectStore.getState().document?.audioTracks ?? [];
+		expect(tracks).toHaveLength(1);
+		expect(id).toBe(tracks[0]?.id);
+		expect(tracks[0]).toMatchObject({
+			assetId: "audio_1",
+			durationSec: 30,
+			// Head at the playhead (4s), span the source's own length.
+			startMs: 4000,
+			label: "voiceover.mp3",
+		});
+	});
+
+	it("addAudioTrack refuses a non-audio (or unknown) asset", async () => {
+		const { result } = renderTimeline();
+		let videoId: string | null = "x";
+		let missingId: string | null = "x";
+		await act(async () => {
+			videoId = await result.current.addAudioTrack("asset_1"); // a video asset
+			missingId = await result.current.addAudioTrack("nope");
+		});
+		expect(videoId).toBeNull();
+		expect(missingId).toBeNull();
+		expect(useProjectStore.getState().document?.audioTracks).toEqual([]);
+	});
+
+	it("place / gain update the track and each is one undo step", async () => {
+		const { result } = renderTimeline();
+		let id = "";
+		await act(async () => {
+			id = (await result.current.addAudioTrack("audio_1", 2)) ?? "";
+		});
+		// A lane drag commits the whole span in one write and re-ventilates it.
+		await act(async () => {
+			await result.current.placeAudioTrack(id, { startMs: 3000, endMs: 8000 });
+		});
+		await act(async () => {
+			await result.current.setAudioTrackGain(id, -6);
+		});
+
+		const track = useProjectStore.getState().document?.audioTracks[0];
+		expect(track).toMatchObject({
+			startMs: 3000,
+			endMs: 8000,
+			gainDb: -6,
+		});
+
+		// Three writes (add + place + gain) → the gain edit undoes first.
+		act(() => {
+			expect(undo()).toBe(true);
+		});
+		expect(useProjectStore.getState().document?.audioTracks[0]?.gainDb).toBe(0);
+	});
+
+	it("clamps a track to the content under it, like every other anchored region", async () => {
+		// The sample timeline is one 0..10s clip. A track dragged past the end has
+		// nothing to anchor to out there — and the exported programme stops at the
+		// last clip regardless — so the span is cut at the content, not stored
+		// hanging off the end where it could never play.
+		const { result } = renderTimeline();
+		let id = "";
+		await act(async () => {
+			id = (await result.current.addAudioTrack("audio_1", 2)) ?? "";
+		});
+		await act(async () => {
+			await result.current.placeAudioTrack(id, { startMs: 9000, endMs: 16_000 });
+		});
+		const track = useProjectStore.getState().document?.audioTracks[0];
+		expect(track).toMatchObject({ startMs: 9000, endMs: 10_000 });
+	});
+
+	it("turning loop on fills the rest of the programme, in one undo step", async () => {
+		// Looping only means anything when the span exceeds the source, so a toggle
+		// that changed nothing else did nothing at all. The sample timeline is one
+		// 0..10s clip and the asset is 30s, so the track is created 2..10 (clamped
+		// to the content) and filling is a no-op — place it short first.
+		const { result } = renderTimeline();
+		let id = "";
+		await act(async () => {
+			id = (await result.current.addAudioTrack("audio_1", 2)) ?? "";
+		});
+		await act(async () => {
+			await result.current.placeAudioTrack(id, { startMs: 2000, endMs: 4000 });
+		});
+		await act(async () => {
+			await result.current.setAudioTrackLoop(id, true);
+		});
+		const tracks = useProjectStore.getState().document?.audioTracks ?? [];
+		expect(tracks[0]).toMatchObject({ startMs: 2000, endMs: 10_000, loop: true });
+
+		// One step: the flag and the fill undo together.
+		act(() => {
+			expect(undo()).toBe(true);
+		});
+		const back = useProjectStore.getState().document?.audioTracks[0];
+		expect(back).toMatchObject({ endMs: 4000, loop: false });
+	});
+
+	it("turning loop off leaves the span alone", async () => {
+		// Shrinking back would throw away a length the user may have set by hand.
+		const { result } = renderTimeline();
+		let id = "";
+		await act(async () => {
+			id = (await result.current.addAudioTrack("audio_1", 2)) ?? "";
+		});
+		await act(async () => {
+			await result.current.setAudioTrackLoop(id, true);
+		});
+		const filled = useProjectStore.getState().document?.audioTracks[0]?.endMs;
+		await act(async () => {
+			await result.current.setAudioTrackLoop(id, false);
+		});
+		const track = useProjectStore.getState().document?.audioTracks[0];
+		expect(track?.loop).toBe(false);
+		expect(track?.endMs).toBe(filled);
+	});
+
+	it("removeAudioTrack deletes the track", async () => {
+		const { result } = renderTimeline();
+		let id = "";
+		await act(async () => {
+			id = (await result.current.addAudioTrack("audio_1")) ?? "";
+		});
+		await act(async () => {
+			await result.current.removeAudioTrack(id);
+		});
+		expect(useProjectStore.getState().document?.audioTracks).toEqual([]);
+	});
+
+	// #350: the toolbar button and the `M` shortcut both call `tl.addAudio`, which opens
+	// the OS file picker and hands the result to `importAudioAsset`. Spy on the store's
+	// import so these assert the wiring (picker → import), not the import itself.
+	it("addAudio imports the picked file, and is a no-op when the picker is cancelled", async () => {
+		const importSpy = vi.fn().mockResolvedValue(null);
+		useProjectStore.setState({ importAudioAsset: importSpy });
+		const pickerMock = vi.fn();
+		Object.defineProperty(window, "electronAPI", {
+			configurable: true,
+			value: { openAudioFilePicker: pickerMock },
+		});
+		const { result } = renderTimeline();
+
+		// Cancelled picker → nothing imported.
+		pickerMock.mockResolvedValueOnce({ success: false });
+		await act(async () => {
+			await result.current.addAudio();
+		});
+		expect(importSpy).not.toHaveBeenCalled();
+
+		// Picked a file → imported with its path and display name.
+		pickerMock.mockResolvedValueOnce({ success: true, path: "/tmp/bgm.mp3", name: "bgm.mp3" });
+		await act(async () => {
+			await result.current.addAudio();
+		});
+		expect(importSpy).toHaveBeenCalledWith("/tmp/bgm.mp3", "bgm.mp3");
+	});
+
+	it("addAudio clears region/clip selections after a successful import", async () => {
+		// importAudioAsset must resolve an asset for the success path to run.
+		useProjectStore.setState({ importAudioAsset: vi.fn().mockResolvedValue({ id: "audio_1" }) });
+		Object.defineProperty(window, "electronAPI", {
+			configurable: true,
+			value: {
+				openAudioFilePicker: vi
+					.fn()
+					.mockResolvedValue({ success: true, path: "/tmp/bgm.mp3", name: "bgm.mp3" }),
+			},
+		});
+		const { result } = renderTimeline();
+
+		// A clip selected before the import (selectClip and selectRegion are mutually
+		// exclusive, so a clip is enough to prove the import wipes the local selection)…
+		act(() => result.current.selectClip("clip_1"));
+		expect(result.current.clipSelection).toBe("clip_1");
+
+		await act(async () => {
+			await result.current.addAudio();
+		});
+		// …is gone after it (the imported track becomes the sole selection).
+		expect(result.current.selection).toBeNull();
+		expect(result.current.multiSelection).toEqual([]);
+		expect(result.current.clipSelection).toBeNull();
+	});
+
+	it("addAudio toasts when the file picker itself rejects", async () => {
+		toastErrorMock.mockClear();
+		const importSpy = vi.fn();
+		useProjectStore.setState({ importAudioAsset: importSpy });
+		Object.defineProperty(window, "electronAPI", {
+			configurable: true,
+			value: { openAudioFilePicker: vi.fn().mockRejectedValueOnce(new Error("ipc down")) },
+		});
+		const { result } = renderTimeline();
+
+		await act(async () => {
+			await result.current.addAudio();
+		});
+		// A picker rejection reaches the localized toast, not an unhandled rejection, and never
+		// attempts an import.
+		expect(importSpy).not.toHaveBeenCalled();
+		expect(toastErrorMock).toHaveBeenCalledTimes(1);
+	});
+
+	// #350 regression: a failed import-time probe leaves durationSec at 0, which
+	// makes the playback window zero-length. The on-load backfill re-probes and
+	// stamps the real duration onto the asset AND the track, so it can play again.
+	it("backfills a missing audio duration on load", async () => {
+		probeAudioDurationMock.mockResolvedValue(12.5);
+		// Asset imported with an unknown duration (probe failed), and a track that
+		// cached the resulting 0.
+		useProjectStore.setState({
+			projectId: "proj_test",
+			document: {
+				...sampleDoc,
+				assets: [
+					...sampleDoc.assets,
+					{
+						id: "audio_2",
+						kind: "audio",
+						label: "bgm.mp3",
+						originalPath: "/tmp/bgm.mp3",
+						cameraTrack: null,
+					},
+				],
+				audioTracks: [
+					{
+						id: "trk_2",
+						assetId: "audio_2",
+						kind: "music" as const,
+						startMs: 0,
+						endMs: 1,
+						durationSec: 0,
+						offsetMs: 0,
+						gainDb: 0,
+						loop: false,
+						fadeInMs: 0,
+						fadeOutMs: 0,
+						muted: false,
+						label: "bgm.mp3",
+						origin: "user" as const,
+					},
+				],
+			},
+			revision: 1,
+			status: "ready",
+			error: null,
+		});
+		renderTimeline();
+		await waitFor(() => {
+			const doc = useProjectStore.getState().document;
+			expect(doc?.assets.find((a) => a.id === "audio_2")?.durationSec).toBe(12.5);
+			expect(doc?.audioTracks[0]?.durationSec).toBe(12.5);
+		});
+		expect(probeAudioDurationMock).toHaveBeenCalledTimes(1);
+	});
+});
diff --git a/src/lib/ai-edition/store/useTimeline.ts b/src/lib/ai-edition/store/useTimeline.ts
index 7823459ec..3119869d6 100644
--- a/src/lib/ai-edition/store/useTimeline.ts
+++ b/src/lib/ai-edition/store/useTimeline.ts
@@ -4,9 +4,17 @@
 // (a reasonable default for the user to then resize).
 
 import { useCallback, useEffect, useRef, useState } from "react";
+import { toast } from "sonner";
 import { toFileUrl } from "@/components/video-editor/projectPersistence";
 import type { AnnotationRegion, AnnotationType } from "@/components/video-editor/types";
 import { useScopedT } from "@/contexts/I18nContext";
+import {
+	anchorAudioTrackFragments,
+	collapseTracksToPills,
+	patchAudioTrack,
+	removeAudioTrack as removeAudioTrackInDocument,
+	trackGroupId,
+} from "../document/audioTracks";
 import { createId } from "../document/ids";
 import {
 	duplicateClip as duplicateClipInDocument,
@@ -19,9 +27,9 @@ import {
 	resequenceClips,
 	setClipSourceRange,
 } from "../document/timeline";
-import type { AxcutClipCropRegion, AxcutDocument } from "../schema";
+import type { AxcutAudioTrack, AxcutClipCropRegion, AxcutDocument } from "../schema";
 import { hasAnyClipWithCamera } from "../timeline/camera";
-import { probeVideoDimensions, probeVideoDuration } from "../timeline/duration";
+import { probeAudioDuration, probeVideoDimensions, probeVideoDuration } from "../timeline/duration";
 import {
 	anchorRegionsWithDerivedMs,
 	dropPillsByIds,
@@ -105,6 +113,15 @@ export function useTimeline() {
 	// the Delete key operates on.
 	const [multiSelection, setMultiSelection] = useState<RegionHandle[]>([]);
 	const [clipSelection, setClipSelection] = useState<string | null>(null);
+	// The selected imported audio track (issue #350) lives in the project store —
+	// not here — because the media panel and the inspector, in different subtrees,
+	// both touch it (see projectStore). It shares "this is the thing I mean"
+	// exclusivity with the region/clip selection above, so the selects below clear
+	// it and it clears them, but it carries none of the region delete/anchor logic.
+	const selectedAudioTrackId = useProjectStore((s) => s.selectedAudioTrackId);
+	const setSelectedAudioTrackId = useProjectStore((s) => s.setSelectedAudioTrackId);
+	const storeAddAudioTrack = useProjectStore((s) => s.addAudioTrack);
+	const importAudioAsset = useProjectStore((s) => s.importAudioAsset);
 	// Pre-drag snapshots for the two optimistic paths (zoom focus, annotations), so a
 	// failed commit can put the document back instead of leaving an edit on screen that
 	// was never written.
@@ -129,6 +146,17 @@ export function useTimeline() {
 
 	const hasDoc = document !== null && projectId !== null;
 
+	// Clear a stale audio-track selection. `removeAudioTrack` clears it on an explicit
+	// delete, but an undo (or any document swap) can drop the selected track WITHOUT
+	// going through that op — and then `selectedAudioTrackId` points at nothing while the
+	// inspector stays open on an empty AudioTrackPane, recoverable only by clicking a facet.
+	useEffect(() => {
+		if (selectedAudioTrackId === null) return;
+		if (!document?.audioTracks.some((t) => trackGroupId(t) === selectedAudioTrackId)) {
+			setSelectedAudioTrackId(null);
+		}
+	}, [document, selectedAudioTrackId, setSelectedAudioTrackId]);
+
 	// Backfill missing source dimensions for any USED asset whose `video` was never probed.
 	// `probeAndCorrectClip` only populates dims on INSERT, gated on a null duration, so an asset
 	// saved with a duration but no dims (e.g. a project migrated from before dims were probed
@@ -213,6 +241,60 @@ export function useTimeline() {
 		};
 	}, [document]);
 
+	// Backfill the real duration of imported audio assets (issue #350), the audio
+	// counterpart of the dimension backfill above. `addAudioAsset` probes once at
+	// import; a transient failure (timeout, a file still being written) would
+	// otherwise leave `durationSec` at 0 forever, and a 0-length window is a track
+	// that never plays and a pill with no width. Re-probe on load — once per asset
+	// per session, success or not — and stamp both the asset AND every track that
+	// caches its duration, with `history: false` so the fix is not an undo step.
+	const probedAudioAssetIdsRef = useRef<Set<string>>(new Set());
+	useEffect(() => {
+		if (!document) return;
+		const usedAssetIds = new Set(document.audioTracks.map((t) => t.assetId));
+		const missing = document.assets.filter(
+			(a) =>
+				a.kind === "audio" &&
+				a.originalPath &&
+				usedAssetIds.has(a.id) &&
+				!(a.durationSec && a.durationSec > 0) &&
+				!probedAudioAssetIdsRef.current.has(a.id),
+		);
+		if (missing.length === 0) return;
+		// Mark every candidate BEFORE the first await. Marking each only as its turn
+		// came meant a document change that re-entered this effect while asset #1 was
+		// still awaiting found #2+ unmarked and probed them a second time.
+		for (const a of missing) probedAudioAssetIdsRef.current.add(a.id);
+		let cancelled = false;
+		void (async () => {
+			const probed: Record<string, number> = {};
+			for (const a of missing) {
+				const durationSec = await probeAudioDuration(toFileUrl(a.originalPath));
+				if (durationSec != null && durationSec > 0) probed[a.id] = durationSec;
+			}
+			if (cancelled || Object.keys(probed).length === 0) return;
+			const current = useProjectStore.getState().document;
+			if (!current) return;
+			await useProjectStore.getState().saveDocument(
+				{
+					...current,
+					assets: current.assets.map((a) =>
+						probed[a.id] ? { ...a, durationSec: probed[a.id] } : a,
+					),
+					audioTracks: current.audioTracks.map((t) =>
+						probed[t.assetId] && !(t.durationSec > 0)
+							? { ...t, durationSec: probed[t.assetId] }
+							: t,
+					),
+				},
+				{ history: false },
+			);
+		})();
+		return () => {
+			cancelled = true;
+		};
+	}, [document]);
+
 	// Every add* below anchors the new region to the clip(s) it covers before storing it.
 	// A modifier MUST own a clip anchor to survive reorder/trim (see
 	// technical-documentation/architecture/timeline-model.md) — writing only startMs/endMs
@@ -894,6 +976,7 @@ export function useTimeline() {
 		(kind: RegionKind, id: string, opts?: { additive?: boolean }) => {
 			const handle = { kind, id };
 			setClipSelection(null);
+			setSelectedAudioTrackId(null);
 			if (opts?.additive) {
 				// Shift-click toggles membership; the focused region follows the click.
 				setMultiSelection((prev) => {
@@ -906,14 +989,15 @@ export function useTimeline() {
 			setMultiSelection([handle]);
 			setSelection(handle);
 		},
-		[],
+		[setSelectedAudioTrackId],
 	);
 
 	const clearSelection = useCallback(() => {
 		setSelection(null);
 		setMultiSelection([]);
 		setClipSelection(null);
-	}, []);
+		setSelectedAudioTrackId(null);
+	}, [setSelectedAudioTrackId]);
 
 	// The Edit Clip dialog's Apply, as ONE document and ONE save.
 	//
@@ -1149,11 +1233,26 @@ export function useTimeline() {
 	);
 
 	// Mirror of selectRegion: picking a clip retires the pill selection.
-	const selectClip = useCallback((id: string) => {
-		setClipSelection(id);
-		setSelection(null);
-		setMultiSelection([]);
-	}, []);
+	const selectClip = useCallback(
+		(id: string) => {
+			setClipSelection(id);
+			setSelection(null);
+			setMultiSelection([]);
+			setSelectedAudioTrackId(null);
+		},
+		[setSelectedAudioTrackId],
+	);
+
+	// Picking an audio track retires every other selection, same exclusivity rule.
+	const selectAudioTrack = useCallback(
+		(id: string) => {
+			setSelectedAudioTrackId(id);
+			setSelection(null);
+			setMultiSelection([]);
+			setClipSelection(null);
+		},
+		[setSelectedAudioTrackId],
+	);
 
 	const speedRegions = hasDoc
 		? (((document.legacyEditor as Record<string, unknown> | null)?.speedRegions as Array<{
@@ -1173,9 +1272,177 @@ export function useTimeline() {
 			}>) ?? [])
 		: [];
 
+	// --- Timeline audio tracks (issue #350) -------------------------------------
+	// CLIP-ANCHORED like every region above: one user-visible track is one pill
+	// over one-or-more stored fragments, so these ops go through the shared pill
+	// helpers and address a track by its group id, never a fragment id.
+
+	// Place a new track for an imported audio asset, its head at the playhead (in
+	// RAW/document timeline seconds — the clock the ruler and playhead use, NOT the
+	// trim-compressed output programme the export mixes onto) unless the caller says
+	// otherwise. Delegates to the store op, which also selects the new track and
+	// returns its id (or null). On success, retire the hook-local region/clip
+	// selection so the new audio-track selection isn't held CONCURRENTLY with a
+	// stale region/clip one.
+	const addAudioTrack = useCallback(
+		async (
+			assetId: string,
+			timelineStartSec?: number,
+			options?: { kind?: "voiceover" | "music"; durationSec?: number; spanSec?: number },
+		): Promise<string | null> => {
+			const id = await storeAddAudioTrack(assetId, timelineStartSec ?? playheadSec(), options);
+			if (id) {
+				setSelection(null);
+				setMultiSelection([]);
+				setClipSelection(null);
+			}
+			return id;
+		},
+		[storeAddAudioTrack],
+	);
+
+	// Import an audio file and drop it on the timeline (issue #350). Lives here — not in
+	// the timeline toolbar — so the toolbar button and the keyboard shortcut (both call
+	// through `tl`) share one path. Opens a file picker, so unlike the region adds it takes
+	// no playhead duration; `importAudioAsset` places the track at the current playhead.
+	const addAudio = useCallback(async () => {
+		try {
+			// Inside the try so a rejected picker (an IPC failure, not a cancel) still reaches the
+			// localized toast instead of surfacing as an unhandled rejection. A cancel resolves with
+			// `success: false` and is a silent early return, not an error.
+			const picker = await window.electronAPI?.openAudioFilePicker?.();
+			if (!picker?.success || !picker.path) return;
+			const label = picker.name || picker.path.split(/[\\/]/).pop() || "Audio";
+			const asset = await importAudioAsset(picker.path, label);
+			// `importAudioAsset` selects the new track in the store, but the region/clip
+			// selections are hook-local state it can't touch — clear them here so an import
+			// doesn't leave a stale annotation/clip selected alongside the new track (the same
+			// exclusivity `addAudioTrack` keeps). Only on success: a failed import changes nothing.
+			if (asset) {
+				setSelection(null);
+				setMultiSelection([]);
+				setClipSelection(null);
+			}
+		} catch (err) {
+			toast.error(ts("audioTrack.importFailed"), {
+				description: err instanceof Error ? err.message : String(err),
+			});
+		}
+	}, [importAudioAsset, ts]);
+
+	const removeAudioTrack = useCallback(
+		async (trackId: string) => {
+			if (!document) return;
+			// Clear the inspector selection only AFTER the delete commits. A failed
+			// write leaves the track in the document, so it must keep its selection.
+			const ok = await saveDocument(removeAudioTrackInDocument(document, trackId), {
+				history: true,
+			});
+			if (ok && selectedAudioTrackId === trackId) setSelectedAudioTrackId(null);
+		},
+		[document, saveDocument, selectedAudioTrackId, setSelectedAudioTrackId],
+	);
+
+	// The commit for a lane drag or edge-resize: move the pill's whole span and
+	// re-ventilate it, so a track dragged across a cut becomes the right set of
+	// fragments in one write (one undo step). `offsetMs` is preserved as the
+	// track's own — `anchorAudioTrackFragments` re-derives each fragment's
+	// advance from the new geometry.
+	const placeAudioTrack = useCallback(
+		async (trackId: string, span: { startMs: number; endMs: number; offsetMs?: number }) => {
+			const doc = useProjectStore.getState().document;
+			if (!doc) return;
+			const others = doc.audioTracks.filter((t) => trackGroupId(t) !== trackId);
+			const [pill] = collapseTracksToPills(
+				doc.audioTracks.filter((t) => trackGroupId(t) === trackId),
+			);
+			if (!pill) return;
+			const moved = {
+				...pill,
+				startMs: Math.max(0, Math.round(span.startMs)),
+				endMs: Math.max(Math.round(span.startMs) + 1, Math.round(span.endMs)),
+				// A left-edge drag is a trim IN: the head moves right and the same
+				// amount is skipped in the source, so the audio under the pill stays
+				// put instead of sliding with it. Omitted by a plain move, which
+				// keeps the offset it already had.
+				offsetMs:
+					span.offsetMs === undefined ? pill.offsetMs : Math.max(0, Math.round(span.offsetMs)),
+			};
+			const fragments = anchorAudioTrackFragments(moved, doc.timeline.clips, () =>
+				createId("audio"),
+			);
+			if (fragments.length === 0) return;
+			await saveDocument({ ...doc, audioTracks: [...others, ...fragments] }, { history: true });
+		},
+		[saveDocument],
+	);
+
+	// Payload edits hit every fragment of the track — the halves of a split take
+	// must not disagree about gain, mute or loop.
+	const updateAudioTrack = useCallback(
+		async (
+			trackId: string,
+			patch: Partial<
+				Pick<AxcutAudioTrack, "gainDb" | "muted" | "loop" | "fadeInMs" | "fadeOutMs" | "offsetMs">
+			>,
+		) => {
+			const doc = useProjectStore.getState().document;
+			if (!doc) return;
+			await saveDocument(patchAudioTrack(doc, trackId, patch), { history: true });
+		},
+		[saveDocument],
+	);
+
+	// Turning loop ON fills the rest of the programme with the track.
+	//
+	// Looping only means anything when the span EXCEEDS the source, so a toggle
+	// that changed nothing else did nothing at all — the user had to know to then
+	// drag the pill's right edge out, which is not a thing anyone guesses. Filling
+	// is what "loop" is for, it is one undo away, and the edge still trims it back
+	// to any length. Turning loop OFF deliberately leaves the span alone: shrinking
+	// it would throw away a length the user may have set by hand.
+	const setAudioTrackLoop = useCallback(
+		async (trackId: string, loop: boolean) => {
+			const doc = useProjectStore.getState().document;
+			if (!doc) return;
+			const fragments = doc.audioTracks.filter((t) => trackGroupId(t) === trackId);
+			const [pill] = collapseTracksToPills(fragments);
+			if (!pill) return;
+			const programmeEndMs = Math.round(
+				doc.timeline.clips.reduce((max, c) => Math.max(max, c.timelineEndSec), 0) * 1000,
+			);
+			// One write, so the fill and the flag are a single undo step.
+			const patched = patchAudioTrack(doc, trackId, { loop });
+			if (!loop || programmeEndMs <= pill.endMs) {
+				await saveDocument(patched, { history: true });
+				return;
+			}
+			const others = patched.audioTracks.filter((t) => trackGroupId(t) !== trackId);
+			const filled = anchorAudioTrackFragments(
+				{ ...pill, loop, endMs: programmeEndMs },
+				doc.timeline.clips,
+				() => createId("audio"),
+			);
+			if (filled.length === 0) {
+				await saveDocument(patched, { history: true });
+				return;
+			}
+			await saveDocument({ ...doc, audioTracks: [...others, ...filled] }, { history: true });
+		},
+		[saveDocument],
+	);
+
+	const setAudioTrackGain = useCallback(
+		async (trackId: string, gainDb: number) => {
+			await updateAudioTrack(trackId, { gainDb });
+		},
+		[updateAudioTrack],
+	);
+
 	return {
 		zoomRegions: document?.zoomRanges ?? [],
 		trimRanges: document?.timeline.trimRanges ?? [],
+		audioTracks: document?.audioTracks ?? [],
 		annotationRegions: (document?.annotations ?? []) as unknown as AnnotationRegion[],
 		speedRegions,
 		cameraFullscreenRegions,
@@ -1193,6 +1460,15 @@ export function useTimeline() {
 		addCameraFullscreen,
 		removeRegion,
 		removeRegions,
+		addAudioTrack,
+		addAudio,
+		removeAudioTrack,
+		updateAudioTrack,
+		setAudioTrackLoop,
+		placeAudioTrack,
+		setAudioTrackGain,
+		selectedAudioTrackId,
+		selectAudioTrack,
 		selectRegion,
 		clearSelection,
 		applyClipEdit,
diff --git a/src/lib/ai-edition/timeline/duration.test.ts b/src/lib/ai-edition/timeline/duration.test.ts
index 528c3b910..ccc41cb5a 100644
--- a/src/lib/ai-edition/timeline/duration.test.ts
+++ b/src/lib/ai-edition/timeline/duration.test.ts
@@ -1,6 +1,6 @@
 // @vitest-environment jsdom
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { probeVideoDuration } from "./duration";
+import { probeAudioDuration, probeVideoDuration } from "./duration";
 
 interface FakeVideo {
 	duration: number;
@@ -8,7 +8,16 @@ interface FakeVideo {
 	onerror: ((ev: Event) => unknown) | null;
 }
 
-describe("probeVideoDuration", () => {
+// `probeVideoDuration` and `probeAudioDuration` are the same probe on a
+// different media element, so the fake-element harness and the cases are shared
+// and driven per tag. See the schema/store for why audio import needs its own
+// probe (issue #350).
+const PROBES = [
+	{ label: "probeVideoDuration", tag: "video", probe: probeVideoDuration },
+	{ label: "probeAudioDuration", tag: "audio", probe: probeAudioDuration },
+] as const;
+
+describe.each(PROBES)("$label", ({ tag, probe }) => {
 	let created: FakeVideo[];
 	let originalCreate: typeof document.createElement;
 	let appendSpy: ReturnType<typeof vi.spyOn> | null;
@@ -21,9 +30,9 @@ describe("probeVideoDuration", () => {
 		// `"webview"`-only overload — the one `.call` resolves to, which then rejects a
 		// generic string tag. Pin the plain `(tagName: string) => HTMLElement` overload.
 		const createReal: (this: Document, tag: string) => HTMLElement = originalCreate;
-		document.createElement = ((tag: string) => {
-			const node = createReal.call(document, tag);
-			if (tag === "video") {
+		document.createElement = ((el: string) => {
+			const node = createReal.call(document, el);
+			if (el === tag) {
 				const fake: FakeVideo = {
 					duration: Number.NaN,
 					onloadedmetadata: null,
@@ -66,11 +75,11 @@ describe("probeVideoDuration", () => {
 	});
 
 	it("returns null when src is empty", async () => {
-		await expect(probeVideoDuration("")).resolves.toBeNull();
+		await expect(probe("")).resolves.toBeNull();
 	});
 
 	it("returns duration on loadedmetadata", async () => {
-		const p = probeVideoDuration("file:///tmp/clip.mp4");
+		const p = probe("file:///tmp/clip");
 		await vi.advanceTimersByTimeAsync(0);
 		const v = created[0];
 		v.duration = 12.5;
@@ -79,14 +88,14 @@ describe("probeVideoDuration", () => {
 	});
 
 	it("returns null on error", async () => {
-		const p = probeVideoDuration("file:///missing.mp4");
+		const p = probe("file:///missing");
 		await vi.advanceTimersByTimeAsync(0);
 		created[0].onerror?.(new Event("error"));
 		await expect(p).resolves.toBeNull();
 	});
 
 	it("returns null on timeout", async () => {
-		const p = probeVideoDuration("file:///slow.mp4", 1000);
+		const p = probe("file:///slow", 1000);
 		await vi.advanceTimersByTimeAsync(0);
 		await vi.advanceTimersByTimeAsync(2000);
 		await expect(p).resolves.toBeNull();
@@ -94,7 +103,7 @@ describe("probeVideoDuration", () => {
 
 	it("returns null for non-finite duration", async () => {
 		for (const d of [Number.POSITIVE_INFINITY, Number.NaN, -1, 0]) {
-			const p = probeVideoDuration("file:///x.mp4");
+			const p = probe("file:///x");
 			await vi.advanceTimersByTimeAsync(0);
 			const v = created[created.length - 1];
 			v.duration = d;
diff --git a/src/lib/ai-edition/timeline/duration.ts b/src/lib/ai-edition/timeline/duration.ts
index 950d2ae3b..41f47dd33 100644
--- a/src/lib/ai-edition/timeline/duration.ts
+++ b/src/lib/ai-edition/timeline/duration.ts
@@ -1,47 +1,47 @@
-// Probe a video file's actual duration by mounting a hidden <video> and
-// waiting for loadedmetadata. Used by the timeline store to size
-// freshly-inserted clips at the real source duration, so the user sees
-// the correct clip width immediately on drop instead of the placeholder.
-//
-// Falls back to null on error / timeout / non-finite duration. Caller
-// decides whether to fall back to a placeholder (60s) or surface an error.
-//
-// ponytail: probe via DOM <video> rather than the existing VirtualPreview.
-// We need this BEFORE the clip is on the timeline (so insertClipAt can
-// size it correctly), but VirtualPreview only mounts once a clip exists.
-// A throwaway <video> is the cleanest no-extra-component solution.
-
 const DEFAULT_TIMEOUT_MS = 5000;
 
-export function probeVideoDuration(
+// The duration probe: mount a hidden media element and wait for loadedmetadata.
+// Falls back to null on error / timeout / non-finite duration; the caller decides
+// whether to use a placeholder (60s) or surface an error.
+//
+// One function for both <video> and <audio> — only the tag differs, and every
+// property touched (preload, style, onloadedmetadata, onerror, duration,
+// removeAttribute, load, src) lives on HTMLMediaElement, which both are. Sharing
+// it keeps a fix to the settle/cleanup/timeout logic from drifting between the two.
+//
+// ponytail: probe via a throwaway DOM element rather than VirtualPreview, which
+// only mounts once a clip exists — we need the duration BEFORE that, so
+// insertClipAt can size the clip correctly on drop.
+function probeMediaDuration(
+	tag: "video" | "audio",
 	src: string,
-	timeoutMs: number = DEFAULT_TIMEOUT_MS,
+	timeoutMs: number,
 ): Promise<number | null> {
 	return new Promise((resolve) => {
 		if (typeof document === "undefined" || !src) {
 			resolve(null);
 			return;
 		}
-		const video = document.createElement("video");
-		video.preload = "metadata";
-		video.style.position = "absolute";
-		video.style.width = "1px";
-		video.style.height = "1px";
-		video.style.opacity = "0";
-		video.style.pointerEvents = "none";
-		video.style.left = "-9999px";
+		const el = document.createElement(tag);
+		el.preload = "metadata";
+		el.style.position = "absolute";
+		el.style.width = "1px";
+		el.style.height = "1px";
+		el.style.opacity = "0";
+		el.style.pointerEvents = "none";
+		el.style.left = "-9999px";
 		let settled = false;
 		const cleanup = () => {
-			video.onloadedmetadata = null;
-			video.onerror = null;
+			el.onloadedmetadata = null;
+			el.onerror = null;
 			clearTimeout(timer);
 			try {
-				video.removeAttribute("src");
-				video.load();
+				el.removeAttribute("src");
+				el.load();
 			} catch {
 				// ignore — browser may refuse if already detached
 			}
-			if (video.parentNode) video.parentNode.removeChild(video);
+			if (el.parentNode) el.parentNode.removeChild(el);
 		};
 		const settle = (value: number | null) => {
 			if (settled) return;
@@ -50,18 +50,37 @@ export function probeVideoDuration(
 			resolve(value);
 		};
 		const timer = setTimeout(() => settle(null), timeoutMs);
-		video.onloadedmetadata = () => {
-			const d = video.duration;
+		el.onloadedmetadata = () => {
+			const d = el.duration;
 			settle(Number.isFinite(d) && d > 0 ? d : null);
 		};
-		video.onerror = () => settle(null);
-		// ponytail: append to body so some browsers (Firefox) actually fire
-		// loadedmetadata for fully-detached <video> elements.
-		document.body.appendChild(video);
-		video.src = src;
+		el.onerror = () => settle(null);
+		// Append to body so some browsers (Firefox) actually fire loadedmetadata
+		// for a fully-detached media element.
+		document.body.appendChild(el);
+		el.src = src;
 	});
 }
 
+/** Duration of a video file, to size a freshly-inserted clip at its real length. */
+export function probeVideoDuration(
+	src: string,
+	timeoutMs: number = DEFAULT_TIMEOUT_MS,
+): Promise<number | null> {
+	return probeMediaDuration("video", src, timeoutMs);
+}
+
+/**
+ * Duration of an imported audio file (issue #350) — the audio counterpart of
+ * `probeVideoDuration`, used to size a voiceover / BGM / SFX track pill on add.
+ */
+export function probeAudioDuration(
+	src: string,
+	timeoutMs: number = DEFAULT_TIMEOUT_MS,
+): Promise<number | null> {
+	return probeMediaDuration("audio", src, timeoutMs);
+}
+
 /** Native pixel dimensions, same probe shape as `probeVideoDuration` (separate DOM element —
  *  cheap, one-shot, not worth merging into a combined probe for the one extra caller that
  *  needs both). `asset.video` was otherwise left permanently unset for most recordings (nothing
diff --git a/src/lib/ai-edition/transcription/status.test.ts b/src/lib/ai-edition/transcription/status.test.ts
index 00261712e..82b282703 100644
--- a/src/lib/ai-edition/transcription/status.test.ts
+++ b/src/lib/ai-edition/transcription/status.test.ts
@@ -243,6 +243,7 @@ describe("transcriptRelevantAssetIds", () => {
 		transcripts: [],
 		annotations: [],
 		zoomRanges: [],
+		audioTracks: [],
 		legacyEditor: null,
 	};
 
diff --git a/src/lib/shortcuts.ts b/src/lib/shortcuts.ts
index 0487b91c7..94098a4c0 100644
--- a/src/lib/shortcuts.ts
+++ b/src/lib/shortcuts.ts
@@ -5,6 +5,8 @@ export const SHORTCUT_ACTIONS = [
 	"addSpeed",
 	"addCameraFullscreen",
 	"addAnnotation",
+	"addAudio",
+	"addVoiceover",
 	"deleteSelected",
 	"playPause",
 	"copySelected",
@@ -113,6 +115,9 @@ export const DEFAULT_SHORTCUTS: ShortcutsConfig = {
 	addSpeed: { key: "s" },
 	addCameraFullscreen: { key: "c" },
 	addAnnotation: { key: "a" },
+	addAudio: { key: "m" },
+	// Record a voiceover over the timeline from the playhead.
+	addVoiceover: { key: "v" },
 	deleteSelected: { key: "d", ctrl: true },
 	playPause: { key: " " },
 	copySelected: { key: "c", ctrl: true },
@@ -126,6 +131,8 @@ export const SHORTCUT_LABELS: Record<ShortcutAction, string> = {
 	addSpeed: "Add Speed",
 	addCameraFullscreen: "Add Full Camera",
 	addAnnotation: "Add Annotation",
+	addAudio: "Add Audio",
+	addVoiceover: "Record Voiceover",
 	deleteSelected: "Delete Selected",
 	playPause: "Play / Pause",
 	copySelected: "Copy Selected",
diff --git a/src/native/browserShim.test.ts b/src/native/browserShim.test.ts
new file mode 100644
index 000000000..07f5966b8
--- /dev/null
+++ b/src/native/browserShim.test.ts
@@ -0,0 +1,60 @@
+// @vitest-environment jsdom
+// The shim persists projects to localStorage, so this needs a DOM.
+import { beforeAll, beforeEach, describe, expect, it } from "vitest";
+import type { AxcutDocument } from "@/lib/ai-edition/schema";
+import { installBrowserShims } from "./browserShim";
+import { nativeBridgeClient } from "./client";
+
+// The bridge contract types `document` as `unknown`; the shim returns real
+// AxcutDocuments, so narrow here rather than reaching for `any`.
+const asDoc = (d: unknown) => d as AxcutDocument;
+
+// installBrowserShims patches the real nativeBridgeClient's methods in place, so
+// installing once is enough; each test starts from a clean localStorage. The
+// `?browser` query is what flips detectBrowserMode() on outside Electron.
+beforeAll(() => {
+	window.history.replaceState(null, "", "/?browser");
+	installBrowserShims();
+});
+beforeEach(() => {
+	localStorage.clear();
+});
+
+async function freshProjectId(): Promise<string> {
+	const created = await nativeBridgeClient.aiEdition.create("P");
+	const id = asDoc(created.document).project.id;
+	if (!id) throw new Error("shim create returned no project");
+	return id;
+}
+
+describe("browserShim addAsset (issue #350)", () => {
+	it("keeps kind 'audio' and does not claim the empty primary slot", async () => {
+		const projectId = await freshProjectId();
+		const res = await nativeBridgeClient.aiEdition.addAsset(
+			projectId,
+			"/tmp/music.mp3",
+			"music",
+			"audio",
+		);
+		const doc = asDoc(res.document);
+		const asset = doc.assets.at(-1);
+		expect(asset?.kind).toBe("audio");
+		// An audio import must never become the primary asset (mirrors the main
+		// process's document-service.addAsset).
+		expect(doc.project.primaryAssetId).toBeUndefined();
+	});
+
+	it("still lets a video import claim the empty primary slot", async () => {
+		const projectId = await freshProjectId();
+		const res = await nativeBridgeClient.aiEdition.addAsset(
+			projectId,
+			"/tmp/screen.mp4",
+			"screen",
+			"video",
+		);
+		const doc = asDoc(res.document);
+		const asset = doc.assets.at(-1);
+		expect(asset?.kind).toBe("video");
+		expect(doc.project.primaryAssetId).toBe(asset?.id);
+	});
+});
diff --git a/src/native/browserShim.ts b/src/native/browserShim.ts
index 8ef5989a8..c9e5d395b 100644
--- a/src/native/browserShim.ts
+++ b/src/native/browserShim.ts
@@ -186,7 +186,7 @@ function createShimBridgeClient() {
 			updatedAt: string;
 			primaryAssetId?: string;
 		};
-		assets: Array<{ id: string; kind: "video"; label: string; originalPath: string }>;
+		assets: Array<{ id: string; kind: "video" | "audio"; label: string; originalPath: string }>;
 		[key: string]: unknown;
 	};
 	const projectsStorageKey = "browser-shim-projects-v2";
@@ -386,6 +386,7 @@ function createShimBridgeClient() {
 					},
 					annotations: [],
 					zoomRanges: [],
+					audioTracks: [],
 					legacyEditor: null,
 				};
 				documentsByProject[doc.project.id] = doc;
@@ -407,20 +408,27 @@ function createShimBridgeClient() {
 				saveProjectsState();
 				return Promise.resolve({ success: true });
 			},
-			addAsset: (projectId: string, path: string, label?: string) => {
+			addAsset: (projectId: string, path: string, label?: string, kind?: "video" | "audio") => {
 				const doc = documentsByProject[projectId];
 				if (!doc) return Promise.resolve({ assetId: "", document: null });
 				const assetId = `asset_${Math.random().toString(36).slice(2, 10)}`;
+				const assetKind = kind ?? "video";
 				const asset = {
 					id: assetId,
-					kind: "video" as const,
+					kind: assetKind,
 					label: label || path.split(/[\\/]/).pop() || "Recording",
 					originalPath: path,
 				};
+				// Mirror the main-process rule: an audio import never claims the empty
+				// primary slot (see document-service.addAsset).
+				const claimsPrimary = assetKind !== "audio" && !doc.project.primaryAssetId;
 				const next: ShimDocument = {
 					...doc,
 					assets: [...doc.assets, asset],
-					project: { ...doc.project, primaryAssetId: doc.project.primaryAssetId ?? assetId },
+					project: {
+						...doc.project,
+						primaryAssetId: claimsPrimary ? assetId : doc.project.primaryAssetId,
+					},
 				};
 				documentsByProject[projectId] = next;
 				saveProjectsState();
diff --git a/src/native/client.ts b/src/native/client.ts
index eed5d68d7..fce40fa6c 100644
--- a/src/native/client.ts
+++ b/src/native/client.ts
@@ -181,11 +181,11 @@ export const nativeBridgeClient = {
 				action: "document.delete",
 				payload: { projectId },
 			}),
-		addAsset: (projectId: string, path: string, label?: string) =>
+		addAsset: (projectId: string, path: string, label?: string, kind?: "video" | "audio") =>
 			requireNativeBridgeData<AiEditionAssetResult>({
 				domain: "aiEdition",
 				action: "document.addAsset",
-				payload: { projectId, path, label },
+				payload: { projectId, path, label, kind },
 			}),
 		removeAsset: (projectId: string, assetId: string) =>
 			requireNativeBridgeData<AiEditionAssetResult>({
diff --git a/src/native/contracts.ts b/src/native/contracts.ts
index 7e7fc11c9..54c1cc775 100644
--- a/src/native/contracts.ts
+++ b/src/native/contracts.ts
@@ -533,7 +533,7 @@ export type NativeBridgeRequest =
 	| {
 			domain: "aiEdition";
 			action: "document.addAsset";
-			payload: { projectId: string; path: string; label?: string };
+			payload: { projectId: string; path: string; label?: string; kind?: "video" | "audio" };
 			requestId?: string;
 	  }
 	| {
diff --git a/src/native/sceneDescription.test.ts b/src/native/sceneDescription.test.ts
index 4fc088e86..01c656967 100644
--- a/src/native/sceneDescription.test.ts
+++ b/src/native/sceneDescription.test.ts
@@ -91,6 +91,7 @@ function makeDoc(
 		},
 		annotations: overrides.annotations ?? [],
 		zoomRanges: overrides.zoomRanges ?? [],
+		audioTracks: overrides.audioTracks ?? [],
 		legacyEditor: overrides.legacyEditor ?? null,
 	};
 }
@@ -1990,3 +1991,230 @@ describe("buildSceneDescription.captions", () => {
 		expect(text?.color).toBe("#ffffff");
 	});
 });
+
+// --- imported audio tracks (issue #350) ------------------------------------
+describe("buildSceneDescription.audioTracks", () => {
+	const audioAsset = makeAsset({
+		id: "aud",
+		kind: "audio",
+		originalPath: "/music.mp3",
+		durationSec: 30,
+	});
+	// A 10s span starting at raw 5s, playing the source from 2s in.
+	const track = {
+		id: "trk1",
+		assetId: "aud",
+		kind: "music" as const,
+		startMs: 5000,
+		endMs: 15_000,
+		durationSec: 30,
+		offsetMs: 2000,
+		gainDb: -3,
+		loop: false,
+		fadeInMs: 0,
+		fadeOutMs: 0,
+		muted: false,
+		label: "",
+		origin: "user" as const,
+	};
+
+	it("maps a track to the mix list with its resolved path and window", () => {
+		const doc = makeDoc({ assets: [audioAsset], audioTracks: [track] });
+		expect(buildSceneDescription(doc).audioTracks).toEqual([
+			{
+				path: "/music.mp3",
+				startSec: 5,
+				gainDb: -3,
+				trimStartSec: 2,
+				// The span is 10s and the file has 28s left after the offset, so the
+				// span is what runs out first.
+				trimEndSec: 12,
+				fadeInSec: 0,
+				fadeOutSec: 0,
+			},
+		]);
+	});
+
+	it("caps the trim-out at the end of the file when the span outlasts it", () => {
+		const doc = makeDoc({
+			assets: [audioAsset],
+			// A 40s span over a 30s file, offset 2s: only 28s of source exist.
+			audioTracks: [{ ...track, endMs: 45_000 }],
+		});
+		expect(buildSceneDescription(doc).audioTracks[0]?.trimEndSec).toBe(30);
+	});
+
+	it("drops a muted track from the mix list", () => {
+		const doc = makeDoc({ assets: [audioAsset], audioTracks: [{ ...track, muted: true }] });
+		expect(buildSceneDescription(doc).audioTracks).toEqual([]);
+	});
+
+	it("emits one entry per repeat for a looping track", () => {
+		const doc = makeDoc({
+			assets: [audioAsset],
+			// 4s of source (offset 26 into a 30s file) under a 10s span → 3 repeats.
+			audioTracks: [{ ...track, offsetMs: 26_000, loop: true, fadeInMs: 500, fadeOutMs: 500 }],
+		});
+		const entries = buildSceneDescription(doc).audioTracks;
+		expect(entries.map((e) => [e.startSec, e.trimStartSec, e.trimEndSec])).toEqual([
+			[5, 26, 30],
+			[9, 26, 30],
+			[13, 26, 28],
+		]);
+		// The fades belong to the track's edges, not to every repeat.
+		expect(entries.map((e) => [e.fadeInSec, e.fadeOutSec])).toEqual([
+			[0.5, 0],
+			[0, 0],
+			[0, 0.5],
+		]);
+	});
+
+	it("projects the head onto the trim-compressed programme (issue #350)", () => {
+		// A 10s screen clip with an interior cut removing raw [2,4] (2s). The audio track's
+		// raw head is 5; on the compressed programme that is 3. Passing 5 through verbatim was
+		// the bug — the track played 2s (the trim) late in the render while the preview, whose
+		// playhead jumps the cut, had it on time.
+		const screen = makeAsset({ id: "scr", originalPath: "/screen.mp4", durationSec: 10 });
+		const doc = makeDoc({
+			assets: [screen, audioAsset],
+			clips: [
+				makeClip({
+					id: "c1",
+					assetId: "scr",
+					sourceStartSec: 0,
+					sourceEndSec: 10,
+					timelineStartSec: 0,
+					timelineEndSec: 10,
+				}),
+			],
+			timeline: {
+				trimRanges: [
+					{ id: "t1", assetId: "scr", startSec: 2, endSec: 4, reason: "", origin: "user" },
+				],
+			},
+			audioTracks: [track],
+		});
+		expect(buildSceneDescription(doc).audioTracks[0]?.startSec).toBeCloseTo(3, 6);
+	});
+
+	it("drops a track that sits entirely inside a trimmed stretch", () => {
+		// The trim takes raw 4..8 out of the programme; a track living at raw 5..7
+		// has nowhere left to play. It used to project both ends onto the cut and
+		// then play its full raw length there — audible, and out of place, with
+		// nothing on screen to account for it.
+		const screen = makeAsset({ id: "scr", originalPath: "/screen.mp4", durationSec: 20 });
+		const doc = makeDoc({
+			assets: [screen, audioAsset],
+			clips: [
+				makeClip({
+					id: "c1",
+					assetId: "scr",
+					sourceStartSec: 0,
+					sourceEndSec: 20,
+					timelineStartSec: 0,
+					timelineEndSec: 20,
+				}),
+			],
+			timeline: {
+				trimRanges: [
+					{ id: "t1", assetId: "scr", startSec: 4, endSec: 8, reason: "", origin: "user" },
+				],
+			},
+			audioTracks: [{ ...track, startMs: 5000, endMs: 7000 }],
+		});
+		expect(buildSceneDescription(doc).audioTracks).toEqual([]);
+	});
+
+	it("shortens a track by the trim it crosses", () => {
+		// Raw 2..12 with raw 4..8 cut is 6s of programme, not 10.
+		const screen = makeAsset({ id: "scr", originalPath: "/screen.mp4", durationSec: 20 });
+		const doc = makeDoc({
+			assets: [screen, audioAsset],
+			clips: [
+				makeClip({
+					id: "c1",
+					assetId: "scr",
+					sourceStartSec: 0,
+					sourceEndSec: 20,
+					timelineStartSec: 0,
+					timelineEndSec: 20,
+				}),
+			],
+			timeline: {
+				trimRanges: [
+					{ id: "t1", assetId: "scr", startSec: 4, endSec: 8, reason: "", origin: "user" },
+				],
+			},
+			audioTracks: [{ ...track, startMs: 2000, endMs: 12_000, offsetMs: 0 }],
+		});
+		const [entry] = buildSceneDescription(doc).audioTracks;
+		expect(entry.startSec).toBeCloseTo(2, 6);
+		expect(entry.trimEndSec - entry.trimStartSec).toBeCloseTo(6, 6);
+	});
+
+	it("places a track after a speed region on the compressed clock", () => {
+		// The programme is time-stretched before the tracks are mixed onto it
+		// (`stretch_clip_pcm_by_speed` then `mix_external_tracks`), so raw 12 with
+		// raw 4..8 at 2x is output 10. Blind to speed the track landed at 12 —
+		// two seconds late, and later still the more the video is sped up.
+		const screen = makeAsset({ id: "scr", originalPath: "/screen.mp4", durationSec: 20 });
+		const doc = makeDoc({
+			assets: [screen, audioAsset],
+			clips: [
+				makeClip({
+					id: "c1",
+					assetId: "scr",
+					sourceStartSec: 0,
+					sourceEndSec: 20,
+					timelineStartSec: 0,
+					timelineEndSec: 20,
+				}),
+			],
+			legacyEditor: { speedRegions: [{ id: "s1", startMs: 4000, endMs: 8000, speed: 2 }] },
+			audioTracks: [{ ...track, startMs: 12_000, endMs: 16_000, offsetMs: 0 }],
+		});
+		const [entry] = buildSceneDescription(doc).audioTracks;
+		expect(entry.startSec).toBeCloseTo(10, 6);
+		// ...and the track itself is NOT stretched: 4 raw seconds of audio stay 4
+		// seconds of source, whatever the video under it is doing.
+		expect(entry.trimEndSec - entry.trimStartSec).toBeCloseTo(4, 6);
+	});
+
+	it("does not shorten a track just because the video under it is sped up", () => {
+		// A speed region compresses the programme; it does not delete anything. The
+		// track still holds all its audio and still plays at 1x, so a 4s voiceover
+		// under a 2x region is still 4s of narration — measuring its length on the
+		// compressed clock silently cut it in half.
+		const screen = makeAsset({ id: "scr", originalPath: "/screen.mp4", durationSec: 20 });
+		const doc = makeDoc({
+			assets: [screen, audioAsset],
+			clips: [
+				makeClip({
+					id: "c1",
+					assetId: "scr",
+					sourceStartSec: 0,
+					sourceEndSec: 20,
+					timelineStartSec: 0,
+					timelineEndSec: 20,
+				}),
+			],
+			legacyEditor: { speedRegions: [{ id: "s1", startMs: 2000, endMs: 10_000, speed: 2 }] },
+			audioTracks: [{ ...track, startMs: 4000, endMs: 8000, offsetMs: 0 }],
+		});
+		const [entry] = buildSceneDescription(doc).audioTracks;
+		expect(entry.trimEndSec - entry.trimStartSec).toBeCloseTo(4, 6);
+		// Its head still moves onto the compressed clock: raw 4 is 1s into a 2x
+		// stretch that began at raw 2, so output 3.
+		expect(entry.startSec).toBeCloseTo(3, 6);
+	});
+
+	it("drops a track whose asset has no resolvable path", () => {
+		const doc = makeDoc({ assets: [], audioTracks: [track] });
+		expect(buildSceneDescription(doc).audioTracks).toEqual([]);
+	});
+
+	it("is empty for a project with no imported audio", () => {
+		const doc = makeDoc({ assets: [makeAsset({ id: "a", originalPath: "/a.mp4" })] });
+		expect(buildSceneDescription(doc).audioTracks).toEqual([]);
+	});
+});
diff --git a/src/native/sceneDescription.ts b/src/native/sceneDescription.ts
index 376a8580a..0d214831b 100644
--- a/src/native/sceneDescription.ts
+++ b/src/native/sceneDescription.ts
@@ -30,7 +30,11 @@ import {
 } from "@/lib/ai-edition/captions";
 import { createId } from "@/lib/ai-edition/document/ids";
 import { pickOutputDims } from "@/lib/ai-edition/document/outputFormat";
-import { resolvePlaybackSegments } from "@/lib/ai-edition/document/timeline";
+import {
+	type PlaybackSpeedRegion,
+	projectRawTimelineSecToPlayback,
+	resolvePlaybackSegments,
+} from "@/lib/ai-edition/document/timeline";
 import type { AxcutClip, AxcutDocument } from "@/lib/ai-edition/schema";
 import { getEditorSettings } from "@/lib/ai-edition/store/editorSettings";
 import { assetCameraSource } from "@/lib/ai-edition/timeline/camera";
@@ -411,6 +415,31 @@ export interface SceneDescription {
 	audio: {
 		gainDb: number;
 	};
+	/**
+	 * Timeline audio tracks (issue #350), mixed over the assembled programme by
+	 * `audio::mix_external_tracks`. One entry per contiguous stretch: a track split by a
+	 * clip boundary contributes one entry per fragment (each picking the source up where
+	 * the last left off), and a looping track one entry per repeat.
+	 *
+	 * `startSec` is the head on the trim-COMPRESSED output programme: the track's raw
+	 * timeline head projected through the trims via `projectRawTimelineSecToPlayback`, so
+	 * a cut ahead of the track pulls it earlier by the removed duration (exactly as the
+	 * preview already plays it). Exact for trims; speed regions stay an approximation.
+	 * `trimEndSec` is always concrete — the compositor preallocates the decode window
+	 * from it — so it is resolved from the span and the source duration.
+	 */
+	audioTracks: Array<{
+		path: string;
+		startSec: number;
+		gainDb: number;
+		trimStartSec: number;
+		trimEndSec: number;
+		/** Ramp lengths at the entry's own edges, in seconds. A split or looping
+		 *  track carries them only on the pieces that touch the track's real
+		 *  start and end, so it fades once rather than at every cut or repeat. */
+		fadeInSec: number;
+		fadeOutSec: number;
+	}>;
 	/**
 	 * Per-clip screen crop (fractions of the frame), or null for the identity
 	 * (full-frame) crop. One entry per clip in the same order as `clips`, so a
@@ -472,11 +501,22 @@ function parseWallpaper(wallpaper: string) {
  * `NativeCompositorOverlay.tsx`'s `nativeClips` (live preview) — previously these three each
  * hand-rolled their own sort+filter, acknowledged as needing to be "kept in lock-step".
  */
+/** Whether a clip's media can actually be read — the one rule that decides
+ *  which clips make it into the programme. Shared with the audio-track
+ *  projection, which must count exactly the clips the programme is built from
+ *  or every track after a relinked-away clip lands late. */
+function clipAssetIsResolvable(
+	clip: { assetId: string },
+	assetById: Map<string, { originalPath?: string }>,
+): boolean {
+	return Boolean(assetById.get(clip.assetId)?.originalPath);
+}
+
 export function resolveVisibleClips(document: AxcutDocument): AxcutClip[] {
 	const assetById = new Map(document.assets.map((a) => [a.id, a]));
 	return resolvePlaybackSegments(document.timeline.clips, document.timeline.trimRanges)
 		.sort((a, b) => a.timelineStartSec - b.timelineStartSec)
-		.filter((clip) => assetById.get(clip.assetId)?.originalPath);
+		.filter((clip) => clipAssetIsResolvable(clip, assetById));
 }
 
 /** Serialize a document into a {@link SceneDescription}. Pure — no per-frame math. */
@@ -487,6 +527,110 @@ export function buildSceneDescription(
 	const settings = getEditorSettings(document);
 
 	const assetById = new Map(document.assets.map((a) => [a.id, a]));
+	// Timeline audio tracks (issue #350) → the compositor's mix list.
+	//
+	// Each STORED track is one clip-anchored fragment, already carrying its own
+	// advanced `offsetMs`, so a fragment maps to one contiguous decode window and
+	// the pieces of a split take play as one continuous take. Project each head
+	// onto the trim-compressed programme the mixer overlays on: the head is
+	// stored in RAW ruler seconds, and passing it verbatim delayed every track by
+	// the total trim duration ahead of it (issue #350).
+	//
+	// Projected onto the same clips the programme is assembled from —
+	// `resolveVisibleClips` drops clips whose asset has no resolvable
+	// `originalPath`, and a projection that counted a relinked-away clip the
+	// programme does not would land every following track past the real end.
+	// `projectRawTimelineSecToPlayback` subtracts the trims itself, so it needs
+	// the RAW clips behind that filter, not the already-compressed segments.
+	const projectedClips = document.timeline.clips.filter((clip) =>
+		clipAssetIsResolvable(clip, assetById),
+	);
+	// Speed regions on the RAW ruler. The programme these tracks mix onto has
+	// already been time-stretched by them (`stretch_clip_pcm_by_speed` runs before
+	// `mix_external_tracks`), so a projection blind to speed lands every track
+	// after a speed region at the wrong second. The tracks themselves are never
+	// stretched — a voiceover should not chipmunk because the video under it was
+	// sped up.
+	const rawSpeedRegions = (
+		((document.legacyEditor as Record<string, unknown> | null)?.speedRegions as
+			| PlaybackSpeedRegion[]
+			| undefined) ?? []
+	).filter((r) => Number.isFinite(r.speed) && r.speed > 0);
+	const audioTracks = document.audioTracks.flatMap((track) => {
+		if (track.muted) return [];
+		const asset = assetById.get(track.assetId);
+		if (!asset?.originalPath) return [];
+		const sourceDurationSec = asset.durationSec ?? track.durationSec;
+		const offsetSec = track.offsetMs / 1000;
+		const startSec = projectRawTimelineSecToPlayback(
+			projectedClips,
+			document.timeline.trimRanges,
+			track.startMs / 1000,
+			rawSpeedRegions,
+		);
+		// Length is measured WITHOUT speed, position WITH it — the two do different
+		// things to a track and must not be conflated.
+		//
+		// A trim REMOVES timeline: a track inside removed time has nowhere left to
+		// be (zero length, dropped), and one crossing a cut loses what the cut took.
+		// A speed region only COMPRESSES: the track still holds all its audio and
+		// still plays at 1x, so speeding the video up must not quietly cut the
+		// narration short. It changes where the track STARTS, because the programme
+		// ahead of it got shorter, and nothing else.
+		const trimmedSpanSec =
+			projectRawTimelineSecToPlayback(
+				projectedClips,
+				document.timeline.trimRanges,
+				track.endMs / 1000,
+			) -
+			projectRawTimelineSecToPlayback(
+				projectedClips,
+				document.timeline.trimRanges,
+				track.startMs / 1000,
+			);
+		const spanSec = trimmedSpanSec;
+		if (spanSec <= 0) return [];
+		const base = {
+			path: asset.originalPath,
+			gainDb: track.gainDb,
+			fadeInSec: track.fadeInMs / 1000,
+			fadeOutSec: track.fadeOutMs / 1000,
+		};
+		// The window the file has left after the offset. Without a probed duration
+		// there is nothing to loop over and nothing to cap the tail with, so the
+		// span itself is the window — the mixer stops at the real end of the file.
+		const windowSec = sourceDurationSec > 0 ? Math.max(0, sourceDurationSec - offsetSec) : spanSec;
+		if (windowSec <= 0) return [];
+		if (!track.loop) {
+			return [
+				{
+					...base,
+					startSec,
+					trimStartSec: offsetSec,
+					// Always concrete: the compositor preallocates its decode window
+					// from it. Whichever runs out first — the span or the file.
+					trimEndSec: offsetSec + Math.min(windowSec, spanSec),
+				},
+			];
+		}
+		// A looping track is one mix entry per repeat: the mixer overlays entries
+		// independently, so the repeats are just more of them. The last one is cut
+		// short wherever the span ends.
+		const entries = [];
+		for (let played = 0; played < spanSec && entries.length < 1000; played += windowSec) {
+			const thisSec = Math.min(windowSec, spanSec - played);
+			entries.push({
+				...base,
+				startSec: startSec + played,
+				trimStartSec: offsetSec,
+				trimEndSec: offsetSec + thisSec,
+				// The fades belong to the track's edges, not to every repeat.
+				fadeInSec: played === 0 ? base.fadeInSec : 0,
+				fadeOutSec: played + thisSec >= spanSec ? base.fadeOutSec : 0,
+			});
+		}
+		return entries;
+	});
 	const visibleClips = resolveVisibleClips(document);
 	const clips: CompositorClipInput[] = visibleClips.flatMap((clip) => {
 		const asset = assetById.get(clip.assetId);
@@ -821,6 +965,7 @@ export function buildSceneDescription(
 		audio: {
 			gainDb: settings.audioGainDb,
 		},
+		audioTracks,
 		background: parseWallpaper(settings.wallpaper),
 		zoomRegions: projectedZoomRegions.map((region) => ({
 			id: region.id,
diff --git a/technical-documentation/architecture/document-model.md b/technical-documentation/architecture/document-model.md
index c312ad605..ea5e76c88 100644
--- a/technical-documentation/architecture/document-model.md
+++ b/technical-documentation/architecture/document-model.md
@@ -27,6 +27,7 @@ and anything unknown is rejected by the `z.literal(axcutSchemaVersion)` check in
 | `timeline` | `{ clips[], gaps[], trimRanges[], muteRanges[], speedRanges[], captionRanges[] }` | Clips carry their own in/out (`sourceStartSec`/`sourceEndSec`); trims are anchored to a clip (`clipId?`) since v7. See [timeline-model.md](timeline-model.md). |
 | `annotations[]` | `AxcutAnnotationRegion[]` | Text/image/figure/blur overlays, anchored to a clip (`clipId?`). |
 | `zoomRanges[]` | `AxcutZoomRegion[]` | Zoom-in effects, depth 1–6, anchored to a clip (`clipId?`). |
+| `audioTracks[]` | `AxcutAudioTrack[]` | Imported audio (voiceover / BGM / SFX, issue #350) mixed over the programme. NOT clip-anchored — addressed in RAW/document timeline seconds (`timelineStartSec`), with `trimStartSec`/`trimEndSec` windowing the source and `gainDb` its level. Added from the timeline toolbar; the referenced asset has `kind: "audio"`. |
 | `legacyEditor` | OpenScreen v2 `ProjectEditorState` passthrough | Appearance/cursor settings not yet first-class in the AI-edition schema. |
 | `agent` | `{ baseIntent?, pendingQuestions[], suggestions[], lastAppliedOperations[], lastReasoningSummary? }` | LLM agent state. |
 | `preview` | `{ strategy: "seek" \| "mse-proxy", revision: number }` | `revision` is the bump used to invalidate cached frames after an edit. |
diff --git a/technical-documentation/architecture/export-pipeline.md b/technical-documentation/architecture/export-pipeline.md
index f5550a1eb..9ddb34a2f 100644
--- a/technical-documentation/architecture/export-pipeline.md
+++ b/technical-documentation/architecture/export-pipeline.md
@@ -110,6 +110,19 @@ and **one** encoder + muxer pair:
   table, asserted by `outputFrameCount.test.ts` and by
   `speed_segments_match_the_exporter_frame_totals`.
 
+- **Imported audio tracks** (voiceover / BGM / SFX, issue #350) are mixed
+  on top of the assembled programme by `audio.rs::mix_external_tracks`,
+  between `assemble_concatenated_pcm` and `finish_audio`. Each track's
+  trim window is decoded through the same `decode_clip_audio` path a clip
+  uses, scaled by its per-track gain, and summed in at its `startSec`
+  offset; a track running past the video is truncated to it so the two
+  streams stay the same length. `startSec` is resolved renderer-side
+  (`buildSceneDescription`) from the track's raw timeline position — an
+  identity map without trims/speed, an accepted approximation otherwise,
+  matching how the preview approximates trims by re-seeking. The CLI's
+  `openscreen export --audio` remains a separate post-export remux
+  (`voiceoverMix.ts`) for a single track and is unaffected.
+
 - **Output** honours the timeline's selected aspect ratio
   (`resolveAspectRatioValue` over `getEditorSettings(document).aspectRatio` —
   the same typed façade `buildSceneDescription` reads, so the dialog cannot