@editframe/elements 0.20.0-beta.0 → 0.20.2-beta.0

package/dist/elements/EFMedia/AssetIdMediaEngine.js

@@ -41,7 +41,7 @@ var AssetIdMediaEngine = class AssetIdMediaEngine extends AssetMediaEngine {
 		return `${this.apiHost}/api/v1/isobmff_tracks/${this.assetId}/${trackId}`;
 	}
 	convertToSegmentRelativeTimestamps(globalTimestamps, segmentId, rendition) {
-		if (!rendition.trackId) throw new Error("Track ID is required for asset metadata");
+		if (!rendition.trackId) throw new Error("[convertToSegmentRelativeTimestamps] Track ID is required for asset metadata");
 		const trackData = this.data[rendition.trackId];
 		if (!trackData) throw new Error("Track not found");
 		const segment = trackData.segments?.[segmentId];

package/dist/elements/EFMedia/AssetMediaEngine.js

@@ -63,7 +63,7 @@ var AssetMediaEngine = class AssetMediaEngine extends BaseMediaEngine {
 		return `/@ef-track/${this.src}?trackId=${trackId}&segmentId=${segmentId}`;
 	}
 	async fetchInitSegment(rendition, signal) {
-		if (!rendition.trackId) throw new Error("Track ID is required for asset metadata");
+		if (!rendition.trackId) throw new Error("[fetchInitSegment] Track ID is required for asset metadata");
 		const url = this.buildInitSegmentUrl(rendition.trackId);
 		const initSegment = this.data[rendition.trackId]?.initSegment;
 		if (!initSegment) throw new Error("Init segment not found");
@@ -71,7 +71,7 @@ var AssetMediaEngine = class AssetMediaEngine extends BaseMediaEngine {
 		return this.fetchMediaWithHeaders(url, headers, signal);
 	}
 	async fetchMediaSegment(segmentId, rendition, signal) {
-		if (!rendition.trackId) throw new Error("Track ID is required for asset metadata");
+		if (!rendition.trackId) throw new Error("[fetchMediaSegment] Track ID is required for asset metadata");
 		if (segmentId === void 0) throw new Error("Segment ID is not available");
 		const url = this.buildMediaSegmentUrl(rendition.trackId, segmentId);
 		const mediaSegment = this.data[rendition.trackId]?.segments[segmentId];
@@ -113,7 +113,10 @@ var AssetMediaEngine = class AssetMediaEngine extends BaseMediaEngine {
 		return segmentRanges;
 	}
 	computeSegmentId(seekTimeMs, rendition) {
-		if (!rendition.trackId) throw new Error("Track ID is required for asset metadata");
+		if (!rendition.trackId) {
+			console.warn(`computeSegmentId: trackId not found for rendition ${JSON.stringify(rendition)}`);
+			throw new Error("[computeSegmentId] Track ID is required for asset metadata");
+		}
 		const track = this.data[rendition.trackId];
 		if (!track) throw new Error("Track not found");
 		const { timescale, segments } = track;
@@ -159,7 +162,7 @@ var AssetMediaEngine = class AssetMediaEngine extends BaseMediaEngine {
 	}
 	convertToSegmentRelativeTimestamps(globalTimestamps, segmentId, rendition) {
 		{
-			if (!rendition.trackId) throw new Error("Track ID is required for asset metadata");
+			if (!rendition.trackId) throw new Error("[convertToSegmentRelativeTimestamps] Track ID is required for asset metadata");
 			const trackData = this.data[rendition.trackId];
 			if (!trackData) throw new Error("Track not found");
 			const segment = trackData.segments?.[segmentId];

package/dist/elements/EFMedia/JitMediaEngine.js

@@ -107,19 +107,10 @@ var JitMediaEngine = class JitMediaEngine extends BaseMediaEngine {
 	* Extract thumbnail canvases using same rendition priority as video playback for frame alignment
 	*/
 	async extractThumbnails(timestamps) {
-		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);
-		}
+		const mainRendition = this.videoRendition;
+		const scrubRendition = this.getScrubVideoRendition();
+		const rendition = mainRendition || scrubRendition;
+		if (!rendition) return timestamps.map(() => null);
 		return this.thumbnailExtractor.extractThumbnails(timestamps, rendition, this.durationMs);
 	}
 	convertToSegmentRelativeTimestamps(globalTimestamps, _segmentId, _rendition) {

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

@@ -22,6 +22,7 @@ const makeAudioBufferTask = (host) => {
 		task: async ([seekTimeMs], { signal }) => {
 			if (EF_RENDERING()) return currentState;
 			const mediaEngine = await getLatestMediaEngine(host, signal);
+			if (!mediaEngine.audioRendition) return currentState;
 			const engineConfig = mediaEngine.getBufferConfig();
 			const bufferDurationMs = engineConfig.audioBufferDurationMs;
 			const maxParallelFetches = engineConfig.maxAudioBufferFetches;
@@ -47,7 +48,7 @@ const makeAudioBufferTask = (host) => {
 				getRendition: async () => {
 					const mediaEngine$1 = await getLatestMediaEngine(host, signal);
 					const audioRendition = mediaEngine$1.audioRendition;
-					if (!audioRendition) throw new Error("Audio rendition not available");
+					if (!audioRendition) throw new Error("No audio track available in source");
 					return audioRendition;
 				},
 				logError: console.error

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

@@ -51,6 +51,8 @@ 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.d.ts

@@ -1,4 +1,4 @@
 import { Task } from '@lit/task';
 import { MediaEngine } from '../../../transcoding/types';
 import { EFMedia } from '../../EFMedia';
-export declare const makeAudioInitSegmentFetchTask: (host: EFMedia) => Task<readonly [MediaEngine | undefined], ArrayBuffer>;
+export declare const makeAudioInitSegmentFetchTask: (host: EFMedia) => Task<readonly [MediaEngine | undefined], ArrayBuffer | undefined>;

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

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

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

@@ -13,7 +13,7 @@ const makeAudioInputTask = (host) => {
 			signal.throwIfAborted();
 			const segment = await host.audioSegmentFetchTask.taskComplete;
 			signal.throwIfAborted();
-			if (!initSegment || !segment) throw new Error("Init segment or segment is not available");
+			if (!initSegment || !segment) throw new Error("No audio track available in source");
 			const mediaEngine = await host.mediaEngineTask.taskComplete;
 			const audioRendition = mediaEngine?.audioRendition;
 			const startTimeOffsetMs = audioRendition?.startTimeOffsetMs;

package/dist/elements/EFMedia/audioTasks/makeAudioSegmentFetchTask.d.ts

@@ -1,4 +1,4 @@
 import { Task } from '@lit/task';
 import { MediaEngine } from '../../../transcoding/types';
 import { EFMedia } from '../../EFMedia';
-export declare const makeAudioSegmentFetchTask: (host: EFMedia) => Task<readonly [MediaEngine | undefined, number | undefined], ArrayBuffer>;
+export declare const makeAudioSegmentFetchTask: (host: EFMedia) => Task<readonly [MediaEngine | undefined, number | undefined], ArrayBuffer | undefined>;

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

@@ -9,19 +9,20 @@ 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 rendition = mediaEngine.audioRendition;
 				const debugInfo = {
-					hasRendition: !!rendition,
-					segmentDurationMs: rendition?.segmentDurationMs,
-					segmentDurationsMs: rendition?.segmentDurationsMs?.length || 0,
+					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)}`);
 			}
-			return mediaEngine.fetchMediaSegment(segmentId, mediaEngine.getAudioRendition(), signal);
+			return mediaEngine.fetchMediaSegment(segmentId, audioRendition, signal);
 		}
 	});
 };

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

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

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

@@ -18,6 +18,8 @@ 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.js

@@ -4,7 +4,7 @@
 */
 const fetchAudioSegmentData = async (segmentIds, mediaEngine, signal) => {
 	const audioRendition = mediaEngine.audioRendition;
-	if (!audioRendition) throw new Error("Audio rendition not available");
+	if (!audioRendition) throw new Error("No audio track available in source");
 	const segmentData = /* @__PURE__ */ new Map();
 	const fetchPromises = segmentIds.map(async (segmentId) => {
 		const arrayBuffer = await mediaEngine.fetchMediaSegment(segmentId, audioRendition, signal);
@@ -31,7 +31,7 @@ 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("Audio rendition not available");
+	if (!mediaEngine?.audioRendition) throw new Error("No audio track available in source");
 	if (!initSegment) throw new Error("Audio init segment is not available");
 	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`);

package/dist/elements/EFMedia/tasks/makeMediaEngineTask.js

@@ -11,7 +11,7 @@ const getLatestMediaEngine = async (host, signal) => {
 };
 const getVideoRendition = (mediaEngine) => {
 	const videoRendition = mediaEngine.videoRendition;
-	if (!videoRendition) throw new Error("Video rendition is not available");
+	if (!videoRendition) throw new Error("No video track available in source");
 	return videoRendition;
 };
 /**

package/dist/elements/EFMedia/videoTasks/makeScrubVideoInitSegmentFetchTask.js

@@ -1,3 +1,4 @@
+import { EF_RENDERING } from "../../../EF_RENDERING.js";
 import { getLatestMediaEngine } from "../tasks/makeMediaEngineTask.js";
 import { Task } from "@lit/task";
 const makeScrubVideoInitSegmentFetchTask = (host) => {
@@ -8,6 +9,7 @@ const makeScrubVideoInitSegmentFetchTask = (host) => {
 		},
 		onComplete: (_value) => {},
 		task: async ([_mediaEngine], { signal }) => {
+			if (EF_RENDERING()) return /* @__PURE__ */ new ArrayBuffer(0);
 			const mediaEngine = await getLatestMediaEngine(host, signal);
 			const scrubRendition = mediaEngine.getScrubVideoRendition();
 			if (!scrubRendition) throw new Error("No scrub rendition available");

package/dist/elements/EFMedia/videoTasks/makeScrubVideoInputTask.js

@@ -1,3 +1,4 @@
+import { EF_RENDERING } from "../../../EF_RENDERING.js";
 import { BufferedSeekingInput } from "../BufferedSeekingInput.js";
 import { EFMedia } from "../../EFMedia.js";
 import { Task } from "@lit/task";
@@ -9,6 +10,7 @@ const makeScrubVideoInputTask = (host) => {
 		},
 		onComplete: (_value) => {},
 		task: async () => {
+			if (EF_RENDERING()) console.info("Scrub not available in rendering mode");
 			const initSegment = await host.scrubVideoInitSegmentFetchTask.taskComplete;
 			const segment = await host.scrubVideoSegmentFetchTask.taskComplete;
 			if (!initSegment || !segment) throw new Error("Scrub init segment or segment is not available");

package/dist/elements/EFMedia/videoTasks/makeScrubVideoSegmentFetchTask.js

@@ -1,3 +1,4 @@
+import { EF_RENDERING } from "../../../EF_RENDERING.js";
 import { getLatestMediaEngine } from "../tasks/makeMediaEngineTask.js";
 import { Task } from "@lit/task";
 const makeScrubVideoSegmentFetchTask = (host) => {
@@ -8,6 +9,7 @@ const makeScrubVideoSegmentFetchTask = (host) => {
 		},
 		onComplete: (_value) => {},
 		task: async (_, { signal }) => {
+			if (EF_RENDERING()) return /* @__PURE__ */ new ArrayBuffer(0);
 			const mediaEngine = await getLatestMediaEngine(host, signal);
 			const segmentId = await host.scrubVideoSegmentIdTask.taskComplete;
 			if (segmentId === void 0) throw new Error("Scrub segment ID is not available for video");

package/dist/elements/EFMedia/videoTasks/makeScrubVideoSegmentIdTask.js

@@ -1,3 +1,4 @@
+import { EF_RENDERING } from "../../../EF_RENDERING.js";
 import { getLatestMediaEngine } from "../tasks/makeMediaEngineTask.js";
 import { Task } from "@lit/task";
 const makeScrubVideoSegmentIdTask = (host) => {
@@ -8,6 +9,7 @@ const makeScrubVideoSegmentIdTask = (host) => {
 		},
 		onComplete: (_value) => {},
 		task: async ([, targetSeekTimeMs], { signal }) => {
+			if (EF_RENDERING()) return void 0;
 			const mediaEngine = await getLatestMediaEngine(host, signal);
 			signal.throwIfAborted();
 			const scrubRendition = mediaEngine.getScrubVideoRendition();

package/dist/elements/EFMedia/videoTasks/makeUnifiedVideoSeekTask.js

@@ -1,3 +1,4 @@
+import { EF_RENDERING } from "../../../EF_RENDERING.js";
 import { getLatestMediaEngine } from "../tasks/makeMediaEngineTask.js";
 import { ScrubInputCache } from "./ScrubInputCache.js";
 import { Task } from "@lit/task";
@@ -13,6 +14,7 @@ const makeUnifiedVideoSeekTask = (host) => {
 		task: async ([desiredSeekTimeMs], { signal }) => {
 			const mediaEngine = await getLatestMediaEngine(host, signal);
 			if (!mediaEngine) return void 0;
+			if (EF_RENDERING()) return await getMainVideoSample(host, mediaEngine, desiredSeekTimeMs, signal);
 			const mainRendition = mediaEngine.videoRendition;
 			if (mainRendition) {
 				const mainSegmentId = mediaEngine.computeSegmentId(desiredSeekTimeMs, mainRendition);

package/dist/elements/EFMedia.d.ts

@@ -58,8 +58,8 @@ export declare class EFMedia extends EFMedia_base {
     get urlGenerator(): UrlGenerator;
     mediaEngineTask: import('@lit/task').Task<readonly [string, string | null], import('../transcoding/types/index.ts').MediaEngine>;
     audioSegmentIdTask: import('@lit/task').Task<readonly [import('../transcoding/types/index.ts').MediaEngine | undefined, number], number | undefined>;
-    audioInitSegmentFetchTask: import('@lit/task').Task<readonly [import('../transcoding/types/index.ts').MediaEngine | undefined], ArrayBuffer>;
-    audioSegmentFetchTask: import('@lit/task').Task<readonly [import('../transcoding/types/index.ts').MediaEngine | undefined, number | undefined], ArrayBuffer>;
+    audioInitSegmentFetchTask: import('@lit/task').Task<readonly [import('../transcoding/types/index.ts').MediaEngine | undefined], ArrayBuffer | undefined>;
+    audioSegmentFetchTask: import('@lit/task').Task<readonly [import('../transcoding/types/index.ts').MediaEngine | undefined, number | undefined], ArrayBuffer | undefined>;
     audioInputTask: import('./EFMedia/shared/MediaTaskUtils.ts').InputTask;
     audioSeekTask: import('@lit/task').Task<readonly [number, import('./EFMedia/BufferedSeekingInput.ts').BufferedSeekingInput | undefined], import('mediabunny').VideoSample | undefined>;
     audioBufferTask: import('@lit/task').Task<readonly [number], import('./EFMedia/audioTasks/makeAudioBufferTask.ts').AudioBufferState>;

package/dist/elements/EFTimegroup.js

@@ -366,7 +366,13 @@ let EFTimegroup = class EFTimegroup$1 extends EFTemporal(LitElement) {
 			const sourceInMs = mediaElement.sourceInMs || mediaElement.trimStartMs || 0;
 			const mediaSourceFromMs = mediaLocalFromMs + sourceInMs;
 			const mediaSourceToMs = mediaLocalToMs + sourceInMs;
-			const audio = await mediaElement.fetchAudioSpanningTime(mediaSourceFromMs, mediaSourceToMs, abortController.signal);
+			let audio;
+			try {
+				audio = await mediaElement.fetchAudioSpanningTime(mediaSourceFromMs, mediaSourceToMs, abortController.signal);
+			} catch (error) {
+				if (error instanceof Error && error.message.includes("No audio track available")) return;
+				throw error;
+			}
 			if (!audio) throw new Error("Failed to fetch audio");
 			const bufferSource = audioContext.createBufferSource();
 			bufferSource.buffer = await audioContext.decodeAudioData(await audio.blob.arrayBuffer());

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@editframe/elements",
-  "version": "0.20.0-beta.0",
+  "version": "0.20.2-beta.0",
   "description": "",
   "exports": {
     ".": {
@@ -27,7 +27,7 @@
   "license": "UNLICENSED",
   "dependencies": {
     "@bramus/style-observer": "^1.3.0",
-    "@editframe/assets": "0.20.0-beta.0",
+    "@editframe/assets": "0.20.2-beta.0",
     "@lit/context": "^1.1.2",
     "@lit/task": "^1.0.1",
     "d3": "^7.9.0",

package/src/elements/ContextProxiesController.ts

@@ -110,6 +110,7 @@ export class ContextProxyController implements ReactiveController {
     try {
       const newEvent = new ContextEvent(
         contextEvent.context,
+        // @ts-ignore (this fails a typecheck but works)
         contextEvent.callback,
         contextEvent.subscribe,
       );

package/src/elements/EFMedia/AssetIdMediaEngine.ts

@@ -87,7 +87,9 @@ export class AssetIdMediaEngine
     rendition: VideoRendition,
   ): number[] {
     if (!rendition.trackId) {
-      throw new Error("Track ID is required for asset metadata");
+      throw new Error(
+        "[convertToSegmentRelativeTimestamps] Track ID is required for asset metadata",
+      );
     }
     // For AssetMediaEngine, we need to calculate the actual segment start time
     // using the precise segment boundaries from the track fragment index

package/src/elements/EFMedia/AssetMediaEngine.ts

@@ -110,7 +110,9 @@ export class AssetMediaEngine extends BaseMediaEngine implements MediaEngine {
     signal: AbortSignal,
   ) {
     if (!rendition.trackId) {
-      throw new Error("Track ID is required for asset metadata");
+      throw new Error(
+        "[fetchInitSegment] Track ID is required for asset metadata",
+      );
     }
     const url = this.buildInitSegmentUrl(rendition.trackId);
     const initSegment = this.data[rendition.trackId]?.initSegment;
@@ -132,7 +134,9 @@ export class AssetMediaEngine extends BaseMediaEngine implements MediaEngine {
     signal?: AbortSignal,
   ) {
     if (!rendition.trackId) {
-      throw new Error("Track ID is required for asset metadata");
+      throw new Error(
+        "[fetchMediaSegment] Track ID is required for asset metadata",
+      );
     }
     if (segmentId === undefined) {
       throw new Error("Segment ID is not available");
@@ -217,7 +221,14 @@ export class AssetMediaEngine extends BaseMediaEngine implements MediaEngine {
 
   computeSegmentId(seekTimeMs: number, rendition: MediaRendition) {
     if (!rendition.trackId) {
-      throw new Error("Track ID is required for asset metadata");
+      console.warn(
+        `computeSegmentId: trackId not found for rendition ${JSON.stringify(
+          rendition,
+        )}`,
+      );
+      throw new Error(
+        "[computeSegmentId] Track ID is required for asset metadata",
+      );
     }
     const track = this.data[rendition.trackId];
     if (!track) {
@@ -311,7 +322,9 @@ export class AssetMediaEngine extends BaseMediaEngine implements MediaEngine {
       // This is because Asset segments are independent timeline fragments
 
       if (!rendition.trackId) {
-        throw new Error("Track ID is required for asset metadata");
+        throw new Error(
+          "[convertToSegmentRelativeTimestamps] Track ID is required for asset metadata",
+        );
       }
       // For AssetMediaEngine, we need to calculate the actual segment start time
       // using the precise segment boundaries from the track fragment index

package/src/elements/EFMedia/JitMediaEngine.ts

@@ -215,29 +215,15 @@ export class JitMediaEngine extends BaseMediaEngine implements MediaEngine {
   async extractThumbnails(
     timestamps: number[],
   ): Promise<(ThumbnailResult | null)[]> {
-    // Use same rendition priority as video: try main rendition first for frame alignment
-    let rendition: VideoRendition;
-    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,
-      );
+    const mainRendition = this.videoRendition;
+    const scrubRendition = this.getScrubVideoRendition();
+
+    const rendition = mainRendition || scrubRendition;
+
+    if (!rendition) {
       return timestamps.map(() => null);
     }
 
-    // Use shared thumbnail extraction logic
     return this.thumbnailExtractor.extractThumbnails(
       timestamps,
       rendition,

package/src/elements/EFMedia/audioTasks/makeAudioBufferTask.ts

@@ -42,13 +42,15 @@ export const makeAudioBufferTask = (host: EFMedia): AudioBufferTask => {
     task: async ([seekTimeMs], { signal }) => {
       // Skip buffering entirely in rendering mode
       if (EF_RENDERING()) {
-        return currentState; // Return existing state without any buffering activity
+        return currentState;
       }
 
-      // Get media engine to potentially override buffer configuration
       const mediaEngine = await getLatestMediaEngine(host, signal);
 
-      // Use media engine's buffer config, falling back to host properties
+      if (!mediaEngine.audioRendition) {
+        return currentState;
+      }
+
       const engineConfig = mediaEngine.getBufferConfig();
       const bufferDurationMs = engineConfig.audioBufferDurationMs;
       const maxParallelFetches = engineConfig.maxAudioBufferFetches;
@@ -85,11 +87,10 @@ export const makeAudioBufferTask = (host: EFMedia): AudioBufferTask => {
             return mediaEngine.isSegmentCached(segmentId, rendition);
           },
           getRendition: async () => {
-            // Get real audio rendition from media engine
             const mediaEngine = await getLatestMediaEngine(host, signal);
             const audioRendition = mediaEngine.audioRendition;
             if (!audioRendition) {
-              throw new Error("Audio rendition not available");
+              throw new Error("No audio track available in source");
             }
             return audioRendition;
           },

package/src/elements/EFMedia/audioTasks/makeAudioFrequencyAnalysisTask.ts

@@ -95,6 +95,11 @@ export function makeAudioFrequencyAnalysisTask(element: EFMedia) {
     task: async (_, { signal }) => {
       if (element.currentSourceTimeMs < 0) return null;
 
+      const mediaEngine = element.mediaEngineTask.value;
+      if (!mediaEngine?.audioRendition) {
+        return null;
+      }
+
       const currentTimeMs = element.currentSourceTimeMs;
 
       // Calculate exact audio window needed based on fftDecay and frame timing

package/src/elements/EFMedia/audioTasks/makeAudioInitSegmentFetchTask.ts

@@ -5,7 +5,7 @@ import { getLatestMediaEngine } from "../tasks/makeMediaEngineTask";
 
 export const makeAudioInitSegmentFetchTask = (
   host: EFMedia,
-): Task<readonly [MediaEngine | undefined], ArrayBuffer> => {
+): Task<readonly [MediaEngine | undefined], ArrayBuffer | undefined> => {
   return new Task(host, {
     args: () => [host.mediaEngineTask.value] as const,
     onError: (error) => {
@@ -14,10 +14,13 @@ export const makeAudioInitSegmentFetchTask = (
     onComplete: (_value) => {},
     task: async ([_mediaEngine], { signal }) => {
       const mediaEngine = await getLatestMediaEngine(host, signal);
-      return mediaEngine.fetchInitSegment(
-        mediaEngine.getAudioRendition(),
-        signal,
-      );
+
+      const audioRendition = mediaEngine.audioRendition;
+      if (!audioRendition) {
+        return undefined;
+      }
+
+      return mediaEngine.fetchInitSegment(audioRendition, signal);
     },
   });
 };

package/src/elements/EFMedia/audioTasks/makeAudioInputTask.ts

@@ -19,20 +19,20 @@ export const makeAudioInputTask = (host: EFMedia): InputTask => {
     onComplete: (_value) => {},
     task: async (_, { signal }) => {
       const initSegment = await host.audioInitSegmentFetchTask.taskComplete;
-      signal.throwIfAborted(); // Abort if a new seek started
+      signal.throwIfAborted();
       const segment = await host.audioSegmentFetchTask.taskComplete;
-      signal.throwIfAborted(); // Abort if a new seek started
+      signal.throwIfAborted();
+
       if (!initSegment || !segment) {
-        throw new Error("Init segment or segment is not available");
+        throw new Error("No audio track available in source");
       }
 
-      // Get startTimeOffsetMs from the audio rendition if available
       const mediaEngine = await host.mediaEngineTask.taskComplete;
       const audioRendition = mediaEngine?.audioRendition;
       const startTimeOffsetMs = audioRendition?.startTimeOffsetMs;
 
       const arrayBuffer = await new Blob([initSegment, segment]).arrayBuffer();
-      signal.throwIfAborted(); // Abort if a new seek started
+      signal.throwIfAborted();
       return new BufferedSeekingInput(arrayBuffer, {
         videoBufferSize: EFMedia.VIDEO_SAMPLE_BUFFER_SIZE,
         audioBufferSize: EFMedia.AUDIO_SAMPLE_BUFFER_SIZE,

package/src/elements/EFMedia/audioTasks/makeAudioSegmentFetchTask.ts

@@ -7,7 +7,7 @@ export const makeAudioSegmentFetchTask = (
   host: EFMedia,
 ): Task<
   readonly [MediaEngine | undefined, number | undefined],
-  ArrayBuffer
+  ArrayBuffer | undefined
 > => {
   return new Task(host, {
     args: () =>
@@ -18,14 +18,18 @@ export const makeAudioSegmentFetchTask = (
     onComplete: (_value) => {},
     task: async (_, { signal }) => {
       const mediaEngine = await getLatestMediaEngine(host, signal);
+
+      const audioRendition = mediaEngine.audioRendition;
+      if (!audioRendition) {
+        return undefined;
+      }
+
       const segmentId = await host.audioSegmentIdTask.taskComplete;
       if (segmentId === undefined) {
-        // Provide more context in the error to help with debugging
-        const rendition = mediaEngine.audioRendition;
         const debugInfo = {
-          hasRendition: !!rendition,
-          segmentDurationMs: rendition?.segmentDurationMs,
-          segmentDurationsMs: rendition?.segmentDurationsMs?.length || 0,
+          hasRendition: true,
+          segmentDurationMs: audioRendition.segmentDurationMs,
+          segmentDurationsMs: audioRendition.segmentDurationsMs?.length || 0,
           desiredSeekTimeMs: host.desiredSeekTimeMs,
           intrinsicDurationMs: host.intrinsicDurationMs,
         };
@@ -34,12 +38,7 @@ export const makeAudioSegmentFetchTask = (
         );
       }
 
-      // SIMPLIFIED: Direct call to mediaEngine - deduplication is built-in
-      return mediaEngine.fetchMediaSegment(
-        segmentId,
-        mediaEngine.getAudioRendition(),
-        signal,
-      );
+      return mediaEngine.fetchMediaSegment(segmentId, audioRendition, signal);
     },
   });
 };

package/src/elements/EFMedia/audioTasks/makeAudioSegmentIdTask.ts

@@ -15,10 +15,13 @@ export const makeAudioSegmentIdTask = (
     task: async ([, targetSeekTimeMs], { signal }) => {
       const mediaEngine = await getLatestMediaEngine(host, signal);
       signal.throwIfAborted(); // Abort if a new seek started
-      return mediaEngine.computeSegmentId(
-        targetSeekTimeMs, // Use captured value, not host.desiredSeekTimeMs
-        mediaEngine.getAudioRendition(),
-      );
+
+      const audioRendition = mediaEngine.audioRendition;
+      if (!audioRendition) {
+        return undefined;
+      }
+
+      return mediaEngine.computeSegmentId(targetSeekTimeMs, audioRendition);
     },
   });
 };

package/src/elements/EFMedia/audioTasks/makeAudioTimeDomainAnalysisTask.ts

@@ -27,6 +27,11 @@ export function makeAudioTimeDomainAnalysisTask(element: EFMedia) {
     task: async (_, { signal }) => {
       if (element.currentSourceTimeMs < 0) return null;
 
+      const mediaEngine = element.mediaEngineTask.value;
+      if (!mediaEngine?.audioRendition) {
+        return null;
+      }
+
       const currentTimeMs = element.currentSourceTimeMs;
 
       // Calculate exact audio window needed based on fftDecay and frame timing

package/src/elements/EFMedia/shared/AudioSpanUtils.ts

@@ -16,7 +16,7 @@ const fetchAudioSegmentData = async (
 ): Promise<Map<number, ArrayBuffer>> => {
   const audioRendition = mediaEngine.audioRendition;
   if (!audioRendition) {
-    throw new Error("Audio rendition not available");
+    throw new Error("No audio track available in source");
   }
 
   const segmentData = new Map<number, ArrayBuffer>();
@@ -73,7 +73,7 @@ export const fetchAudioSpanningTime = async (
   const initSegment = await host.audioInitSegmentFetchTask.taskComplete;
 
   if (!mediaEngine?.audioRendition) {
-    throw new Error("Audio rendition not available");
+    throw new Error("No audio track available in source");
   }
 
   if (!initSegment) {