From 9920be77a41327025e9d431395f22bc0bbe1a982 Mon Sep 17 00:00:00 2001
From: Glen Barnes <barnaclebarnes@mac.com>
Date: Fri, 17 Jul 2026 16:02:15 +1200
Subject: [PATCH] fix(export): mix all source audio tracks so the mic isn't
 dropped
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Native macOS recordings write system audio and the microphone as two
separate AAC tracks in the screen recording, and both are flagged
`default`. The exporter decoded audio through web-demuxer's bare "audio"
selector, which resolves to the single stream FFmpeg's
`av_find_best_stream` picks — the first (system-audio) track. When
nothing was playing, that track is silent, so the exported video had no
audible audio even though the mic was recorded fine. The browser
recorder already blends system + mic into one track; the native path
never did.

Decode every audio stream and mix them into one timeline before
encoding, mirroring the browser recorder:

- `mixPlanarSources` (pure, unit-tested) sums each decoded source,
  downmixed to the target channels and aligned at its source-time
  offset, clamped to [-1, 1].
- Per-stream decode via `readAVPacket(streamIndex)` targets each track
  by container index instead of the best-stream heuristic.
- The trim-only and offline (speed) export paths both mix multi-track
  sources; multi-track speed projects are routed to the offline path
  because the real-time <audio> capture can only play one track.
- The source-copy fast path is disabled for multi-track sources, since
  copying verbatim carries both tracks over and players fall back to the
  silent first one.

Single-track recordings keep the original fast path unchanged. Adds a
real-browser regression test (fixture: silent track + 440 Hz tone) that
asserts the exported audio carries the tone through both mixing paths.

Closes #108

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 .gitignore                                    |   1 +
 src/lib/exporter/audioEncoder.test.ts         |  94 ++-
 src/lib/exporter/audioEncoder.ts              | 558 +++++++++++++++---
 .../exporter/audioMixExport.browser.test.ts   |  90 +++
 src/lib/exporter/streamingDecoder.ts          |   6 +-
 src/lib/exporter/videoExporter.ts             |  11 +-
 tests/fixtures/sample-dual-audio.mp4          | Bin 0 -> 23515 bytes
 7 files changed, 670 insertions(+), 90 deletions(-)
 create mode 100644 src/lib/exporter/audioMixExport.browser.test.ts
 create mode 100644 tests/fixtures/sample-dual-audio.mp4

diff --git a/.gitignore b/.gitignore
index 61dc9d2fc..33cf7a9d2 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/src/lib/exporter/audioEncoder.test.ts b/src/lib/exporter/audioEncoder.test.ts
index 0fb3708c5..13f29af10 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,95 @@ 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("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 b97aea1fd..9e7e85cae 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,68 @@ 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 clamped to [-1, 1] so a loud overlap can't wrap or
+ * overflow the encoder. 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 +288,269 @@ 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.
+		const startFrame = Math.max(0, 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;
+		// A single decodable stream can't be "mixed" — fall back to the normal path.
+		if (sources.length === 1) return null;
+
+		const sampleRate = sources[0].sampleRate;
+		if (sources.some((s) => s.sampleRate !== sampleRate)) {
+			console.warn("[AudioProcessor] Audio streams differ in sample rate; skipping mix");
+			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 +579,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 +623,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 +999,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 +1183,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 000000000..0897ba979
--- /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 well above the noise floor. A comfortable threshold below the tone's
+		// real level (~0.08) but far above silence.
+		expect(rms).toBeGreaterThan(0.01);
+	});
+
+	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.01);
+	});
+});
diff --git a/src/lib/exporter/streamingDecoder.ts b/src/lib/exporter/streamingDecoder.ts
index 54f4b9f8d..8dd763470 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.ts b/src/lib/exporter/videoExporter.ts
index 2703a9437..03af3fa88 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 0000000000000000000000000000000000000000..e0a504dd4dffcfb99be0d57632a4bf6cad19fc45
GIT binary patch
literal 23515
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

literal 0
HcmV?d00001