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

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

@@ -0,0 +1,28 @@
+import { getLatestMediaEngine } from "../tasks/makeMediaEngineTask.js";
+import { Task } from "@lit/task";
+const makeAudioSegmentFetchTask = (host) => {
+	return new Task(host, {
+		args: () => [host.mediaEngineTask.value, host.audioSegmentIdTask.value],
+		onError: (error) => {
+			console.error("audioSegmentFetchTask error", error);
+		},
+		onComplete: (_value) => {},
+		task: async (_, { signal }) => {
+			const mediaEngine = await getLatestMediaEngine(host, signal);
+			const segmentId = await host.audioSegmentIdTask.taskComplete;
+			if (segmentId === void 0) {
+				const rendition = mediaEngine.audioRendition;
+				const debugInfo = {
+					hasRendition: !!rendition,
+					segmentDurationMs: rendition?.segmentDurationMs,
+					segmentDurationsMs: rendition?.segmentDurationsMs?.length || 0,
+					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);
+		}
+	});
+};
+export { makeAudioSegmentFetchTask };

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

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

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

@@ -0,0 +1,17 @@
+import { getLatestMediaEngine } from "../tasks/makeMediaEngineTask.js";
+import { Task } from "@lit/task";
+const makeAudioSegmentIdTask = (host) => {
+	return new Task(host, {
+		args: () => [host.mediaEngineTask.value, host.desiredSeekTimeMs],
+		onError: (error) => {
+			console.error("audioSegmentIdTask error", error);
+		},
+		onComplete: (_value) => {},
+		task: async ([, targetSeekTimeMs], { signal }) => {
+			const mediaEngine = await getLatestMediaEngine(host, signal);
+			signal.throwIfAborted();
+			return mediaEngine.computeSegmentId(targetSeekTimeMs, mediaEngine.getAudioRendition());
+		}
+	});
+};
+export { makeAudioSegmentIdTask };

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

@@ -0,0 +1,3 @@
+import { Task } from '@lit/task';
+import { EFMedia } from '../../EFMedia.js';
+export declare function makeAudioTimeDomainAnalysisTask(element: EFMedia): Task<readonly [import('@lit/task').TaskStatus, number, number, number, number, boolean], Uint8Array | null>;

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

@@ -0,0 +1,107 @@
+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 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) {
+				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/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/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/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.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 {};

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

@@ -0,0 +1,60 @@
+import { EF_INTERACTIVE } from "../../../EF_INTERACTIVE.js";
+import { AssetMediaEngine } from "../AssetMediaEngine.js";
+import { AssetIdMediaEngine } from "../AssetIdMediaEngine.js";
+import { JitMediaEngine } from "../JitMediaEngine.js";
+import { Task } from "@lit/task";
+const getLatestMediaEngine = async (host, signal) => {
+	const mediaEngine = await host.mediaEngineTask.taskComplete;
+	signal.throwIfAborted();
+	if (!mediaEngine) throw new Error("Media engine is not available");
+	return mediaEngine;
+};
+const getVideoRendition = (mediaEngine) => {
+	const videoRendition = mediaEngine.videoRendition;
+	if (!videoRendition) throw new Error("Video rendition is not available");
+	return videoRendition;
+};
+/**
+* Core logic for creating a MediaEngine with explicit dependencies.
+* Pure function that requires all dependencies to be provided.
+*/
+const createMediaEngine = (host) => {
+	const { src, assetId, urlGenerator, apiHost } = host;
+	if (assetId !== null && assetId !== void 0 && assetId.trim() !== "") {
+		if (!apiHost) return Promise.reject(/* @__PURE__ */ new Error("API host is required for AssetID mode"));
+		return AssetIdMediaEngine.fetchByAssetId(host, urlGenerator, assetId, apiHost);
+	}
+	if (!src || typeof src !== "string" || src.trim() === "") {
+		console.error(`Unsupported media source: ${src}, assetId: ${assetId}`);
+		return Promise.reject(/* @__PURE__ */ new Error("Unsupported media source"));
+	}
+	const lowerSrc = src.toLowerCase();
+	if (lowerSrc.startsWith("http://") || lowerSrc.startsWith("https://")) {
+		const url = urlGenerator.generateManifestUrl(src);
+		return JitMediaEngine.fetch(host, urlGenerator, url);
+	}
+	return AssetMediaEngine.fetch(host, urlGenerator, src);
+};
+/**
+* Handle completion of media engine task - triggers necessary updates.
+* Extracted for testability.
+*/
+const handleMediaEngineComplete = (host) => {
+	host.requestUpdate("intrinsicDurationMs");
+	host.requestUpdate("ownCurrentTimeMs");
+	host.rootTimegroup?.requestUpdate("ownCurrentTimeMs");
+	host.rootTimegroup?.requestUpdate("durationMs");
+};
+const makeMediaEngineTask = (host) => {
+	return new Task(host, {
+		autoRun: EF_INTERACTIVE,
+		args: () => [host.src, host.assetId],
+		task: async () => {
+			return createMediaEngine(host);
+		},
+		onComplete: (_value) => {
+			handleMediaEngineComplete(host);
+		}
+	});
+};
+export { getLatestMediaEngine, getVideoRendition, makeMediaEngineTask };

package/dist/elements/EFMedia/videoTasks/makeVideoBufferTask.browsertest.d.ts

@@ -0,0 +1,9 @@
+import { EFVideo } from '../../EFVideo';
+declare class TestMediaVideoBuffer extends EFVideo {
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "test-media-video-buffer": TestMediaVideoBuffer;
+    }
+}
+export {};

package/dist/elements/EFMedia/videoTasks/makeVideoBufferTask.d.ts

@@ -0,0 +1,16 @@
+import { Task } from '@lit/task';
+import { EFVideo } from '../../EFVideo';
+import { MediaBufferConfig, MediaBufferState } from '../shared/BufferUtils';
+/**
+ * Configuration for video buffering - extends the generic interface
+ */
+export interface VideoBufferConfig extends MediaBufferConfig {
+}
+/**
+ * State of the video buffer - uses the generic interface
+ */
+export interface VideoBufferState extends MediaBufferState {
+}
+type VideoBufferTask = Task<readonly [number], VideoBufferState>;
+export declare const makeVideoBufferTask: (host: EFVideo) => VideoBufferTask;
+export {};

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

@@ -0,0 +1,46 @@
+import { EF_INTERACTIVE } from "../../../EF_INTERACTIVE.js";
+import { EF_RENDERING } from "../../../EF_RENDERING.js";
+import { manageMediaBuffer } from "../shared/BufferUtils.js";
+import { getLatestMediaEngine, getVideoRendition } from "../tasks/makeMediaEngineTask.js";
+import { Task } from "@lit/task";
+const makeVideoBufferTask = (host) => {
+	let currentState = {
+		currentSeekTimeMs: 0,
+		activeRequests: /* @__PURE__ */ new Set(),
+		cachedSegments: /* @__PURE__ */ new Set(),
+		requestQueue: []
+	};
+	return new Task(host, {
+		autoRun: EF_INTERACTIVE,
+		args: () => [host.desiredSeekTimeMs],
+		onError: (error) => {
+			console.error("videoBufferTask error", error);
+		},
+		onComplete: (value) => {
+			currentState = value;
+		},
+		task: async ([seekTimeMs], { signal }) => {
+			const currentConfig = {
+				bufferDurationMs: host.videoBufferDurationMs,
+				maxParallelFetches: host.maxVideoBufferFetches,
+				enableBuffering: host.enableVideoBuffering && !EF_RENDERING
+			};
+			return manageMediaBuffer(seekTimeMs, currentConfig, currentState, host.intrinsicDurationMs || 1e4, signal, {
+				computeSegmentId: async (timeMs, rendition) => {
+					const mediaEngine = await getLatestMediaEngine(host, signal);
+					return mediaEngine.computeSegmentId(timeMs, rendition);
+				},
+				fetchSegment: async (segmentId, rendition) => {
+					const mediaEngine = await getLatestMediaEngine(host, signal);
+					return mediaEngine.fetchMediaSegment(segmentId, rendition);
+				},
+				getRendition: async () => {
+					const mediaEngine = await getLatestMediaEngine(host, signal);
+					return getVideoRendition(mediaEngine);
+				},
+				logError: console.error
+			});
+		}
+	});
+};
+export { makeVideoBufferTask };

package/dist/elements/EFMedia/videoTasks/makeVideoInitSegmentFetchTask.browsertest.d.ts

@@ -0,0 +1,9 @@
+import { EFVideo } from '../../EFVideo';
+declare class TestMediaVideoInitSegmentFetch extends EFVideo {
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        "test-media-video-init-segment-fetch": TestMediaVideoInitSegmentFetch;
+    }
+}
+export {};