@editframe/elements 0.20.3-beta.0 → 0.21.0-beta.0

package/dist/elements/EFMedia/BufferedSeekingInput.js

@@ -1,7 +1,8 @@
+import { withSpan } from "../../otel/tracingHelpers.js";
 import { roundToMilliseconds } from "./shared/PrecisionUtils.js";
 import { SampleBuffer } from "../SampleBuffer.js";
 import { AudioSampleSink, BufferSource, Input, InputAudioTrack, InputVideoTrack, MP4, VideoSampleSink } from "mediabunny";
-const defaultOptions = {
+var defaultOptions = {
 	videoBufferSize: 30,
 	audioBufferSize: 100,
 	startTimeOffsetMs: 0
@@ -14,11 +15,10 @@ var BufferedSeekingInput = class {
 		this.trackIteratorCreationPromises = /* @__PURE__ */ new Map();
 		this.trackSeekPromises = /* @__PURE__ */ new Map();
 		const bufferSource = new BufferSource(arrayBuffer);
-		const input = new Input({
+		this.input = new Input({
 			source: bufferSource,
 			formats: [MP4]
 		});
-		this.input = input;
 		this.options = {
 			...defaultOptions,
 			...options
@@ -34,8 +34,7 @@ var BufferedSeekingInput = class {
 		return buffer ? Object.freeze([...buffer.getContents()]) : [];
 	}
 	getBufferTimestamps(trackId) {
-		const contents = this.getBufferContents(trackId);
-		return contents.map((sample) => sample.timestamp || 0);
+		return this.getBufferContents(trackId).map((sample) => sample.timestamp || 0);
 	}
 	clearBuffer(trackId) {
 		const buffer = this.trackBuffers.get(trackId);
@@ -45,30 +44,25 @@ var BufferedSeekingInput = class {
 		return this.input.computeDuration();
 	}
 	async getTrack(trackId) {
-		const tracks = await this.input.getTracks();
-		const track = tracks.find((track$1) => track$1.id === trackId);
+		const track = (await this.input.getTracks()).find((track$1) => track$1.id === trackId);
 		if (!track) throw new Error(`Track ${trackId} not found`);
 		return track;
 	}
 	async getAudioTrack(trackId) {
-		const tracks = await this.input.getAudioTracks();
-		const track = tracks.find((track$1) => track$1.id === trackId && track$1.type === "audio");
+		const track = (await this.input.getAudioTracks()).find((track$1) => track$1.id === trackId && track$1.type === "audio");
 		if (!track) throw new Error(`Track ${trackId} not found`);
 		return track;
 	}
 	async getVideoTrack(trackId) {
-		const tracks = await this.input.getVideoTracks();
-		const track = tracks.find((track$1) => track$1.id === trackId && track$1.type === "video");
+		const track = (await this.input.getVideoTracks()).find((track$1) => track$1.id === trackId && track$1.type === "video");
 		if (!track) throw new Error(`Track ${trackId} not found`);
 		return track;
 	}
 	async getFirstVideoTrack() {
-		const tracks = await this.input.getVideoTracks();
-		return tracks[0];
+		return (await this.input.getVideoTracks())[0];
 	}
 	async getFirstAudioTrack() {
-		const tracks = await this.input.getAudioTracks();
-		return tracks[0];
+		return (await this.input.getAudioTracks())[0];
 	}
 	getTrackIterator(track) {
 		if (this.trackIterators.has(track.id)) return this.trackIterators.get(track.id);
@@ -82,18 +76,15 @@ var BufferedSeekingInput = class {
 		throw new Error(`Unsupported track type ${track.type}`);
 	}
 	createTrackIterator(track) {
-		const sampleSink = this.createTrackSampleSink(track);
-		return sampleSink.samples();
+		return this.createTrackSampleSink(track).samples();
 	}
 	createTrackBuffer(track) {
 		if (track.type === "audio") {
 			const bufferSize$1 = this.options.audioBufferSize;
-			const sampleBuffer$1 = new SampleBuffer(bufferSize$1);
-			return sampleBuffer$1;
+			return new SampleBuffer(bufferSize$1);
 		}
 		const bufferSize = this.options.videoBufferSize;
-		const sampleBuffer = new SampleBuffer(bufferSize);
-		return sampleBuffer;
+		return new SampleBuffer(bufferSize);
 	}
 	getTrackBuffer(track) {
 		const maybeTrackBuffer = this.trackBuffers.get(track.id);
@@ -103,21 +94,30 @@ var BufferedSeekingInput = class {
 		return trackBuffer;
 	}
 	async seek(trackId, timeMs) {
-		const mediaTimeMs = timeMs + this.startTimeOffsetMs;
-		const roundedMediaTimeMs = roundToMilliseconds(mediaTimeMs);
-		const existingSeek = this.trackSeekPromises.get(trackId);
-		if (existingSeek) await existingSeek;
-		const seekPromise = this.seekSafe(trackId, roundedMediaTimeMs);
-		this.trackSeekPromises.set(trackId, seekPromise);
-		try {
-			return await seekPromise;
-		} finally {
-			this.trackSeekPromises.delete(trackId);
-		}
+		return withSpan("bufferedInput.seek", {
+			trackId,
+			timeMs,
+			startTimeOffsetMs: this.startTimeOffsetMs
+		}, void 0, async (span) => {
+			const mediaTimeMs = timeMs + this.startTimeOffsetMs;
+			const roundedMediaTimeMs = roundToMilliseconds(mediaTimeMs);
+			span.setAttribute("roundedMediaTimeMs", roundedMediaTimeMs);
+			const existingSeek = this.trackSeekPromises.get(trackId);
+			if (existingSeek) {
+				span.setAttribute("waitedForExistingSeek", true);
+				await existingSeek;
+			}
+			const seekPromise = this.seekSafe(trackId, roundedMediaTimeMs);
+			this.trackSeekPromises.set(trackId, seekPromise);
+			try {
+				return await seekPromise;
+			} finally {
+				this.trackSeekPromises.delete(trackId);
+			}
+		});
 	}
 	async resetIterator(track) {
-		const trackBuffer = this.trackBuffers.get(track.id);
-		trackBuffer?.clear();
+		this.trackBuffers.get(track.id)?.clear();
 		const ongoingIteratorCreation = this.trackIteratorCreationPromises.get(track.id);
 		if (ongoingIteratorCreation) await ongoingIteratorCreation;
 		const iterator = this.trackIterators.get(track.id);
@@ -128,50 +128,108 @@ var BufferedSeekingInput = class {
 	}
 	#seekLock;
 	async seekSafe(trackId, timeMs) {
-		if (this.#seekLock) await this.#seekLock.promise;
-		const seekLock = Promise.withResolvers();
-		this.#seekLock = seekLock;
-		try {
-			const track = await this.getTrack(trackId);
-			const trackBuffer = this.getTrackBuffer(track);
-			const roundedTimeMs = roundToMilliseconds(timeMs);
-			const firstTimestampMs = roundToMilliseconds(await track.getFirstTimestamp() * 1e3);
-			if (roundedTimeMs < firstTimestampMs) {
-				console.error("Seeking outside bounds of input", {
-					roundedTimeMs,
-					firstTimestampMs
-				});
-				throw new NoSample(`Seeking outside bounds of input ${roundedTimeMs} < ${firstTimestampMs}`);
+		return withSpan("bufferedInput.seekSafe", {
+			trackId,
+			timeMs
+		}, void 0, async (span) => {
+			if (this.#seekLock) {
+				span.setAttribute("waitedForSeekLock", true);
+				await this.#seekLock.promise;
 			}
-			const bufferContents = trackBuffer.getContents();
-			if (bufferContents.length > 0) {
-				const bufferStartMs = roundToMilliseconds(trackBuffer.firstTimestamp * 1e3);
-				if (roundedTimeMs < bufferStartMs) await this.resetIterator(track);
+			const seekLock = Promise.withResolvers();
+			this.#seekLock = seekLock;
+			try {
+				const track = await this.getTrack(trackId);
+				span.setAttribute("trackType", track.type);
+				const trackBuffer = this.getTrackBuffer(track);
+				const roundedTimeMs = roundToMilliseconds(timeMs);
+				const firstTimestampMs = roundToMilliseconds(await track.getFirstTimestamp() * 1e3);
+				span.setAttribute("firstTimestampMs", firstTimestampMs);
+				if (roundedTimeMs < firstTimestampMs) {
+					console.error("Seeking outside bounds of input", {
+						roundedTimeMs,
+						firstTimestampMs
+					});
+					throw new NoSample(`Seeking outside bounds of input ${roundedTimeMs} < ${firstTimestampMs}`);
+				}
+				const bufferContents = trackBuffer.getContents();
+				span.setAttribute("bufferContentsLength", bufferContents.length);
+				if (bufferContents.length > 0) {
+					const bufferStartMs = roundToMilliseconds(trackBuffer.firstTimestamp * 1e3);
+					span.setAttribute("bufferStartMs", bufferStartMs);
+					if (roundedTimeMs < bufferStartMs) {
+						span.setAttribute("resetIterator", true);
+						await this.resetIterator(track);
+					}
+				}
+				const alreadyInBuffer = trackBuffer.find(timeMs);
+				if (alreadyInBuffer) {
+					span.setAttribute("foundInBuffer", true);
+					span.setAttribute("bufferSize", trackBuffer.length);
+					const contents$1 = trackBuffer.getContents();
+					if (contents$1.length > 0) span.setAttribute("bufferTimestamps", contents$1.map((s) => Math.round((s.timestamp || 0) * 1e3)).slice(0, 10).join(","));
+					return alreadyInBuffer;
+				}
+				span.setAttribute("foundInBuffer", false);
+				span.setAttribute("bufferSize", trackBuffer.length);
+				span.setAttribute("requestedTimeMs", Math.round(timeMs));
+				const contents = trackBuffer.getContents();
+				if (contents.length > 0) {
+					const firstSample = contents[0];
+					const lastSample = contents[contents.length - 1];
+					if (firstSample && lastSample) {
+						const bufferStartMs = Math.round((firstSample.timestamp || 0) * 1e3);
+						const bufferEndMs = Math.round(((lastSample.timestamp || 0) + (lastSample.duration || 0)) * 1e3);
+						span.setAttribute("bufferStartMs", bufferStartMs);
+						span.setAttribute("bufferEndMs", bufferEndMs);
+						span.setAttribute("bufferRangeMs", `${bufferStartMs}-${bufferEndMs}`);
+					}
+				}
+				const iterator = this.getTrackIterator(track);
+				let iterationCount = 0;
+				const decodeStart = performance.now();
+				while (true) {
+					iterationCount++;
+					const iterStart = performance.now();
+					const { done, value: decodedSample } = await iterator.next();
+					const iterEnd = performance.now();
+					if (iterationCount <= 5) span.setAttribute(`iter${iterationCount}Ms`, Math.round((iterEnd - iterStart) * 100) / 100);
+					if (decodedSample) {
+						trackBuffer.push(decodedSample);
+						if (iterationCount <= 5) span.setAttribute(`iter${iterationCount}Timestamp`, Math.round((decodedSample.timestamp || 0) * 1e3));
+					}
+					const foundSample = trackBuffer.find(roundedTimeMs);
+					if (foundSample) {
+						const decodeEnd = performance.now();
+						span.setAttribute("iterationCount", iterationCount);
+						span.setAttribute("decodeMs", Math.round((decodeEnd - decodeStart) * 100) / 100);
+						span.setAttribute("avgIterMs", Math.round((decodeEnd - decodeStart) / iterationCount * 100) / 100);
+						span.setAttribute("foundSample", true);
+						span.setAttribute("foundTimestamp", Math.round((foundSample.timestamp || 0) * 1e3));
+						return foundSample;
+					}
+					if (done) break;
+				}
+				span.setAttribute("iterationCount", iterationCount);
+				span.setAttribute("reachedEnd", true);
+				const finalBufferContents = trackBuffer.getContents();
+				if (finalBufferContents.length > 0) {
+					const lastSample = finalBufferContents[finalBufferContents.length - 1];
+					const lastSampleEndMs = roundToMilliseconds(((lastSample?.timestamp || 0) + (lastSample?.duration || 0)) * 1e3);
+					const trackDurationMs = await track.computeDuration() * 1e3;
+					const isSeekingToTrackEnd = roundToMilliseconds(timeMs) === roundToMilliseconds(trackDurationMs);
+					const isAtEndOfTrack = roundToMilliseconds(timeMs) >= lastSampleEndMs;
+					if (isSeekingToTrackEnd && isAtEndOfTrack) {
+						span.setAttribute("returnedLastSample", true);
+						return lastSample;
+					}
+				}
+				throw new NoSample(`Sample not found for time ${timeMs} in ${track.type} track ${trackId}`);
+			} finally {
+				this.#seekLock = void 0;
+				seekLock.resolve();
 			}
-			const alreadyInBuffer = trackBuffer.find(timeMs);
-			if (alreadyInBuffer) return alreadyInBuffer;
-			const iterator = this.getTrackIterator(track);
-			while (true) {
-				const { done, value: decodedSample } = await iterator.next();
-				if (decodedSample) trackBuffer.push(decodedSample);
-				const foundSample = trackBuffer.find(roundedTimeMs);
-				if (foundSample) return foundSample;
-				if (done) break;
-			}
-			const finalBufferContents = trackBuffer.getContents();
-			if (finalBufferContents.length > 0) {
-				const lastSample = finalBufferContents[finalBufferContents.length - 1];
-				const lastSampleEndMs = roundToMilliseconds(((lastSample?.timestamp || 0) + (lastSample?.duration || 0)) * 1e3);
-				const trackDurationMs = await track.computeDuration() * 1e3;
-				const isSeekingToTrackEnd = roundToMilliseconds(timeMs) === roundToMilliseconds(trackDurationMs);
-				const isAtEndOfTrack = roundToMilliseconds(timeMs) >= lastSampleEndMs;
-				if (isSeekingToTrackEnd && isAtEndOfTrack) return lastSample;
-			}
-			throw new NoSample(`Sample not found for time ${timeMs} in ${track.type} track ${trackId}`);
-		} finally {
-			this.#seekLock = void 0;
-			seekLock.resolve();
-		}
+		});
 	}
 };
 export { BufferedSeekingInput };

package/dist/elements/EFMedia/JitMediaEngine.js

@@ -3,8 +3,7 @@ import { ThumbnailExtractor } from "./shared/ThumbnailExtractor.js";
 var JitMediaEngine = class JitMediaEngine extends BaseMediaEngine {
 	static async fetch(host, urlGenerator, url) {
 		const engine = new JitMediaEngine(host, urlGenerator);
-		const data = await engine.fetchManifest(url);
-		engine.data = data;
+		engine.data = await engine.fetchManifest(url);
 		return engine;
 	}
 	constructor(host, urlGenerator) {
@@ -20,7 +19,7 @@ var JitMediaEngine = class JitMediaEngine extends BaseMediaEngine {
 		return this.data.sourceUrl;
 	}
 	get audioRendition() {
-		if (!this.data.audioRenditions || this.data.audioRenditions.length === 0) return void 0;
+		if (!this.data.audioRenditions || this.data.audioRenditions.length === 0) return;
 		const rendition = this.data.audioRenditions[0];
 		if (!rendition) return void 0;
 		return {
@@ -32,7 +31,7 @@ var JitMediaEngine = class JitMediaEngine extends BaseMediaEngine {
 		};
 	}
 	get videoRendition() {
-		if (!this.data.videoRenditions || this.data.videoRenditions.length === 0) return void 0;
+		if (!this.data.videoRenditions || this.data.videoRenditions.length === 0) return;
 		const rendition = this.data.videoRenditions[0];
 		if (!rendition) return void 0;
 		return {
@@ -57,26 +56,24 @@ var JitMediaEngine = class JitMediaEngine extends BaseMediaEngine {
 		return this.fetchMedia(url);
 	}
 	computeSegmentId(desiredSeekTimeMs, rendition) {
-		if (desiredSeekTimeMs > this.durationMs) return void 0;
+		if (desiredSeekTimeMs > this.durationMs) return;
 		if (rendition.segmentDurationsMs && rendition.segmentDurationsMs.length > 0) {
 			let cumulativeTime = 0;
 			for (let i = 0; i < rendition.segmentDurationsMs.length; i++) {
 				const segmentDuration = rendition.segmentDurationsMs[i];
 				if (segmentDuration === void 0) throw new Error("Segment duration is required for JIT metadata");
-				const segmentStartMs$1 = cumulativeTime;
+				const segmentStartMs = cumulativeTime;
 				const segmentEndMs = cumulativeTime + segmentDuration;
-				const isLastSegment = i === rendition.segmentDurationsMs.length - 1;
-				const includesEndTime = isLastSegment && desiredSeekTimeMs === this.durationMs;
-				if (desiredSeekTimeMs >= segmentStartMs$1 && (desiredSeekTimeMs < segmentEndMs || includesEndTime)) return i + 1;
+				const includesEndTime = i === rendition.segmentDurationsMs.length - 1 && desiredSeekTimeMs === this.durationMs;
+				if (desiredSeekTimeMs >= segmentStartMs && (desiredSeekTimeMs < segmentEndMs || includesEndTime)) return i + 1;
 				cumulativeTime += segmentDuration;
 				if (cumulativeTime >= this.durationMs) break;
 			}
-			return void 0;
+			return;
 		}
 		if (!rendition.segmentDurationMs) throw new Error("Segment duration is required for JIT metadata");
 		const segmentIndex = Math.floor(desiredSeekTimeMs / rendition.segmentDurationMs);
-		const segmentStartMs = segmentIndex * rendition.segmentDurationMs;
-		if (segmentStartMs >= this.durationMs) return void 0;
+		if (segmentIndex * rendition.segmentDurationMs >= this.durationMs) return;
 		return segmentIndex + 1;
 	}
 	getScrubVideoRendition() {
@@ -91,10 +88,6 @@ var JitMediaEngine = class JitMediaEngine extends BaseMediaEngine {
 			segmentDurationsMs: scrubManifestRendition.segmentDurationsMs
 		};
 	}
-	/**
-	* Get preferred buffer configuration for JIT transcoding
-	* Uses higher buffering since transcoding introduces latency
-	*/
 	getBufferConfig() {
 		return {
 			videoBufferDurationMs: 8e3,
@@ -103,14 +96,20 @@ var JitMediaEngine = class JitMediaEngine extends BaseMediaEngine {
 			maxAudioBufferFetches: 3
 		};
 	}
-	/**
-	* Extract thumbnail canvases using same rendition priority as video playback for frame alignment
-	*/
 	async extractThumbnails(timestamps) {
-		const mainRendition = this.videoRendition;
-		const scrubRendition = this.getScrubVideoRendition();
-		const rendition = mainRendition || scrubRendition;
-		if (!rendition) return timestamps.map(() => null);
+		let rendition;
+		try {
+			const mainRendition = this.getVideoRendition();
+			if (mainRendition) rendition = mainRendition;
+			else {
+				const scrubRendition = this.getScrubVideoRendition();
+				if (scrubRendition) rendition = scrubRendition;
+				else throw new Error("No video rendition available");
+			}
+		} catch (error) {
+			console.warn("JitMediaEngine: No video rendition available for thumbnails", error);
+			return timestamps.map(() => null);
+		}
 		return this.thumbnailExtractor.extractThumbnails(timestamps, rendition, this.durationMs);
 	}
 	convertToSegmentRelativeTimestamps(globalTimestamps, _segmentId, _rendition) {

package/dist/elements/EFMedia/audioTasks/makeAudioBufferTask.js

@@ -33,12 +33,10 @@ const makeAudioBufferTask = (host) => {
 			};
 			return manageMediaBuffer(seekTimeMs, currentConfig, currentState, host.intrinsicDurationMs || 1e4, signal, {
 				computeSegmentId: async (timeMs, rendition) => {
-					const mediaEngine$1 = await getLatestMediaEngine(host, signal);
-					return mediaEngine$1.computeSegmentId(timeMs, rendition);
+					return (await getLatestMediaEngine(host, signal)).computeSegmentId(timeMs, rendition);
 				},
 				prefetchSegment: async (segmentId, rendition) => {
-					const mediaEngine$1 = await getLatestMediaEngine(host, signal);
-					await mediaEngine$1.fetchMediaSegment(segmentId, rendition);
+					await (await getLatestMediaEngine(host, signal)).fetchMediaSegment(segmentId, rendition);
 				},
 				isSegmentCached: (segmentId, rendition) => {
 					const mediaEngine$1 = host.mediaEngineTask.value;
@@ -46,9 +44,8 @@ const makeAudioBufferTask = (host) => {
 					return mediaEngine$1.isSegmentCached(segmentId, rendition);
 				},
 				getRendition: async () => {
-					const mediaEngine$1 = await getLatestMediaEngine(host, signal);
-					const audioRendition = mediaEngine$1.audioRendition;
-					if (!audioRendition) throw new Error("No audio track available in source");
+					const audioRendition = (await getLatestMediaEngine(host, signal)).audioRendition;
+					if (!audioRendition) throw new Error("Audio rendition not available");
 					return audioRendition;
 				},
 				logError: console.error

package/dist/elements/EFMedia/audioTasks/makeAudioFrequencyAnalysisTask.js

@@ -1,7 +1,7 @@
 import { EF_INTERACTIVE } from "../../../EF_INTERACTIVE.js";
 import { LRUCache } from "../../../utils/LRUCache.js";
 import { Task } from "@lit/task";
-const DECAY_WEIGHT = .8;
+var DECAY_WEIGHT = .8;
 function processFFTData(fftData, zeroThresholdPercent = .1) {
 	const totalBins = fftData.length;
 	const zeroThresholdCount = Math.floor(totalBins * zeroThresholdPercent);
@@ -51,8 +51,6 @@ function makeAudioFrequencyAnalysisTask(element) {
 		],
 		task: async (_, { signal }) => {
 			if (element.currentSourceTimeMs < 0) return null;
-			const mediaEngine = element.mediaEngineTask.value;
-			if (!mediaEngine?.audioRendition) return null;
 			const currentTimeMs = element.currentSourceTimeMs;
 			const frameIntervalMs = 1e3 / 30;
 			const earliestFrameMs = currentTimeMs - (element.fftDecay - 1) * frameIntervalMs;

package/dist/elements/EFMedia/audioTasks/makeAudioInitSegmentFetchTask.js

@@ -9,8 +9,8 @@ const makeAudioInitSegmentFetchTask = (host) => {
 		onComplete: (_value) => {},
 		task: async ([_mediaEngine], { signal }) => {
 			const mediaEngine = await getLatestMediaEngine(host, signal);
-			const audioRendition = mediaEngine.audioRendition;
-			if (!audioRendition) return void 0;
+			const audioRendition = mediaEngine.getAudioRendition();
+			if (!audioRendition) return;
 			return mediaEngine.fetchInitSegment(audioRendition, signal);
 		}
 	});

package/dist/elements/EFMedia/audioTasks/makeAudioInputTask.js

@@ -9,16 +9,18 @@ const makeAudioInputTask = (host) => {
 		},
 		onComplete: (_value) => {},
 		task: async (_, { signal }) => {
-			const initSegment = await host.audioInitSegmentFetchTask.taskComplete;
-			signal.throwIfAborted();
-			const segment = await host.audioSegmentFetchTask.taskComplete;
-			signal.throwIfAborted();
-			if (!initSegment || !segment) throw new Error("No audio track available in source");
 			const mediaEngine = await host.mediaEngineTask.taskComplete;
+			if (signal.aborted) return void 0;
 			const audioRendition = mediaEngine?.audioRendition;
-			const startTimeOffsetMs = audioRendition?.startTimeOffsetMs;
+			if (!audioRendition) return;
+			const initSegment = await host.audioInitSegmentFetchTask.taskComplete;
+			if (signal.aborted) return void 0;
+			const segment = await host.audioSegmentFetchTask.taskComplete;
+			if (signal.aborted) return void 0;
+			if (!initSegment || !segment) return;
+			const startTimeOffsetMs = audioRendition.startTimeOffsetMs;
 			const arrayBuffer = await new Blob([initSegment, segment]).arrayBuffer();
-			signal.throwIfAborted();
+			if (signal.aborted) return void 0;
 			return new BufferedSeekingInput(arrayBuffer, {
 				videoBufferSize: EFMedia.VIDEO_SAMPLE_BUFFER_SIZE,
 				audioBufferSize: EFMedia.AUDIO_SAMPLE_BUFFER_SIZE,

package/dist/elements/EFMedia/audioTasks/makeAudioSeekTask.js

@@ -13,9 +13,7 @@ const makeAudioSeekTask = (host) => {
 			else console.error("audioSeekTask unknown error", error);
 		},
 		onComplete: (_value) => {},
-		task: async () => {
-			return void 0;
-		}
+		task: async () => {}
 	});
 };
 export { makeAudioSeekTask };

package/dist/elements/EFMedia/audioTasks/makeAudioSegmentFetchTask.js

@@ -9,19 +9,9 @@ const makeAudioSegmentFetchTask = (host) => {
 		onComplete: (_value) => {},
 		task: async (_, { signal }) => {
 			const mediaEngine = await getLatestMediaEngine(host, signal);
-			const audioRendition = mediaEngine.audioRendition;
-			if (!audioRendition) return void 0;
 			const segmentId = await host.audioSegmentIdTask.taskComplete;
-			if (segmentId === void 0) {
-				const debugInfo = {
-					hasRendition: true,
-					segmentDurationMs: audioRendition.segmentDurationMs,
-					segmentDurationsMs: audioRendition.segmentDurationsMs?.length || 0,
-					desiredSeekTimeMs: host.desiredSeekTimeMs,
-					intrinsicDurationMs: host.intrinsicDurationMs
-				};
-				throw new Error(`Segment ID is not available for audio. Debug info: ${JSON.stringify(debugInfo)}`);
-			}
+			const audioRendition = mediaEngine.getAudioRendition();
+			if (!audioRendition || segmentId === void 0) return;
 			return mediaEngine.fetchMediaSegment(segmentId, audioRendition, signal);
 		}
 	});

package/dist/elements/EFMedia/audioTasks/makeAudioSegmentIdTask.js

@@ -10,8 +10,8 @@ const makeAudioSegmentIdTask = (host) => {
 		task: async ([, targetSeekTimeMs], { signal }) => {
 			const mediaEngine = await getLatestMediaEngine(host, signal);
 			signal.throwIfAborted();
-			const audioRendition = mediaEngine.audioRendition;
-			if (!audioRendition) return void 0;
+			const audioRendition = mediaEngine.getAudioRendition();
+			if (!audioRendition) return;
 			return mediaEngine.computeSegmentId(targetSeekTimeMs, audioRendition);
 		}
 	});

package/dist/elements/EFMedia/audioTasks/makeAudioTasksVideoOnly.browsertest.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/elements/EFMedia/audioTasks/makeAudioTimeDomainAnalysisTask.js

@@ -1,12 +1,17 @@
 import { EF_INTERACTIVE } from "../../../EF_INTERACTIVE.js";
 import { LRUCache } from "../../../utils/LRUCache.js";
+import { IgnorableError } from "../../EFMedia.js";
 import { Task } from "@lit/task";
-const DECAY_WEIGHT = .8;
+var DECAY_WEIGHT = .8;
 function makeAudioTimeDomainAnalysisTask(element) {
 	const cache = new LRUCache(1e3);
 	return new Task(element, {
 		autoRun: EF_INTERACTIVE,
 		onError: (error) => {
+			if (error instanceof IgnorableError) {
+				console.info("byteTimeDomainTask skipped: no audio track");
+				return;
+			}
 			console.error("byteTimeDomainTask error", error);
 		},
 		args: () => [
@@ -18,8 +23,6 @@ function makeAudioTimeDomainAnalysisTask(element) {
 		],
 		task: async (_, { signal }) => {
 			if (element.currentSourceTimeMs < 0) return null;
-			const mediaEngine = element.mediaEngineTask.value;
-			if (!mediaEngine?.audioRendition) return null;
 			const currentTimeMs = element.currentSourceTimeMs;
 			const frameIntervalMs = 1e3 / 30;
 			const earliestFrameMs = currentTimeMs - (element.fftDecay - 1) * frameIntervalMs;

package/dist/elements/EFMedia/shared/AudioSpanUtils.d.ts

@@ -4,4 +4,4 @@ import { EFMedia } from '../../EFMedia';
  * Fetch audio spanning a time range
  * Main function that orchestrates segment calculation, fetching, and blob creation
  */
-export declare const fetchAudioSpanningTime: (host: EFMedia, fromMs: number, toMs: number, signal: AbortSignal) => Promise<AudioSpan>;
+export declare const fetchAudioSpanningTime: (host: EFMedia, fromMs: number, toMs: number, signal: AbortSignal) => Promise<AudioSpan | undefined>;

package/dist/elements/EFMedia/shared/AudioSpanUtils.js

@@ -1,10 +1,6 @@
-/**
-* Fetch audio segment data using MediaEngine
-* Pure function with explicit dependencies
-*/
-const fetchAudioSegmentData = async (segmentIds, mediaEngine, signal) => {
+var fetchAudioSegmentData = async (segmentIds, mediaEngine, signal) => {
 	const audioRendition = mediaEngine.audioRendition;
-	if (!audioRendition) throw new Error("No audio track available in source");
+	if (!audioRendition) throw new Error("Audio rendition not available");
 	const segmentData = /* @__PURE__ */ new Map();
 	const fetchPromises = segmentIds.map(async (segmentId) => {
 		const arrayBuffer = await mediaEngine.fetchMediaSegment(segmentId, audioRendition, signal);
@@ -15,24 +11,16 @@ const fetchAudioSegmentData = async (segmentIds, mediaEngine, signal) => {
 	for (const [segmentId, arrayBuffer] of fetchedSegments) segmentData.set(segmentId, arrayBuffer);
 	return segmentData;
 };
-/**
-* Create audio span blob from init segment and media segments
-* Pure function for blob creation
-*/
-const createAudioSpanBlob = (initSegment, mediaSegments) => {
+var createAudioSpanBlob = (initSegment, mediaSegments) => {
 	const chunks = [initSegment, ...mediaSegments];
 	return new Blob(chunks, { type: "audio/mp4" });
 };
-/**
-* Fetch audio spanning a time range
-* Main function that orchestrates segment calculation, fetching, and blob creation
-*/
 const fetchAudioSpanningTime = async (host, fromMs, toMs, signal) => {
 	if (fromMs >= toMs || fromMs < 0) throw new Error(`Invalid time range: fromMs=${fromMs}, toMs=${toMs}`);
 	const mediaEngine = await host.mediaEngineTask.taskComplete;
 	const initSegment = await host.audioInitSegmentFetchTask.taskComplete;
-	if (!mediaEngine?.audioRendition) throw new Error("No audio track available in source");
-	if (!initSegment) throw new Error("Audio init segment is not available");
+	if (!mediaEngine?.audioRendition) return;
+	if (!initSegment) return;
 	const segmentRanges = mediaEngine.calculateAudioSegmentRange(fromMs, toMs, mediaEngine.audioRendition, host.intrinsicDurationMs || 1e4);
 	if (segmentRanges.length === 0) throw new Error(`No segments found for time range ${fromMs}-${toMs}ms`);
 	const segmentIds = segmentRanges.map((r) => r.segmentId);

package/dist/elements/EFMedia/shared/BufferUtils.d.ts

@@ -24,7 +24,7 @@ export interface MediaBufferDependencies<T extends AudioRendition | VideoRenditi
     computeSegmentId: (timeMs: number, rendition: T) => Promise<number | undefined>;
     prefetchSegment: (segmentId: number, rendition: T) => Promise<void>;
     isSegmentCached: (segmentId: number, rendition: T) => boolean;
-    getRendition: () => Promise<T>;
+    getRendition: () => Promise<T | undefined>;
     logError: (message: string, error: any) => void;
 }
 /**

package/dist/elements/EFMedia/shared/BufferUtils.js

@@ -1,6 +1,3 @@
-/**
-* Async version of computeSegmentRange for when computeSegmentId is async
-*/
 const computeSegmentRangeAsync = async (startTimeMs, endTimeMs, durationMs, rendition, computeSegmentId) => {
 	const segments = [];
 	const segmentDurationMs = rendition.segmentDurationMs || 1e3;
@@ -15,23 +12,15 @@ const computeSegmentRangeAsync = async (startTimeMs, endTimeMs, durationMs, rend
 	}
 	return segments.filter((id, index, arr) => arr.indexOf(id) === index);
 };
-/**
-* Compute buffer queue based on desired segments and what we've already requested
-* Pure function - determines what new segments should be prefetched
-*/
 const computeBufferQueue = (desiredSegments, requestedSegments) => {
 	return desiredSegments.filter((segmentId) => !requestedSegments.has(segmentId));
 };
-/**
-* Core media buffering orchestration logic - prefetch only, no data storage
-* Integrates with BaseMediaEngine's existing caching and request deduplication
-*/
 const manageMediaBuffer = async (seekTimeMs, config, currentState, durationMs, signal, deps) => {
 	if (!config.enableBuffering) return currentState;
 	const rendition = await deps.getRendition();
+	if (!rendition) return currentState;
 	const endTimeMs = seekTimeMs + config.bufferDurationMs;
-	const desiredSegments = await computeSegmentRangeAsync(seekTimeMs, endTimeMs, durationMs, rendition, deps.computeSegmentId);
-	const uncachedSegments = desiredSegments.filter((segmentId) => !deps.isSegmentCached(segmentId, rendition));
+	const uncachedSegments = (await computeSegmentRangeAsync(seekTimeMs, endTimeMs, durationMs, rendition, deps.computeSegmentId)).filter((segmentId) => !deps.isSegmentCached(segmentId, rendition));
 	const newQueue = computeBufferQueue(uncachedSegments, currentState.requestedSegments);
 	const newRequestedSegments = new Set(currentState.requestedSegments);
 	const newActiveRequests = new Set(currentState.activeRequests);