@editframe/elements 0.18.3-beta.0 → 0.18.7-beta.0

package/dist/elements/EFMedia/AssetMediaEngine.d.ts

@@ -3,6 +3,7 @@ import { AudioRendition, InitSegmentPaths, MediaEngine, SegmentTimeRange } from
 import { UrlGenerator } from '../../transcoding/utils/UrlGenerator';
 import { EFMedia } from '../EFMedia';
 import { BaseMediaEngine } from './BaseMediaEngine';
+import { MediaRendition } from './shared/MediaTaskUtils';
 export declare class AssetMediaEngine extends BaseMediaEngine implements MediaEngine {
     host: EFMedia;
     src: string;
@@ -40,8 +41,5 @@ export declare class AssetMediaEngine extends BaseMediaEngine implements MediaEn
      * Calculate audio segments for variable-duration segments using track fragment index
      */
     calculateAudioSegmentRange(fromMs: number, toMs: number, rendition: AudioRendition, _durationMs: number): SegmentTimeRange[];
-    computeSegmentId(desiredSeekTimeMs: number, rendition: {
-        trackId: number | undefined;
-        src: string;
-    }): number;
+    computeSegmentId(desiredSeekTimeMs: number, rendition: MediaRendition): number;
 }

package/dist/elements/EFMedia/AssetMediaEngine.js

@@ -1,4 +1,5 @@
 import { BaseMediaEngine } from "./BaseMediaEngine.js";
+import { convertToScaledTime, roundToMilliseconds } from "./shared/PrecisionUtils.js";
 var AssetMediaEngine = class AssetMediaEngine extends BaseMediaEngine {
 	static async fetch(host, urlGenerator, src) {
 		const url = urlGenerator.generateTrackFragmentIndexUrl(src);
@@ -105,12 +106,30 @@ var AssetMediaEngine = class AssetMediaEngine extends BaseMediaEngine {
 		const track = this.data[rendition.trackId];
 		if (!track) throw new Error("Track not found");
 		const { timescale, segments } = track;
-		const desiredSeekTime = desiredSeekTimeMs / 1e3 * timescale;
+		const startTimeOffsetMs = "startTimeOffsetMs" in rendition && rendition.startTimeOffsetMs || 0;
+		const mediaTimeMs = roundToMilliseconds(desiredSeekTimeMs + startTimeOffsetMs);
+		const scaledSeekTime = convertToScaledTime(mediaTimeMs, timescale);
 		for (let i = segments.length - 1; i >= 0; i--) {
 			const segment = segments[i];
-			if (segment.cts <= desiredSeekTime) return i;
+			const segmentEndTime = segment.cts + segment.duration;
+			if (segment.cts <= scaledSeekTime && scaledSeekTime < segmentEndTime) return i;
+		}
+		let nearestSegmentIndex = 0;
+		let nearestDistance = Number.MAX_SAFE_INTEGER;
+		for (let i = 0; i < segments.length; i++) {
+			const segment = segments[i];
+			const segmentStartTime = segment.cts;
+			const segmentEndTime = segment.cts + segment.duration;
+			let distance;
+			if (scaledSeekTime < segmentStartTime) distance = segmentStartTime - scaledSeekTime;
+			else if (scaledSeekTime >= segmentEndTime) distance = scaledSeekTime - segmentEndTime;
+			else return i;
+			if (distance < nearestDistance) {
+				nearestDistance = distance;
+				nearestSegmentIndex = i;
+			}
 		}
-		return 0;
+		return nearestSegmentIndex;
 	}
 };
 export { AssetMediaEngine };

package/dist/elements/EFMedia/BaseMediaEngine.js

@@ -76,14 +76,33 @@ var BaseMediaEngine = class {
 	*/
 	calculateAudioSegmentRange(fromMs, toMs, rendition, durationMs) {
 		if (fromMs >= toMs) return [];
-		const segmentDurationMs = rendition.segmentDurationMs || 1e3;
 		const segments = [];
+		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) continue;
+				const segmentStartMs = cumulativeTime;
+				const segmentEndMs = Math.min(cumulativeTime + segmentDuration, durationMs);
+				if (segmentStartMs >= durationMs) break;
+				if (segmentStartMs < toMs && segmentEndMs > fromMs) segments.push({
+					segmentId: i + 1,
+					startMs: segmentStartMs,
+					endMs: segmentEndMs
+				});
+				cumulativeTime += segmentDuration;
+				if (cumulativeTime >= durationMs) break;
+			}
+			return segments;
+		}
+		const segmentDurationMs = rendition.segmentDurationMs || 1e3;
 		const startSegmentIndex = Math.floor(fromMs / segmentDurationMs);
 		const endSegmentIndex = Math.floor(toMs / segmentDurationMs);
 		for (let i = startSegmentIndex; i <= endSegmentIndex; i++) {
 			const segmentId = i + 1;
 			const segmentStartMs = i * segmentDurationMs;
 			const segmentEndMs = Math.min((i + 1) * segmentDurationMs, durationMs);
+			if (segmentStartMs >= durationMs) break;
 			if (segmentStartMs < toMs && segmentEndMs > fromMs) segments.push({
 				segmentId,
 				startMs: segmentStartMs,

package/dist/elements/EFMedia/BufferedSeekingInput.d.ts

@@ -3,8 +3,8 @@ interface BufferedSeekingInputOptions {
     videoBufferSize?: number;
     audioBufferSize?: number;
     /**
-     * FFmpeg start_time offset in milliseconds from the processed video.
-     * Applied during seeking to correct for timing shifts introduced by FFmpeg processing.
+     * Timeline offset in milliseconds to map user timeline to media timeline.
+     * Applied during seeking to handle media that doesn't start at 0ms.
      */
     startTimeOffsetMs?: number;
 }
@@ -18,8 +18,8 @@ export declare class BufferedSeekingInput {
     private trackIteratorCreationPromises;
     private trackSeekPromises;
     /**
-     * FFmpeg start_time offset in milliseconds from the processed video.
-     * Applied during seeking to correct for timing shifts introduced by FFmpeg processing.
+     * Timeline offset in milliseconds to map user timeline to media timeline.
+     * Applied during seeking to handle media that doesn't start at 0ms.
      */
     private readonly startTimeOffsetMs;
     constructor(arrayBuffer: ArrayBuffer, options?: BufferedSeekingInputOptions);
@@ -36,7 +36,7 @@ export declare class BufferedSeekingInput {
     getTrackIterator(trackId: number): Promise<AsyncIterator<MediaSample, any, undefined>>;
     private createIteratorSafe;
     createTrackBuffer(trackId: number): Promise<void>;
-    seek(trackId: number, timeMs: number): Promise<MediaSample>;
+    seek(trackId: number, timeMs: number): Promise<MediaSample | undefined>;
     private resetIterator;
     private seekSafe;
 }

package/dist/elements/EFMedia/BufferedSeekingInput.js

@@ -1,3 +1,4 @@
+import { roundToMilliseconds } from "./shared/PrecisionUtils.js";
 import { SampleBuffer } from "../SampleBuffer.js";
 import { AudioSampleSink, BufferSource, Input, MP4, VideoSampleSink } from "mediabunny";
 const defaultOptions = {
@@ -113,10 +114,11 @@ var BufferedSeekingInput = class {
 		}
 	}
 	async seek(trackId, timeMs) {
-		const correctedTimeMs = timeMs + this.startTimeOffsetMs;
+		const mediaTimeMs = timeMs + this.startTimeOffsetMs;
+		const roundedMediaTimeMs = roundToMilliseconds(mediaTimeMs);
 		const existingSeek = this.trackSeekPromises.get(trackId);
 		if (existingSeek) await existingSeek;
-		const seekPromise = this.seekSafe(trackId, correctedTimeMs);
+		const seekPromise = this.seekSafe(trackId, roundedMediaTimeMs);
 		this.trackSeekPromises.set(trackId, seekPromise);
 		try {
 			return await seekPromise;
@@ -138,12 +140,24 @@ var BufferedSeekingInput = class {
 	async seekSafe(trackId, timeMs) {
 		if (!this.trackBuffers.has(trackId)) await this.createTrackBuffer(trackId);
 		const trackBuffer = this.trackBuffers.get(trackId);
-		if (timeMs < trackBuffer.firstTimestamp * 1e3) await this.resetIterator(trackId);
-		const alreadyInBuffer = trackBuffer.find(timeMs);
 		const track = await this.getTrack(trackId);
-		const firstTimestampMs = await track.getFirstTimestamp() * 1e3;
-		const lastSampleEndMs = await track.computeDuration() * 1e3;
-		if (timeMs < firstTimestampMs || timeMs >= lastSampleEndMs) throw new NoSample(`Seek time ${timeMs}ms is outside track range [${firstTimestampMs}ms, ${lastSampleEndMs}ms]`);
+		const firstTimestampMs = roundToMilliseconds(await track.getFirstTimestamp() * 1e3);
+		let roundedTimeMs = roundToMilliseconds(timeMs);
+		if (roundedTimeMs < firstTimestampMs) {
+			const bufferContents$1 = trackBuffer.getContents();
+			if (bufferContents$1.length > 0) {
+				timeMs = firstTimestampMs;
+				roundedTimeMs = roundToMilliseconds(timeMs);
+			}
+		}
+		const bufferContents = trackBuffer.getContents();
+		if (bufferContents.length > 0) {
+			const bufferStartMs = roundToMilliseconds(trackBuffer.firstTimestamp * 1e3);
+			const lastSample = bufferContents[bufferContents.length - 1];
+			const bufferEndMs = lastSample ? roundToMilliseconds((lastSample.timestamp + (lastSample.duration || 0)) * 1e3) : bufferStartMs;
+			if (roundedTimeMs < bufferStartMs || roundedTimeMs > bufferEndMs) await this.resetIterator(trackId);
+		}
+		const alreadyInBuffer = trackBuffer.find(timeMs);
 		if (alreadyInBuffer) return alreadyInBuffer;
 		const iterator = await this.getTrackIterator(trackId);
 		while (true) {
@@ -153,6 +167,12 @@ var BufferedSeekingInput = class {
 			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);
+			if (roundToMilliseconds(timeMs) >= lastSampleEndMs) return lastSample;
+		}
 		throw new NoSample(`Sample not found for time ${timeMs} in ${track.type} track ${trackId}`);
 	}
 };

package/dist/elements/EFMedia/JitMediaEngine.d.ts

@@ -27,5 +27,5 @@ export declare class JitMediaEngine extends BaseMediaEngine implements MediaEngi
         trackId: number | undefined;
         src: string;
     }): Promise<ArrayBuffer>;
-    computeSegmentId(desiredSeekTimeMs: number, rendition: VideoRendition | AudioRendition): number;
+    computeSegmentId(desiredSeekTimeMs: number, rendition: VideoRendition | AudioRendition): number | undefined;
 }

package/dist/elements/EFMedia/JitMediaEngine.js

@@ -24,7 +24,8 @@ var JitMediaEngine = class JitMediaEngine extends BaseMediaEngine {
 			id: rendition.id,
 			trackId: void 0,
 			src: this.data.sourceUrl,
-			segmentDurationMs: rendition.segmentDurationMs
+			segmentDurationMs: rendition.segmentDurationMs,
+			segmentDurationsMs: rendition.segmentDurationsMs
 		};
 	}
 	get videoRendition() {
@@ -34,7 +35,8 @@ var JitMediaEngine = class JitMediaEngine extends BaseMediaEngine {
 			id: rendition.id,
 			trackId: void 0,
 			src: this.data.sourceUrl,
-			segmentDurationMs: rendition.segmentDurationMs
+			segmentDurationMs: rendition.segmentDurationMs,
+			segmentDurationsMs: rendition.segmentDurationsMs
 		};
 	}
 	get templates() {
@@ -53,9 +55,26 @@ var JitMediaEngine = class JitMediaEngine extends BaseMediaEngine {
 		return this.fetchMediaCache(url);
 	}
 	computeSegmentId(desiredSeekTimeMs, rendition) {
+		if (desiredSeekTimeMs > this.durationMs) return void 0;
+		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 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;
+				cumulativeTime += segmentDuration;
+				if (cumulativeTime >= this.durationMs) break;
+			}
+			return void 0;
+		}
 		if (!rendition.segmentDurationMs) throw new Error("Segment duration is required for JIT metadata");
 		const segmentIndex = Math.floor(desiredSeekTimeMs / rendition.segmentDurationMs);
-		if (segmentIndex * rendition.segmentDurationMs >= this.durationMs) return segmentIndex;
+		const segmentStartMs = segmentIndex * rendition.segmentDurationMs;
+		if (segmentStartMs >= this.durationMs) return void 0;
 		return segmentIndex + 1;
 	}
 };

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

@@ -57,7 +57,10 @@ function makeAudioFrequencyAnalysisTask(element) {
 			const currentTimeMs = element.currentSourceTimeMs;
 			const analysisWindowMs = 5e3;
 			const fromMs = Math.max(0, currentTimeMs);
-			const toMs = fromMs + analysisWindowMs;
+			const maxToMs = fromMs + analysisWindowMs;
+			const videoDurationMs = element.intrinsicDurationMs || 0;
+			const toMs = videoDurationMs > 0 ? Math.min(maxToMs, videoDurationMs) : maxToMs;
+			if (fromMs >= toMs) return null;
 			const { fetchAudioSpanningTime: fetchAudioSpan } = await import("../shared/AudioSpanUtils.js");
 			const audioSpan = await fetchAudioSpan(element, fromMs, toMs, new AbortController().signal);
 			if (!audioSpan || !audioSpan.blob) {

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

@@ -8,13 +8,21 @@ const makeAudioInputTask = (host) => {
 			console.error("audioInputTask error", error);
 		},
 		onComplete: (_value) => {},
-		task: async () => {
+		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("Init segment or segment is not available");
-			return new BufferedSeekingInput(await new Blob([initSegment, segment]).arrayBuffer(), {
+			const mediaEngine = await host.mediaEngineTask.taskComplete;
+			const audioRendition = mediaEngine?.audioRendition;
+			const startTimeOffsetMs = audioRendition?.startTimeOffsetMs;
+			const arrayBuffer = await new Blob([initSegment, segment]).arrayBuffer();
+			signal.throwIfAborted();
+			return new BufferedSeekingInput(arrayBuffer, {
 				videoBufferSize: EFMedia.VIDEO_SAMPLE_BUFFER_SIZE,
-				audioBufferSize: EFMedia.AUDIO_SAMPLE_BUFFER_SIZE
+				audioBufferSize: EFMedia.AUDIO_SAMPLE_BUFFER_SIZE,
+				startTimeOffsetMs
 			});
 		}
 	});

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

@@ -8,15 +8,23 @@ const makeAudioSeekTask = (host) => {
 			console.error("audioSeekTask error", error);
 		},
 		onComplete: (_value) => {},
-		task: async (_) => {
+		task: async ([targetSeekTimeMs], { signal }) => {
 			await host.audioSegmentIdTask.taskComplete;
+			signal.throwIfAborted();
 			await host.audioSegmentFetchTask.taskComplete;
+			signal.throwIfAborted();
 			await host.audioInitSegmentFetchTask.taskComplete;
+			signal.throwIfAborted();
 			const audioInput = await host.audioInputTask.taskComplete;
+			signal.throwIfAborted();
 			if (!audioInput) throw new Error("Audio input is not available");
 			const audioTrack = await audioInput.getFirstAudioTrack();
 			if (!audioTrack) throw new Error("Audio track is not available");
-			const sample = await audioInput.seek(audioTrack.id, host.desiredSeekTimeMs);
+			signal.throwIfAborted();
+			const sample = await audioInput.seek(audioTrack.id, targetSeekTimeMs);
+			signal.throwIfAborted();
+			if (sample === void 0 && signal.aborted) return void 0;
+			if (sample === void 0) throw new Error("Audio seek failed to find sample");
 			return sample;
 		}
 	});

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

@@ -10,7 +10,17 @@ const makeAudioSegmentFetchTask = (host) => {
 		task: async (_, { signal }) => {
 			const mediaEngine = await getLatestMediaEngine(host, signal);
 			const segmentId = await host.audioSegmentIdTask.taskComplete;
-			if (segmentId === void 0) throw new Error("Segment ID is not available");
+			if (segmentId === void 0) {
+				const rendition = mediaEngine.audioRendition;
+				const debugInfo = {
+					hasRendition: !!rendition,
+					segmentDurationMs: rendition?.segmentDurationMs,
+					segmentDurationsMs: rendition?.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);
 		}
 	});

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

@@ -7,9 +7,10 @@ const makeAudioSegmentIdTask = (host) => {
 			console.error("audioSegmentIdTask error", error);
 		},
 		onComplete: (_value) => {},
-		task: async (_, { signal }) => {
+		task: async ([, targetSeekTimeMs], { signal }) => {
 			const mediaEngine = await getLatestMediaEngine(host, signal);
-			return mediaEngine.computeSegmentId(host.desiredSeekTimeMs, mediaEngine.getAudioRendition());
+			signal.throwIfAborted();
+			return mediaEngine.computeSegmentId(targetSeekTimeMs, mediaEngine.getAudioRendition());
 		}
 	});
 };

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

@@ -24,7 +24,10 @@ function makeAudioTimeDomainAnalysisTask(element) {
 			const currentTimeMs = element.currentSourceTimeMs;
 			const analysisWindowMs = 5e3;
 			const fromMs = Math.max(0, currentTimeMs);
-			const toMs = fromMs + analysisWindowMs;
+			const maxToMs = fromMs + analysisWindowMs;
+			const videoDurationMs = element.intrinsicDurationMs || 0;
+			const toMs = videoDurationMs > 0 ? Math.min(maxToMs, videoDurationMs) : maxToMs;
+			if (fromMs >= toMs) return null;
 			const { fetchAudioSpanningTime: fetchAudioSpan } = await import("../shared/AudioSpanUtils.js");
 			const audioSpan = await fetchAudioSpan(element, fromMs, toMs, new AbortController().signal);
 			if (!audioSpan || !audioSpan.blob) {

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

@@ -0,0 +1,28 @@
+/**
+ * Centralized precision utilities for consistent timing calculations across the media pipeline.
+ *
+ * The key insight is that floating-point precision errors can cause inconsistencies between:
+ * 1. Segment selection logic (in AssetMediaEngine.computeSegmentId)
+ * 2. Sample finding logic (in SampleBuffer.find)
+ * 3. Timeline mapping (in BufferedSeekingInput.seek)
+ *
+ * All timing calculations must use the same rounding strategy to ensure consistency.
+ */
+/**
+ * Round time to millisecond precision to handle floating-point precision issues.
+ * Uses Math.round for consistent behavior across the entire pipeline.
+ *
+ * This function should be used for ALL time-related calculations that need to be
+ * compared between different parts of the system.
+ */
+export declare const roundToMilliseconds: (timeMs: number) => number;
+/**
+ * Convert media time (in seconds) to scaled time units using consistent rounding.
+ * This is used in segment selection to convert from milliseconds to timescale units.
+ */
+export declare const convertToScaledTime: (timeMs: number, timescale: number) => number;
+/**
+ * Convert scaled time units back to media time (in milliseconds) using consistent rounding.
+ * This is the inverse of convertToScaledTime.
+ */
+export declare const convertFromScaledTime: (scaledTime: number, timescale: number) => number;

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

@@ -0,0 +1,29 @@
+/**
+* Centralized precision utilities for consistent timing calculations across the media pipeline.
+*
+* The key insight is that floating-point precision errors can cause inconsistencies between:
+* 1. Segment selection logic (in AssetMediaEngine.computeSegmentId)
+* 2. Sample finding logic (in SampleBuffer.find)
+* 3. Timeline mapping (in BufferedSeekingInput.seek)
+*
+* All timing calculations must use the same rounding strategy to ensure consistency.
+*/
+/**
+* Round time to millisecond precision to handle floating-point precision issues.
+* Uses Math.round for consistent behavior across the entire pipeline.
+*
+* This function should be used for ALL time-related calculations that need to be
+* compared between different parts of the system.
+*/
+const roundToMilliseconds = (timeMs) => {
+	return Math.round(timeMs * 1e3) / 1e3;
+};
+/**
+* Convert media time (in seconds) to scaled time units using consistent rounding.
+* This is used in segment selection to convert from milliseconds to timescale units.
+*/
+const convertToScaledTime = (timeMs, timescale) => {
+	const scaledTime = timeMs / 1e3 * timescale;
+	return Math.round(scaledTime);
+};
+export { convertToScaledTime, roundToMilliseconds };

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

@@ -8,16 +8,25 @@ const makeVideoSeekTask = (host) => {
 			console.error("videoSeekTask error", error);
 		},
 		onComplete: (_value) => {},
-		task: async (_) => {
+		task: async ([targetSeekTimeMs], { signal }) => {
 			await host.mediaEngineTask.taskComplete;
+			signal.throwIfAborted();
 			await host.videoSegmentIdTask.taskComplete;
+			signal.throwIfAborted();
 			await host.videoSegmentFetchTask.taskComplete;
+			signal.throwIfAborted();
 			await host.videoInitSegmentFetchTask.taskComplete;
+			signal.throwIfAborted();
 			const videoInput = await host.videoInputTask.taskComplete;
+			signal.throwIfAborted();
 			if (!videoInput) throw new Error("Video input is not available");
 			const videoTrack = await videoInput.getFirstVideoTrack();
 			if (!videoTrack) throw new Error("Video track is not available");
-			const sample = await videoInput.seek(videoTrack.id, host.desiredSeekTimeMs);
+			signal.throwIfAborted();
+			const sample = await videoInput.seek(videoTrack.id, targetSeekTimeMs);
+			signal.throwIfAborted();
+			if (sample === void 0 && signal.aborted) return void 0;
+			if (sample === void 0) throw new Error("Video seek failed to find sample");
 			return sample;
 		}
 	});

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

@@ -10,7 +10,17 @@ const makeVideoSegmentFetchTask = (host) => {
 		task: async (_, { signal }) => {
 			const mediaEngine = await getLatestMediaEngine(host, signal);
 			const segmentId = await host.videoSegmentIdTask.taskComplete;
-			if (segmentId === void 0) throw new Error("Segment ID is not available");
+			if (segmentId === void 0) {
+				const rendition = mediaEngine.videoRendition;
+				const debugInfo = {
+					hasRendition: !!rendition,
+					segmentDurationMs: rendition?.segmentDurationMs,
+					segmentDurationsMs: rendition?.segmentDurationsMs?.length || 0,
+					desiredSeekTimeMs: host.desiredSeekTimeMs,
+					intrinsicDurationMs: host.intrinsicDurationMs
+				};
+				throw new Error(`Segment ID is not available for video. Debug info: ${JSON.stringify(debugInfo)}`);
+			}
 			return mediaEngine.fetchMediaSegment(segmentId, mediaEngine.getVideoRendition(), signal);
 		}
 	});

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

@@ -7,9 +7,10 @@ const makeVideoSegmentIdTask = (host) => {
 			console.error("videoSegmentIdTask error", error);
 		},
 		onComplete: (_value) => {},
-		task: async (_, { signal }) => {
+		task: async ([, targetSeekTimeMs], { signal }) => {
 			const mediaEngine = await getLatestMediaEngine(host, signal);
-			return mediaEngine.computeSegmentId(host.desiredSeekTimeMs, mediaEngine.getVideoRendition());
+			signal.throwIfAborted();
+			return mediaEngine.computeSegmentId(targetSeekTimeMs, mediaEngine.getVideoRendition());
 		}
 	});
 };

package/dist/elements/EFMedia.d.ts

@@ -12,8 +12,6 @@ export declare class EFMedia extends EFMedia_base {
     static readonly VIDEO_SAMPLE_BUFFER_SIZE = 30;
     static readonly AUDIO_SAMPLE_BUFFER_SIZE = 120;
     static get observedAttributes(): string[];
-    private mediaSourceService;
-    private audioElementFactory;
     static styles: import('lit').CSSResult[];
     currentTimeMs: number;
     /**
@@ -86,10 +84,6 @@ export declare class EFMedia extends EFMedia_base {
      * Now powered by clean, testable utility functions
      */
     fetchAudioSpanningTime(fromMs: number, toMs: number, signal?: AbortSignal): Promise<AudioSpan>;
-    /**
-     * Get the HTML audio element for ContextMixin integration
-     */
-    get audioElement(): HTMLAudioElement | null;
     /**
      * Check if an audio segment is cached in the unified buffer system
      * Now uses the same caching approach as video for consistency
@@ -100,11 +94,5 @@ export declare class EFMedia extends EFMedia_base {
      * Now uses the same caching approach as video for consistency
      */
     getCachedAudioSegments(segmentIds: number[]): Set<number>;
-    /**
-     * Get MediaElementAudioSourceNode for ContextMixin integration
-     * Uses AudioElementFactory for proper caching and lifecycle management
-     */
-    getMediaElementSource(audioContext: AudioContext): Promise<MediaElementAudioSourceNode>;
-    disconnectedCallback(): void;
 }
 export {};

package/dist/elements/EFMedia.js

@@ -8,8 +8,7 @@ import { makeAudioSeekTask } from "./EFMedia/audioTasks/makeAudioSeekTask.js";
 import { makeAudioSegmentFetchTask } from "./EFMedia/audioTasks/makeAudioSegmentFetchTask.js";
 import { makeAudioSegmentIdTask } from "./EFMedia/audioTasks/makeAudioSegmentIdTask.js";
 import { makeAudioTimeDomainAnalysisTask } from "./EFMedia/audioTasks/makeAudioTimeDomainAnalysisTask.js";
-import { AudioElementFactory } from "./EFMedia/services/AudioElementFactory.js";
-import { MediaSourceService } from "./EFMedia/services/MediaSourceService.js";
+import { fetchAudioSpanningTime } from "./EFMedia/shared/AudioSpanUtils.js";
 import { EFSourceMixin } from "./EFSourceMixin.js";
 import { EFTemporal } from "./EFTemporal.js";
 import { FetchMixin } from "./FetchMixin.js";
@@ -28,13 +27,6 @@ const deepGetMediaElements = (element, medias = []) => {
 var EFMedia = class extends EFTargetable(EFSourceMixin(EFTemporal(FetchMixin(LitElement)), { assetType: "isobmff_files" })) {
 	constructor(..._args) {
 		super(..._args);
-		this.mediaSourceService = new MediaSourceService({
-			onError: (error) => {
-				console.error("🎵 [EFMedia] MediaSourceService error:", error);
-			},
-			onReady: () => {}
-		});
-		this.audioElementFactory = new AudioElementFactory();
 		this.currentTimeMs = 0;
 		this.audioBufferDurationMs = 3e4;
 		this.maxAudioBufferFetches = 2;
@@ -112,6 +104,8 @@ var EFMedia = class extends EFTargetable(EFSourceMixin(EFTemporal(FetchMixin(Lit
 	}
 	updated(changedProperties) {
 		super.updated(changedProperties);
+		const newCurrentSourceTimeMs = this.currentSourceTimeMs;
+		if (newCurrentSourceTimeMs !== this.desiredSeekTimeMs) this.executeSeek(newCurrentSourceTimeMs);
 		if (changedProperties.has("ownCurrentTimeMs")) this.executeSeek(this.currentSourceTimeMs);
 		if (changedProperties.has("currentTime") || changedProperties.has("ownCurrentTimeMs")) updateAnimations(this);
 	}
@@ -132,15 +126,7 @@ var EFMedia = class extends EFTargetable(EFSourceMixin(EFTemporal(FetchMixin(Lit
 	* Now powered by clean, testable utility functions
 	*/
 	async fetchAudioSpanningTime(fromMs, toMs, signal = new AbortController().signal) {
-		await this.mediaSourceService.initialize();
-		const { fetchAudioSpanningTime: fetchAudioSpan } = await import("./EFMedia/shared/AudioSpanUtils.js");
-		return fetchAudioSpan(this, fromMs, toMs, signal);
-	}
-	/**
-	* Get the HTML audio element for ContextMixin integration
-	*/
-	get audioElement() {
-		return this.mediaSourceService.getAudioElement();
+		return fetchAudioSpanningTime(this, fromMs, toMs, signal);
 	}
 	/**
 	* Check if an audio segment is cached in the unified buffer system
@@ -158,18 +144,6 @@ var EFMedia = class extends EFTargetable(EFSourceMixin(EFTemporal(FetchMixin(Lit
 		if (!bufferState) return /* @__PURE__ */ new Set();
 		return new Set(segmentIds.filter((id) => bufferState.cachedSegments.has(id)));
 	}
-	/**
-	* Get MediaElementAudioSourceNode for ContextMixin integration
-	* Uses AudioElementFactory for proper caching and lifecycle management
-	*/
-	async getMediaElementSource(audioContext) {
-		return this.audioElementFactory.createMediaElementSource(audioContext, this.mediaSourceService);
-	}
-	disconnectedCallback() {
-		super.disconnectedCallback?.();
-		this.mediaSourceService.cleanup();
-		this.audioElementFactory.clearCache();
-	}
 };
 _decorate([property({ type: Number })], EFMedia.prototype, "currentTimeMs", void 0);
 _decorate([property({

package/dist/elements/EFTimegroup.js

@@ -301,23 +301,18 @@ let EFTimegroup = class EFTimegroup$1 extends EFTemporal(LitElement) {
 	* Usage: timegroup.testPlayAudio(0, 5000) // Play first 5 seconds
 	*/
 	async testPlayAudio(fromMs, toMs) {
-		try {
-			const renderedBuffer = await this.renderAudio(fromMs, toMs);
-			const playbackContext = new AudioContext();
-			const bufferSource = playbackContext.createBufferSource();
-			bufferSource.buffer = renderedBuffer;
-			bufferSource.connect(playbackContext.destination);
-			bufferSource.start(0);
-			return new Promise((resolve) => {
-				bufferSource.onended = () => {
-					playbackContext.close();
-					resolve();
-				};
-			});
-		} catch (error) {
-			console.error("🎵 [TEST_PLAY_AUDIO] Error:", error);
-			throw error;
-		}
+		const renderedBuffer = await this.renderAudio(fromMs, toMs);
+		const playbackContext = new AudioContext();
+		const bufferSource = playbackContext.createBufferSource();
+		bufferSource.buffer = renderedBuffer;
+		bufferSource.connect(playbackContext.destination);
+		bufferSource.start(0);
+		return new Promise((resolve) => {
+			bufferSource.onended = () => {
+				playbackContext.close();
+				resolve();
+			};
+		});
 	}
 	async loadMd5Sums() {
 		const efElements = this.efElements;

package/dist/elements/EFVideo.d.ts

@@ -1,6 +1,5 @@
 import { Task } from '@lit/task';
 import { PropertyValueMap } from 'lit';
-import { CacheStats, ScrubTrackManager } from '../ScrubTrackManager.js';
 import { EFMedia } from './EFMedia.js';
 declare global {
     var EF_FRAMEGEN: import("../EF_FRAMEGEN.js").EFFramegen;
@@ -36,10 +35,6 @@ export declare class EFVideo extends EFVideo_base {
     videoInputTask: import('./EFMedia/shared/MediaTaskUtils.ts').InputTask;
     videoSeekTask: Task<readonly [number, import('./EFMedia/BufferedSeekingInput.ts').BufferedSeekingInput | undefined], import('mediabunny').VideoSample | undefined>;
     videoBufferTask: Task<readonly [number], import('./EFMedia/videoTasks/makeVideoBufferTask.ts').VideoBufferState>;
-    /**
-     * Scrub track manager for fast timeline navigation
-     */
-    scrubTrackManager?: ScrubTrackManager;
     /**
      * Delayed loading state manager for user feedback
      */
@@ -84,10 +79,6 @@ export declare class EFVideo extends EFVideo_base {
      * Check if EF_FRAMEGEN has explicitly started frame rendering (not just initialization)
      */
     private isFrameRenderingActive;
-    /**
-     * Get scrub track performance statistics
-     */
-    getScrubTrackStats(): CacheStats | null;
     /**
      * Effective mode - always returns "asset" for EFVideo
      */