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

package/dist/elements/EFAudio.d.ts

@@ -2,8 +2,7 @@ import { Task } from '@lit/task';
 import { EFMedia } from './EFMedia.js';
 declare const EFAudio_base: typeof EFMedia;
 export declare class EFAudio extends EFAudio_base {
-    static get observedAttributes(): string[];
-    attributeChangedCallback(name: string, old: string | null, value: string | null): void;
+    private _propertyHack;
     audioElementRef: import('lit-html/directives/ref.js').Ref<HTMLAudioElement>;
     render(): import('lit-html').TemplateResult<1>;
     frameTask: Task<readonly [import('@lit/task').TaskStatus, import('@lit/task').TaskStatus, import('@lit/task').TaskStatus, import('@lit/task').TaskStatus], void>;

package/dist/elements/EFAudio.js

@@ -2,12 +2,13 @@ import { EFMedia } from "./EFMedia.js";
 import { TWMixin } from "../gui/TWMixin2.js";
 import { Task } from "@lit/task";
 import { html } from "lit";
-import { customElement } from "lit/decorators.js";
+import { customElement, property } from "lit/decorators.js";
 import _decorate from "@oxc-project/runtime/helpers/decorate";
 import { createRef, ref } from "lit/directives/ref.js";
 let EFAudio = class EFAudio$1 extends TWMixin(EFMedia) {
 	constructor(..._args) {
 		super(..._args);
+		this._propertyHack = false;
 		this.audioElementRef = createRef();
 		this.frameTask = new Task(this, {
 			args: () => [
@@ -25,14 +26,6 @@ let EFAudio = class EFAudio$1 extends TWMixin(EFMedia) {
 			}
 		});
 	}
-	static get observedAttributes() {
-		const parentAttributes = super.observedAttributes || [];
-		return [...parentAttributes];
-	}
-	attributeChangedCallback(name, old, value) {
-		super.attributeChangedCallback(name, old, value);
-		if (name === "asset-id") this.assetId = value;
-	}
 	render() {
 		return html`<audio ${ref(this.audioElementRef)}></audio>`;
 	}
@@ -61,5 +54,9 @@ let EFAudio = class EFAudio$1 extends TWMixin(EFMedia) {
 		return this.audioBufferTask;
 	}
 };
+_decorate([property({
+	type: Boolean,
+	attribute: "dummy-property"
+})], EFAudio.prototype, "_propertyHack", void 0);
 EFAudio = _decorate([customElement("ef-audio")], EFAudio);
 export { EFAudio };

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);
@@ -81,9 +82,15 @@ var AssetMediaEngine = class AssetMediaEngine extends BaseMediaEngine {
 	* Calculate audio segments for variable-duration segments using track fragment index
 	*/
 	calculateAudioSegmentRange(fromMs, toMs, rendition, _durationMs) {
-		if (fromMs >= toMs || !rendition.trackId) return [];
+		if (fromMs >= toMs || !rendition.trackId) {
+			console.warn(`calculateAudioSegmentRange: invalid fromMs ${fromMs} toMs ${toMs} rendition ${JSON.stringify(rendition)}`);
+			return [];
+		}
 		const track = this.data[rendition.trackId];
-		if (!track) return [];
+		if (!track) {
+			console.warn(`calculateAudioSegmentRange: track not found for rendition ${JSON.stringify(rendition)}`);
+			return [];
+		}
 		const { timescale, segments } = track;
 		const segmentRanges = [];
 		for (let i = 0; i < segments.length; i++) {
@@ -98,6 +105,10 @@ var AssetMediaEngine = class AssetMediaEngine extends BaseMediaEngine {
 				endMs: segmentEndMs
 			});
 		}
+		if (segmentRanges.length === 0) console.warn(`calculateAudioSegmentRange: no segments found for fromMs ${fromMs} toMs ${toMs} rendition ${JSON.stringify({
+			rendition,
+			track
+		})}`);
 		return segmentRanges;
 	}
 	computeSegmentId(desiredSeekTimeMs, rendition) {
@@ -105,12 +116,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

@@ -4,19 +4,32 @@ const makeAudioSeekTask = (host) => {
 	return new Task(host, {
 		args: () => [host.desiredSeekTimeMs, host.audioInputTask.value],
 		onError: (error) => {
-			if (error instanceof IgnorableError) console.info("audioSeekTask aborted");
-			console.error("audioSeekTask error", error);
+			if (error instanceof IgnorableError) {
+				console.info("audioSeekTask aborted");
+				return;
+			}
+			if (error instanceof DOMException) console.error(`audioSeekTask error: ${error.message} ${error.name} ${error.code}`);
+			else if (error instanceof Error) console.error(`audioSeekTask error ${error.name}: ${error.message}`);
+			else console.error("audioSeekTask unknown 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 {};