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

package/dist/EF_FRAMEGEN.js

@@ -103,7 +103,7 @@ var EFFramegen = class {
 		});
 	}
 	get showFrameBox() {
-		return true;
+		return this.renderOptions?.showFrameBox ?? false;
 	}
 	async initialize(renderOptions) {
 		this.renderOptions = renderOptions;

package/dist/elements/EFAudio.d.ts

@@ -1,13 +1,32 @@
 import { Task } from '@lit/task';
 import { EFMedia } from './EFMedia.js';
-export declare class EFAudio extends EFMedia {
+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;
     audioElementRef: import('lit-html/directives/ref.js').Ref<HTMLAudioElement>;
     render(): import('lit-html').TemplateResult<1>;
-    get audioElement(): HTMLAudioElement | undefined;
     frameTask: Task<readonly [import('@lit/task').TaskStatus, import('@lit/task').TaskStatus, import('@lit/task').TaskStatus, import('@lit/task').TaskStatus], void>;
+    /**
+     * Legacy getter for fragment index task (maps to audioSegmentIdTask)
+     */
+    get fragmentIndexTask(): Task<readonly [import('../transcoding/types/index.js').MediaEngine | undefined, number], number | undefined>;
+    /**
+     * Legacy getter for media segments task (maps to audioSegmentFetchTask)
+     */
+    get mediaSegmentsTask(): Task<readonly [import('../transcoding/types/index.js').MediaEngine | undefined, number | undefined], ArrayBuffer>;
+    /**
+     * Legacy getter for seek task (maps to audioSeekTask)
+     */
+    get seekTask(): Task<readonly [number, import('./EFMedia/BufferedSeekingInput.js').BufferedSeekingInput | undefined], import('mediabunny').VideoSample | undefined>;
+    /**
+     * Legacy getter for audio asset task (maps to audioBufferTask)
+     */
+    get videoAssetTask(): Task<readonly [number], import('./EFMedia/audioTasks/makeAudioBufferTask.js').AudioBufferState>;
 }
 declare global {
     interface HTMLElementTagNameMap {
         "ef-audio": EFAudio;
     }
 }
+export {};

package/dist/elements/EFAudio.js

@@ -1,34 +1,64 @@
 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 _decorate from "@oxc-project/runtime/helpers/decorate";
 import { createRef, ref } from "lit/directives/ref.js";
-let EFAudio = class EFAudio$1 extends EFMedia {
+let EFAudio = class EFAudio$1 extends TWMixin(EFMedia) {
 	constructor(..._args) {
 		super(..._args);
 		this.audioElementRef = createRef();
 		this.frameTask = new Task(this, {
 			args: () => [
-				this.fragmentIndexTask.status,
-				this.seekTask.status,
-				this.mediaSegmentsTask.status,
-				this.videoAssetTask.status
+				this.audioBufferTask.status,
+				this.audioSeekTask.status,
+				this.audioSegmentFetchTask.status,
+				this.mediaEngineTask.status
 			],
 			task: async () => {
-				await this.fragmentIndexTask.taskComplete;
-				await this.seekTask.taskComplete;
-				await this.mediaSegmentsTask.taskComplete;
-				await this.videoAssetTask.taskComplete;
+				await this.mediaEngineTask.taskComplete;
+				await this.audioSegmentFetchTask.taskComplete;
+				await this.audioSeekTask.taskComplete;
+				await this.audioBufferTask.taskComplete;
 				this.rootTimegroup?.requestUpdate();
 			}
 		});
 	}
+	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>`;
 	}
-	get audioElement() {
-		return this.audioElementRef.value;
+	/**
+	* Legacy getter for fragment index task (maps to audioSegmentIdTask)
+	*/
+	get fragmentIndexTask() {
+		return this.audioSegmentIdTask;
+	}
+	/**
+	* Legacy getter for media segments task (maps to audioSegmentFetchTask)
+	*/
+	get mediaSegmentsTask() {
+		return this.audioSegmentFetchTask;
+	}
+	/**
+	* Legacy getter for seek task (maps to audioSeekTask)
+	*/
+	get seekTask() {
+		return this.audioSeekTask;
+	}
+	/**
+	* Legacy getter for audio asset task (maps to audioBufferTask)
+	*/
+	get videoAssetTask() {
+		return this.audioBufferTask;
 	}
 };
 EFAudio = _decorate([customElement("ef-audio")], EFAudio);

package/dist/elements/EFImage.d.ts

@@ -9,6 +9,7 @@ export declare class EFImage extends EFImage_base {
     set assetId(value: string | null);
     get assetId(): string | null;
     render(): import('lit-html').TemplateResult<1>;
+    private isDirectUrl;
     assetPath(): string;
     get hasOwnDuration(): boolean;
     fetchImage: Task<readonly [string, typeof fetch], void>;

package/dist/elements/EFImage.js

@@ -16,11 +16,13 @@ let EFImage = class EFImage$1 extends EFTemporal(EFSourceMixin(FetchMixin(LitEle
 			autoRun: EF_INTERACTIVE,
 			args: () => [this.assetPath(), this.fetch],
 			task: async ([assetPath, fetch], { signal }) => {
+				if (this.isDirectUrl(assetPath)) return;
 				const response = await fetch(assetPath, { signal });
 				const image = new Image();
 				image.src = URL.createObjectURL(await response.blob());
-				await new Promise((resolve) => {
+				await new Promise((resolve, reject) => {
 					image.onload = resolve;
+					image.onerror = reject;
 				});
 				if (!this.canvasRef.value) throw new Error("Canvas not ready");
 				const ctx = this.canvasRef.value.getContext("2d");
@@ -46,7 +48,7 @@ let EFImage = class EFImage$1 extends EFTemporal(EFSourceMixin(FetchMixin(LitEle
         align-items: center;
         justify-content: center;
       }
-      canvas {
+      canvas, img {
         all: inherit;
       }
     `];
@@ -59,10 +61,16 @@ let EFImage = class EFImage$1 extends EFTemporal(EFSourceMixin(FetchMixin(LitEle
 		return this.#assetId ?? this.getAttribute("asset-id");
 	}
 	render() {
-		return html`<canvas ${ref(this.canvasRef)}></canvas>`;
+		const assetPath = this.assetPath();
+		const isDirectUrl = this.isDirectUrl(assetPath);
+		return isDirectUrl ? html`<img ${ref(this.imageRef)} src=${assetPath} />` : html`<canvas ${ref(this.canvasRef)}></canvas>`;
+	}
+	isDirectUrl(src) {
+		return src.startsWith("http://") || src.startsWith("https://");
 	}
 	assetPath() {
 		if (this.assetId) return `${this.apiHost}/api/v1/image_files/${this.assetId}`;
+		if (this.isDirectUrl(this.src)) return this.src;
 		return `/@ef-image/${this.src}`;
 	}
 	get hasOwnDuration() {

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

@@ -0,0 +1,18 @@
+import { TrackFragmentIndex } from '../../../../assets/src/index.ts';
+import { InitSegmentPaths, MediaEngine } from '../../transcoding/types';
+import { UrlGenerator } from '../../transcoding/utils/UrlGenerator';
+import { EFMedia } from '../EFMedia';
+import { AssetMediaEngine } from './AssetMediaEngine';
+export declare class AssetIdMediaEngine extends AssetMediaEngine implements MediaEngine {
+    assetId: string;
+    private apiHost;
+    static fetchByAssetId(host: EFMedia, _urlGenerator: UrlGenerator, assetId: string, apiHost: string): Promise<AssetIdMediaEngine>;
+    constructor(host: EFMedia, assetId: string, data: Record<number, TrackFragmentIndex>, apiHost: string);
+    get initSegmentPaths(): InitSegmentPaths;
+    get templates(): {
+        initSegment: string;
+        mediaSegment: string;
+    };
+    buildInitSegmentUrl(trackId: number): string;
+    buildMediaSegmentUrl(trackId: number, _segmentId: number): string;
+}

package/dist/elements/EFMedia/AssetIdMediaEngine.js

@@ -0,0 +1,41 @@
+import { AssetMediaEngine } from "./AssetMediaEngine.js";
+var AssetIdMediaEngine = class AssetIdMediaEngine extends AssetMediaEngine {
+	static async fetchByAssetId(host, _urlGenerator, assetId, apiHost) {
+		const url = `${apiHost}/api/v1/isobmff_files/${assetId}/index`;
+		const response = await host.fetch(url);
+		const data = await response.json();
+		return new AssetIdMediaEngine(host, assetId, data, apiHost);
+	}
+	constructor(host, assetId, data, apiHost) {
+		super(host, assetId, data);
+		this.assetId = assetId;
+		this.apiHost = apiHost;
+	}
+	get initSegmentPaths() {
+		const paths = {};
+		if (this.audioTrackIndex !== void 0) paths.audio = {
+			path: `${this.apiHost}/api/v1/isobmff_tracks/${this.assetId}/${this.audioTrackIndex.track}`,
+			pos: this.audioTrackIndex.initSegment.offset,
+			size: this.audioTrackIndex.initSegment.size
+		};
+		if (this.videoTrackIndex !== void 0) paths.video = {
+			path: `${this.apiHost}/api/v1/isobmff_tracks/${this.assetId}/${this.videoTrackIndex.track}`,
+			pos: this.videoTrackIndex.initSegment.offset,
+			size: this.videoTrackIndex.initSegment.size
+		};
+		return paths;
+	}
+	get templates() {
+		return {
+			initSegment: `${this.apiHost}/api/v1/isobmff_tracks/${this.assetId}/{trackId}`,
+			mediaSegment: `${this.apiHost}/api/v1/isobmff_tracks/${this.assetId}/{trackId}`
+		};
+	}
+	buildInitSegmentUrl(trackId) {
+		return `${this.apiHost}/api/v1/isobmff_tracks/${this.assetId}/${trackId}`;
+	}
+	buildMediaSegmentUrl(trackId, _segmentId) {
+		return `${this.apiHost}/api/v1/isobmff_tracks/${this.assetId}/${trackId}`;
+	}
+};
+export { AssetIdMediaEngine };

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

@@ -0,0 +1,45 @@
+import { TrackFragmentIndex } from '../../../../assets/src/index.ts';
+import { AudioRendition, InitSegmentPaths, MediaEngine, SegmentTimeRange } from '../../transcoding/types';
+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;
+    protected data: Record<number, TrackFragmentIndex>;
+    static fetch(host: EFMedia, urlGenerator: UrlGenerator, src: string): Promise<AssetMediaEngine>;
+    durationMs: number;
+    constructor(host: EFMedia, src: string, data: Record<number, TrackFragmentIndex>);
+    get audioTrackIndex(): import('../../../../assets/src/index.ts').AudioTrackFragmentIndex | undefined;
+    get videoTrackIndex(): import('../../../../assets/src/index.ts').VideoTrackFragmentIndex | undefined;
+    get videoRendition(): {
+        trackId: number | undefined;
+        src: string;
+        startTimeOffsetMs: number | undefined;
+    };
+    get audioRendition(): {
+        trackId: number | undefined;
+        src: string;
+    };
+    get initSegmentPaths(): InitSegmentPaths;
+    get templates(): {
+        initSegment: string;
+        mediaSegment: string;
+    };
+    buildInitSegmentUrl(trackId: number): string;
+    buildMediaSegmentUrl(trackId: number, segmentId: number): string;
+    fetchInitSegment(rendition: {
+        trackId: number | undefined;
+        src: string;
+    }, signal: AbortSignal): Promise<ArrayBuffer>;
+    fetchMediaSegmentImpl(segmentId: number, rendition: {
+        trackId: number | undefined;
+        src: string;
+    }, signal?: AbortSignal): Promise<ArrayBuffer>;
+    /**
+     * 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: MediaRendition): number;
+}

package/dist/elements/EFMedia/AssetMediaEngine.js

@@ -0,0 +1,135 @@
+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);
+		const response = await host.fetch(url);
+		const data = await response.json();
+		if (src.startsWith("/")) src = src.slice(1);
+		return new AssetMediaEngine(host, src, data);
+	}
+	constructor(host, src, data) {
+		super();
+		this.host = host;
+		this.src = src;
+		this.data = data;
+		const longestFragment = Object.values(data).reduce((max, fragment) => Math.max(max, fragment.duration / fragment.timescale), 0);
+		this.durationMs = longestFragment * 1e3;
+	}
+	get audioTrackIndex() {
+		return Object.values(this.data).find((track) => track.type === "audio");
+	}
+	get videoTrackIndex() {
+		return Object.values(this.data).find((track) => track.type === "video");
+	}
+	get videoRendition() {
+		return {
+			trackId: this.videoTrackIndex?.track,
+			src: this.src,
+			startTimeOffsetMs: this.videoTrackIndex?.startTimeOffsetMs
+		};
+	}
+	get audioRendition() {
+		return {
+			trackId: this.audioTrackIndex?.track,
+			src: this.src
+		};
+	}
+	get initSegmentPaths() {
+		const paths = {};
+		if (this.audioTrackIndex !== void 0) paths.audio = {
+			path: `@ef-track/${this.audioTrackIndex.track}.m4s`,
+			pos: this.audioTrackIndex.initSegment.offset,
+			size: this.audioTrackIndex.initSegment.size
+		};
+		if (this.videoTrackIndex !== void 0) paths.video = {
+			path: `/@ef-track/${this.videoTrackIndex.track}.m4s`,
+			pos: this.videoTrackIndex.initSegment.offset,
+			size: this.videoTrackIndex.initSegment.size
+		};
+		return paths;
+	}
+	get templates() {
+		return {
+			initSegment: "/@ef-track/{src}?trackId={trackId}",
+			mediaSegment: "/@ef-track/{src}?trackId={trackId}"
+		};
+	}
+	buildInitSegmentUrl(trackId) {
+		return `/@ef-track/${this.src}?trackId=${trackId}`;
+	}
+	buildMediaSegmentUrl(trackId, segmentId) {
+		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");
+		const url = this.buildInitSegmentUrl(rendition.trackId);
+		const initSegment = this.data[rendition.trackId]?.initSegment;
+		if (!initSegment) throw new Error("Init segment not found");
+		const headers = { Range: `bytes=${initSegment.offset}-${initSegment.offset + initSegment.size - 1}` };
+		return this.fetchMediaCacheWithHeaders(url, headers, signal);
+	}
+	async fetchMediaSegmentImpl(segmentId, rendition, signal) {
+		if (!rendition.trackId) throw new Error("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];
+		if (!mediaSegment) throw new Error("Media segment not found");
+		const headers = { Range: `bytes=${mediaSegment.offset}-${mediaSegment.offset + mediaSegment.size - 1}` };
+		return this.fetchMediaCacheWithHeaders(url, headers, signal);
+	}
+	/**
+	* Calculate audio segments for variable-duration segments using track fragment index
+	*/
+	calculateAudioSegmentRange(fromMs, toMs, rendition, _durationMs) {
+		if (fromMs >= toMs || !rendition.trackId) return [];
+		const track = this.data[rendition.trackId];
+		if (!track) return [];
+		const { timescale, segments } = track;
+		const segmentRanges = [];
+		for (let i = 0; i < segments.length; i++) {
+			const segment = segments[i];
+			const segmentStartTime = segment.cts;
+			const segmentEndTime = segment.cts + segment.duration;
+			const segmentStartMs = segmentStartTime / timescale * 1e3;
+			const segmentEndMs = segmentEndTime / timescale * 1e3;
+			if (segmentStartMs < toMs && segmentEndMs > fromMs) segmentRanges.push({
+				segmentId: i,
+				startMs: segmentStartMs,
+				endMs: segmentEndMs
+			});
+		}
+		return segmentRanges;
+	}
+	computeSegmentId(desiredSeekTimeMs, rendition) {
+		if (!rendition.trackId) throw new Error("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;
+		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];
+			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 nearestSegmentIndex;
+	}
+};
+export { AssetMediaEngine };

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

@@ -0,0 +1,55 @@
+import { AudioRendition, SegmentTimeRange, VideoRendition } from '../../transcoding/types';
+import { EFMedia } from '../EFMedia.js';
+export declare abstract class BaseMediaEngine {
+    private requestDeduplicator;
+    abstract get videoRendition(): VideoRendition | undefined;
+    abstract get audioRendition(): AudioRendition | undefined;
+    abstract get host(): EFMedia;
+    getVideoRendition(): VideoRendition;
+    getAudioRendition(): AudioRendition;
+    /**
+     * Generate cache key for segment requests
+     */
+    private getSegmentCacheKey;
+    /**
+     * Abstract method for actual segment fetching - implemented by subclasses
+     */
+    abstract fetchMediaSegmentImpl(segmentId: number, rendition: {
+        trackId: number | undefined;
+        src: string;
+    }): Promise<ArrayBuffer>;
+    /**
+     * Fetch media segment with built-in deduplication
+     * Eliminates the need for separate coordinators - cleaner architecture
+     */
+    fetchMediaSegment(segmentId: number, rendition: {
+        trackId: number | undefined;
+        src: string;
+    }, _signal?: AbortSignal): Promise<ArrayBuffer>;
+    /**
+     * Check if a segment is currently being fetched
+     */
+    isSegmentBeingFetched(segmentId: number, rendition: {
+        src: string;
+        trackId: number | undefined;
+    }): boolean;
+    /**
+     * Get count of active segment requests (for debugging/monitoring)
+     */
+    getActiveSegmentRequestCount(): number;
+    /**
+     * Cancel all active segment requests (for cleanup)
+     */
+    cancelAllSegmentRequests(): void;
+    fetchMediaCache(mediaUrl: string): Promise<ArrayBuffer>;
+    /**
+     * Enhanced caching method that supports custom headers (e.g., Range requests)
+     * Cache key includes both URL and headers for proper cache isolation
+     */
+    fetchMediaCacheWithHeaders(mediaUrl: string, headers?: Record<string, string>, signal?: AbortSignal): Promise<ArrayBuffer>;
+    /**
+     * Calculate audio segments needed for a time range
+     * Each media engine implements this based on their segment structure
+     */
+    calculateAudioSegmentRange(fromMs: number, toMs: number, rendition: AudioRendition, durationMs: number): SegmentTimeRange[];
+}

package/dist/elements/EFMedia/BaseMediaEngine.js

@@ -0,0 +1,115 @@
+import { RequestDeduplicator } from "../../transcoding/cache/RequestDeduplicator.js";
+import { SizeAwareLRUCache } from "../../utils/LRUCache.js";
+const mediaCache = new SizeAwareLRUCache(100 * 1024 * 1024);
+var BaseMediaEngine = class {
+	constructor() {
+		this.requestDeduplicator = new RequestDeduplicator();
+	}
+	getVideoRendition() {
+		if (!this.videoRendition) throw new Error("No video rendition available");
+		return this.videoRendition;
+	}
+	getAudioRendition() {
+		if (!this.audioRendition) throw new Error("No audio rendition available");
+		return this.audioRendition;
+	}
+	/**
+	* Generate cache key for segment requests
+	*/
+	getSegmentCacheKey(segmentId, rendition) {
+		return `${rendition.src}-${rendition.id}-${segmentId}-${rendition.trackId}`;
+	}
+	/**
+	* Fetch media segment with built-in deduplication
+	* Eliminates the need for separate coordinators - cleaner architecture
+	*/
+	async fetchMediaSegment(segmentId, rendition, _signal) {
+		const cacheKey = this.getSegmentCacheKey(segmentId, rendition);
+		return this.requestDeduplicator.executeRequest(cacheKey, async () => {
+			return this.fetchMediaSegmentImpl(segmentId, rendition);
+		});
+	}
+	/**
+	* Check if a segment is currently being fetched
+	*/
+	isSegmentBeingFetched(segmentId, rendition) {
+		const cacheKey = this.getSegmentCacheKey(segmentId, rendition);
+		return this.requestDeduplicator.isPending(cacheKey);
+	}
+	/**
+	* Get count of active segment requests (for debugging/monitoring)
+	*/
+	getActiveSegmentRequestCount() {
+		return this.requestDeduplicator.getPendingCount();
+	}
+	/**
+	* Cancel all active segment requests (for cleanup)
+	*/
+	cancelAllSegmentRequests() {
+		this.requestDeduplicator.clear();
+	}
+	async fetchMediaCache(mediaUrl) {
+		const cached = mediaCache.get(mediaUrl);
+		if (cached) return cached;
+		const promise = this.host.fetch(mediaUrl).then((response) => response.arrayBuffer());
+		mediaCache.set(mediaUrl, promise);
+		return promise;
+	}
+	/**
+	* Enhanced caching method that supports custom headers (e.g., Range requests)
+	* Cache key includes both URL and headers for proper cache isolation
+	*/
+	async fetchMediaCacheWithHeaders(mediaUrl, headers, signal) {
+		const cacheKey = headers ? `${mediaUrl}:${JSON.stringify(headers)}` : mediaUrl;
+		const cached = mediaCache.get(cacheKey);
+		if (cached) return cached;
+		const promise = this.host.fetch(mediaUrl, {
+			headers,
+			signal
+		}).then((response) => response.arrayBuffer());
+		mediaCache.set(cacheKey, promise);
+		return promise;
+	}
+	/**
+	* Calculate audio segments needed for a time range
+	* Each media engine implements this based on their segment structure
+	*/
+	calculateAudioSegmentRange(fromMs, toMs, rendition, durationMs) {
+		if (fromMs >= toMs) return [];
+		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,
+				endMs: segmentEndMs
+			});
+		}
+		return segments;
+	}
+};
+export { BaseMediaEngine };

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

@@ -0,0 +1,43 @@
+import { MediaSample } from '../SampleBuffer';
+interface BufferedSeekingInputOptions {
+    videoBufferSize?: number;
+    audioBufferSize?: number;
+    /**
+     * 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;
+}
+export declare class NoSample extends RangeError {
+}
+export declare class BufferedSeekingInput {
+    private input;
+    private trackIterators;
+    private trackBuffers;
+    private options;
+    private trackIteratorCreationPromises;
+    private trackSeekPromises;
+    /**
+     * 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);
+    getBufferSize(trackId: number): number;
+    getBufferContents(trackId: number): readonly MediaSample[];
+    getBufferTimestamps(trackId: number): number[];
+    clearBuffer(trackId: number): void;
+    computeDuration(): Promise<number>;
+    getTrack(trackId: number): Promise<import('mediabunny').InputTrack>;
+    getAudioTrack(trackId: number): Promise<import('mediabunny').InputAudioTrack>;
+    getVideoTrack(trackId: number): Promise<import('mediabunny').InputVideoTrack>;
+    getFirstVideoTrack(): Promise<import('mediabunny').InputVideoTrack | undefined>;
+    getFirstAudioTrack(): Promise<import('mediabunny').InputAudioTrack | undefined>;
+    getTrackIterator(trackId: number): Promise<AsyncIterator<MediaSample, any, undefined>>;
+    private createIteratorSafe;
+    createTrackBuffer(trackId: number): Promise<void>;
+    seek(trackId: number, timeMs: number): Promise<MediaSample | undefined>;
+    private resetIterator;
+    private seekSafe;
+}
+export {};