diff --git a/examples/media-player/index.html b/examples/media-player/index.html
index 1e9e5c5..6f3ff31 100644
--- a/examples/media-player/index.html
+++ b/examples/media-player/index.html
@@ -78,6 +78,8 @@
 
 				<p id="duration" class="tabular-nums w-10 sm:w-24 text-sm"></p>
 
+				<button id="live-dot" title="Seek to live edge" style="display: none;" class="mx-2 size-3 rounded-full bg-red-500 cursor-pointer shrink-0 animate-pulse"></button>
+
 				<button class="p-2 group outline-none" id="fullscreen-button">
 					<div class="size-6 invert group-hover:scale-110">
 						<img src="../../docs/assets/fullscreen-icon.svg" class="size-full">
diff --git a/examples/media-player/media-player.ts b/examples/media-player/media-player.ts
index bb8b94d..1e1169a 100644
--- a/examples/media-player/media-player.ts
+++ b/examples/media-player/media-player.ts
@@ -1,19 +1,10 @@
 import {
 	ALL_FORMATS,
 	AudioBufferSink,
-	BlobSource,
 	CanvasSink,
-	Input,
-	InputAudioTrack,
-	InputVideoTrack,
-	UrlSource,
+	createInputFrom,
 	WrappedAudioBuffer,
 	WrappedCanvas,
-	asc,
-	canDecodeAudio,
-	createInputFrom,
-	desc,
-	prefer,
 } from 'mediabunny';
 
 import SampleFileUrl from '../../docs/assets/big-buck-bunny-trimmed.mp4';
@@ -38,6 +29,7 @@ const volumeBarContainer = document.querySelector('#volume-bar-container') as HT
 const volumeBar = document.querySelector('#volume-bar') as HTMLDivElement;
 const volumeIconWrapper = document.querySelector('#volume-icon-wrapper') as HTMLDivElement;
 const volumeButton = document.querySelector('#volume-button') as HTMLButtonElement;
+const liveDot = document.querySelector('#live-dot') as HTMLButtonElement;
 const fullscreenButton = document.querySelector('#fullscreen-button') as HTMLButtonElement;
 const errorElement = document.querySelector('#error-element') as HTMLDivElement;
 const warningElement = document.querySelector('#warning-element') as HTMLDivElement;
@@ -51,7 +43,9 @@ let fileLoaded = false;
 let videoSink: CanvasSink | null = null;
 let audioSink: AudioBufferSink | null = null;
 
-let totalDuration = 0;
+let firstTimestamp = 0;
+let endTimestamp = 0;
+let isRelativeToUnixEpoch = false;
 /** The value of the audio context's currentTime the moment the playback was started. */
 let audioContextStartTime: number | null = null;
 let playing = false;
@@ -69,6 +63,8 @@ const queuedAudioNodes: Set<AudioBufferSourceNode> = new Set();
  */
 let asyncId = 0;
 
+let liveRefreshIntervalId = -1;
+
 let draggingProgressBar = false;
 let volume = 0.7;
 let draggingVolumeBar = false;
@@ -84,107 +80,49 @@ const initMediaPlayer = async (resource: File | string) => {
 			pause();
 		}
 
-		// const dirHandle = await showDirectoryPicker({ mode: 'read' });
-
 		void videoFrameIterator?.return();
 		void audioBufferIterator?.return();
+
 		asyncId++;
 
 		fileLoaded = false;
-		fileNameElement.textContent = 'pish'; // resource instanceof File ? resource.name : resource;
+		fileNameElement.textContent = resource instanceof File ? resource.name : resource;
 		horizontalRule.style.display = '';
 		loadingElement.style.display = '';
 		playerContainer.style.display = 'none';
 		errorElement.textContent = '';
 		warningElement.textContent = '';
+		liveDot.style.display = 'none';
+		clearTimeout(liveRefreshIntervalId);
 
-		const start = 0;
-
-		let videoTrack: InputVideoTrack | null = null;
-		let audioTrack: InputAudioTrack | null = null;
-		if (true || typeof resource === 'string' && resource.includes('.m3u8')) {
-			const input = createInputFrom(resource, ALL_FORMATS);
-
-			/*
-			const input = new Input({
-				entryPath: resource, // 'master.m3u8',
-				source: async ({ path }) => {
-					return new UrlSource(path);
-					const fileHandle = await dirHandle.getFileHandle(path);
-					const file = await fileHandle.getFile();
-					return new BlobSource(file);
-				},
-				formats: ALL_FORMATS,
-			});
-			*/
-			// const variant = (await manifestInput.getVariants())[0]!;
-
-			// console.log(await input.getFormat(), await input.getTracks());
-			// return;
-
-			/*
-			await input.getVideoTracks({
-				filter: desc => desc.hasPairableAudioTrack(),
-				sortBy: desc => asc(desc.bitrate),
-			});
-			*/
-
-			videoTrack = await input.getPrimaryVideoTrack({
-				filter: async desc => (desc.displayHeight ?? (await desc.getTrack()).displayHeight) < 720,
-				// filter: async track => (await track.resolve('displayHeight')) < 1080,
-			});
-			audioTrack = await input.getPrimaryAudioTrack({
-				sortBy: desc => prefer(desc.canBePairedWith(videoTrack)),
-			});
-
-			// await videoTrack?.hydrate();
-			// await audioTrack?.hydrate();
-
-			totalDuration = Math.max(
-				await videoTrack?.computeDuration({ skipLiveWait: true }) ?? 0,
-				await audioTrack?.computeDuration({ skipLiveWait: true }) ?? 0,
-			);
-
-			console.log(videoTrack, audioTrack, totalDuration);
-
-			// start = totalDuration - 2;
-
-			// totalDuration += 3600;
-
-			// https://test-streams.mux.dev/test_001/stream.m3u8
-			// https://test-streams.mux.dev/test_001/stream_1000k_48k_640x360_050.ts
-		} else {
-			const source = resource instanceof File
-				? new BlobSource(resource)
-				: new UrlSource(resource);
-
-			const input = new Input({
-				source,
-				formats: ALL_FORMATS,
-			});
-
-			totalDuration = await input.computeDuration();
-			videoTrack = await input.getPrimaryVideoTrack();
-			audioTrack = await input.getPrimaryAudioTrack();
-		}
-
-		/*
 		// Create an Input from the resource
-		const source = resource instanceof File
-			? new BlobSource(resource)
-			: new UrlSource(resource);
-		*/
+		const input = createInputFrom(resource, ALL_FORMATS);
 
-		/*
-		const input = new Input({
-			source,
-			formats: ALL_FORMATS,
-		});
-		*/
+		let videoTrack = await input.getPrimaryVideoTrack();
+		let audioTrack = await input.getPrimaryAudioTrack();
 
-		playbackTimeAtStart = 0;
+		const tracks = [videoTrack, audioTrack].filter(t => t !== null);
 
-		durationElement.textContent = formatSeconds(totalDuration);
+		firstTimestamp = Math.max(
+			await input.getFirstTimestamp(tracks),
+			0,
+		);
+		endTimestamp = await input.getDurationFromMetadata(tracks, { skipLiveWait: true })
+			?? await input.computeDuration(tracks, { skipLiveWait: true });
+		isRelativeToUnixEpoch = tracks.some(t => t?.isRelativeToUnixEpoch);
+		playbackTimeAtStart = firstTimestamp;
+
+		// Configure the time display elements accordingly
+		const timestampFontSize = isRelativeToUnixEpoch ? '12px' : '';
+		const timestampWhiteSpace = isRelativeToUnixEpoch ? 'pre' : '';
+		const timestampTextAlign = isRelativeToUnixEpoch ? 'center' : '';
+		currentTimeElement.style.fontSize = timestampFontSize;
+		currentTimeElement.style.whiteSpace = timestampWhiteSpace;
+		currentTimeElement.style.textAlign = timestampTextAlign;
+		durationElement.style.fontSize = timestampFontSize;
+		durationElement.style.whiteSpace = timestampWhiteSpace;
+		durationElement.style.textAlign = timestampTextAlign;
+		durationElement.textContent = formatTimestamp(endTimestamp);
 
 		let problemMessage = '';
 
@@ -269,8 +207,6 @@ const initMediaPlayer = async (resource: File | string) => {
 		await startVideoIterator();
 
 		if (audioContext.state === 'running') {
-			await seekToTime(start);
-
 			// Start playback automatically if the audio context permits
 			await play();
 		}
@@ -284,6 +220,38 @@ const initMediaPlayer = async (resource: File | string) => {
 			controlsElement.style.pointerEvents = '';
 			playerContainer.style.cursor = '';
 		}
+
+		const refreshIntervals = await Promise.all(tracks.map(t => t.getLiveRefreshInterval()));
+		const nonNullIntervals = refreshIntervals.filter(x => x !== null);
+
+		if (nonNullIntervals.length > 0) {
+			// At least one track is live! This means that we'll need to continually refresh the end timestamp of the
+			// media to allow continuous live playback.
+
+			const interval = Math.min(...nonNullIntervals);
+			liveDot.style.display = '';
+			liveDot.onclick = () => {
+				void seekToTime(endTimestamp - interval * 1.5);
+			};
+
+			const scheduleLiveRefresh = () => {
+				// eslint-disable-next-line @typescript-eslint/no-misused-promises
+				liveRefreshIntervalId = window.setTimeout(async () => {
+					endTimestamp = await input.getDurationFromMetadata(tracks, { skipLiveWait: true })
+						?? await input.computeDuration(tracks, { skipLiveWait: true });
+					durationElement.textContent = formatTimestamp(endTimestamp);
+
+					// Check if we're still live
+					const stillLive = await Promise.all(tracks.map(t => t.isLive()));
+					if (stillLive.every(live => !live)) {
+						liveDot.style.display = 'none';
+					} else {
+						scheduleLiveRefresh();
+					}
+				}, interval * 1000);
+			};
+			scheduleLiveRefresh();
+		}
 	} catch (error) {
 		console.error(error);
 
@@ -325,10 +293,10 @@ const startVideoIterator = async () => {
 const render = (requestFrame = true) => {
 	if (fileLoaded) {
 		const playbackTime = getPlaybackTime();
-		if (playbackTime >= totalDuration) {
+		if (playbackTime >= endTimestamp) {
 			// Pause playback once the end is reached
 			pause();
-			playbackTimeAtStart = totalDuration;
+			playbackTimeAtStart = endTimestamp;
 		}
 
 		// Check if the current playback time has caught up to the next frame
@@ -449,9 +417,9 @@ const play = async () => {
 		await audioContext!.resume();
 	}
 
-	if (getPlaybackTime() === totalDuration) {
+	if (getPlaybackTime() === endTimestamp) {
 		// If we're at the end, let's snap back to the start
-		playbackTimeAtStart = 0;
+		playbackTimeAtStart = firstTimestamp;
 		await startVideoIterator();
 	}
 
@@ -506,7 +474,7 @@ const seekToTime = async (seconds: number) => {
 
 	await startVideoIterator();
 
-	if (wasPlaying && playbackTimeAtStart < totalDuration) {
+	if (wasPlaying && playbackTimeAtStart < endTimestamp) {
 		void play();
 	}
 };
@@ -514,8 +482,8 @@ const seekToTime = async (seconds: number) => {
 /** === PROGRESS BAR LOGIC === */
 
 const updateProgressBarTime = (seconds: number) => {
-	currentTimeElement.textContent = formatSeconds(seconds);
-	progressBar.style.width = `${(seconds / totalDuration) * 100}%`;
+	currentTimeElement.textContent = formatTimestamp(seconds);
+	progressBar.style.width = `${((seconds - firstTimestamp) / (endTimestamp - firstTimestamp)) * 100}%`;
 };
 
 progressBarContainer.addEventListener('pointerdown', (event) => {
@@ -524,7 +492,7 @@ progressBarContainer.addEventListener('pointerdown', (event) => {
 
 	const rect = progressBarContainer.getBoundingClientRect();
 	const completion = Math.max(Math.min((event.clientX - rect.left) / rect.width, 1), 0);
-	updateProgressBarTime(completion * totalDuration);
+	updateProgressBarTime(firstTimestamp + completion * (endTimestamp - firstTimestamp));
 
 	clearTimeout(hideControlsTimeout);
 
@@ -534,7 +502,7 @@ progressBarContainer.addEventListener('pointerdown', (event) => {
 
 		const rect = progressBarContainer.getBoundingClientRect();
 		const completion = Math.max(Math.min((event.clientX - rect.left) / rect.width, 1), 0);
-		const newTime = completion * totalDuration;
+		const newTime = firstTimestamp + completion * (endTimestamp - firstTimestamp);
 
 		void seekToTime(newTime);
 		showControlsTemporarily();
@@ -545,7 +513,7 @@ progressBarContainer.addEventListener('pointermove', (event) => {
 	if (draggingProgressBar) {
 		const rect = progressBarContainer.getBoundingClientRect();
 		const completion = Math.max(Math.min((event.clientX - rect.left) / rect.width, 1), 0);
-		updateProgressBarTime(completion * totalDuration);
+		updateProgressBarTime(firstTimestamp + completion * (endTimestamp - firstTimestamp));
 	}
 });
 
@@ -662,10 +630,10 @@ window.addEventListener('keydown', (e) => {
 	} else if (e.code === 'KeyF') {
 		fullscreenButton.click();
 	} else if (e.code === 'ArrowLeft') {
-		const newTime = Math.max(getPlaybackTime() - 5, 0);
+		const newTime = Math.max(getPlaybackTime() - 5, firstTimestamp);
 		void seekToTime(newTime);
 	} else if (e.code === 'ArrowRight') {
-		const newTime = Math.min(getPlaybackTime() + 5, totalDuration);
+		const newTime = Math.min(getPlaybackTime() + 5, endTimestamp);
 		void seekToTime(newTime);
 	} else if (e.code === 'KeyM') {
 		volumeButton.click();
@@ -711,6 +679,15 @@ controlsElement.addEventListener('click', (event) => {
 
 /** === UTILS === */
 
+const formatTimestamp = (seconds: number) => {
+	if (isRelativeToUnixEpoch) {
+		const iso = new Date(seconds * 1000).toISOString();
+		return iso.replace('T', '\n');
+	}
+
+	return formatSeconds(seconds);
+};
+
 const formatSeconds = (seconds: number) => {
 	const showMilliseconds = window.innerWidth >= 640;
 
@@ -737,9 +714,9 @@ const formatSeconds = (seconds: number) => {
 };
 
 window.addEventListener('resize', () => {
-	if (totalDuration) {
+	if (endTimestamp) {
 		updateProgressBarTime(getPlaybackTime());
-		durationElement.textContent = formatSeconds(totalDuration);
+		durationElement.textContent = formatTimestamp(endTimestamp);
 	}
 });
 
@@ -779,12 +756,6 @@ document.addEventListener('dragover', (event) => {
 	event.dataTransfer!.dropEffect = 'copy';
 });
 
-/*
-document.addEventListener('click', () => {
-	void initMediaPlayer();
-}, { once: true });
-*/
-
 document.addEventListener('drop', (event) => {
 	event.preventDefault();
 	const files = event.dataTransfer?.files;
diff --git a/examples/metadata-extraction/metadata-extraction.ts b/examples/metadata-extraction/metadata-extraction.ts
index c58804f..af2acd1 100644
--- a/examples/metadata-extraction/metadata-extraction.ts
+++ b/examples/metadata-extraction/metadata-extraction.ts
@@ -1,4 +1,4 @@
-import { Input, ALL_FORMATS, BlobSource, UrlSource } from 'mediabunny';
+import { ALL_FORMATS, createInputFrom } from 'mediabunny';
 
 import SampleFileUrl from '../../docs/assets/big-buck-bunny-trimmed.mp4';
 (document.querySelector('#sample-file-download') as HTMLAnchorElement).href = SampleFileUrl;
@@ -10,44 +10,42 @@ const horizontalRule = document.querySelector('hr') as HTMLHRElement;
 const bytesReadElement = document.querySelector('#bytes-read') as HTMLParagraphElement;
 const metadataContainer = document.querySelector('#metadata-container') as HTMLDivElement;
 
-const extractMetadata = async (resource: File | string) => {
+const extractMetadata = (resource: File | string) => {
 	// Create a new input from the resource
-	let input: Input;
-	if (resource instanceof File) {
-		input = new Input({
-			source: new BlobSource(resource),
-			formats: ALL_FORMATS, // Accept all formats
-		});
-	} else {
-		input = new Input({
-			entryPath: resource,
-			source: ({ path }) => new UrlSource(path),
-			formats: ALL_FORMATS, // Accept all formats
-		});
-	}
+	const input = createInputFrom(resource, ALL_FORMATS); // Accept all formats
 
 	let bytesRead = 0;
 	let fileSize: number | null = null;
+	let obtainedSources = 0;
 
 	const updateBytesRead = () => {
-		bytesReadElement.textContent = `Bytes read: ${bytesRead} / ${fileSize === null ? '?' : fileSize}`;
+		if (obtainedSources > 1) {
+			bytesReadElement.textContent = `Bytes read: ${bytesRead} across ${obtainedSources} files`;
+		} else {
+			bytesReadElement.textContent = `Bytes read: ${bytesRead} / ${fileSize === null ? '?' : fileSize}`;
 
-		if (fileSize !== null) {
-			bytesReadElement.textContent += ` (${(100 * bytesRead / fileSize).toPrecision(3)}% of entire file)`;
+			if (fileSize !== null) {
+				bytesReadElement.textContent += ` (${(100 * bytesRead / fileSize).toPrecision(3)}% of entire file)`;
+			}
 		}
 	};
 
-	const source = await input.getSource();
+	input.on('source', ({ source, isRoot }) => {
+		if (isRoot) {
+			// Get the input's size
+			void source.getSize().then((size) => {
+				fileSize = size;
+				updateBytesRead();
+			});
+		}
 
-	source.onread = (start, end) => {
-		bytesRead += end - start;
+		obtainedSources++;
 		updateBytesRead();
-	};
 
-	// Get the input's size
-	void source.getSize().then((size) => {
-		fileSize = size;
-		updateBytesRead();
+		source.on('read', ({ start, end }) => {
+			bytesRead += end - start;
+			updateBytesRead();
+		});
 	});
 
 	// This object contains all the data that gets displayed:
@@ -57,28 +55,26 @@ const extractMetadata = async (resource: File | string) => {
 		'Starts at': input.getFirstTimestamp().then(start => `${start} seconds`),
 		'Ends at': input.computeDuration().then(duration => `${duration} seconds`),
 		'Tracks': input.getTracks().then(tracks => tracks.map(track => ({
-			'Type': track.resolve('type').then(type => type),
-			'Codec': track.resolve('codec').then(codec => codec),
+			'Type': track.type,
+			'Codec': track.codec,
 			'Full codec string': track.getCodecParameterString(),
 			'Starts at': track.getFirstTimestamp().then(start => `${start} seconds`),
 			'Ends at': track.computeDuration().then(duration => `${duration} seconds`),
-			'Language code': track.resolve('languageCode').then(languageCode => languageCode),
+			'Language code': track.languageCode,
 			...(track.isVideoTrack()
 				? {
-						'Coded width': track.resolve('codedWidth').then(codedWidth => `${codedWidth} pixels`),
-						'Coded height': track.resolve('codedHeight').then(codedHeight => `${codedHeight} pixels`),
-						'Rotation': track.resolve('rotation').then(rotation => `${rotation}° clockwise`),
-						'Pixel aspect ratio': track.resolve('pixelAspectRatio').then(pixelAspectRatio =>
-							`${pixelAspectRatio.num}:${pixelAspectRatio.den}`,
-						),
-						'Display width': track.resolve('displayWidth').then(displayWidth => `${displayWidth} pixels`),
-						'Display height': track.resolve('displayHeight').then(displayHeight => `${displayHeight} pixels`),
+						'Coded width': `${track.codedWidth} pixels`,
+						'Coded height': `${track.codedHeight} pixels`,
+						'Rotation': `${track.rotation}° clockwise`,
+						'Pixel aspect ratio': `${track.pixelAspectRatio.num}:${track.pixelAspectRatio.den}`,
+						'Display width': `${track.displayWidth} pixels`,
+						'Display height': `${track.displayHeight} pixels`,
 						'Transparency': track.canBeTransparent(),
 					}
 				: track.isAudioTrack()
 					? {
-							'Number of channels': track.resolve('numberOfChannels').then(numberOfChannels => numberOfChannels),
-							'Sample rate': track.resolve('sampleRate').then(sampleRate => `${sampleRate} Hz`),
+							'Number of channels': track.numberOfChannels,
+							'Sample rate': `${track.sampleRate} Hz`,
 						}
 					: {}),
 			'Packet statistics': shortDelay().then(() => track.computePacketStats()).then(stats => ({
diff --git a/examples/procedural-generation/procedural-generation.ts b/examples/procedural-generation/procedural-generation.ts
index 93efdb2..ca4d90d 100644
--- a/examples/procedural-generation/procedural-generation.ts
+++ b/examples/procedural-generation/procedural-generation.ts
@@ -8,12 +8,6 @@ import {
 	getFirstEncodableAudioCodec,
 	getFirstEncodableVideoCodec,
 	OutputFormat,
-	HlsOutputFormat,
-	OutputTrackGroup,
-	MpegTsOutputFormat,
-	AdtsOutputFormat,
-	StreamTarget,
-	CmafOutputFormat,
 } from 'mediabunny';
 
 const durationSlider = document.querySelector('#duration-slider') as HTMLInputElement;
@@ -72,11 +66,6 @@ const generateVideo = async () => {
 	let progressInterval = -1;
 
 	try {
-		const dirHandle = await showDirectoryPicker({ mode: 'readwrite' });
-		for await (const [name, handle] of dirHandle) {
-			await dirHandle.removeEntry(name, { recursive: true });
-		}
-
 		// Let's set some DOM state
 		renderButton.disabled = true;
 		renderButton.textContent = 'Generating...';
@@ -97,39 +86,8 @@ const generateVideo = async () => {
 
 		// Create a new output file
 		output = new Output({
-			rootPath: 'master.m3u8',
-			target: async ({ path }) => {
-				const fileHandle = await dirHandle.getFileHandle(path, { create: true });
-				const writable = await fileHandle.createWritable();
-
-				const target = new StreamTarget(writable);
-				target.on('finalized', () => console.log('Finalizado', path));
-
-				return target;
-
-				/*
-				const target = new BufferTarget();
-				target.on('finalized', async () => {
-					if (path.includes('m3u8')) {
-						console.log(new TextDecoder().decode(target.buffer!));
-					}
-				});
-
-				if (path.includes('m4s')) {
-					console.log('here');
-					target.on('write', ({ start, end }) => console.log(start, end));
-					target.on('finalized', () => console.log('yippie'));
-				}
-
-				return target;
-				*/
-			},
-			format: new HlsOutputFormat({
-				segmentFormat: new CmafOutputFormat(),
-				// singleFilePerPlaylist: true,
-				// live: true,
-				getPlaylistPath: info => `sussex-${info.n}.m3u8`,
-			}),
+			target: new BufferTarget(), // Stored in memory
+			format: new Mp4OutputFormat(),
 		});
 
 		// Retrieve the first video codec supported by this browser that can be contained in the output format
@@ -145,18 +103,11 @@ const generateVideo = async () => {
 		const canvasSource = new CanvasSource(renderCanvas, {
 			codec: videoCodec,
 			bitrate: QUALITY_HIGH,
-			keyFrameInterval: 2,
-			transform: {
-				// frameRate: 5,
-			},
 		});
 		output.addVideoTrack(canvasSource, { frameRate });
 
-		// output._defaultTrackGroup.pair(otherGroup);
-
 		// For audio, we use ArrayBufferSource, because we'll be creating an ArrayBuffer with OfflineAudioContext
 		let audioBufferSource: AudioBufferSource | null = null;
-		const audioBufferSource2: AudioBufferSource | null = null;
 
 		// Retrieve the first audio codec supported by this browser that can be contained in the output format
 		const audioCodec = await getFirstEncodableAudioCodec(output.format.getSupportedAudioCodecs(), {
@@ -167,19 +118,8 @@ const generateVideo = async () => {
 			audioBufferSource = new AudioBufferSource({
 				codec: audioCodec,
 				bitrate: QUALITY_HIGH,
-				transform: {
-
-				},
 			});
 			output.addAudioTrack(audioBufferSource);
-
-			/*
-			audioBufferSource2 = new AudioBufferSource({
-				codec: audioCodec,
-				bitrate: QUALITY_HIGH,
-			});
-			output.addAudioTrack(audioBufferSource2, { languageCode: 'esp' });
-			*/
 		} else {
 			alert('Your browser doesn\'t support audio encoding, so we won\'t include audio in the output file.');
 		}
@@ -211,8 +151,6 @@ const generateVideo = async () => {
 			// Add the current state of the canvas as a frame to the video. Using `await` here is crucial to
 			// automatically slow down the rendering loop when the encoder can't keep up.
 			await canvasSource.add(currentTime, 1 / frameRate);
-
-			// await new Promise(resolve => setTimeout(resolve, 1000 / frameRate));
 		}
 
 		// Signal to the output that no more video frames are coming (not necessary, but recommended)
@@ -224,9 +162,6 @@ const generateVideo = async () => {
 			const audioBuffer = await audioContext.startRendering();
 			await audioBufferSource.add(audioBuffer);
 			audioBufferSource.close();
-
-			// await audioBufferSource2!.add(audioBuffer);
-			// audioBufferSource2!.close();
 		}
 
 		clearInterval(progressInterval);
@@ -245,14 +180,12 @@ const generateVideo = async () => {
 		videoInfo.style.display = '';
 
 		// Display and play the resulting media file
-		/*
 		const videoBlob = new Blob([output.target.buffer!], { type: output.format.mimeType });
 		resultVideo.src = URL.createObjectURL(videoBlob);
 		void resultVideo.play();
 
 		const fileSizeMiB = (videoBlob.size / (1024 * 1024)).toPrecision(3);
 		videoInfo.textContent = `File size: ${fileSizeMiB} MiB`;
-		*/
 	} catch (error) {
 		console.error(error);
 
diff --git a/src/adts/adts-demuxer.ts b/src/adts/adts-demuxer.ts
index 79957cf..5c78489 100644
--- a/src/adts/adts-demuxer.ts
+++ b/src/adts/adts-demuxer.ts
@@ -143,10 +143,6 @@ export class AdtsDemuxer extends Demuxer {
 		this.lastLoadedPos = header.startPos + header.frameLength;
 	}
 
-	async getDurationFromMetadata(): Promise<number | null> {
-		return null; // No way
-	}
-
 	async getMimeType() {
 		return 'audio/aac';
 	}
@@ -232,7 +228,7 @@ class AdtsAudioTrackBacking implements InputAudioTrackBacking {
 	}
 
 	async getDurationFromMetadata() {
-		return null;
+		return null; // No way
 	}
 
 	async getLiveRefreshInterval() {
diff --git a/src/conversion.ts b/src/conversion.ts
index e4430a7..2c3449a 100644
--- a/src/conversion.ts
+++ b/src/conversion.ts
@@ -733,9 +733,7 @@ export class Conversion {
 			// down later due to discarded tracks, but we need to fix the start timestamp now due to track processing
 			// depending on it.
 			this._startTimestamp = Math.max(
-				Math.min(
-					...await Promise.all(filteredTracks.map(x => x.getFirstTimestamp())),
-				),
+				await this.input.getFirstTimestamp(filteredTracks),
 				// Samples can also have negative timestamps, but the meaning typically is "don't present me", so let's
 				// cut those out by default.
 				0,
diff --git a/src/demuxer.ts b/src/demuxer.ts
index 8cac71d..36a746c 100644
--- a/src/demuxer.ts
+++ b/src/demuxer.ts
@@ -36,7 +36,6 @@ export abstract class Demuxer {
 	abstract getTrackBackings(): Promise<InputTrackBacking[]>;
 	abstract getMimeType(): Promise<string>;
 	abstract getMetadataTags(): Promise<MetadataTags>;
-	abstract getDurationFromMetadata(options: DurationMetadataRequestOptions): Promise<number | null>;
 
 	dispose() {
 		// Can be overridden
diff --git a/src/flac/flac-demuxer.ts b/src/flac/flac-demuxer.ts
index 7617058..10a77d5 100644
--- a/src/flac/flac-demuxer.ts
+++ b/src/flac/flac-demuxer.ts
@@ -97,17 +97,6 @@ export class FlacDemuxer extends Demuxer {
 		return [this.trackBacking];
 	}
 
-	async getDurationFromMetadata(): Promise<number | null> {
-		await this.readMetadata();
-		assert(this.audioInfo);
-
-		if (this.audioInfo.totalSamples === 0) {
-			return null;
-		}
-
-		return this.audioInfo.totalSamples / this.audioInfo.sampleRate;
-	}
-
 	async getMimeType() {
 		return 'audio/flac';
 	}
@@ -618,8 +607,14 @@ class FlacAudioTrackBacking implements InputAudioTrackBacking {
 		return null;
 	}
 
-	getDurationFromMetadata() {
-		return this.demuxer.getDurationFromMetadata();
+	async getDurationFromMetadata() {
+		assert(this.demuxer.audioInfo);
+
+		if (this.demuxer.audioInfo.totalSamples === 0) {
+			return null;
+		}
+
+		return this.demuxer.audioInfo.totalSamples / this.demuxer.audioInfo.sampleRate;
 	}
 
 	async getLiveRefreshInterval() {
diff --git a/src/hls/hls-demuxer.ts b/src/hls/hls-demuxer.ts
index 4ba874a..45dcdd9 100644
--- a/src/hls/hls-demuxer.ts
+++ b/src/hls/hls-demuxer.ts
@@ -593,12 +593,6 @@ export class HlsDemuxer extends Demuxer {
 		return segmentedInput;
 	}
 
-	async getDurationFromMetadata(options: DurationMetadataRequestOptions): Promise<number | null> {
-		return this.hasMasterPlaylist
-			? null
-			: this.segmentedInputs[0]!.getDurationFromMetadata(options);
-	}
-
 	async getMetadataTags(): Promise<MetadataTags> {
 		return {};
 	}
diff --git a/src/hls/hls-muxer.ts b/src/hls/hls-muxer.ts
index a52a69e..b3f078c 100644
--- a/src/hls/hls-muxer.ts
+++ b/src/hls/hls-muxer.ts
@@ -99,6 +99,7 @@ export class HlsMuxer extends Muxer {
 	maxLiveSegmentCount: number;
 	isRelativeToUnixEpoch = false;
 	globalTargetDuration: number;
+	numWrittenMasterPlaylists = 0;
 
 	playlists: Playlist[] = [];
 	playlistDeclarations: PlaylistDeclaration[] = [];
@@ -909,11 +910,11 @@ export class HlsMuxer extends Muxer {
 						return slice;
 					} else {
 						const playlistInfo = toPlaylistInfo(playlist);
-						const path = await this.getInitPath(playlistInfo);
-						validateInitPath(path);
+						const initPath = await this.getInitPath(playlistInfo);
+						validateInitPath(initPath);
 
 						playlist.initSegment = {
-							path,
+							path: initPath,
 							duration: 0,
 							timestamp: 0,
 							byteSize: 0,
@@ -921,7 +922,7 @@ export class HlsMuxer extends Muxer {
 						};
 
 						const target = await this.output._getTarget({
-							path,
+							path: initPath,
 							isRoot: false,
 						});
 						target.on('write', ({ end }) => {
@@ -1371,14 +1372,25 @@ export class HlsMuxer extends Muxer {
 
 		this.format._options.onMaster?.(masterPlaylistText);
 
-		const target = await this.output._getTarget({ path: pathedTarget.rootPath, isRoot: true });
-		const writer = new Writer(target);
+		let writer: Writer;
+		if (this.numWrittenMasterPlaylists === 0) {
+			// For the first master playlist write, we use the normal root writer getter, so that the target returned by
+			// Output.target emits valid write events.
+			writer = await this.output._getRootWriter();
+		} else {
+			// For subsequent master playlist writes, we *must* obtain a different target in order to overwrite
+			// the file.
+			const target = await this.output._getTarget({ path: pathedTarget.rootPath, isRoot: true });
+			writer = new Writer(target);
+			writer.start();
+		}
 
-		writer.start();
 		writer.write(textEncoder.encode(masterPlaylistText));
 
 		await writer.flush();
 		await writer.finalize();
+
+		this.numWrittenMasterPlaylists++;
 	}
 
 	private async tryWriteMasterPlaylist() {
diff --git a/src/input-track.ts b/src/input-track.ts
index 11c9481..48c249a 100644
--- a/src/input-track.ts
+++ b/src/input-track.ts
@@ -179,16 +179,16 @@ export abstract class InputTrack {
 	}
 
 	/**
-	 * The peak bitrate of the track as specified in the track's metadata. This might not match the actual
-	 * media data's bitrate.
+	 * The peak bitrate of the track, in bits per second, as specified in the track's metadata. This might not match the
+	 * actual media data's bitrate.
 	 */
 	get bitrate() {
 		return this._backing.getBitrate();
 	}
 
 	/**
-	 * The average bitrate of the track as specified in the track's metadata. This might not match the actual
-	 * media data's bitrate.
+	 * The average bitrate of the track, in bits per second, as specified in the track's metadata. This might not match
+	 * the actual media data's bitrate.
 	 */
 	get averageBitrate() {
 		return this._backing.getAverageBitrate();
@@ -219,9 +219,9 @@ export abstract class InputTrack {
 	}
 
 	/**
-	 * Gets the duration (end timestamp) of this track from metadata stored in the file. This value may be
+	 * Gets the duration (end timestamp) in seconds of this track from metadata stored in the file. This value may be
 	 * approximate or diverge from the actual, precise duration returned by `.computeDuration()`, but compared to that
-	 * method, this method is very cheap. When the duration cannot be determined from the file metadata, `null`
+	 * method, this method is cheaper. When the duration cannot be determined from the file metadata, `null`
 	 * is returned.
 	 *
 	 * By default, when the underlying media is live, this method will only resolve once the live stream
diff --git a/src/input.ts b/src/input.ts
index 1287105..35e4c23 100644
--- a/src/input.ts
+++ b/src/input.ts
@@ -33,6 +33,7 @@ import {
 	arrayCount,
 	assert,
 	EventEmitter,
+	MaybePromise,
 	polyfillSymbolDispose,
 	removeItem,
 } from './misc';
@@ -53,9 +54,14 @@ import {
 	UrlSource,
 	UrlSourceOptions,
 } from './source';
+import * as nodeAlias from './node';
 
 polyfillSymbolDispose();
 
+const node = typeof nodeAlias !== 'undefined'
+	? nodeAlias // Aliasing it prevents some bundler warnings
+	: undefined!;
+
 export const DEFAULT_SOURCE_CACHE_GROUP = 1;
 export const ENCRYPTION_KEY_CACHE_GROUP = 2;
 
@@ -109,6 +115,8 @@ export type InputEvents = {
 		source: Source;
 		/** The request that led to loading this source, or `null` if the input is not pathed. */
 		request: SourceRequest | null;
+		/** Whether the source is the root file of the media. */
+		isRoot: boolean;
 	};
 };
 
@@ -149,6 +157,10 @@ export class Input<S extends Source = Source> extends EventEmitter<InputEvents>
 	/** @internal */
 	_sourceCache: SourceCacheEntry<S>[] = [];
 	/** @internal */
+	_rootRef: SourceRef<S> | null = null;
+	/** @internal */
+	_rootRefPromise: Promise<SourceRef<S>> | null = null;
+	/** @internal */
 	_sourceCachePromises: {
 		request: SourceRequest;
 		cacheGroup: number;
@@ -180,6 +192,9 @@ export class Input<S extends Source = Source> extends EventEmitter<InputEvents>
 		)) {
 			throw new TypeError('options.source must be a Source, SourceRef, or PathedSource.');
 		}
+		if (options.source instanceof Source && options.source._disposed) {
+			throw new TypeError('options.source must not be a disposed Source.');
+		}
 		if (options.initInput !== undefined && !(options.initInput instanceof Input)) {
 			throw new TypeError('options.initInput, when provided, must be an Input.');
 		}
@@ -200,17 +215,34 @@ export class Input<S extends Source = Source> extends EventEmitter<InputEvents>
 		inputFinalizationRegistry?.register(this, this._sourceRefs, this);
 	}
 
+	/** @internal */
+	_getSourceValidated(request: SourceRequest): MaybePromise<S | SourceRef<S>> {
+		assert(this._source instanceof PathedSource);
+
+		const result = this._source.getSource(request);
+		const handleResult = (result: S | SourceRef<S>) => {
+			if (!(result instanceof Source || result instanceof SourceRef)) {
+				throw new TypeError('getSource must return a Source or a SourceRef.');
+			}
+			if (result instanceof Source && result._disposed) {
+				throw new TypeError('The returned Source must not be disposed.');
+			}
+
+			return result;
+		};
+
+		if (result instanceof Promise) {
+			return result.then(handleResult);
+		} else {
+			return handleResult(result);
+		}
+	}
+
 	/** @internal */
 	async _getSourceUncached(request: SourceRequest) {
 		assert(this._source instanceof PathedSource);
 
-		const source = await this._source.getSource(request);
-		if (!(source instanceof Source || source instanceof SourceRef)) {
-			throw new TypeError('The source function must return a Source or a SourceRef.');
-		}
-		if (source instanceof Source && source._disposed) {
-			throw new TypeError('The returned Source must not be disposed.');
-		}
+		const source = await this._getSourceValidated(request);
 
 		let ref: SourceRef<S>;
 		if (source instanceof Source) {
@@ -219,7 +251,7 @@ export class Input<S extends Source = Source> extends EventEmitter<InputEvents>
 			ref = source;
 		}
 
-		this._emit('source', { source: ref.source, request });
+		this._emit('source', { source: ref.source, request, isRoot: request.isRoot });
 		return ref;
 	}
 
@@ -243,22 +275,13 @@ export class Input<S extends Source = Source> extends EventEmitter<InputEvents>
 		const promise = (async () => {
 			const sourceRef = await this._getSourceUncached(request);
 
-			const cacheEntry: SourceCacheEntry<S> = {
-				request,
-				sourceRef,
-				age: this._nextSourceCacheAge++,
-				cacheGroup,
-			};
-
-			this._sourceCache.push(cacheEntry);
-
 			const MAX_SOURCE_CACHE_SIZE = 4;
 			const count = arrayCount(
 				this._sourceCache,
 				x => x.cacheGroup === cacheGroup && x.sourceRef.source._refCount === 1,
 			);
 
-			if (count > MAX_SOURCE_CACHE_SIZE) {
+			if (count >= MAX_SOURCE_CACHE_SIZE) {
 				const minAgeIndex = arrayArgmin(
 					this._sourceCache,
 					x => x.cacheGroup === cacheGroup && x.sourceRef.source._refCount === 1 ? x.age : Infinity,
@@ -268,7 +291,7 @@ export class Input<S extends Source = Source> extends EventEmitter<InputEvents>
 				this._sourceCache.splice(minAgeIndex, 1);
 
 				entry.sourceRef.free();
-				removeItem(this._sourceRefs, sourceRef);
+				removeItem(this._sourceRefs, entry.sourceRef);
 			}
 
 			this._sourceRefs.push(sourceRef);
@@ -277,6 +300,12 @@ export class Input<S extends Source = Source> extends EventEmitter<InputEvents>
 			assert(promiseIndex !== -1);
 			this._sourceCachePromises.splice(promiseIndex, 1);
 
+			const cacheEntry: SourceCacheEntry<S> = {
+				request,
+				sourceRef,
+				age: this._nextSourceCacheAge++,
+				cacheGroup,
+			};
 			return cacheEntry;
 		})();
 
@@ -286,22 +315,64 @@ export class Input<S extends Source = Source> extends EventEmitter<InputEvents>
 			promise,
 		});
 
-		return promise.then(x => x.sourceRef.source.ref());
+		return promise.then((entry) => {
+			const ref = entry.sourceRef.source.ref();
+
+			// We need to add it to the cache this late to avoid the ref being freed prematurely due to race conditions
+			this._sourceCache.push(entry);
+
+			return ref;
+		});
+	}
+
+	/** @internal */
+	_getRootSourceRef(): MaybePromise<SourceRef<S>> {
+		if (this._rootRef) {
+			return this._rootRef;
+		}
+		if (this._rootRefPromise) {
+			return this._rootRefPromise;
+		}
+
+		if (this._source instanceof SourceRef) {
+			this._emit('source', { source: this._source.source, request: null, isRoot: true });
+			this._rootRef = this._source;
+
+			assert(this._sourceRefs.includes(this._source)); // Assert that it's already been added
+
+			return this._source;
+		}
+
+		const request: SourceRequest = { path: this._source.rootPath, isRoot: true };
+		const result = this._getSourceValidated(request);
+
+		const handleResult = (result: S | SourceRef<S>) => {
+			let ref: SourceRef<S>;
+			if (result instanceof Source) {
+				ref = result.ref();
+			} else {
+				ref = result;
+			}
+
+			this._sourceRefs.push(ref);
+			this._emit('source', { source: ref.source, request, isRoot: true });
+			this._rootRef = ref;
+
+			return ref;
+		};
+
+		if (result instanceof Promise) {
+			return this._rootRefPromise = result.then(handleResult);
+		} else {
+			return handleResult(result);
+		}
 	}
 
 	/** @internal */
 	_getDemuxer() {
 		return this._demuxerPromise ??= (async () => {
-			let ref: SourceRef;
-			if (this._source instanceof SourceRef) {
-				ref = this._source;
-				this._emit('source', { source: ref.source, request: null });
-			} else {
-				ref = await this._getSourceUncached({ path: this._source.rootPath, isRoot: true });
-				this._sourceRefs.push(ref);
-			}
-
-			this._reader = new Reader(ref.source);
+			const rootRef = await this._getRootSourceRef();
+			this._reader = new Reader(rootRef.source);
 
 			for (const format of this._formats) {
 				const canRead = await format._canReadInput(this);
@@ -316,27 +387,27 @@ export class Input<S extends Source = Source> extends EventEmitter<InputEvents>
 	}
 
 	/**
-	 * Returns the source from which this input file reads data for the entry path. Throws if the source-resolving
-	 * function returns a promise; prefer the `'source'` event for those cases.
+	 * Returns the source from which this input file reads data for the root path. Throws when using
+	 * {@link PathedSource} with an async callback; prefer the `'source'` event for those cases.
 	 */
 	get source(): S {
-		if (this._source instanceof SourceRef) {
-			return this._source.source;
+		const errorMessage = 'Input.source cannot be used when using PathedSource with an async callback.'
+			+ ' Use the \'source\' event instead.';
+
+		// We use this field to make sure we can reliably throw in the `source` getter whenever retrieving the source
+		// requiring awaiting a promise. We do this so there is no different behavior based on order: if the source has
+		// already been retrieved via the normal internal operations, and then somebody calls the `source` getter, even
+		// if the source is now available, the getter should still throw to be consistent in behavior and in definition.
+		if (this._rootRefPromise) {
+			throw new TypeError(errorMessage);
 		}
 
-		const source = this._source.getSource({ path: this._source.rootPath, isRoot: true });
-		if (source instanceof Promise) {
-			throw new TypeError(
-				'Input.source cannot be used when the source function resolves asynchronously.'
-				+ ' Use the \'source\' event instead.',
-			);
+		const rootRefResult = this._getRootSourceRef();
+		if (rootRefResult instanceof Promise) {
+			throw new TypeError(errorMessage);
 		}
 
-		if (source instanceof Source) {
-			return source;
-		} else {
-			return source.source;
-		}
+		return rootRefResult.source;
 	}
 
 	/**
@@ -364,54 +435,76 @@ export class Input<S extends Source = Source> extends EventEmitter<InputEvents>
 		}
 	}
 
+	/**
+	 * Returns the timestamp at which the input file starts. More precisely, returns the smallest starting timestamp
+	 * among all tracks.
+	 *
+	 * Optionally, you can pass in the list of tracks for which you want to compute the starting timestamp.
+	 *
+	 * Note that this method is potentially expensive for inputs with many tracks (such as HLS manifests), since it
+	 * probes every track.
+	 */
+	async getFirstTimestamp(tracks?: InputTrack[]) {
+		tracks ??= await this.getTracks();
+
+		const filtered = tracks.filter(x => x !== null);
+		if (filtered.length === 0) {
+			return 0;
+		}
+
+		const firstTimestamps = await Promise.all(filtered.map(x => x.getFirstTimestamp()));
+		return Math.min(...firstTimestamps);
+	}
+
 	/**
 	 * Computes the duration of the input file, in seconds. More precisely, returns the largest end timestamp among
 	 * all tracks.
 	 *
+	 * Optionally, you can pass in the list of tracks for which you want to compute the duration.
+	 *
+	 * This method can be potentially expensive depending on the underlying file format, because it returns the most
+	 * accurate duration possible and must check all tracks. Use {@link Input.getDurationFromMetadata} for a faster but
+	 * less accurate estimate of duration.
+	 *
 	 * By default, when any track in the underlying media is live, this method will only resolve once the live stream
 	 * ends. If you want to query the current duration of the media, set {@link PacketRetrievalOptions.skipLiveWait}
 	 * to `true` in the options.
 	 */
-	async computeDuration(options?: PacketRetrievalOptions) {
-		const tracks = await this.getTracks();
-		if (tracks.length === 0) {
+	async computeDuration(tracks?: InputTrack[], options?: PacketRetrievalOptions) {
+		tracks ??= await this.getTracks();
+
+		const filtered = tracks.filter(x => x !== null);
+		if (filtered.length === 0) {
 			return 0;
 		}
 
-		const tracksDurations = await Promise.all(tracks.map(x => x.computeDuration(options)));
+		const tracksDurations = await Promise.all(filtered.map(x => x.computeDuration(options)));
 		return Math.max(...tracksDurations);
 	}
 
 	/**
-	 * Returns the timestamp at which the input file starts. More precisely, returns the smallest starting timestamp
-	 * among all tracks.
-	 *
-	 * Note that this method is potentially expensive for inputs with many tracks (such as HLS manifests), since it
-	 * probes every track.
-	 */
-	async getFirstTimestamp() {
-		const tracks = await this.getTracks();
-		if (tracks.length === 0) {
-			return 0;
-		}
-
-		const firstTimestamps = await Promise.all(tracks.map(x => x.getFirstTimestamp()));
-		return Math.min(...firstTimestamps);
-	}
-
-	/**
-	 * Gets the duration (end timestamp) of the input file from metadata stored in the file. This value may be
-	 * approximate or diverge from the actual, precise duration returned by `.computeDuration()`, but compared to that
-	 * method, this method is very cheap. When the duration cannot be determined from the file metadata, `null`
+	 * Gets the duration (end timestamp) in seconds of the input file from metadata stored in the file. This value may
+	 * be approximate or diverge from the actual, precise duration returned by `.computeDuration()`, but compared to
+	 * that method, this method is cheaper. When the duration cannot be determined from the file metadata, `null`
 	 * is returned.
 	 *
+	 * Optionally, you can pass in the list of tracks for which you want to get the duration from metadata.
+	 *
 	 * By default, when the underlying media is live, this method will only resolve once the live stream
 	 * ends. If you want to query the current duration of the media, set
 	 * {@link DurationMetadataRequestOptions.skipLiveWait} to `true` in the options.
 	 */
-	async getDurationFromMetadata(options: DurationMetadataRequestOptions = {}) {
-		const demuxer = await this._getDemuxer();
-		return demuxer.getDurationFromMetadata(options);
+	async getDurationFromMetadata(tracks?: InputTrack[], options?: DurationMetadataRequestOptions) {
+		tracks ??= await this.getTracks();
+
+		const filtered = tracks.filter(x => x !== null);
+		const tracksDurations = await Promise.all(filtered.map(x => x.getDurationFromMetadata(options)));
+		const nonNullDurations = tracksDurations.filter(x => x !== null);
+		if (nonNullDurations.length === 0) {
+			return null;
+		}
+
+		return Math.max(...nonNullDurations);
 	}
 
 	/**
@@ -737,6 +830,9 @@ export type CreateInputFromOptions =
  * The available options are the union of the options for each {@link Source}. Check the sources to see which field
  * applies to which source.
  *
+ * **Note:** In server-side environments, it is critical that you validate the input to this function if it is a string.
+ * If you're expecting a user-defined URL, you must validate that it's actually a URL and not a local file path.
+ *
  * @group Input files & tracks
  * @public
  */
@@ -812,9 +908,8 @@ export const createInputFrom = (
 	}
 
 	if (typeof data === 'string') {
-		const isUrl = data.includes('://');
-
-		if (isUrl) {
+		const isTreatedAsUrl = !node.fs || data.includes('://');
+		if (isTreatedAsUrl) {
 			return new Input({
 				formats,
 				source: new PathedSource(
@@ -825,7 +920,7 @@ export const createInputFrom = (
 			});
 		}
 
-		// It's a file path; this throws automatically if this isn't server-side
+		// Treat it as a local file path
 		return new Input({
 			formats,
 			source: new PathedSource(
diff --git a/src/isobmff/isobmff-demuxer.ts b/src/isobmff/isobmff-demuxer.ts
index e1b4b3d..7b6381a 100644
--- a/src/isobmff/isobmff-demuxer.ts
+++ b/src/isobmff/isobmff-demuxer.ts
@@ -446,29 +446,6 @@ export class IsobmffDemuxer extends Demuxer {
 		})();
 	}
 
-	async getDurationFromMetadata(): Promise<number | null> {
-		await this.readMetadata();
-
-		if (this.movieDurationInTimescale <= 0) {
-			// The duration is often zero for fragmented files for example; return `null` to signal that the duration
-			// must be computed instead.
-			return null;
-		}
-
-		let endTimestamp = this.movieDurationInTimescale / this.movieTimescale;
-		if (this.tracks.length > 0) {
-			const minFirstTimestamp = Math.min(
-				...(await Promise.all(this.tracks.map(async (x) => {
-					const p = await x.trackBacking!.getFirstPacket({ metadataOnly: true });
-					return p?.timestamp ?? 0;
-				}))),
-			);
-			endTimestamp += minFirstTimestamp;
-		}
-
-		return endTimestamp;
-	}
-
 	getSampleTableForTrack(internalTrack: InternalTrack) {
 		if (internalTrack.sampleTable) {
 			return internalTrack.sampleTable;
@@ -2584,6 +2561,8 @@ abstract class IsobmffTrackBacking implements InputTrackBacking {
 	async getDurationFromMetadata() {
 		const track = this.internalTrack;
 		if (track.durationInMediaTimescale <= 0) {
+			// The duration is often zero for fragmented files for example; return `null` to signal that the duration
+			// must be computed instead.
 			return null;
 		}
 
diff --git a/src/matroska/matroska-demuxer.ts b/src/matroska/matroska-demuxer.ts
index 2945945..a88f077 100644
--- a/src/matroska/matroska-demuxer.ts
+++ b/src/matroska/matroska-demuxer.ts
@@ -317,32 +317,6 @@ export class MatroskaDemuxer extends Demuxer {
 		return metadataTags;
 	}
 
-	async getDurationFromMetadata(): Promise<number | null> {
-		await this.readMetadata();
-
-		let maxEndTimestamp: number | null = null;
-		for (const segment of this.segments) {
-			if (segment.duration > 0) {
-				let endTimestamp = segment.duration / segment.timestampFactor;
-
-				if (segment.tracks.length > 0) {
-					const minFirstTimestamp = Math.min(
-						...await Promise.all(segment.tracks.map(x =>
-							x.trackBacking!.getFirstPacket({ metadataOnly: true })
-								.then(p => p?.timestamp ?? 0),
-						)),
-					);
-
-					endTimestamp += minFirstTimestamp;
-				}
-
-				maxEndTimestamp = Math.max(maxEndTimestamp ?? -Infinity, endTimestamp);
-			}
-		}
-
-		return maxEndTimestamp;
-	}
-
 	readMetadata() {
 		return this.readMetadataPromise ??= (async () => {
 			let currentPos = 0;
@@ -1995,11 +1969,16 @@ abstract class MatroskaTrackBacking implements InputTrackBacking {
 
 	async getDurationFromMetadata() {
 		const segment = this.internalTrack.segment;
-		if (segment.tracks.length > 1) {
+		if (segment.duration <= 0) {
 			return null;
 		}
 
-		return this.internalTrack.demuxer.getDurationFromMetadata();
+		let endTimestamp = segment.duration / segment.timestampFactor;
+
+		const firstPacket = await this.getFirstPacket({ metadataOnly: true });
+		endTimestamp += firstPacket?.timestamp ?? 0;
+
+		return endTimestamp;
 	}
 
 	async getLiveRefreshInterval() {
diff --git a/src/mp3/mp3-demuxer.ts b/src/mp3/mp3-demuxer.ts
index 646b313..e1b6c86 100644
--- a/src/mp3/mp3-demuxer.ts
+++ b/src/mp3/mp3-demuxer.ts
@@ -178,38 +178,6 @@ export class Mp3Demuxer extends Demuxer {
 		return;
 	}
 
-	async getDurationFromMetadata(): Promise<number | null> {
-		await this.readMetadata();
-		assert(this.firstFrameHeader !== null);
-		assert(this.firstFrameHeaderPos !== null);
-
-		if (this.xingData) {
-			if (this.xingData.frameCount !== null) {
-				return this.xingData.frameCount
-					* this.firstFrameHeader.audioSamplesInFrame
-					/ this.firstFrameHeader.sampleRate;
-			}
-		} else {
-			// No Xing, assuming CBR
-
-			if (this.reader.fileSize !== null) {
-				const averageFrameSize = computeAverageMp3FrameSize(
-					this.firstFrameHeader.lowSamplingFrequency,
-					this.firstFrameHeader.layer,
-					this.firstFrameHeader.bitrate,
-					this.firstFrameHeader.sampleRate,
-				);
-				const frameCount = (this.reader.fileSize - this.firstFrameHeaderPos) / averageFrameSize;
-
-				return Math.round(frameCount)
-					* this.firstFrameHeader.audioSamplesInFrame
-					/ this.firstFrameHeader.sampleRate;
-			}
-		}
-
-		return null;
-	}
-
 	async getMimeType() {
 		return 'audio/mpeg';
 	}
@@ -309,8 +277,37 @@ class Mp3AudioTrackBacking implements InputAudioTrackBacking {
 		return null;
 	}
 
-	getDurationFromMetadata() {
-		return this.demuxer.getDurationFromMetadata();
+	async getDurationFromMetadata() {
+		const demuxer = this.demuxer;
+
+		assert(demuxer.firstFrameHeader !== null);
+		assert(demuxer.firstFrameHeaderPos !== null);
+
+		if (demuxer.xingData) {
+			if (demuxer.xingData.frameCount !== null) {
+				return demuxer.xingData.frameCount
+					* demuxer.firstFrameHeader.audioSamplesInFrame
+					/ demuxer.firstFrameHeader.sampleRate;
+			}
+		} else {
+			// No Xing, assuming CBR
+
+			if (demuxer.reader.fileSize !== null) {
+				const averageFrameSize = computeAverageMp3FrameSize(
+					demuxer.firstFrameHeader.lowSamplingFrequency,
+					demuxer.firstFrameHeader.layer,
+					demuxer.firstFrameHeader.bitrate,
+					demuxer.firstFrameHeader.sampleRate,
+				);
+				const frameCount = (demuxer.reader.fileSize - demuxer.firstFrameHeaderPos) / averageFrameSize;
+
+				return Math.round(frameCount)
+					* demuxer.firstFrameHeader.audioSamplesInFrame
+					/ demuxer.firstFrameHeader.sampleRate;
+			}
+		}
+
+		return null;
 	}
 
 	async getLiveRefreshInterval() {
diff --git a/src/mpeg-ts/mpeg-ts-demuxer.ts b/src/mpeg-ts/mpeg-ts-demuxer.ts
index 260fd68..652c796 100644
--- a/src/mpeg-ts/mpeg-ts-demuxer.ts
+++ b/src/mpeg-ts/mpeg-ts-demuxer.ts
@@ -714,10 +714,6 @@ export class MpegTsDemuxer extends Demuxer {
 		return this.trackBackingEntries;
 	}
 
-	async getDurationFromMetadata(): Promise<number | null> {
-		return null;
-	}
-
 	async getMetadataTags(): Promise<MetadataTags> {
 		return {}; // Nothing for now
 	}
diff --git a/src/ogg/ogg-demuxer.ts b/src/ogg/ogg-demuxer.ts
index d54482e..6191e7f 100644
--- a/src/ogg/ogg-demuxer.ts
+++ b/src/ogg/ogg-demuxer.ts
@@ -388,10 +388,6 @@ export class OggDemuxer extends Demuxer {
 		});
 	}
 
-	async getDurationFromMetadata(): Promise<number | null> {
-		return null; // Not stored anywhere
-	}
-
 	async getTrackBackings() {
 		await this.readMetadata();
 		return this.trackBackings;
@@ -471,7 +467,7 @@ class OggAudioTrackBacking implements InputAudioTrackBacking {
 	}
 
 	async getDurationFromMetadata() {
-		return null;
+		return null; // Not stored anywhere
 	}
 
 	async getLiveRefreshInterval() {
diff --git a/src/output.ts b/src/output.ts
index fb9f8d9..26ff181 100644
--- a/src/output.ts
+++ b/src/output.ts
@@ -335,6 +335,8 @@ export type OutputEvents = {
 		target: Target;
 		/** The request that led to the target being obtained, or `null` if the output is not pathed. */
 		request: TargetRequest | null;
+		/** Whether the target is the root file of the media. */
+		isRoot: boolean;
 	};
 };
 
@@ -379,21 +381,33 @@ export class Output<
 	_mutex = new AsyncMutex();
 	/** @internal */
 	_metadataTags: MetadataTags = {};
+	/** @internal */
+	_rootTarget: T | null = null;
+	/** @internal */
+	_rootTargetPromise: Promise<T> | null = null;
 
-	/** The target to which the root file will be written. Throws if the target-resolving function returns a Promise. */
+	/**
+	 * The target to which the root file will be written. Throws when using {@link PathedTarget} with an async callback;
+	 * prefer the `'target'` event for those cases.
+	 */
 	get target(): T {
-		if (this._target instanceof Target) {
-			return this._target;
+		const errorMessage = 'Output.target cannot be used when using PathedTarget with an async callback.'
+			+ ' Use the \'target\' event instead.';
+
+		// We use this field to make sure we can reliably throw in the `target` getter whenever retrieving the target
+		// requires awaiting a promise. We do this so there is no different behavior based on order: if the target has
+		// already been retrieved via the normal internal operations, and then somebody calls the `target` getter, even
+		// if the target is now available, the getter should still throw to be consistent in behavior and in definition.
+		if (this._rootTargetPromise) {
+			throw new TypeError(errorMessage);
 		}
 
-		const target = this._target.getTarget({ path: this._target.rootPath, isRoot: true });
-		if (target instanceof Promise) {
-			throw new TypeError(
-				'Output.target cannot be used when the target function resolves asynchronously.',
-			);
+		const rootTargetResult = this._getRootTarget();
+		if (rootTargetResult instanceof Promise) {
+			throw new TypeError(errorMessage);
 		}
 
-		return target;
+		return rootTargetResult;
 	}
 
 	/**
@@ -443,13 +457,33 @@ export class Output<
 		this._muxer = options.format._createMuxer(this);
 	}
 
+	/** @internal */
+	_getTargetValidated(request: TargetRequest): MaybePromise<T> {
+		assert(this._target instanceof PathedTarget);
+
+		const result = this._target.getTarget(request);
+		const handleResult = (result: T) => {
+			if (!(result instanceof Target)) {
+				throw new TypeError('getTarget must return a Target.');
+			}
+
+			return result;
+		};
+
+		if (result instanceof Promise) {
+			return result.then(handleResult);
+		} else {
+			return handleResult(result);
+		}
+	}
+
 	/** @internal */
 	async _getTarget(request: TargetRequest) {
 		assert(this._target instanceof PathedTarget);
 
-		const target = await this._target.getTarget(request);
+		const target = await this._getTargetValidated(request);
 		target._output = this;
-		this._emit('target', { target, request });
+		this._emit('target', { target, request, isRoot: request.isRoot });
 
 		if (this.state === 'canceled') {
 			await target._close();
@@ -485,17 +519,49 @@ export class Output<
 		return this._initTarget !== null;
 	}
 
+	/** @internal */
+	_getRootTarget(): MaybePromise<T> {
+		if (this._rootTarget) {
+			return this._rootTarget;
+		}
+		if (this._rootTargetPromise) {
+			return this._rootTargetPromise;
+		}
+
+		if (this._target instanceof Target) {
+			this._emit('target', { target: this._target, request: null, isRoot: true });
+			this._rootTarget = this._target;
+			return this._target;
+		}
+
+		const request: TargetRequest = { path: this._target.rootPath, isRoot: true };
+		const result = this._getTargetValidated(request);
+
+		const handleResult = (target: T) => {
+			target._output = this;
+
+			if (this.state === 'canceled') {
+				void target._close();
+			} else {
+				this._targets.add(target);
+			}
+
+			this._emit('target', { target, request, isRoot: true });
+			this._rootTarget = target;
+			return target;
+		};
+
+		if (result instanceof Promise) {
+			return this._rootTargetPromise = result.then(handleResult);
+		} else {
+			return handleResult(result);
+		}
+	}
+
 	/** @internal */
 	_getRootWriter() {
 		return this._rootWriterPromise ??= (async () => {
-			let target: Target;
-
-			if (this._target instanceof PathedTarget) {
-				target = await this._getTarget({ path: this._target.rootPath, isRoot: true });
-			} else {
-				target = this._target;
-				this._emit('target', { target: this._target, request: null });
-			}
+			const target = await this._getRootTarget();
 
 			const writer = new Writer(target);
 			writer.start();
@@ -799,8 +865,10 @@ export class Output<
 
 				if (this._rootWriterPromise) {
 					const rootWriter = await this._rootWriterPromise;
-					await rootWriter.flush();
-					await rootWriter.finalize();
+					if (!rootWriter.finalized) {
+						await rootWriter.flush();
+						await rootWriter.finalize();
+					}
 				}
 
 				this.state = 'finalized';
diff --git a/src/segmented-input.ts b/src/segmented-input.ts
index 0846b76..77f01fe 100644
--- a/src/segmented-input.ts
+++ b/src/segmented-input.ts
@@ -117,10 +117,6 @@ class SegmentedInputDemuxer extends Demuxer {
 		this.segmentedInput = segmentedInput;
 	}
 
-	async getDurationFromMetadata(): Promise<number | null> {
-		throw new Error('Unreachable');
-	}
-
 	async getMetadataTags(): Promise<MetadataTags> {
 		throw new Error('Unreachable');
 	}
diff --git a/src/source.ts b/src/source.ts
index 92915b1..11404fc 100644
--- a/src/source.ts
+++ b/src/source.ts
@@ -207,11 +207,11 @@ export class SourceRef<S extends Source = Source> implements Disposable {
 
 	/**
 	 * Frees the ref, decrementing the source's internal reference count. If the source's internal reference count
-	 * reaches zero, it gets disposed. This method is idempotent.
+	 * reaches zero, it gets disposed. To catch bugs, this method throws if the ref is already freed.
 	 */
 	free() {
 		if (this._freed) {
-			return;
+			throw new Error('Illegal operation: double free on SourceRef.');
 		}
 
 		const source = this.source;
diff --git a/src/wave/wave-demuxer.ts b/src/wave/wave-demuxer.ts
index c9f6545..f52231c 100644
--- a/src/wave/wave-demuxer.ts
+++ b/src/wave/wave-demuxer.ts
@@ -328,13 +328,6 @@ export class WaveDemuxer extends Demuxer {
 		return null;
 	}
 
-	async getDurationFromMetadata(): Promise<number | null> {
-		await this.readMetadata();
-		assert(this.dataSize !== -1);
-
-		return this.dataSize / this.audioInfo!.blockSizeInBytes / this.audioInfo!.sampleRate;
-	}
-
 	async getMimeType() {
 		return 'audio/wav';
 	}
@@ -421,8 +414,10 @@ class WaveAudioTrackBacking implements InputAudioTrackBacking {
 		return null;
 	}
 
-	getDurationFromMetadata() {
-		return this.demuxer.getDurationFromMetadata();
+	async getDurationFromMetadata() {
+		assert(this.demuxer.dataSize !== -1);
+
+		return this.demuxer.dataSize / this.demuxer.audioInfo!.blockSizeInBytes / this.demuxer.audioInfo!.sampleRate;
 	}
 
 	async getLiveRefreshInterval() {
diff --git a/src/writer.ts b/src/writer.ts
index f3cf4c6..43c1622 100644
--- a/src/writer.ts
+++ b/src/writer.ts
@@ -11,6 +11,8 @@ import { Target } from './target';
 
 export class Writer {
 	target: Target;
+	finalized = false;
+	started = false;
 
 	private pos = 0;
 
@@ -19,7 +21,9 @@ export class Writer {
 	}
 
 	start() {
+		assert(!this.started);
 		this.target._start();
+		this.started = true;
 	}
 
 	ensureMonotonicity() {
@@ -29,6 +33,8 @@ export class Writer {
 
 	/** Writes the given data to the target, at the current position. */
 	write(data: Uint8Array) {
+		assert(this.started && !this.finalized);
+
 		this.maybeTrackWrites(data);
 		this.target._write(data, this.pos);
 		this.pos += data.byteLength;
@@ -46,15 +52,19 @@ export class Writer {
 
 	/** Signals to the writer that it may be time to flush. */
 	async flush() {
+		assert(this.started && !this.finalized);
 		return this.target._flush();
 	}
 
 	/** Called after muxing has finished. */
 	async finalize() {
+		assert(this.started && !this.finalized);
 		assert(this.target._output);
 
 		await this.target._finalize();
 		this.target._output._targets.delete(this.target);
+
+		this.finalized = true;
 	}
 
 	private trackedWrites: Uint8Array | null = null;
diff --git a/test/node/hls-input.test.ts b/test/node/hls-input.test.ts
index 14a84e5..688fb40 100644
--- a/test/node/hls-input.test.ts
+++ b/test/node/hls-input.test.ts
@@ -13,11 +13,14 @@ test.concurrent('Big Buck Bunny', { timeout: 15_000 }, async () => {
 	let sourceCount = 0;
 	input.on('source', () => sourceCount++);
 
+	let rootReadCount = 0;
+	input.source.on('read', () => rootReadCount++);
+
 	expect(await input.getFormat()).toBeInstanceOf(HlsInputFormat);
 	expect(await input.getFormat()).toBe(HLS);
-	expect(await input.getDurationFromMetadata()).toBe(null); // Since it's a master playlist!
 
 	expect(sourceCount).toBe(1);
+	expect(rootReadCount).toBeGreaterThan(0);
 
 	// Test descriptors (unhydrated metadata from master playlist)
 	const descriptors = await input.getTrackDescriptors();
@@ -211,6 +214,8 @@ test.concurrent('Big Buck Bunny', { timeout: 15_000 }, async () => {
 	// Since they're the highest-bitrate option
 	expect(primaryVideoTrack).toBe(videoTracks[4]);
 	expect(primaryAudioTrack).toBe(audioTracks[4]);
+
+	expect(await input.getDurationFromMetadata()).not.toBe(null);
 });
 
 test.concurrent('Single-variant Big Buck Bunny', { timeout: 15_000 }, async () => {
diff --git a/test/node/hls-output.test.ts b/test/node/hls-output.test.ts
index ef3c877..292c35e 100644
--- a/test/node/hls-output.test.ts
+++ b/test/node/hls-output.test.ts
@@ -1817,7 +1817,7 @@ segment-1-1.ts
 	);
 });
 
-test('onSegment, onPlaylist, onMaster events', async () => {
+test('write, onSegment, onPlaylist, onMaster events', async () => {
 	const onSegment = vi.fn();
 	const onPlaylist = vi.fn();
 	const onMaster = vi.fn();
@@ -1832,6 +1832,9 @@ test('onSegment, onPlaylist, onMaster events', async () => {
 		target: new PathedTarget('', () => new BufferTarget()),
 	});
 
+	let targetWrites = 0;
+	output.target.on('write', () => targetWrites++);
+
 	const source = videoSource();
 	output.addVideoTrack(source);
 
@@ -1858,6 +1861,8 @@ test('onSegment, onPlaylist, onMaster events', async () => {
 
 	await output.finalize();
 
+	expect(targetWrites).toBeGreaterThan(0);
+
 	// Second segment finalized on close
 	expect(onSegment).toHaveBeenCalledTimes(2);
 	expect(onSegment.mock.calls[1]![1]).toEqual(expect.objectContaining({ n: 2 }));