diff --git a/.gitignore b/.gitignore
index 61dc9d2fcf..33cf7a9d2f 100644
--- a/.gitignore
+++ b/.gitignore
@@ -49,6 +49,7 @@ playwright-report/
 
 # Vitest browser mode screenshots
 __screenshots__/
+.vitest-attachments/
 
 # shell files
 /shell.sh
diff --git a/electron/native/wgc-capture/src/main.cpp b/electron/native/wgc-capture/src/main.cpp
index 30a3069d67..1c0f081400 100644
--- a/electron/native/wgc-capture/src/main.cpp
+++ b/electron/native/wgc-capture/src/main.cpp
@@ -606,9 +606,14 @@ int main(int argc, char* argv[]) {
         int64_t lastEncodedVideoTimestampHns = -1;
 
         while (!control.stopRequested && !encodeFailed) {
+            Microsoft::WRL::ComPtr<IMFSample> videoSample;
+            Microsoft::WRL::ComPtr<IMFSample> webcamSample;
+            bool hasVideoSample = false;
+            bool hasWebcamSample = false;
+
             {
                 std::unique_lock lock(mutex);
-                control.cv.wait(lock, [&] {
+                control.cv.wait_for(lock, std::chrono::milliseconds(100), [&] {
                     return control.stopRequested.load() ||
                         encodeFailed.load() ||
                         (!control.paused.load() && latestFrameTexture);
@@ -653,29 +658,59 @@ int main(int argc, char* argv[]) {
                     latestWebcamSequence != lastWrittenWebcamSequence) {
                     const int64_t webcamTimestampHns = static_cast<int64_t>(
                         (webcamOutputFrameIndex * 10'000'000ULL) / std::max(1, webcamCapture.fps()));
-                    if (!webcamEncoder.writeBgraFrame(webcamFrame, webcamTimestampHns)) {
+                    hasWebcamSample = webcamEncoder.captureBgraSample(webcamFrame, webcamTimestampHns, webcamSample);
+                    if (!hasWebcamSample) {
                         encodeFailed = true;
                         control.stopRequested = true;
                         control.cv.notify_all();
-                        return;
+                        break;
                     }
                     lastWrittenWebcamSequence = latestWebcamSequence;
                     webcamOutputFrameIndex += 1;
                 }
-                if (latestFrameTexture && !encoder.writeFrame(
+                if (latestFrameTexture) {
+                    // captureVideoSample performs the GPU readback
+                    // (CopyResource/Map) from latestFrameTexture, which must
+                    // stay serialized (via `mutex`) against the WGC
+                    // frame-arrival callback above, which writes new data
+                    // into the same texture on another thread.
+                    hasVideoSample = encoder.captureVideoSample(
                         latestFrameTexture.Get(),
                         frameTimestampHns,
-                        !writeSeparateWebcam && webcamFrame.data ? &webcamFrame : nullptr)) {
-                    encodeFailed = true;
-                    control.stopRequested = true;
-                    control.cv.notify_all();
-                    return;
-                }
-                if (latestFrameTexture) {
+                        !writeSeparateWebcam && webcamFrame.data ? &webcamFrame : nullptr,
+                        videoSample);
+                    if (!hasVideoSample) {
+                        encodeFailed = true;
+                        control.stopRequested = true;
+                        control.cv.notify_all();
+                        break;
+                    }
                     lastEncodedVideoTimestampHns = frameTimestampHns;
                 }
             }
 
+            // Submit the captured samples to their sink writers OUTSIDE
+            // `mutex`. IMFSinkWriter::WriteSample runs the H.264 encode
+            // synchronously and can be slow (especially the software encoder
+            // fallback used when preferSoftwareEncoder is set). Holding
+            // `mutex` across it would block the main thread's stop-wait
+            // (which locks the same mutex to check control.stopRequested)
+            // for as long as this thread keeps re-acquiring the lock faster
+            // than the main thread can, hanging the helper indefinitely
+            // after a stop request (issue #115).
+            if (hasWebcamSample && !webcamEncoder.submitVideoSample(webcamSample.Get())) {
+                encodeFailed = true;
+                control.stopRequested = true;
+                control.cv.notify_all();
+                break;
+            }
+            if (hasVideoSample && !encoder.submitVideoSample(videoSample.Get())) {
+                encodeFailed = true;
+                control.stopRequested = true;
+                control.cv.notify_all();
+                break;
+            }
+
             frameIndex += 1;
             std::this_thread::sleep_for(frameDuration);
         }
diff --git a/electron/native/wgc-capture/src/mf_encoder.cpp b/electron/native/wgc-capture/src/mf_encoder.cpp
index 42b7089105..60f82e9f55 100644
--- a/electron/native/wgc-capture/src/mf_encoder.cpp
+++ b/electron/native/wgc-capture/src/mf_encoder.cpp
@@ -603,23 +603,38 @@ bool MFEncoder::copyBgraFrameToBuffer(const BgraFrameView& frame, BYTE* destinat
     return true;
 }
 
-bool MFEncoder::writeFrame(ID3D11Texture2D* texture, int64_t timestampHns, const BgraFrameView* webcamFrame) {
-    std::scoped_lock writerLock(writerMutex_);
-    if (!sinkWriter_ || finalized_) {
-        return false;
-    }
+bool MFEncoder::captureVideoSample(
+    ID3D11Texture2D* texture,
+    int64_t timestampHns,
+    const BgraFrameView* webcamFrame,
+    Microsoft::WRL::ComPtr<IMFSample>& outSample) {
+    outSample.Reset();
 
-    if (firstTimestampHns_ < 0) {
-        firstTimestampHns_ = timestampHns;
-    }
+    const int64_t sampleDuration = 10'000'000LL / fps_;
+    int64_t sampleTime = 0;
+    {
+        std::scoped_lock writerLock(writerMutex_);
+        if (!sinkWriter_ || finalized_) {
+            return false;
+        }
 
-    int64_t sampleTime = timestampHns - firstTimestampHns_;
-    if (sampleTime <= lastTimestampHns_) {
-        sampleTime = lastTimestampHns_ + (10'000'000LL / fps_);
+        if (firstTimestampHns_ < 0) {
+            firstTimestampHns_ = timestampHns;
+        }
+
+        sampleTime = timestampHns - firstTimestampHns_;
+        if (sampleTime <= lastTimestampHns_) {
+            sampleTime = lastTimestampHns_ + sampleDuration;
+        }
+        lastTimestampHns_ = sampleTime;
     }
-    const int64_t sampleDuration = 10'000'000LL / fps_;
-    lastTimestampHns_ = sampleTime;
 
+    // The GPU readback below (copyFrameToBuffer -> CopyResource/Map on
+    // `texture`) is not internally synchronized here. Callers must hold their
+    // own lock around this call that also serializes against whatever thread
+    // writes new frame data into `texture` (see main.cpp's writeVideoFrames,
+    // which holds the shared frame-state mutex across this call but not
+    // across submitVideoSample).
     Microsoft::WRL::ComPtr<IMFMediaBuffer> buffer;
     const DWORD frameBytes = static_cast<DWORD>(width_ * height_ * 4);
     if (!succeeded(MFCreateMemoryBuffer(frameBytes, &buffer), "MFCreateMemoryBuffer")) {
@@ -648,25 +663,34 @@ bool MFEncoder::writeFrame(ID3D11Texture2D* texture, int64_t timestampHns, const
     sample->SetSampleTime(sampleTime);
     sample->SetSampleDuration(sampleDuration);
 
-    return succeeded(sinkWriter_->WriteSample(videoStreamIndex_, sample.Get()), "WriteSample");
+    outSample = sample;
+    return true;
 }
 
-bool MFEncoder::writeBgraFrame(const BgraFrameView& frame, int64_t timestampHns) {
-    std::scoped_lock writerLock(writerMutex_);
-    if (!sinkWriter_ || finalized_) {
-        return false;
-    }
+bool MFEncoder::captureBgraSample(
+    const BgraFrameView& frame,
+    int64_t timestampHns,
+    Microsoft::WRL::ComPtr<IMFSample>& outSample) {
+    outSample.Reset();
 
-    if (firstTimestampHns_ < 0) {
-        firstTimestampHns_ = timestampHns;
-    }
+    const int64_t sampleDuration = 10'000'000LL / fps_;
+    int64_t sampleTime = 0;
+    {
+        std::scoped_lock writerLock(writerMutex_);
+        if (!sinkWriter_ || finalized_) {
+            return false;
+        }
 
-    int64_t sampleTime = timestampHns - firstTimestampHns_;
-    if (sampleTime <= lastTimestampHns_) {
-        sampleTime = lastTimestampHns_ + (10'000'000LL / fps_);
+        if (firstTimestampHns_ < 0) {
+            firstTimestampHns_ = timestampHns;
+        }
+
+        sampleTime = timestampHns - firstTimestampHns_;
+        if (sampleTime <= lastTimestampHns_) {
+            sampleTime = lastTimestampHns_ + sampleDuration;
+        }
+        lastTimestampHns_ = sampleTime;
     }
-    const int64_t sampleDuration = 10'000'000LL / fps_;
-    lastTimestampHns_ = sampleTime;
 
     Microsoft::WRL::ComPtr<IMFMediaBuffer> buffer;
     const DWORD frameBytes = static_cast<DWORD>(width_ * height_ * 4);
@@ -696,7 +720,25 @@ bool MFEncoder::writeBgraFrame(const BgraFrameView& frame, int64_t timestampHns)
     sample->SetSampleTime(sampleTime);
     sample->SetSampleDuration(sampleDuration);
 
-    return succeeded(sinkWriter_->WriteSample(videoStreamIndex_, sample.Get()), "WriteSample(webcam)");
+    outSample = sample;
+    return true;
+}
+
+bool MFEncoder::submitVideoSample(IMFSample* sample) {
+    if (!sample) {
+        return false;
+    }
+
+    // This is the potentially slow, blocking step (especially with the
+    // software H.264 encoder fallback): IMFSinkWriter::WriteSample runs the
+    // encode synchronously on the calling thread. Callers must NOT hold any
+    // lock shared with a thread that needs to make timely progress (e.g. a
+    // stop-request check) across this call.
+    std::scoped_lock writerLock(writerMutex_);
+    if (!sinkWriter_ || finalized_) {
+        return false;
+    }
+    return succeeded(sinkWriter_->WriteSample(videoStreamIndex_, sample), "WriteSample");
 }
 
 bool MFEncoder::writeAudio(const BYTE* data, DWORD byteCount, int64_t timestampHns, int64_t durationHns) {
diff --git a/electron/native/wgc-capture/src/mf_encoder.h b/electron/native/wgc-capture/src/mf_encoder.h
index 8f57874819..e5fbd74c88 100644
--- a/electron/native/wgc-capture/src/mf_encoder.h
+++ b/electron/native/wgc-capture/src/mf_encoder.h
@@ -53,8 +53,25 @@ class MFEncoder {
         ID3D11DeviceContext* context,
         const AudioInputFormat* audioFormat = nullptr,
         MFEncoderOptions options = {});
-    bool writeFrame(ID3D11Texture2D* texture, int64_t timestampHns, const BgraFrameView* webcamFrame = nullptr);
-    bool writeBgraFrame(const BgraFrameView& frame, int64_t timestampHns);
+    // Capturing a video/webcam sample (GPU readback + IMFSample creation) is
+    // split from submitting it to the sink writer (IMFSinkWriter::WriteSample)
+    // so callers that hold an external lock across the GPU-touching capture
+    // step (to serialize against a producer thread writing into the same
+    // texture) are not forced to also hold that lock across the potentially
+    // slow, blocking WriteSample call. See main.cpp's writeVideoFrames for why
+    // this split exists: holding the shared frame-state mutex across
+    // WriteSample let the software H.264 encoder path starve the main
+    // thread's stop-request check indefinitely (issue #115).
+    bool captureVideoSample(
+        ID3D11Texture2D* texture,
+        int64_t timestampHns,
+        const BgraFrameView* webcamFrame,
+        Microsoft::WRL::ComPtr<IMFSample>& outSample);
+    bool captureBgraSample(
+        const BgraFrameView& frame,
+        int64_t timestampHns,
+        Microsoft::WRL::ComPtr<IMFSample>& outSample);
+    bool submitVideoSample(IMFSample* sample);
     bool writeAudio(const BYTE* data, DWORD byteCount, int64_t timestampHns, int64_t durationHns);
     bool finalize();
     const char* videoEncoderSelection() const;
diff --git a/electron/native/wgc-capture/src/wgc_session.cpp b/electron/native/wgc-capture/src/wgc_session.cpp
index e20096c4ea..89f0b55fe0 100644
--- a/electron/native/wgc-capture/src/wgc_session.cpp
+++ b/electron/native/wgc-capture/src/wgc_session.cpp
@@ -32,6 +32,28 @@ int64_t timeSpanToHns(wf::TimeSpan const& value) {
     return value.count();
 }
 
+// H.264 encoding (and the RGB32->NV12 conversion feeding it) requires even
+// frame dimensions. Monitor resolutions are always even in practice, so
+// CreateForMonitor items never hit this. Windows, however, frequently have
+// odd client-area dimensions (arbitrary drag-resize, DPI rounding), and
+// GraphicsCaptureItem::Size() reports the window's *actual* size verbatim.
+// If we requested a Direct3D11CaptureFramePool sized to that odd value while
+// the rest of the pipeline (main.cpp's bitrate calc, MFEncoder) rounds down
+// to even, the frame pool's real DXGI textures end up one pixel wider/taller
+// than the staging texture the encoder allocates. ID3D11DeviceContext::
+// CopyResource silently no-ops on a size mismatch (it only emits a debug-
+// layer warning), so the staging texture never receives pixel data and the
+// output is solid black for the entire recording -- or, if the mismatch
+// trips up the video MFT's input negotiation, SetInputMediaType fails
+// outright. Rounding up to the nearest even size here, and using that
+// rounded size (not the raw item size) for both the frame pool and
+// `captureWidth()`/`captureHeight()`, keeps every consumer of this session
+// looking at the exact same dimensions as the real captured texture.
+int roundUpToEven(int value) {
+    const int clamped = std::max(2, value);
+    return (clamped % 2 == 0) ? clamped : clamped + 1;
+}
+
 } // namespace
 
 WgcSession::~WgcSession() {
@@ -135,8 +157,8 @@ bool WgcSession::createCaptureItem(HWND window) {
 
     item_ = item;
     const auto size = item_.Size();
-    width_ = static_cast<int>(size.Width);
-    height_ = static_cast<int>(size.Height);
+    width_ = roundUpToEven(static_cast<int>(size.Width));
+    height_ = roundUpToEven(static_cast<int>(size.Height));
     return width_ > 0 && height_ > 0;
 }
 
@@ -199,7 +221,7 @@ bool WgcSession::initialize(HMONITOR monitor, int fps, bool captureCursor) {
         winrtDevice_,
         wgdx::DirectXPixelFormat::B8G8R8A8UIntNormalized,
         2,
-        item_.Size());
+        winrt::Windows::Graphics::SizeInt32{width_, height_});
     session_ = framePool_.CreateCaptureSession(item_);
 
     if (!applySessionOptions(captureCursor)) {
@@ -223,7 +245,7 @@ bool WgcSession::initialize(HWND window, int fps, bool captureCursor) {
         winrtDevice_,
         wgdx::DirectXPixelFormat::B8G8R8A8UIntNormalized,
         2,
-        item_.Size());
+        winrt::Windows::Graphics::SizeInt32{width_, height_});
     session_ = framePool_.CreateCaptureSession(item_);
 
     if (!applySessionOptions(captureCursor)) {
diff --git a/src/components/video-editor/VideoEditor.tsx b/src/components/video-editor/VideoEditor.tsx
index b49197da4c..f0bfbd3fed 100644
--- a/src/components/video-editor/VideoEditor.tsx
+++ b/src/components/video-editor/VideoEditor.tsx
@@ -1004,6 +1004,16 @@ export default function VideoEditor() {
 		video.currentTime = time;
 	}
 
+	// Reads the live playhead position directly off the <video> element, bypassing
+	// `currentTime` React state entirely. The timeline's playhead subscribes to this
+	// via its own rAF loop so it stays in lockstep with actual playback regardless of
+	// how long this (large) component's own re-render takes — see issue #111.
+	const getPlaybackTimeMs = useCallback(() => {
+		const video = videoPlaybackRef.current?.video;
+		if (video) return video.currentTime * 1000;
+		return currentTimeRef.current * 1000;
+	}, []);
+
 	const handleSelectZoom = useCallback((id: string | null) => {
 		setSelectedZoomId(id);
 		if (id) {
@@ -1136,6 +1146,11 @@ export default function VideoEditor() {
 
 	// Builds fresh "auto" zoom regions from cursor telemetry without overlapping
 	// existing ones. Used by both the on-load auto-suggest pass and the wand toggle.
+	// These regions always follow the cursor for their whole span (focusMode "auto") —
+	// that's the entire point of an auto-placed zoom: it should pan to track the cursor
+	// as it moves, not freeze at the dwell point that triggered the suggestion. This is
+	// independent of the global "Auto Focus All" toggle, which only affects the default
+	// for manually-drawn zoom regions.
 	const buildAutoZoomRegions = useCallback(
 		(existingRegions: ZoomRegion[]): ZoomRegion[] => {
 			const totalMs = Math.round(duration * 1000);
@@ -1152,11 +1167,11 @@ export default function VideoEditor() {
 				depth: DEFAULT_ZOOM_DEPTH,
 				customScale: ZOOM_DEPTH_SCALES[DEFAULT_ZOOM_DEPTH],
 				focus: clampFocusToDepth(suggestion.focus, DEFAULT_ZOOM_DEPTH),
-				focusMode: autoFocusAll ? ("auto" as const) : undefined,
+				focusMode: "auto" as const,
 				source: "auto" as const,
 			}));
 		},
-		[cursorTelemetry, duration, autoFocusAll],
+		[cursorTelemetry, duration],
 	);
 
 	// Auto-suggest zooms once per fresh recording (no existing zooms, telemetry
@@ -3213,6 +3228,7 @@ export default function VideoEditor() {
 								<TimelineEditor
 									videoDuration={duration}
 									currentTime={currentTime}
+									getPlaybackTimeMs={getPlaybackTimeMs}
 									onSeek={handleSeek}
 									zoomRegions={zoomRegions}
 									onZoomAdded={handleZoomAdded}
diff --git a/src/components/video-editor/VideoPlayback.tsx b/src/components/video-editor/VideoPlayback.tsx
index 11c9e4061f..8b7f2e8298 100644
--- a/src/components/video-editor/VideoPlayback.tsx
+++ b/src/components/video-editor/VideoPlayback.tsx
@@ -1308,25 +1308,26 @@ const VideoPlayback = forwardRef<VideoPlaybackRef, VideoPlaybackProps>(
 			layoutVideoContentRef.current?.();
 			video.pause();
 
-			const { handlePlay, handlePause, handleSeeked, handleSeeking } = createVideoEventHandlers({
-				video,
-				isSeekingRef,
-				isPlayingRef,
-				allowPlaybackRef,
-				currentTimeRef,
-				timeUpdateAnimationRef,
-				onPlayStateChange: (playing) => onPlayStateChangeRef.current(playing),
-				onTimeUpdate: (time) => onTimeUpdateRef.current(time),
-				trimRegionsRef,
-				speedRegionsRef,
-				isScrubbingRef,
-				scrubEndTimerRef,
-				onScrubChange: (scrubbing) => setIsScrubbing(scrubbing),
-				seekSteppingRef,
-				stepVirtualSecRef,
-				stepLastTsRef,
-				stepPrevMutedRef,
-			});
+			const { handlePlay, handlePause, handleSeeked, handleSeeking, dispose } =
+				createVideoEventHandlers({
+					video,
+					isSeekingRef,
+					isPlayingRef,
+					allowPlaybackRef,
+					currentTimeRef,
+					timeUpdateAnimationRef,
+					onPlayStateChange: (playing) => onPlayStateChangeRef.current(playing),
+					onTimeUpdate: (time) => onTimeUpdateRef.current(time),
+					trimRegionsRef,
+					speedRegionsRef,
+					isScrubbingRef,
+					scrubEndTimerRef,
+					onScrubChange: (scrubbing) => setIsScrubbing(scrubbing),
+					seekSteppingRef,
+					stepVirtualSecRef,
+					stepLastTsRef,
+					stepPrevMutedRef,
+				});
 
 			video.addEventListener("play", handlePlay);
 			video.addEventListener("pause", handlePause);
@@ -1344,6 +1345,7 @@ const VideoPlayback = forwardRef<VideoPlaybackRef, VideoPlaybackProps>(
 				if (timeUpdateAnimationRef.current) {
 					cancelAnimationFrame(timeUpdateAnimationRef.current);
 				}
+				dispose();
 
 				if (videoSprite) {
 					videoContainer.removeChild(videoSprite);
diff --git a/src/components/video-editor/timeline/TimelineEditor.tsx b/src/components/video-editor/timeline/TimelineEditor.tsx
index b6e323a315..242714a868 100644
--- a/src/components/video-editor/timeline/TimelineEditor.tsx
+++ b/src/components/video-editor/timeline/TimelineEditor.tsx
@@ -58,6 +58,12 @@ interface TimelineEditorProps {
 	videoDuration: number;
 	hasVideoSource?: boolean;
 	currentTime: number;
+	/**
+	 * Reads the live playhead position (ms) directly, bypassing `currentTime` React
+	 * state. The playhead subscribes to this via its own rAF loop so it stays in sync
+	 * with actual playback regardless of how long an ancestor's re-render takes.
+	 */
+	getPlaybackTimeMs?: () => number;
 	onSeek?: (time: number) => void;
 	zoomRegions: ZoomRegion[];
 	onZoomAdded: (span: Span) => void;
@@ -284,6 +290,7 @@ function shouldStartTimelineScrub(target: EventTarget | null, timelineElement: H
 function PlaybackCursor({
 	currentTimeMs,
 	videoDurationMs,
+	getPlaybackTimeMs,
 	onSeek,
 	onRangeChange,
 	timelineRef,
@@ -291,6 +298,7 @@ function PlaybackCursor({
 }: {
 	currentTimeMs: number;
 	videoDurationMs: number;
+	getPlaybackTimeMs?: () => number;
 	onSeek?: (time: number) => void;
 	onRangeChange?: (updater: (previous: Range) => Range) => void;
 	timelineRef: React.RefObject<HTMLDivElement>;
@@ -301,6 +309,38 @@ function PlaybackCursor({
 	const [isDragging, setIsDragging] = useState(false);
 	const [dragPreviewTimeMs, setDragPreviewTimeMs] = useState<number | null>(null);
 
+	// Drives the playhead position from the video element every animation frame,
+	// isolated from the rest of the tree: this component's own `useState` call only
+	// re-renders this small subtree, not TimelineEditor/VideoEditor above it. That
+	// decoupling is what keeps the playhead glued to actual playback even while an
+	// ancestor's (much heavier) re-render is in flight — see issue #111.
+	const [liveTimeMs, setLiveTimeMs] = useState(currentTimeMs);
+	const getPlaybackTimeMsRef = useRef(getPlaybackTimeMs);
+	useEffect(() => {
+		getPlaybackTimeMsRef.current = getPlaybackTimeMs;
+	}, [getPlaybackTimeMs]);
+
+	useEffect(() => {
+		if (!getPlaybackTimeMsRef.current) {
+			return;
+		}
+
+		let rafId: number;
+		const tick = () => {
+			const getter = getPlaybackTimeMsRef.current;
+			if (getter) {
+				const latest = getter();
+				setLiveTimeMs((previous) => (previous === latest ? previous : latest));
+			}
+			rafId = requestAnimationFrame(tick);
+		};
+		rafId = requestAnimationFrame(tick);
+
+		return () => cancelAnimationFrame(rafId);
+	}, []);
+
+	const resolvedTimeMs = getPlaybackTimeMs ? liveTimeMs : currentTimeMs;
+
 	useEffect(() => {
 		if (!isDragging) return;
 
@@ -399,7 +439,7 @@ function PlaybackCursor({
 	]);
 
 	const displayTimeMs =
-		isDragging && dragPreviewTimeMs !== null ? dragPreviewTimeMs : currentTimeMs;
+		isDragging && dragPreviewTimeMs !== null ? dragPreviewTimeMs : resolvedTimeMs;
 
 	if (videoDurationMs <= 0 || displayTimeMs < 0) {
 		return null;
@@ -428,7 +468,7 @@ function PlaybackCursor({
 				}}
 				onMouseDown={(e) => {
 					e.stopPropagation(); // Prevent timeline click
-					setDragPreviewTimeMs(currentTimeMs);
+					setDragPreviewTimeMs(resolvedTimeMs);
 					setIsDragging(true);
 				}}
 			>
@@ -571,6 +611,7 @@ function Timeline({
 	items,
 	videoDurationMs,
 	currentTimeMs,
+	getPlaybackTimeMs,
 	onSeek,
 	onRangeChange,
 	onSelectZoom,
@@ -592,6 +633,7 @@ function Timeline({
 	items: TimelineRenderItem[];
 	videoDurationMs: number;
 	currentTimeMs: number;
+	getPlaybackTimeMs?: () => number;
 	onSeek?: (time: number) => void;
 	onRangeChange?: (updater: (previous: Range) => Range) => void;
 	onSelectZoom?: (id: string | null) => void;
@@ -797,6 +839,7 @@ function Timeline({
 			<PlaybackCursor
 				currentTimeMs={currentTimeMs}
 				videoDurationMs={videoDurationMs}
+				getPlaybackTimeMs={getPlaybackTimeMs}
 				onSeek={onSeek}
 				onRangeChange={onRangeChange}
 				timelineRef={localTimelineRef}
@@ -934,6 +977,7 @@ export default function TimelineEditor({
 	videoDuration,
 	hasVideoSource = false,
 	currentTime,
+	getPlaybackTimeMs,
 	onSeek,
 	zoomRegions,
 	onZoomAdded,
@@ -1803,6 +1847,7 @@ export default function TimelineEditor({
 						items={timelineItems}
 						videoDurationMs={totalMs}
 						currentTimeMs={currentTimeMs}
+						getPlaybackTimeMs={getPlaybackTimeMs}
 						onSeek={onSeek}
 						onRangeChange={setRange}
 						onSelectZoom={onSelectZoom}
diff --git a/src/components/video-editor/videoPlayback/rafCoalescer.test.ts b/src/components/video-editor/videoPlayback/rafCoalescer.test.ts
new file mode 100644
index 0000000000..6f896081a5
--- /dev/null
+++ b/src/components/video-editor/videoPlayback/rafCoalescer.test.ts
@@ -0,0 +1,97 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { createRafCoalescer } from "./rafCoalescer";
+
+describe("createRafCoalescer", () => {
+	let rafCallbacks: FrameRequestCallback[];
+	let nextRafId: number;
+
+	beforeEach(() => {
+		rafCallbacks = [];
+		nextRafId = 1;
+		vi.stubGlobal("requestAnimationFrame", (cb: FrameRequestCallback) => {
+			rafCallbacks.push(cb);
+			return nextRafId++;
+		});
+		vi.stubGlobal("cancelAnimationFrame", (id: number) => {
+			// Mark the callback as a no-op instead of removing it, to mirror the
+			// browser's index-stable semantics.
+			const index = id - 1;
+			if (rafCallbacks[index]) {
+				rafCallbacks[index] = () => {
+					// Cancelled: no-op.
+				};
+			}
+		});
+	});
+
+	afterEach(() => {
+		vi.unstubAllGlobals();
+	});
+
+	function flushOneFrame(timeMs = 0) {
+		const callbacks = rafCallbacks;
+		rafCallbacks = [];
+		for (const cb of callbacks) cb(timeMs);
+	}
+
+	it("does not call flush until an animation frame runs", () => {
+		const flush = vi.fn();
+		const coalescer = createRafCoalescer<number>(flush);
+
+		coalescer.schedule(1);
+
+		expect(flush).not.toHaveBeenCalled();
+	});
+
+	it("collapses multiple schedule calls within the same frame into a single flush", () => {
+		const flush = vi.fn();
+		const coalescer = createRafCoalescer<number>(flush);
+
+		coalescer.schedule(1);
+		coalescer.schedule(2);
+		coalescer.schedule(3);
+
+		flushOneFrame();
+
+		expect(flush).toHaveBeenCalledTimes(1);
+		expect(flush).toHaveBeenCalledWith(3);
+	});
+
+	it("schedules a fresh frame for values reported after the previous frame flushed", () => {
+		const flush = vi.fn();
+		const coalescer = createRafCoalescer<number>(flush);
+
+		coalescer.schedule(1);
+		flushOneFrame();
+		coalescer.schedule(2);
+		flushOneFrame();
+
+		expect(flush).toHaveBeenCalledTimes(2);
+		expect(flush).toHaveBeenNthCalledWith(1, 1);
+		expect(flush).toHaveBeenNthCalledWith(2, 2);
+	});
+
+	it("cancel() prevents a pending flush from firing", () => {
+		const flush = vi.fn();
+		const coalescer = createRafCoalescer<number>(flush);
+
+		coalescer.schedule(1);
+		coalescer.cancel();
+		flushOneFrame();
+
+		expect(flush).not.toHaveBeenCalled();
+	});
+
+	it("a schedule() call after cancel() still flushes on the next frame", () => {
+		const flush = vi.fn();
+		const coalescer = createRafCoalescer<number>(flush);
+
+		coalescer.schedule(1);
+		coalescer.cancel();
+		coalescer.schedule(2);
+		flushOneFrame();
+
+		expect(flush).toHaveBeenCalledTimes(1);
+		expect(flush).toHaveBeenCalledWith(2);
+	});
+});
diff --git a/src/components/video-editor/videoPlayback/rafCoalescer.ts b/src/components/video-editor/videoPlayback/rafCoalescer.ts
new file mode 100644
index 0000000000..be0b2f1a98
--- /dev/null
+++ b/src/components/video-editor/videoPlayback/rafCoalescer.ts
@@ -0,0 +1,41 @@
+/**
+ * Coalesces rapid-fire calls into at most one flush per animation frame.
+ *
+ * Used so a ref-backed value can be updated synchronously on every call (cheap),
+ * while an expensive side effect — e.g. a React state commit — is deferred to
+ * once per frame. Without this, a burst of calls within the same frame (many
+ * `seeking` events fired while dragging the timeline playhead) would otherwise
+ * force one state commit per call, saturating the main thread and making both
+ * the drag and the playhead's own rendering feel laggy.
+ */
+export function createRafCoalescer<T>(flush: (value: T) => void) {
+	let pendingValue: T | undefined;
+	let hasPending = false;
+	let rafId: number | null = null;
+
+	const schedule = (value: T) => {
+		pendingValue = value;
+		hasPending = true;
+		if (rafId !== null) return;
+		rafId = requestAnimationFrame(() => {
+			rafId = null;
+			if (hasPending) {
+				hasPending = false;
+				const valueToFlush = pendingValue as T;
+				pendingValue = undefined;
+				flush(valueToFlush);
+			}
+		});
+	};
+
+	const cancel = () => {
+		if (rafId !== null) {
+			cancelAnimationFrame(rafId);
+			rafId = null;
+		}
+		hasPending = false;
+		pendingValue = undefined;
+	};
+
+	return { schedule, cancel };
+}
diff --git a/src/components/video-editor/videoPlayback/videoEventHandlers.ts b/src/components/video-editor/videoPlayback/videoEventHandlers.ts
index 6d03e7692b..aac2785cf8 100644
--- a/src/components/video-editor/videoPlayback/videoEventHandlers.ts
+++ b/src/components/video-editor/videoPlayback/videoEventHandlers.ts
@@ -1,5 +1,6 @@
 import type React from "react";
 import { MAX_NATIVE_PLAYBACK_RATE, type SpeedRegion, type TrimRegion } from "../types";
+import { createRafCoalescer } from "./rafCoalescer";
 
 // Keep "scrub mode" on for a brief tail after `seeked`: rapid drag-scrubbing fires
 // `seeking`/`seeked` dozens of times a second and toggling effects each time would flicker.
@@ -77,9 +78,16 @@ export function createVideoEventHandlers(params: VideoEventHandlersParams) {
 		}
 	};
 
+	// currentTimeRef is updated synchronously on every call (cheap; other imperative
+	// consumers like the Pixi renderer read it directly). The React state commit
+	// (`onTimeUpdate`) is coalesced to at most once per animation frame so a burst of
+	// `seeking` events (fast timeline drag) or the per-frame rAF playback loop can't
+	// force more than one parent re-render per frame.
+	const timeUpdateCoalescer = createRafCoalescer<number>(onTimeUpdate);
+
 	const emitTime = (timeValue: number) => {
 		currentTimeRef.current = timeValue * 1000;
-		onTimeUpdate(timeValue);
+		timeUpdateCoalescer.schedule(timeValue);
 	};
 
 	const findActiveTrimRegion = (currentTimeMs: number): TrimRegion | null => {
@@ -331,5 +339,6 @@ export function createVideoEventHandlers(params: VideoEventHandlersParams) {
 		handlePause,
 		handleSeeked,
 		handleSeeking,
+		dispose: () => timeUpdateCoalescer.cancel(),
 	};
 }
diff --git a/src/components/video-editor/videoPlayback/zoomRegionUtils.test.ts b/src/components/video-editor/videoPlayback/zoomRegionUtils.test.ts
new file mode 100644
index 0000000000..d5d58cbf41
--- /dev/null
+++ b/src/components/video-editor/videoPlayback/zoomRegionUtils.test.ts
@@ -0,0 +1,59 @@
+import { describe, expect, it } from "vitest";
+import type { CursorTelemetryPoint, ZoomRegion } from "../types";
+import { DEFAULT_ZOOM_DEPTH, ZOOM_DEPTH_SCALES } from "../types";
+import { findDominantRegion } from "./zoomRegionUtils";
+
+/**
+ * Regression coverage for issue #72: an auto-placed zoom region must pan to follow
+ * the cursor for its whole span, not freeze at the focus point captured when the
+ * region was created/suggested.
+ */
+describe("findDominantRegion — auto-zoom cursor following", () => {
+	const baseRegion: ZoomRegion = {
+		id: "zoom-1",
+		startMs: 0,
+		endMs: 4000,
+		depth: DEFAULT_ZOOM_DEPTH,
+		customScale: ZOOM_DEPTH_SCALES[DEFAULT_ZOOM_DEPTH],
+		// The static focus captured at suggestion time (e.g. the dwell centroid) — should
+		// be ignored in favor of the live cursor position once focusMode is "auto". Kept
+		// within the depth-3 focus bounds (~0.28-0.72) so clamping doesn't distort assertions.
+		focus: { cx: 0.35, cy: 0.5 },
+		focusMode: "auto",
+		source: "auto",
+	};
+
+	// Cursor sweeps steadily from the left edge to the right edge across the region.
+	const movingTelemetry: CursorTelemetryPoint[] = [
+		{ timeMs: 0, cx: 0.1, cy: 0.5 },
+		{ timeMs: 2000, cx: 0.5, cy: 0.5 },
+		{ timeMs: 4000, cx: 0.9, cy: 0.5 },
+	];
+
+	it("tracks the cursor across the region instead of freezing at the initial focus", () => {
+		const early = findDominantRegion([baseRegion], 200, { cursorTelemetry: movingTelemetry });
+		const mid = findDominantRegion([baseRegion], 2000, { cursorTelemetry: movingTelemetry });
+		const late = findDominantRegion([baseRegion], 3800, { cursorTelemetry: movingTelemetry });
+
+		expect(early.region).not.toBeNull();
+		expect(mid.region).not.toBeNull();
+		expect(late.region).not.toBeNull();
+
+		// The focus must move meaningfully between samples (cursor-following), not stay pinned.
+		expect(mid.region?.focus.cx).toBeGreaterThan(early.region?.focus.cx ?? 0);
+		expect(late.region?.focus.cx).toBeGreaterThan(mid.region?.focus.cx ?? 0);
+
+		// And it must not equal the static creation-time focus baked into the region.
+		expect(mid.region?.focus.cx).not.toBeCloseTo(baseRegion.focus.cx, 2);
+	});
+
+	it("stays frozen at the static focus when focusMode is not auto (manual regions unaffected)", () => {
+		const manualRegion: ZoomRegion = { ...baseRegion, focusMode: "manual", source: "manual" };
+
+		const early = findDominantRegion([manualRegion], 200, { cursorTelemetry: movingTelemetry });
+		const late = findDominantRegion([manualRegion], 3800, { cursorTelemetry: movingTelemetry });
+
+		expect(early.region?.focus.cx).toBeCloseTo(manualRegion.focus.cx, 5);
+		expect(late.region?.focus.cx).toBeCloseTo(manualRegion.focus.cx, 5);
+	});
+});
diff --git a/src/lib/exporter/audioEncoder.test.ts b/src/lib/exporter/audioEncoder.test.ts
index 0fb3708c5a..e7c7fb9f04 100644
--- a/src/lib/exporter/audioEncoder.test.ts
+++ b/src/lib/exporter/audioEncoder.test.ts
@@ -1,5 +1,5 @@
 import { afterEach, describe, expect, it, vi } from "vitest";
-import { AudioProcessor, downmixPlanarChannelsForExport } from "./audioEncoder";
+import { AudioProcessor, downmixPlanarChannelsForExport, mixPlanarSources } from "./audioEncoder";
 
 describe("AudioProcessor.selectSupportedExportCodec", () => {
 	afterEach(() => {
@@ -70,3 +70,110 @@ describe("downmixPlanarChannelsForExport", () => {
 		expect(Array.from(stereo)).toEqual([0.25, -0.5, 0.25, -0.5]);
 	});
 });
+
+describe("mixPlanarSources", () => {
+	it("sums overlapping stereo sources sample-aligned", () => {
+		const system = {
+			planes: [new Float32Array([0.1, 0.2, 0.3]), new Float32Array([0.1, 0.2, 0.3])],
+			startFrame: 0,
+		};
+		const mic = {
+			planes: [new Float32Array([0.2, 0.2, 0.2]), new Float32Array([0.4, 0.4, 0.4])],
+			startFrame: 0,
+		};
+
+		const mixed = mixPlanarSources([system, mic], 2, 3);
+
+		expect(mixed).toHaveLength(2);
+		expect(Array.from(mixed[0])).toEqual([
+			expect.closeTo(0.3, 5),
+			expect.closeTo(0.4, 5),
+			expect.closeTo(0.5, 5),
+		]);
+		expect(Array.from(mixed[1])).toEqual([
+			expect.closeTo(0.5, 5),
+			expect.closeTo(0.6, 5),
+			expect.closeTo(0.7, 5),
+		]);
+	});
+
+	it("recovers a track when the other is silent (the #108 case)", () => {
+		// System audio captured silence; the microphone track holds the real signal.
+		const silentSystem = {
+			planes: [new Float32Array([0, 0, 0]), new Float32Array([0, 0, 0])],
+			startFrame: 0,
+		};
+		const mic = {
+			planes: [new Float32Array([0.5, -0.5, 0.25]), new Float32Array([0.5, -0.5, 0.25])],
+			startFrame: 0,
+		};
+
+		const mixed = mixPlanarSources([silentSystem, mic], 2, 3);
+
+		expect(Array.from(mixed[0])).toEqual([
+			expect.closeTo(0.5, 5),
+			expect.closeTo(-0.5, 5),
+			expect.closeTo(0.25, 5),
+		]);
+	});
+
+	it("aligns each source at its startFrame offset", () => {
+		const early = { planes: [new Float32Array([1, 1])], startFrame: 0 };
+		// Mic packets often start slightly after the video (source start_time > 0).
+		const late = { planes: [new Float32Array([0.5, 0.5])], startFrame: 2 };
+
+		const mixed = mixPlanarSources([early, late], 1, 4);
+
+		expect(Array.from(mixed[0])).toEqual([
+			expect.closeTo(1, 5),
+			expect.closeTo(1, 5),
+			expect.closeTo(0.5, 5),
+			expect.closeTo(0.5, 5),
+		]);
+	});
+
+	it("discards samples before frame zero from a negative startFrame (AAC preroll)", () => {
+		// AAC preroll gives the first decoded frame a negative timestamp, so the source's
+		// startFrame is signed. The preroll samples (timeline < 0) must be dropped while
+		// the real timestamp-zero sample keeps its true offset.
+		const withPreroll = {
+			planes: [new Float32Array([0.9, 0.5, 0.5])],
+			startFrame: -2,
+		};
+
+		const mixed = mixPlanarSources([withPreroll], 1, 2);
+
+		// Frames -2 and -1 (0.9, 0.5) are discarded; frame 0 keeps the real sample.
+		expect(Array.from(mixed[0])).toEqual([expect.closeTo(0.5, 5), expect.closeTo(0, 5)]);
+	});
+
+	it("upmixes a mono source to stereo before mixing", () => {
+		const mono = { planes: [new Float32Array([0.3, 0.3])], startFrame: 0 };
+		const stereo = {
+			planes: [new Float32Array([0.1, 0.1]), new Float32Array([0.2, 0.2])],
+			startFrame: 0,
+		};
+
+		const mixed = mixPlanarSources([mono, stereo], 2, 2);
+
+		expect(Array.from(mixed[0])).toEqual([expect.closeTo(0.4, 5), expect.closeTo(0.4, 5)]);
+		expect(Array.from(mixed[1])).toEqual([expect.closeTo(0.5, 5), expect.closeTo(0.5, 5)]);
+	});
+
+	it("clamps the summed signal to [-1, 1] to avoid overflow", () => {
+		const a = { planes: [new Float32Array([0.8, -0.8])], startFrame: 0 };
+		const b = { planes: [new Float32Array([0.8, -0.8])], startFrame: 0 };
+
+		const mixed = mixPlanarSources([a, b], 1, 2);
+
+		expect(Array.from(mixed[0])).toEqual([1, -1]);
+	});
+
+	it("ignores samples that fall beyond the mixed length", () => {
+		const source = { planes: [new Float32Array([0.5, 0.5, 0.5])], startFrame: 1 };
+
+		const mixed = mixPlanarSources([source], 1, 2);
+
+		expect(Array.from(mixed[0])).toEqual([expect.closeTo(0, 5), expect.closeTo(0.5, 5)]);
+	});
+});
diff --git a/src/lib/exporter/audioEncoder.ts b/src/lib/exporter/audioEncoder.ts
index b97aea1fd8..f95c755081 100644
--- a/src/lib/exporter/audioEncoder.ts
+++ b/src/lib/exporter/audioEncoder.ts
@@ -1,4 +1,4 @@
-import { WebDemuxer } from "web-demuxer";
+import { AVMediaType, type WebAVStream, WebDemuxer } from "web-demuxer";
 import {
 	MAX_NATIVE_PLAYBACK_RATE,
 	type SpeedRegion,
@@ -133,6 +133,71 @@ function getStereoDownmixWeights(sourceChannels: number) {
 	};
 }
 
+/** One decoded audio source to be mixed: its per-channel PCM and where it starts on the timeline. */
+export interface PlanarAudioSource {
+	/** Per-channel planar samples (`channels[c][frame]`). */
+	planes: Float32Array[];
+	/** Timeline sample offset of this source's first sample (from the stream's start_time). */
+	startFrame: number;
+}
+
+/**
+ * Mixes several decoded audio sources into a single planar buffer.
+ *
+ * Native macOS recordings write system audio and the microphone as two separate
+ * tracks in the same file. The exporter historically decoded only the one track
+ * FFmpeg's `av_find_best_stream` selects — which, when both tracks are marked
+ * default, is the first (system) track. If nothing was playing that track is
+ * silent, so the mic was dropped from the export (issue #108). Mixing every audio
+ * source together mirrors the browser recorder, which already blends system + mic
+ * into one track before encoding.
+ *
+ * Each source is first downmixed to `targetChannels`, then summed sample-aligned at
+ * its `startFrame`. The result is hard-clamped to [-1, 1] so a loud overlap can't wrap
+ * or overflow the encoder. Hard clipping (rather than a 1/N gain pre-sum or soft-knee
+ * limiter) can add harmonic distortion when two sources are simultaneously near unity —
+ * an acceptable trade-off for a screen recorder, where keeping both tracks at full level
+ * matters more than headroom. Sources of differing lengths and offsets are supported;
+ * samples past `totalFrames` are dropped.
+ */
+export function mixPlanarSources(
+	sources: PlanarAudioSource[],
+	targetChannels: number,
+	totalFrames: number,
+): Float32Array[] {
+	const mixed = Array.from({ length: targetChannels }, () => new Float32Array(totalFrames));
+
+	for (const source of sources) {
+		const frameCount = source.planes[0]?.length ?? 0;
+		if (frameCount === 0) continue;
+
+		// Reuse the export downmix so mono→stereo, surround→stereo, etc. match the
+		// single-track path exactly. Output is planar-concatenated: [ch0…, ch1…].
+		const downmixed = downmixPlanarChannelsForExport(source.planes, targetChannels);
+
+		for (let channel = 0; channel < targetChannels; channel++) {
+			const target = mixed[channel];
+			const base = channel * frameCount;
+			for (let frame = 0; frame < frameCount; frame++) {
+				const outFrame = source.startFrame + frame;
+				if (outFrame < 0) continue;
+				if (outFrame >= totalFrames) break;
+				target[outFrame] += downmixed[base + frame];
+			}
+		}
+	}
+
+	for (const channel of mixed) {
+		for (let frame = 0; frame < channel.length; frame++) {
+			const sample = channel[frame];
+			if (sample > 1) channel[frame] = 1;
+			else if (sample < -1) channel[frame] = -1;
+		}
+	}
+
+	return mixed;
+}
+
 export function downmixPlanarChannelsForExport(
 	sourcePlanes: Float32Array[],
 	targetChannels: number,
@@ -226,6 +291,277 @@ export class AudioProcessor {
 		);
 	}
 
+	/** All audio streams in the source, in container order. Empty on failure. */
+	private static async listAudioStreams(demuxer: WebDemuxer): Promise<WebAVStream[]> {
+		try {
+			const info = await demuxer.getMediaInfo();
+			return info.streams.filter((s) => s.codec_type_string === "audio");
+		} catch {
+			return [];
+		}
+	}
+
+	/**
+	 * Fully decodes one specific audio stream to contiguous planar PCM. Unlike
+	 * `demuxer.read("audio")`/`getDecoderConfig("audio")` — which resolve to the
+	 * single stream `av_find_best_stream` picks — this targets a stream by its
+	 * container index, so each track of a multi-track recording can be decoded
+	 * independently and then mixed. Returns null when the stream can't be decoded.
+	 */
+	private async decodeAudioStreamToPlanes(
+		demuxer: WebDemuxer,
+		stream: WebAVStream,
+		readEndSec: number | undefined,
+	): Promise<(PlanarAudioSource & { sampleRate: number; numberOfChannels: number }) | null> {
+		const config: AudioDecoderConfig = {
+			codec: stream.codec_string || "",
+			sampleRate: stream.sample_rate,
+			numberOfChannels: stream.channels,
+			description: stream.extradata && stream.extradata.length > 0 ? stream.extradata : undefined,
+		};
+		if (!config.codec || !config.sampleRate || !config.numberOfChannels) return null;
+
+		const support = await AudioDecoder.isConfigSupported(config);
+		if (!support.supported) {
+			console.warn(
+				`[AudioProcessor] Audio codec not supported for stream ${stream.index}:`,
+				config.codec,
+			);
+			return null;
+		}
+
+		const decoded: AudioData[] = [];
+		const decoder = new AudioDecoder({
+			output: (data: AudioData) => decoded.push(data),
+			error: (e: DOMException) => console.error("[AudioProcessor] Decode error:", e),
+		});
+		decoder.configure(config);
+
+		const safeReadEnd =
+			typeof readEndSec === "number" && Number.isFinite(readEndSec) ? Math.max(0, readEndSec) : 0;
+		const packetStream = demuxer.readAVPacket(
+			0,
+			safeReadEnd,
+			AVMediaType.AVMEDIA_TYPE_AUDIO,
+			stream.index,
+		);
+		const reader = packetStream.getReader();
+		try {
+			while (!this.cancelled) {
+				const { done, value: packet } = await reader.read();
+				if (done || !packet) break;
+				decoder.decode(
+					new EncodedAudioChunk({
+						type: packet.keyframe === 1 ? "key" : "delta",
+						timestamp: Math.round(packet.timestamp * 1_000_000),
+						duration: Math.round(packet.duration * 1_000_000),
+						data: packet.data,
+					}),
+				);
+				while (decoder.decodeQueueSize > DECODE_BACKPRESSURE_LIMIT && !this.cancelled) {
+					await new Promise((resolve) => setTimeout(resolve, 1));
+				}
+			}
+		} finally {
+			try {
+				await reader.cancel();
+			} catch {
+				/* reader already closed */
+			}
+		}
+
+		if (decoder.state === "configured") {
+			if (!this.cancelled) await decoder.flush();
+			decoder.close();
+		}
+
+		if (this.cancelled || decoded.length === 0) {
+			for (const d of decoded) d.close();
+			return null;
+		}
+
+		// Decode order is normally monotonic; sort defensively so timeline placement
+		// stays correct even if the decoder emits out of order.
+		decoded.sort((a, b) => a.timestamp - b.timestamp);
+		const sampleRate = decoded[0].sampleRate;
+		const numberOfChannels = decoded[0].numberOfChannels;
+		// Absolute timeline position of this stream's first sample (mic tracks often
+		// start slightly after the video, e.g. start_time ~0.17s), so mixing keeps
+		// every track locked to the same source-time origin the video uses. Kept signed:
+		// AAC preroll carries a negative timestamp, and clamping it to zero would land the
+		// preroll and the real timestamp-zero frame on the same offset. mixPlanarSources()
+		// discards frames before zero, so the signed origin stays correct.
+		const startFrame = Math.round((decoded[0].timestamp / 1_000_000) * sampleRate);
+
+		let totalFrames = 0;
+		for (const d of decoded) {
+			const frameOffset =
+				Math.round((d.timestamp / 1_000_000) * sampleRate) - startFrame + d.numberOfFrames;
+			if (frameOffset > totalFrames) totalFrames = frameOffset;
+		}
+
+		const planes = Array.from({ length: numberOfChannels }, () => new Float32Array(totalFrames));
+		for (const d of decoded) {
+			const at = Math.max(0, Math.round((d.timestamp / 1_000_000) * sampleRate) - startFrame);
+			const room = totalFrames - at;
+			if (room > 0) {
+				const take = Math.min(d.numberOfFrames, room);
+				for (let c = 0; c < numberOfChannels; c++) {
+					const temp = new Float32Array(d.numberOfFrames);
+					d.copyTo(temp, { format: "f32-planar", planeIndex: c });
+					planes[c].set(temp.subarray(0, take), at);
+				}
+			}
+			d.close();
+		}
+
+		return { planes, startFrame, sampleRate, numberOfChannels };
+	}
+
+	/**
+	 * Decodes every audio stream and mixes them into one planar timeline (see
+	 * {@link mixPlanarSources}). Returns null when there is at most one audio stream
+	 * (callers keep the existing single-stream fast path) or when the streams can't
+	 * be mixed (e.g. mismatched sample rates — never the case for native captures,
+	 * which are all 48 kHz).
+	 */
+	private async decodeMixedAudioPlanes(
+		demuxer: WebDemuxer,
+		streams: WebAVStream[],
+		readEndSec: number | undefined,
+		outputChannels: number,
+	): Promise<{ planes: Float32Array[]; sampleRate: number; numberOfChannels: number } | null> {
+		if (streams.length < 2) return null;
+
+		const sources: Array<PlanarAudioSource & { sampleRate: number }> = [];
+		for (const stream of streams) {
+			if (this.cancelled) return null;
+			const decoded = await this.decodeAudioStreamToPlanes(demuxer, stream, readEndSec);
+			if (decoded) sources.push(decoded);
+		}
+
+		if (sources.length === 0) return null;
+		// If only one of several streams decoded, keep it rather than falling back to the
+		// demuxer's best stream — that fallback can re-select the stream that just failed
+		// to decode and export silence. mixPlanarSources() handles a single source fine.
+
+		const sampleRate = sources[0].sampleRate;
+		if (sources.some((s) => s.sampleRate !== sampleRate)) {
+			console.warn(
+				`[AudioProcessor] Audio streams differ in sample rate; skipping mix (rates: ${sources
+					.map((s) => s.sampleRate)
+					.join(", ")}Hz)`,
+			);
+			return null;
+		}
+
+		const channels = Math.min(2, Math.max(1, outputChannels || 2));
+		let totalFrames = 0;
+		for (const s of sources) {
+			const end = s.startFrame + (s.planes[0]?.length ?? 0);
+			if (end > totalFrames) totalFrames = end;
+		}
+		if (totalFrames === 0) return null;
+
+		const planes = mixPlanarSources(
+			sources.map((s) => ({ planes: s.planes, startFrame: s.startFrame })),
+			channels,
+			totalFrames,
+		);
+		console.log(
+			`[AudioProcessor] Mixed ${sources.length} audio tracks (${totalFrames} frames @ ${sampleRate}Hz)`,
+		);
+		return { planes, sampleRate, numberOfChannels: channels };
+	}
+
+	/**
+	 * Encodes a pre-mixed planar timeline into the muxer, applying the same trim
+	 * skipping + timestamp remap the single-stream trim-only path uses. Blocks are a
+	 * single AAC frame wide so trim boundaries land at the same granularity.
+	 */
+	private async encodeMixedPlanarTimeline(
+		mixed: { planes: Float32Array[]; sampleRate: number; numberOfChannels: number },
+		muxer: VideoMuxer,
+		sortedTrims: TrimRegion[],
+		exportCodec: ExportAudioCodec,
+	): Promise<void> {
+		const { planes, sampleRate } = mixed;
+		const totalFrames = planes[0]?.length ?? 0;
+		if (totalFrames === 0) return;
+
+		const outputSampleRate = exportCodec.sampleRate || sampleRate;
+		const outputChannels = exportCodec.numberOfChannels || mixed.numberOfChannels;
+
+		const encodeConfig: AudioEncoderConfig = {
+			codec: exportCodec.encoderCodec,
+			sampleRate: outputSampleRate,
+			numberOfChannels: outputChannels,
+			bitrate: AUDIO_BITRATE,
+		};
+		const encodeSupport = await AudioEncoder.isConfigSupported(encodeConfig);
+		if (!encodeSupport.supported) {
+			console.warn(`[AudioProcessor] ${exportCodec.label} encoding not supported, skipping audio`);
+			return;
+		}
+
+		const encodedChunks: { chunk: EncodedAudioChunk; meta?: EncodedAudioChunkMetadata }[] = [];
+		const encoder = new AudioEncoder({
+			output: (chunk: EncodedAudioChunk, meta?: EncodedAudioChunkMetadata) => {
+				encodedChunks.push({ chunk, meta });
+			},
+			error: (e: DOMException) => console.error("[AudioProcessor] Encode error:", e),
+		});
+		encoder.configure(encodeConfig);
+
+		// One AAC frame per block so trim skipping matches the packet granularity of
+		// the single-stream path.
+		const BLOCK_FRAMES = 1024;
+		for (let start = 0; start < totalFrames && !this.cancelled; start += BLOCK_FRAMES) {
+			const count = Math.min(BLOCK_FRAMES, totalFrames - start);
+			const timestampMs = (start / sampleRate) * 1000;
+			if (this.isInTrimRegion(timestampMs, sortedTrims)) continue;
+
+			const trimOffsetMs = this.computeTrimOffset(timestampMs, sortedTrims);
+			const adjustedTimestampUs = Math.max(
+				0,
+				Math.round((start / sampleRate - trimOffsetMs / 1000) * 1_000_000),
+			);
+
+			const buffer = new Float32Array(count * outputChannels);
+			for (let c = 0; c < outputChannels; c++) {
+				const srcPlane = planes[Math.min(c, planes.length - 1)];
+				buffer.set(srcPlane.subarray(start, start + count), c * count);
+			}
+
+			const audioData = new AudioData({
+				format: "f32-planar",
+				sampleRate: outputSampleRate,
+				numberOfFrames: count,
+				numberOfChannels: outputChannels,
+				timestamp: adjustedTimestampUs,
+				data: buffer.buffer as ArrayBuffer,
+			});
+			encoder.encode(audioData);
+			audioData.close();
+
+			while (encoder.encodeQueueSize > ENCODE_BACKPRESSURE_LIMIT && !this.cancelled) {
+				await new Promise((resolve) => setTimeout(resolve, 1));
+			}
+		}
+
+		if (encoder.state === "configured") {
+			await encoder.flush();
+			encoder.close();
+		}
+
+		for (const { chunk, meta } of encodedChunks) {
+			if (this.cancelled) break;
+			await muxer.addAudioChunk(chunk, meta);
+		}
+
+		console.log(`[AudioProcessor] Encoded mixed audio timeline: ${encodedChunks.length} chunks`);
+	}
+
 	/**
 	 * Two modes: no speed regions uses the fast WebCodecs trim-only pipeline; speed
 	 * regions use the pitch-preserving rendered timeline pipeline.
@@ -254,7 +590,12 @@ export class AudioProcessor {
 		if (sortedSpeedRegions.length > 0) {
 			const segments = buildSpeedSegments(validatedDurationSec, sortedTrims, sortedSpeedRegions);
 
-			if (maxTimelineSpeed(segments) > MAX_NATIVE_PLAYBACK_RATE) {
+			// The real-time capture path plays the file through an <audio> element,
+			// which decodes only one audio track — so multi-track recordings must take
+			// the offline WebCodecs path, the only one that can decode every track and
+			// mix them. (Losing the mic entirely is worse than WSOLA vs real-time.)
+			const audioStreams = await AudioProcessor.listAudioStreams(demuxer);
+			if (maxTimelineSpeed(segments) > MAX_NATIVE_PLAYBACK_RATE || audioStreams.length > 1) {
 				await this.renderOfflineTimelineAudio(
 					demuxer,
 					muxer,
@@ -293,6 +634,27 @@ export class AudioProcessor {
 		readEndSec?: number,
 		exportCodec?: ExportAudioCodec,
 	): Promise<void> {
+		// Multi-track recordings (native macOS writes system audio + mic as separate
+		// tracks) must be mixed — reading only the best stream drops the other track,
+		// which is how the mic went missing in issue #108. Single-track sources keep
+		// the original fast path below.
+		const audioStreams = await AudioProcessor.listAudioStreams(demuxer);
+		if (audioStreams.length > 1 && exportCodec) {
+			const mixed = await this.decodeMixedAudioPlanes(
+				demuxer,
+				audioStreams,
+				readEndSec,
+				exportCodec.numberOfChannels,
+			);
+			if (this.cancelled) return;
+			if (mixed) {
+				await this.encodeMixedPlanarTimeline(mixed, muxer, sortedTrims, exportCodec);
+				return;
+			}
+			// Mixing unavailable (e.g. only one stream decoded); fall through to the
+			// single-stream path rather than exporting silence.
+		}
+
 		let audioConfig: AudioDecoderConfig;
 		try {
 			audioConfig = await demuxer.getDecoderConfig("audio");
@@ -648,22 +1010,42 @@ export class AudioProcessor {
 		exportCodec: ExportAudioCodec,
 		targetFrameRate: number,
 	): Promise<void> {
-		let audioConfig: AudioDecoderConfig;
-		try {
-			audioConfig = await demuxer.getDecoderConfig("audio");
-		} catch {
-			console.warn("[AudioProcessor] No audio track found, skipping");
-			return;
-		}
+		// Multi-track sources are decoded and mixed up front, then fed through the same
+		// segment/WSOLA machinery as a single pre-mixed stream. Single-track sources
+		// stream through the decoder as before.
+		const audioStreams = await AudioProcessor.listAudioStreams(demuxer);
+		const lastSegmentEndSec = segments.length > 0 ? segments[segments.length - 1].endSec : 0;
+		const mixReadEndSec = lastSegmentEndSec + 0.5;
+		const mixed =
+			audioStreams.length > 1
+				? await this.decodeMixedAudioPlanes(
+						demuxer,
+						audioStreams,
+						mixReadEndSec,
+						exportCodec.numberOfChannels,
+					)
+				: null;
+		if (this.cancelled) return;
 
-		const codecCheck = await AudioDecoder.isConfigSupported(audioConfig);
-		if (!codecCheck.supported) {
-			console.warn("[AudioProcessor] Audio codec not supported:", audioConfig.codec);
-			return;
+		let audioConfig: AudioDecoderConfig | null = null;
+		if (!mixed) {
+			try {
+				audioConfig = await demuxer.getDecoderConfig("audio");
+			} catch {
+				console.warn("[AudioProcessor] No audio track found, skipping");
+				return;
+			}
+
+			const codecCheck = await AudioDecoder.isConfigSupported(audioConfig);
+			if (!codecCheck.supported) {
+				console.warn("[AudioProcessor] Audio codec not supported:", audioConfig.codec);
+				return;
+			}
 		}
 
-		const sampleRate = audioConfig.sampleRate || 48000;
-		const outputChannels = exportCodec.numberOfChannels || audioConfig.numberOfChannels || 2;
+		const sampleRate = mixed?.sampleRate || audioConfig?.sampleRate || 48000;
+		const outputChannels =
+			exportCodec.numberOfChannels || mixed?.numberOfChannels || audioConfig?.numberOfChannels || 2;
 		const outputSampleRate = exportCodec.sampleRate || sampleRate;
 
 		const encodeConfig: AudioEncoderConfig = {
@@ -812,89 +1194,104 @@ export class AudioProcessor {
 			}
 		};
 
-		// Streaming decode: frames arrive in source order via the decoder callback.
-		const pending: AudioData[] = [];
-		const decoder = new AudioDecoder({
-			output: (data: AudioData) => pending.push(data),
-			error: (e: DOMException) => console.error("[AudioProcessor] Decode error:", e),
-		});
-		decoder.configure(audioConfig);
-
-		const drainPending = async () => {
-			while (pending.length > 0) {
-				if (this.cancelled) {
-					for (const d of pending) d.close();
-					pending.length = 0;
-					return;
-				}
-				const data = pending.shift();
-				if (!data) continue;
-				const frameCount = data.numberOfFrames;
-				const sourceChannels = data.numberOfChannels;
-				const srcPlanes: Float32Array[] = [];
-				for (let c = 0; c < sourceChannels; c++) {
-					const plane = new Float32Array(frameCount);
-					data.copyTo(plane, { format: "f32-planar", planeIndex: c });
-					srcPlanes.push(plane);
-				}
-				// Raw source timestamps — the same origin the video decoder uses
-				// (streamingDecoder), so audio and video stay in one coordinate system.
-				// Frames before the first segment start (e.g. negative-timestamp codec
-				// preroll, or a leading trim) are correctly discarded by routeFrame.
-				const frameStartSample = Math.round((data.timestamp / 1_000_000) * sampleRate);
-				data.close();
-
-				// Match source channels through untouched; otherwise downmix (to 1 or 2).
-				let planes: Float32Array[];
-				if (outputChannels === sourceChannels) {
-					planes = srcPlanes;
-				} else {
-					const downmixed = downmixPlanarChannelsForExport(srcPlanes, outputChannels);
-					planes = [];
-					for (let c = 0; c < outputChannels; c++) {
-						planes.push(downmixed.subarray(c * frameCount, (c + 1) * frameCount));
-					}
-				}
-
-				routeFrame(planes, frameStartSample, frameCount);
+		if (mixed) {
+			// Pre-mixed timeline (multi-track): route it through the same segment/WSOLA
+			// machinery in source order, in fixed-size chunks. The mixed buffer starts
+			// at source-time 0 so a chunk's start index is its absolute source sample.
+			const total = mixed.planes[0]?.length ?? 0;
+			const CHUNK_FRAMES = 4096;
+			for (let start = 0; start < total && !this.cancelled; start += CHUNK_FRAMES) {
+				const count = Math.min(CHUNK_FRAMES, total - start);
+				const chunkPlanes = mixed.planes.map((p) => p.subarray(start, start + count));
+				routeFrame(chunkPlanes, start, count);
 				flushOutput(false);
-
 				while (encoder.encodeQueueSize > ENCODE_BACKPRESSURE_LIMIT && !this.cancelled) {
 					await new Promise((resolve) => setTimeout(resolve, 1));
 				}
 			}
-		};
+		} else if (audioConfig) {
+			// Streaming decode: frames arrive in source order via the decoder callback.
+			const pending: AudioData[] = [];
+			const decoder = new AudioDecoder({
+				output: (data: AudioData) => pending.push(data),
+				error: (e: DOMException) => console.error("[AudioProcessor] Decode error:", e),
+			});
+			decoder.configure(audioConfig);
 
-		// Read past the last segment's source end (mirrors streamingDecoder's +0.5s
-		// window so both paths read the same distance past the boundary).
-		const lastSegmentEndSec = segments.length > 0 ? segments[segments.length - 1].endSec : 0;
-		const readEndSec = lastSegmentEndSec + 0.5;
-		const reader = demuxer.read("audio", 0, readEndSec).getReader();
-		try {
-			while (!this.cancelled) {
-				const { done, value: chunk } = await reader.read();
-				if (done || !chunk) break;
-				decoder.decode(chunk);
-				while (decoder.decodeQueueSize > DECODE_BACKPRESSURE_LIMIT && !this.cancelled) {
-					await new Promise((resolve) => setTimeout(resolve, 1));
+			const drainPending = async () => {
+				while (pending.length > 0) {
+					if (this.cancelled) {
+						for (const d of pending) d.close();
+						pending.length = 0;
+						return;
+					}
+					const data = pending.shift();
+					if (!data) continue;
+					const frameCount = data.numberOfFrames;
+					const sourceChannels = data.numberOfChannels;
+					const srcPlanes: Float32Array[] = [];
+					for (let c = 0; c < sourceChannels; c++) {
+						const plane = new Float32Array(frameCount);
+						data.copyTo(plane, { format: "f32-planar", planeIndex: c });
+						srcPlanes.push(plane);
+					}
+					// Raw source timestamps — the same origin the video decoder uses
+					// (streamingDecoder), so audio and video stay in one coordinate system.
+					// Frames before the first segment start (e.g. negative-timestamp codec
+					// preroll, or a leading trim) are correctly discarded by routeFrame.
+					const frameStartSample = Math.round((data.timestamp / 1_000_000) * sampleRate);
+					data.close();
+
+					// Match source channels through untouched; otherwise downmix (to 1 or 2).
+					let planes: Float32Array[];
+					if (outputChannels === sourceChannels) {
+						planes = srcPlanes;
+					} else {
+						const downmixed = downmixPlanarChannelsForExport(srcPlanes, outputChannels);
+						planes = [];
+						for (let c = 0; c < outputChannels; c++) {
+							planes.push(downmixed.subarray(c * frameCount, (c + 1) * frameCount));
+						}
+					}
+
+					routeFrame(planes, frameStartSample, frameCount);
+					flushOutput(false);
+
+					while (encoder.encodeQueueSize > ENCODE_BACKPRESSURE_LIMIT && !this.cancelled) {
+						await new Promise((resolve) => setTimeout(resolve, 1));
+					}
 				}
-				await drainPending();
-			}
-		} finally {
+			};
+
+			// Read past the last segment's source end (mirrors streamingDecoder's +0.5s
+			// window so both paths read the same distance past the boundary).
+			const reader = demuxer.read("audio", 0, mixReadEndSec).getReader();
 			try {
-				await reader.cancel();
-			} catch {
-				/* reader already closed */
+				while (!this.cancelled) {
+					const { done, value: chunk } = await reader.read();
+					if (done || !chunk) break;
+					decoder.decode(chunk);
+					while (decoder.decodeQueueSize > DECODE_BACKPRESSURE_LIMIT && !this.cancelled) {
+						await new Promise((resolve) => setTimeout(resolve, 1));
+					}
+					await drainPending();
+				}
+			} finally {
+				try {
+					await reader.cancel();
+				} catch {
+					/* reader already closed */
+				}
 			}
-		}
 
-		if (decoder.state === "configured") {
-			if (!this.cancelled) {
-				await decoder.flush();
+			if (decoder.state === "configured") {
+				if (!this.cancelled) {
+					await decoder.flush();
+				}
+				decoder.close();
 			}
-			decoder.close();
+			await drainPending();
 		}
-		await drainPending();
 
 		if (this.cancelled) {
 			if (encoder.state === "configured") encoder.close();
diff --git a/src/lib/exporter/audioMixExport.browser.test.ts b/src/lib/exporter/audioMixExport.browser.test.ts
new file mode 100644
index 0000000000..e4ca8d224e
--- /dev/null
+++ b/src/lib/exporter/audioMixExport.browser.test.ts
@@ -0,0 +1,90 @@
+import { describe, expect, it } from "vitest";
+import dualAudioUrl from "../../../tests/fixtures/sample-dual-audio.mp4?url";
+import { VideoExporter } from "./videoExporter";
+
+/**
+ * Regression test for issue #108: native macOS recordings write system audio and
+ * the microphone as two separate tracks. FFmpeg's `av_find_best_stream` (used by
+ * web-demuxer) resolves the bare "audio" selector to the first track, so when the
+ * system-audio track is silent the exporter dropped the mic and produced silence.
+ *
+ * The fixture mirrors that layout: track 0 is silent, track 1 is a 440 Hz tone.
+ * A correct export mixes both, so the output must carry the tone.
+ */
+async function measureAudioRms(blob: Blob): Promise<{ rms: number; hasAudio: boolean }> {
+	const bytes = await blob.arrayBuffer();
+	const audioContext = new AudioContext();
+	try {
+		const audioBuffer = await audioContext.decodeAudioData(bytes.slice(0));
+		if (audioBuffer.numberOfChannels === 0 || audioBuffer.length === 0) {
+			return { rms: 0, hasAudio: false };
+		}
+		let sumSquares = 0;
+		let sampleCount = 0;
+		for (let channel = 0; channel < audioBuffer.numberOfChannels; channel++) {
+			const data = audioBuffer.getChannelData(channel);
+			for (let i = 0; i < data.length; i++) {
+				sumSquares += data[i] * data[i];
+				sampleCount++;
+			}
+		}
+		return { rms: Math.sqrt(sumSquares / sampleCount), hasAudio: true };
+	} finally {
+		await audioContext.close();
+	}
+}
+
+describe("Multi-track audio export (real browser)", () => {
+	it("mixes both audio tracks so a silent first track can't drop the mic (#108)", async () => {
+		const exporter = new VideoExporter({
+			videoUrl: dualAudioUrl,
+			width: 320,
+			height: 180,
+			frameRate: 15,
+			bitrate: 1_000_000,
+			wallpaper: "#1a1a2e",
+			zoomRegions: [],
+			showShadow: false,
+			shadowIntensity: 0,
+			showBlur: false,
+			cropRegion: { x: 0, y: 0, width: 1, height: 1 },
+		});
+
+		const result = await exporter.export();
+		expect(result.success, result.error).toBe(true);
+		expect(result.blob).toBeInstanceOf(Blob);
+
+		const { rms, hasAudio } = await measureAudioRms(result.blob!);
+		expect(hasAudio).toBe(true);
+		// Silence (the first track alone) sits near 0; the mixed-in 440 Hz tone lifts
+		// RMS to ~0.08. Threshold sits below the tone's real level but well above the
+		// noise floor, so a near-silent fallback (the old #108 bug) still fails.
+		expect(rms).toBeGreaterThan(0.05);
+	});
+
+	it("mixes both audio tracks through the speed-region (offline) path too", async () => {
+		const exporter = new VideoExporter({
+			videoUrl: dualAudioUrl,
+			width: 320,
+			height: 180,
+			frameRate: 15,
+			bitrate: 1_000_000,
+			wallpaper: "#1a1a2e",
+			zoomRegions: [],
+			// A speed region routes audio through renderOfflineTimelineAudio, a distinct
+			// mixing branch from the trim-only path exercised above.
+			speedRegions: [{ id: "speed", startMs: 500, endMs: 1500, speed: 2 }],
+			showShadow: false,
+			shadowIntensity: 0,
+			showBlur: false,
+			cropRegion: { x: 0, y: 0, width: 1, height: 1 },
+		});
+
+		const result = await exporter.export();
+		expect(result.success, result.error).toBe(true);
+
+		const { rms, hasAudio } = await measureAudioRms(result.blob!);
+		expect(hasAudio).toBe(true);
+		expect(rms).toBeGreaterThan(0.05);
+	});
+});
diff --git a/src/lib/exporter/streamingDecoder.ts b/src/lib/exporter/streamingDecoder.ts
index 54f4b9f8d8..8dd7634706 100644
--- a/src/lib/exporter/streamingDecoder.ts
+++ b/src/lib/exporter/streamingDecoder.ts
@@ -67,6 +67,8 @@ export interface DecodedVideoInfo {
 	codec: string;
 	hasAudio: boolean;
 	audioCodec?: string;
+	/** Number of audio streams in the container (native macOS writes system + mic separately). */
+	audioStreamCount: number;
 }
 
 type EarlyDecodeEndCheck = {
@@ -283,7 +285,8 @@ export class StreamingVideoDecoder {
 			}
 		}
 
-		const audioStream = mediaInfo.streams.find((s) => s.codec_type_string === "audio");
+		const audioStreams = mediaInfo.streams.filter((s) => s.codec_type_string === "audio");
+		const audioStream = audioStreams[0];
 
 		// Scan video packets for the true content boundary; MediaRecorder (especially on
 		// Linux) writes unreliable container durations and packet timestamps are ground truth.
@@ -329,6 +332,7 @@ export class StreamingVideoDecoder {
 			codec: videoStream?.codec_string || "unknown",
 			hasAudio: !!audioStream,
 			audioCodec: audioStream?.codec_string,
+			audioStreamCount: audioStreams.length,
 		};
 
 		return this.metadata;
diff --git a/src/lib/exporter/videoExporter.test.ts b/src/lib/exporter/videoExporter.test.ts
index 176f5f8edb..4ce257e362 100644
--- a/src/lib/exporter/videoExporter.test.ts
+++ b/src/lib/exporter/videoExporter.test.ts
@@ -129,6 +129,29 @@ describe("getSourceCopyFastPathBlockers", () => {
 			}),
 		).toContain("output-size 1920x1080 differs from source 1920x1032");
 	});
+
+	// A verbatim source copy would carry over every audio track; most players play only
+	// the first, which on native macOS captures is often the silent system track — the
+	// #108 bug. Multi-track sources must be blocked from the copy path so they get mixed.
+	it("blocks the copy path when the source has multiple audio tracks (#108)", () => {
+		expect(
+			getSourceCopyFastPathBlockers(createConfig(), {
+				width: 1920,
+				height: 1080,
+				audioStreamCount: 2,
+			}),
+		).toContain("source has multiple audio tracks (must be mixed)");
+	});
+
+	it("does not report the audio-track blocker for a single-track source", () => {
+		expect(
+			getSourceCopyFastPathBlockers(createConfig(), {
+				width: 1920,
+				height: 1080,
+				audioStreamCount: 1,
+			}),
+		).not.toContain("source has multiple audio tracks (must be mixed)");
+	});
 });
 
 // The original bug measured the timeout from the encoder's last *output* event
diff --git a/src/lib/exporter/videoExporter.ts b/src/lib/exporter/videoExporter.ts
index 2703a9437f..03af3fa88c 100644
--- a/src/lib/exporter/videoExporter.ts
+++ b/src/lib/exporter/videoExporter.ts
@@ -121,14 +121,14 @@ function isDefaultCrop(cropRegion: CropRegion) {
 
 export function isSourceCopyFastPathEligible(
 	config: VideoExporterConfig,
-	videoInfo: { width: number; height: number },
+	videoInfo: { width: number; height: number; audioStreamCount?: number },
 ) {
 	return getSourceCopyFastPathBlockers(config, videoInfo).length === 0;
 }
 
 export function getSourceCopyFastPathBlockers(
 	config: VideoExporterConfig,
-	videoInfo: { width: number; height: number },
+	videoInfo: { width: number; height: number; audioStreamCount?: number },
 ) {
 	const blockers: string[] = [];
 
@@ -137,6 +137,13 @@ export function getSourceCopyFastPathBlockers(
 			`output-size ${config.width}x${config.height} differs from source ${videoInfo.width}x${videoInfo.height}`,
 		);
 	}
+	// Copying the source verbatim would carry over its multiple audio tracks (native
+	// macOS writes system audio + mic separately). Most players play only the first,
+	// which is often the silent system track — so multi-track sources must go through
+	// the full pipeline, which mixes every track into one (issue #108).
+	if ((videoInfo.audioStreamCount ?? 0) > 1) {
+		blockers.push("source has multiple audio tracks (must be mixed)");
+	}
 	if (config.webcamVideoUrl) blockers.push("webcam overlay is enabled");
 	if (hasActiveTimeRegions(config.trimRegions)) blockers.push("trim regions are present");
 	if (hasActiveSpeedRegions(config.speedRegions)) blockers.push("speed regions are present");
diff --git a/tests/fixtures/sample-dual-audio.mp4 b/tests/fixtures/sample-dual-audio.mp4
new file mode 100644
index 0000000000..e0a504dd4d
Binary files /dev/null and b/tests/fixtures/sample-dual-audio.mp4 differ