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

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

@@ -0,0 +1,104 @@
+import { EF_INTERACTIVE } from "../../../EF_INTERACTIVE.js";
+import { LRUCache } from "../../../utils/LRUCache.js";
+import { Task } from "@lit/task";
+const DECAY_WEIGHT = .8;
+function makeAudioTimeDomainAnalysisTask(element) {
+	const cache = new LRUCache(1e3);
+	return new Task(element, {
+		autoRun: EF_INTERACTIVE,
+		onError: (error) => {
+			console.error("byteTimeDomainTask error", error);
+		},
+		args: () => [
+			element.audioBufferTask.status,
+			element.currentSourceTimeMs,
+			element.fftSize,
+			element.fftDecay,
+			element.fftGain,
+			element.shouldInterpolateFrequencies
+		],
+		task: async () => {
+			await element.audioBufferTask.taskComplete;
+			if (!element.audioBufferTask.value) return null;
+			if (element.currentSourceTimeMs < 0) return null;
+			const currentTimeMs = element.currentSourceTimeMs;
+			const analysisWindowMs = 5e3;
+			const fromMs = Math.max(0, currentTimeMs);
+			const toMs = fromMs + analysisWindowMs;
+			const { fetchAudioSpanningTime: fetchAudioSpan } = await import("../shared/AudioSpanUtils.js");
+			const audioSpan = await fetchAudioSpan(element, fromMs, toMs, new AbortController().signal);
+			if (!audioSpan || !audioSpan.blob) {
+				console.warn("Time domain analysis skipped: no audio data available");
+				return null;
+			}
+			const tempAudioContext = new OfflineAudioContext(2, 48e3, 48e3);
+			const arrayBuffer = await audioSpan.blob.arrayBuffer();
+			const audioBuffer = await tempAudioContext.decodeAudioData(arrayBuffer);
+			const startOffsetMs = audioSpan.startMs;
+			const smoothedKey = `${element.shouldInterpolateFrequencies}:${element.fftSize}:${element.fftDecay}:${element.fftGain}:${startOffsetMs}:${currentTimeMs}`;
+			const cachedData = cache.get(smoothedKey);
+			if (cachedData) return cachedData;
+			const framesData = await Promise.all(Array.from({ length: element.fftDecay }, async (_, frameIndex) => {
+				const frameOffset = frameIndex * (1e3 / 30);
+				const startTime = Math.max(0, (currentTimeMs - frameOffset - startOffsetMs) / 1e3);
+				const cacheKey = `${element.shouldInterpolateFrequencies}:${element.fftSize}:${element.fftGain}:${startOffsetMs}:${startTime}`;
+				const cachedFrame = cache.get(cacheKey);
+				if (cachedFrame) return cachedFrame;
+				let audioContext;
+				try {
+					audioContext = new OfflineAudioContext(2, 48e3 * (1 / 30), 48e3);
+				} catch (error) {
+					throw new Error(`[EFMedia.byteTimeDomainTask] Failed to create OfflineAudioContext(2, ${48e3 * (1 / 30)}, 48000) for frame ${frameIndex} at time ${startTime}s: ${error instanceof Error ? error.message : String(error)}. This is for audio time domain analysis.`);
+				}
+				const source = audioContext.createBufferSource();
+				source.buffer = audioBuffer;
+				const analyser = audioContext.createAnalyser();
+				analyser.fftSize = element.fftSize;
+				analyser.minDecibels = -90;
+				analyser.maxDecibels = -20;
+				const gainNode = audioContext.createGain();
+				gainNode.gain.value = element.fftGain;
+				source.connect(gainNode);
+				gainNode.connect(analyser);
+				analyser.connect(audioContext.destination);
+				source.start(0, startTime, 1 / 30);
+				const dataLength = analyser.fftSize / 2;
+				try {
+					await audioContext.startRendering();
+					const frameData = new Uint8Array(dataLength);
+					analyser.getByteTimeDomainData(frameData);
+					const points = new Uint8Array(dataLength);
+					for (let i = 0; i < dataLength; i++) {
+						const pointSamples = frameData.slice(i * (frameData.length / dataLength), (i + 1) * (frameData.length / dataLength));
+						const rms = Math.sqrt(pointSamples.reduce((sum, sample) => {
+							const normalized = (sample - 128) / 128;
+							return sum + normalized * normalized;
+						}, 0) / pointSamples.length);
+						const avgSign = Math.sign(pointSamples.reduce((sum, sample) => sum + (sample - 128), 0));
+						points[i] = Math.min(255, Math.round(128 + avgSign * rms * 128));
+					}
+					cache.set(cacheKey, points);
+					return points;
+				} finally {
+					source.disconnect();
+					analyser.disconnect();
+				}
+			}));
+			const frameLength = framesData[0]?.length ?? 0;
+			const smoothedData = new Uint8Array(frameLength);
+			for (let i = 0; i < frameLength; i++) {
+				let weightedSum = 0;
+				let weightSum = 0;
+				framesData.forEach((frame, frameIndex) => {
+					const decayWeight = DECAY_WEIGHT ** frameIndex;
+					weightedSum += (frame[i] ?? 0) * decayWeight;
+					weightSum += decayWeight;
+				});
+				smoothedData[i] = Math.min(255, Math.round(weightedSum / weightSum));
+			}
+			cache.set(smoothedKey, smoothedData);
+			return smoothedData;
+		}
+	});
+}
+export { makeAudioTimeDomainAnalysisTask };

package/dist/elements/EFMedia/services/AudioElementFactory.browsertest.d.ts

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

package/dist/elements/EFMedia/services/AudioElementFactory.d.ts

@@ -0,0 +1,22 @@
+import { MediaSourceService } from './MediaSourceService.js';
+/**
+ * Factory for creating and caching MediaElementAudioSourceNode instances
+ * Handles the complex lifecycle and caching logic previously embedded in EFMedia
+ */
+export declare class AudioElementFactory {
+    private cache;
+    private currentSource;
+    private currentAudioContext;
+    /**
+     * Create or retrieve cached MediaElementAudioSourceNode for the given AudioContext
+     */
+    createMediaElementSource(audioContext: AudioContext, mediaSourceService: MediaSourceService): Promise<MediaElementAudioSourceNode>;
+    /**
+     * Clear all cached sources (useful for testing or cleanup)
+     */
+    clearCache(): void;
+    /**
+     * Check if we have a cached source for the given AudioContext
+     */
+    hasCachedSource(audioContext: AudioContext): boolean;
+}

package/dist/elements/EFMedia/services/AudioElementFactory.js

@@ -0,0 +1,72 @@
+/**
+* Factory for creating and caching MediaElementAudioSourceNode instances
+* Handles the complex lifecycle and caching logic previously embedded in EFMedia
+*/
+var AudioElementFactory = class {
+	constructor() {
+		this.cache = /* @__PURE__ */ new WeakMap();
+		this.currentSource = null;
+		this.currentAudioContext = null;
+	}
+	/**
+	* Create or retrieve cached MediaElementAudioSourceNode for the given AudioContext
+	*/
+	async createMediaElementSource(audioContext, mediaSourceService) {
+		const cached = this.cache.get(audioContext);
+		if (cached && audioContext.state !== "closed" && this.currentAudioContext === audioContext) return cached;
+		if (this.currentSource && this.currentAudioContext !== audioContext) {
+			this.currentSource.disconnect();
+			if (this.currentAudioContext) this.cache.delete(this.currentAudioContext);
+			this.currentSource = null;
+			this.currentAudioContext = null;
+		}
+		await mediaSourceService.ensureInitialized();
+		const audioElement = mediaSourceService.getAudioElement();
+		if (!audioElement) throw new Error("Audio element not available from MediaSourceService");
+		let mediaElementSource;
+		try {
+			mediaElementSource = audioContext.createMediaElementSource(audioElement);
+		} catch (error) {
+			if (error instanceof Error && error.message.includes("already connected")) {
+				this.clearCache();
+				try {
+					mediaElementSource = audioContext.createMediaElementSource(audioElement);
+				} catch (retryError) {
+					console.warn("AudioElementFactory: Failed to create MediaElementSource even after clearing cache:", retryError);
+					throw retryError;
+				}
+			} else throw error;
+		}
+		this.currentSource = mediaElementSource;
+		this.currentAudioContext = audioContext;
+		this.cache.set(audioContext, mediaElementSource);
+		const cleanup = () => {
+			if (audioContext.state === "closed") {
+				this.cache.delete(audioContext);
+				if (this.currentAudioContext === audioContext) {
+					this.currentSource = null;
+					this.currentAudioContext = null;
+				}
+				audioContext.removeEventListener("statechange", cleanup);
+			}
+		};
+		audioContext.addEventListener("statechange", cleanup);
+		return mediaElementSource;
+	}
+	/**
+	* Clear all cached sources (useful for testing or cleanup)
+	*/
+	clearCache() {
+		if (this.currentSource) this.currentSource.disconnect();
+		this.cache = /* @__PURE__ */ new WeakMap();
+		this.currentSource = null;
+		this.currentAudioContext = null;
+	}
+	/**
+	* Check if we have a cached source for the given AudioContext
+	*/
+	hasCachedSource(audioContext) {
+		return this.cache.has(audioContext) && audioContext.state !== "closed";
+	}
+};
+export { AudioElementFactory };

package/dist/elements/EFMedia/services/MediaSourceService.browsertest.d.ts

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

package/dist/elements/EFMedia/services/MediaSourceService.d.ts

@@ -0,0 +1,47 @@
+export interface MediaSourceServiceOptions {
+    onError?: (error: Error) => void;
+    onReady?: () => void;
+    onUpdateEnd?: () => void;
+    timeout?: number;
+}
+/**
+ * Service for managing MediaSource lifecycle and audio element creation
+ * Extracted from EFMedia to improve separation of concerns and testability
+ */
+export declare class MediaSourceService {
+    private mediaSourceManager;
+    private options;
+    constructor(options?: MediaSourceServiceOptions);
+    /**
+     * Initialize MediaSource if not already initialized
+     */
+    ensureInitialized(): Promise<void>;
+    /**
+     * Initialize fresh MediaSource
+     */
+    initialize(): Promise<void>;
+    /**
+     * Get audio element for MediaElementSource creation
+     */
+    getAudioElement(): HTMLAudioElement | null;
+    /**
+     * Feed audio segments to MediaSource
+     */
+    feedSegment(segmentBuffer: ArrayBuffer): Promise<void>;
+    /**
+     * Check if MediaSource is ready
+     */
+    isReady(): boolean;
+    /**
+     * Get buffered time ranges
+     */
+    getBuffered(): TimeRanges | null;
+    /**
+     * Set audio element current time
+     */
+    setCurrentTime(timeMs: number): void;
+    /**
+     * Clean up MediaSource resources
+     */
+    cleanup(): void;
+}

package/dist/elements/EFMedia/services/MediaSourceService.js

@@ -0,0 +1,73 @@
+import { MediaSourceManager } from "../../../services/MediaSourceManager.js";
+/**
+* Service for managing MediaSource lifecycle and audio element creation
+* Extracted from EFMedia to improve separation of concerns and testability
+*/
+var MediaSourceService = class {
+	constructor(options = {}) {
+		this.mediaSourceManager = null;
+		this.options = options;
+	}
+	/**
+	* Initialize MediaSource if not already initialized
+	*/
+	async ensureInitialized() {
+		if (this.mediaSourceManager?.isReady()) return;
+		await this.initialize();
+	}
+	/**
+	* Initialize fresh MediaSource
+	*/
+	async initialize() {
+		this.cleanup();
+		const managerOptions = {
+			onError: this.options.onError,
+			onReady: this.options.onReady,
+			onUpdateEnd: this.options.onUpdateEnd,
+			timeout: this.options.timeout
+		};
+		this.mediaSourceManager = new MediaSourceManager(managerOptions);
+		await this.mediaSourceManager.initialize();
+	}
+	/**
+	* Get audio element for MediaElementSource creation
+	*/
+	getAudioElement() {
+		return this.mediaSourceManager?.getAudioElement() || null;
+	}
+	/**
+	* Feed audio segments to MediaSource
+	*/
+	async feedSegment(segmentBuffer) {
+		await this.ensureInitialized();
+		if (this.mediaSourceManager) await this.mediaSourceManager.feedSegment(segmentBuffer);
+	}
+	/**
+	* Check if MediaSource is ready
+	*/
+	isReady() {
+		return this.mediaSourceManager?.isReady() ?? false;
+	}
+	/**
+	* Get buffered time ranges
+	*/
+	getBuffered() {
+		return this.mediaSourceManager?.getBuffered() || null;
+	}
+	/**
+	* Set audio element current time
+	*/
+	setCurrentTime(timeMs) {
+		this.mediaSourceManager?.setCurrentTime(timeMs);
+	}
+	/**
+	* Clean up MediaSource resources
+	*/
+	cleanup() {
+		if (this.mediaSourceManager) {
+			this.mediaSourceManager.cleanup();
+			this.mediaSourceManager = null;
+		}
+	}
+};
+export { MediaSourceService };

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

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

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

@@ -0,0 +1,54 @@
+/**
+* Fetch audio segment data using MediaEngine
+* Pure function with explicit dependencies
+*/
+const fetchAudioSegmentData = async (segmentIds, mediaEngine, signal) => {
+	const audioRendition = mediaEngine.audioRendition;
+	if (!audioRendition) throw new Error("Audio rendition not available");
+	const segmentData = /* @__PURE__ */ new Map();
+	const fetchPromises = segmentIds.map(async (segmentId) => {
+		const arrayBuffer = await mediaEngine.fetchMediaSegment(segmentId, audioRendition, signal);
+		return [segmentId, arrayBuffer];
+	});
+	const fetchedSegments = await Promise.all(fetchPromises);
+	signal.throwIfAborted();
+	for (const [segmentId, arrayBuffer] of fetchedSegments) segmentData.set(segmentId, arrayBuffer);
+	return segmentData;
+};
+/**
+* Create audio span blob from init segment and media segments
+* Pure function for blob creation
+*/
+const createAudioSpanBlob = (initSegment, mediaSegments) => {
+	const chunks = [initSegment, ...mediaSegments];
+	return new Blob(chunks, { type: "audio/mp4" });
+};
+/**
+* Fetch audio spanning a time range
+* Main function that orchestrates segment calculation, fetching, and blob creation
+*/
+const fetchAudioSpanningTime = async (host, fromMs, toMs, signal) => {
+	if (fromMs >= toMs || fromMs < 0) throw new Error(`Invalid time range: fromMs=${fromMs}, toMs=${toMs}`);
+	const mediaEngine = await host.mediaEngineTask.taskComplete;
+	const initSegment = await host.audioInitSegmentFetchTask.taskComplete;
+	if (!mediaEngine?.audioRendition) throw new Error("Audio rendition not available");
+	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`);
+	const segmentIds = segmentRanges.map((r) => r.segmentId);
+	const segmentData = await fetchAudioSegmentData(segmentIds, mediaEngine, signal);
+	const orderedSegments = segmentIds.map((id) => {
+		const segment = segmentData.get(id);
+		if (!segment) throw new Error(`Missing segment data for segment ID ${id}`);
+		return segment;
+	});
+	const blob = createAudioSpanBlob(initSegment, orderedSegments);
+	const actualStartMs = Math.min(...segmentRanges.map((r) => r.startMs));
+	const actualEndMs = Math.max(...segmentRanges.map((r) => r.endMs));
+	return {
+		startMs: actualStartMs,
+		endMs: actualEndMs,
+		blob
+	};
+};
+export { fetchAudioSpanningTime };

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

@@ -0,0 +1,70 @@
+import { AudioRendition, VideoRendition } from '../../../transcoding/types';
+/**
+ * State interface for media buffering - generic for both audio and video
+ */
+export interface MediaBufferState {
+    currentSeekTimeMs: number;
+    activeRequests: Set<number>;
+    cachedSegments: Set<number>;
+    requestQueue: number[];
+}
+/**
+ * Configuration interface for media buffering - generic for both audio and video
+ */
+export interface MediaBufferConfig {
+    bufferDurationMs: number;
+    maxParallelFetches: number;
+    enableBuffering: boolean;
+    enableContinuousBuffering?: boolean;
+}
+/**
+ * Dependencies interface for media buffering - generic for both audio and video
+ */
+export interface MediaBufferDependencies<T extends AudioRendition | VideoRendition> {
+    computeSegmentId: (timeMs: number, rendition: T) => Promise<number | undefined>;
+    fetchSegment: (segmentId: number, rendition: T) => Promise<ArrayBuffer>;
+    getRendition: () => Promise<T>;
+    logError: (message: string, error: any) => void;
+}
+/**
+ * Compute segment range for a time window
+ * Pure function - determines which segments are needed for a time range
+ */
+export declare const computeSegmentRange: <T extends AudioRendition | VideoRendition>(startTimeMs: number, endTimeMs: number, rendition: T, computeSegmentId: (timeMs: number, rendition: T) => number | undefined) => number[];
+/**
+ * Async version of computeSegmentRange for when computeSegmentId is async
+ */
+export declare const computeSegmentRangeAsync: <T extends AudioRendition | VideoRendition>(startTimeMs: number, endTimeMs: number, durationMs: number, rendition: T, computeSegmentId: (timeMs: number, rendition: T) => Promise<number | undefined>) => Promise<number[]>;
+/**
+ * Compute buffer queue based on current state and desired segments
+ * Pure function - determines what segments should be fetched
+ */
+export declare const computeBufferQueue: (desiredSegments: number[], activeRequests: Set<number>, cachedSegments: Set<number>) => number[];
+/**
+ * Handle seek time change and recompute buffer queue
+ * Pure function - computes new queue when seek time changes
+ */
+export declare const handleSeekTimeChange: <T extends AudioRendition | VideoRendition>(newSeekTimeMs: number, bufferDurationMs: number, rendition: T, currentState: MediaBufferState, computeSegmentId: (timeMs: number, rendition: T) => number | undefined) => {
+    newQueue: number[];
+    overlappingRequests: number[];
+};
+/**
+ * Check if a specific segment is cached in the buffer
+ * Pure function for accessing buffer cache state
+ */
+export declare const getCachedSegment: (segmentId: number, bufferState: MediaBufferState | undefined) => boolean;
+/**
+ * Get cached segments from a list of segment IDs
+ * Pure function that returns which segments are available in cache
+ */
+export declare const getCachedSegments: (segmentIds: number[], bufferState: MediaBufferState | undefined) => Set<number>;
+/**
+ * Get missing segments from a list of segment IDs
+ * Pure function that returns which segments need to be fetched
+ */
+export declare const getMissingSegments: (segmentIds: number[], bufferState: MediaBufferState | undefined) => number[];
+/**
+ * Core media buffering logic with explicit dependencies
+ * Generic implementation that works for both audio and video
+ */
+export declare const manageMediaBuffer: <T extends AudioRendition | VideoRendition>(seekTimeMs: number, config: MediaBufferConfig, currentState: MediaBufferState, durationMs: number, signal: AbortSignal, deps: MediaBufferDependencies<T>) => Promise<MediaBufferState>;

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

@@ -0,0 +1,89 @@
+/**
+* Async version of computeSegmentRange for when computeSegmentId is async
+*/
+const computeSegmentRangeAsync = async (startTimeMs, endTimeMs, durationMs, rendition, computeSegmentId) => {
+	const segments = [];
+	const segmentDurationMs = rendition.segmentDurationMs || 1e3;
+	const startSegmentIndex = Math.floor(startTimeMs / segmentDurationMs);
+	const endSegmentIndex = Math.floor(Math.min(endTimeMs, durationMs) / segmentDurationMs);
+	for (let i = startSegmentIndex; i <= endSegmentIndex; i++) {
+		const timeMs = i * segmentDurationMs;
+		if (timeMs < durationMs) {
+			const segmentId = await computeSegmentId(timeMs, rendition);
+			if (segmentId !== void 0) segments.push(segmentId);
+		}
+	}
+	return segments.filter((id, index, arr) => arr.indexOf(id) === index);
+};
+/**
+* Compute buffer queue based on current state and desired segments
+* Pure function - determines what segments should be fetched
+*/
+const computeBufferQueue = (desiredSegments, activeRequests, cachedSegments) => {
+	return desiredSegments.filter((segmentId) => !activeRequests.has(segmentId) && !cachedSegments.has(segmentId));
+};
+/**
+* Core media buffering logic with explicit dependencies
+* Generic implementation that works for both audio and video
+*/
+const manageMediaBuffer = async (seekTimeMs, config, currentState, durationMs, signal, deps) => {
+	if (!config.enableBuffering) return currentState;
+	const rendition = await deps.getRendition();
+	const endTimeMs = seekTimeMs + config.bufferDurationMs;
+	const desiredSegments = await computeSegmentRangeAsync(seekTimeMs, endTimeMs, durationMs, rendition, deps.computeSegmentId);
+	const newQueue = computeBufferQueue(desiredSegments, currentState.activeRequests, currentState.cachedSegments);
+	const segmentsToFetch = newQueue.slice(0, config.maxParallelFetches);
+	const newActiveRequests = new Set(currentState.activeRequests);
+	const newCachedSegments = new Set(currentState.cachedSegments);
+	const startNextSegment = (remainingQueue) => {
+		if (remainingQueue.length === 0 || signal.aborted) return;
+		const availableSlots = config.maxParallelFetches - newActiveRequests.size;
+		if (availableSlots <= 0) return;
+		const nextSegmentId = remainingQueue[0];
+		if (nextSegmentId === void 0) return;
+		if (newActiveRequests.has(nextSegmentId) || newCachedSegments.has(nextSegmentId)) {
+			startNextSegment(remainingQueue.slice(1));
+			return;
+		}
+		newActiveRequests.add(nextSegmentId);
+		deps.fetchSegment(nextSegmentId, rendition).then(() => {
+			if (signal.aborted) return;
+			newActiveRequests.delete(nextSegmentId);
+			newCachedSegments.add(nextSegmentId);
+			startNextSegment(remainingQueue.slice(1));
+		}).catch((error) => {
+			if (signal.aborted) return;
+			newActiveRequests.delete(nextSegmentId);
+			deps.logError(`Failed to fetch segment ${nextSegmentId}`, error);
+			startNextSegment(remainingQueue.slice(1));
+		});
+	};
+	for (const segmentId of segmentsToFetch) {
+		if (signal.aborted) break;
+		newActiveRequests.add(segmentId);
+		deps.fetchSegment(segmentId, rendition).then(() => {
+			if (signal.aborted) return;
+			newActiveRequests.delete(segmentId);
+			newCachedSegments.add(segmentId);
+			if (config.enableContinuousBuffering ?? true) {
+				const remainingQueue = newQueue.slice(segmentsToFetch.length);
+				startNextSegment(remainingQueue);
+			}
+		}).catch((error) => {
+			if (signal.aborted) return;
+			newActiveRequests.delete(segmentId);
+			deps.logError(`Failed to fetch segment ${segmentId}`, error);
+			if (config.enableContinuousBuffering ?? true) {
+				const remainingQueue = newQueue.slice(segmentsToFetch.length);
+				startNextSegment(remainingQueue);
+			}
+		});
+	}
+	return {
+		currentSeekTimeMs: seekTimeMs,
+		activeRequests: newActiveRequests,
+		cachedSegments: newCachedSegments,
+		requestQueue: newQueue.slice(segmentsToFetch.length)
+	};
+};
+export { manageMediaBuffer };

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

@@ -0,0 +1,23 @@
+import { Task } from '@lit/task';
+import { AudioRendition, MediaEngine, VideoRendition } from '../../../transcoding/types';
+import { BufferedSeekingInput } from '../BufferedSeekingInput';
+/**
+ * Generic rendition type that can be either audio or video
+ */
+export type MediaRendition = AudioRendition | VideoRendition;
+/**
+ * Generic task type for init segment fetch
+ */
+export type InitSegmentFetchTask = Task<readonly [MediaEngine | undefined], ArrayBuffer>;
+/**
+ * Generic task type for segment ID calculation
+ */
+export type SegmentIdTask = Task<readonly [MediaEngine | undefined, number], number | undefined>;
+/**
+ * Generic task type for segment fetch
+ */
+export type SegmentFetchTask = Task<readonly [MediaEngine | undefined, number | undefined], ArrayBuffer>;
+/**
+ * Generic task type for input creation
+ */
+export type InputTask = Task<readonly [ArrayBuffer, ArrayBuffer], BufferedSeekingInput>;

package/dist/elements/EFMedia/shared/RenditionHelpers.browsertest.d.ts

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

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

@@ -0,0 +1,19 @@
+import { AudioRendition, MediaEngine, VideoRendition } from '../../../transcoding/types';
+/**
+ * Get audio rendition from media engine, throwing if not available
+ */
+export declare const getAudioRendition: (mediaEngine: MediaEngine) => AudioRendition;
+/**
+ * Get video rendition from media engine, throwing if not available
+ */
+export declare const getVideoRendition: (mediaEngine: MediaEngine) => VideoRendition;
+/**
+ * Calculate which segment contains a given timestamp
+ * Returns 1-based segment ID, or undefined if segmentDurationMs is not available
+ */
+export declare const computeSegmentId: (timeMs: number, rendition: AudioRendition | VideoRendition) => number | undefined;
+/**
+ * Calculate range of segment IDs that overlap with a time range
+ * Returns array of 1-based segment IDs, or empty array if segmentDurationMs is not available
+ */
+export declare const calculateSegmentRange: (startTimeMs: number, endTimeMs: number, rendition: AudioRendition | VideoRendition) => number[];

package/dist/elements/EFMedia/tasks/makeMediaEngineTask.browsertest.d.ts

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

package/dist/elements/EFMedia/tasks/makeMediaEngineTask.d.ts

@@ -0,0 +1,18 @@
+import { Task } from '@lit/task';
+import { MediaEngine, VideoRendition } from '../../../transcoding/types';
+import { EFMedia } from '../../EFMedia';
+export declare const getLatestMediaEngine: (host: EFMedia, signal: AbortSignal) => Promise<MediaEngine>;
+export declare const getVideoRendition: (mediaEngine: MediaEngine) => VideoRendition;
+/**
+ * Core logic for creating a MediaEngine with explicit dependencies.
+ * Pure function that requires all dependencies to be provided.
+ */
+export declare const createMediaEngine: (host: EFMedia) => Promise<MediaEngine>;
+/**
+ * Handle completion of media engine task - triggers necessary updates.
+ * Extracted for testability.
+ */
+export declare const handleMediaEngineComplete: (host: EFMedia) => void;
+type MediaEngineTask = Task<readonly [string, string | null], MediaEngine>;
+export declare const makeMediaEngineTask: (host: EFMedia) => MediaEngineTask;
+export {};