@editframe/elements 0.20.4-beta.0 → 0.23.6-beta.0

package/dist/elements/EFMedia/JitMediaEngine.js

@@ -3,8 +3,7 @@ import { ThumbnailExtractor } from "./shared/ThumbnailExtractor.js";
 var JitMediaEngine = class JitMediaEngine extends BaseMediaEngine {
 	static async fetch(host, urlGenerator, url) {
 		const engine = new JitMediaEngine(host, urlGenerator);
-		const data = await engine.fetchManifest(url);
-		engine.data = data;
+		engine.data = await engine.fetchManifest(url);
 		return engine;
 	}
 	constructor(host, urlGenerator) {
@@ -20,7 +19,7 @@ var JitMediaEngine = class JitMediaEngine extends BaseMediaEngine {
 		return this.data.sourceUrl;
 	}
 	get audioRendition() {
-		if (!this.data.audioRenditions || this.data.audioRenditions.length === 0) return void 0;
+		if (!this.data.audioRenditions || this.data.audioRenditions.length === 0) return;
 		const rendition = this.data.audioRenditions[0];
 		if (!rendition) return void 0;
 		return {
@@ -32,7 +31,7 @@ var JitMediaEngine = class JitMediaEngine extends BaseMediaEngine {
 		};
 	}
 	get videoRendition() {
-		if (!this.data.videoRenditions || this.data.videoRenditions.length === 0) return void 0;
+		if (!this.data.videoRenditions || this.data.videoRenditions.length === 0) return;
 		const rendition = this.data.videoRenditions[0];
 		if (!rendition) return void 0;
 		return {
@@ -57,26 +56,24 @@ var JitMediaEngine = class JitMediaEngine extends BaseMediaEngine {
 		return this.fetchMedia(url);
 	}
 	computeSegmentId(desiredSeekTimeMs, rendition) {
-		if (desiredSeekTimeMs > this.durationMs) return void 0;
+		if (desiredSeekTimeMs > this.durationMs) return;
 		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 segmentStartMs = 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;
+				const includesEndTime = i === rendition.segmentDurationsMs.length - 1 && desiredSeekTimeMs === this.durationMs;
+				if (desiredSeekTimeMs >= segmentStartMs && (desiredSeekTimeMs < segmentEndMs || includesEndTime)) return i + 1;
 				cumulativeTime += segmentDuration;
 				if (cumulativeTime >= this.durationMs) break;
 			}
-			return void 0;
+			return;
 		}
 		if (!rendition.segmentDurationMs) throw new Error("Segment duration is required for JIT metadata");
 		const segmentIndex = Math.floor(desiredSeekTimeMs / rendition.segmentDurationMs);
-		const segmentStartMs = segmentIndex * rendition.segmentDurationMs;
-		if (segmentStartMs >= this.durationMs) return void 0;
+		if (segmentIndex * rendition.segmentDurationMs >= this.durationMs) return;
 		return segmentIndex + 1;
 	}
 	getScrubVideoRendition() {
@@ -91,10 +88,6 @@ var JitMediaEngine = class JitMediaEngine extends BaseMediaEngine {
 			segmentDurationsMs: scrubManifestRendition.segmentDurationsMs
 		};
 	}
-	/**
-	* Get preferred buffer configuration for JIT transcoding
-	* Uses higher buffering since transcoding introduces latency
-	*/
 	getBufferConfig() {
 		return {
 			videoBufferDurationMs: 8e3,
@@ -103,9 +96,6 @@ var JitMediaEngine = class JitMediaEngine extends BaseMediaEngine {
 			maxAudioBufferFetches: 3
 		};
 	}
-	/**
-	* Extract thumbnail canvases using same rendition priority as video playback for frame alignment
-	*/
 	async extractThumbnails(timestamps) {
 		let rendition;
 		try {

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

@@ -24,21 +24,16 @@ const makeAudioBufferTask = (host) => {
 			const mediaEngine = await getLatestMediaEngine(host, signal);
 			if (!mediaEngine.audioRendition) return currentState;
 			const engineConfig = mediaEngine.getBufferConfig();
-			const bufferDurationMs = engineConfig.audioBufferDurationMs;
-			const maxParallelFetches = engineConfig.maxAudioBufferFetches;
-			const currentConfig = {
-				bufferDurationMs,
-				maxParallelFetches,
+			return manageMediaBuffer(seekTimeMs, {
+				bufferDurationMs: engineConfig.audioBufferDurationMs,
+				maxParallelFetches: engineConfig.maxAudioBufferFetches,
 				enableBuffering: host.enableAudioBuffering
-			};
-			return manageMediaBuffer(seekTimeMs, currentConfig, currentState, host.intrinsicDurationMs || 1e4, signal, {
+			}, currentState, host.intrinsicDurationMs || 1e4, signal, {
 				computeSegmentId: async (timeMs, rendition) => {
-					const mediaEngine$1 = await getLatestMediaEngine(host, signal);
-					return mediaEngine$1.computeSegmentId(timeMs, rendition);
+					return (await getLatestMediaEngine(host, signal)).computeSegmentId(timeMs, rendition);
 				},
 				prefetchSegment: async (segmentId, rendition) => {
-					const mediaEngine$1 = await getLatestMediaEngine(host, signal);
-					await mediaEngine$1.fetchMediaSegment(segmentId, rendition);
+					await (await getLatestMediaEngine(host, signal)).fetchMediaSegment(segmentId, rendition);
 				},
 				isSegmentCached: (segmentId, rendition) => {
 					const mediaEngine$1 = host.mediaEngineTask.value;
@@ -46,8 +41,7 @@ const makeAudioBufferTask = (host) => {
 					return mediaEngine$1.isSegmentCached(segmentId, rendition);
 				},
 				getRendition: async () => {
-					const mediaEngine$1 = await getLatestMediaEngine(host, signal);
-					const audioRendition = mediaEngine$1.audioRendition;
+					const audioRendition = (await getLatestMediaEngine(host, signal)).audioRendition;
 					if (!audioRendition) throw new Error("Audio rendition not available");
 					return audioRendition;
 				},

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

@@ -1,7 +1,7 @@
 import { EF_INTERACTIVE } from "../../../EF_INTERACTIVE.js";
 import { LRUCache } from "../../../utils/LRUCache.js";
 import { Task } from "@lit/task";
-const DECAY_WEIGHT = .8;
+var DECAY_WEIGHT = .8;
 function processFFTData(fftData, zeroThresholdPercent = .1) {
 	const totalBins = fftData.length;
 	const zeroThresholdCount = Math.floor(totalBins * zeroThresholdPercent);
@@ -13,8 +13,7 @@ function processFFTData(fftData, zeroThresholdPercent = .1) {
 		break;
 	}
 	if (cutoffIndex < zeroThresholdCount) return fftData;
-	const goodData = fftData.slice(0, cutoffIndex);
-	const resampledData = interpolateData(goodData, fftData.length);
+	const resampledData = interpolateData(fftData.slice(0, cutoffIndex), fftData.length);
 	const attenuationStartIndex = Math.floor(totalBins * .9);
 	for (let i = attenuationStartIndex; i < totalBins; i++) {
 		const attenuationProgress = (i - attenuationStartIndex) / (totalBins - attenuationStartIndex) + .2;

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

@@ -10,7 +10,7 @@ const makeAudioInitSegmentFetchTask = (host) => {
 		task: async ([_mediaEngine], { signal }) => {
 			const mediaEngine = await getLatestMediaEngine(host, signal);
 			const audioRendition = mediaEngine.getAudioRendition();
-			if (!audioRendition) return void 0;
+			if (!audioRendition) return;
 			return mediaEngine.fetchInitSegment(audioRendition, signal);
 		}
 	});

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

@@ -10,16 +10,17 @@ const makeAudioInputTask = (host) => {
 		onComplete: (_value) => {},
 		task: async (_, { signal }) => {
 			const mediaEngine = await host.mediaEngineTask.taskComplete;
+			if (signal.aborted) return void 0;
 			const audioRendition = mediaEngine?.audioRendition;
-			if (!audioRendition) return void 0;
+			if (!audioRendition) return;
 			const initSegment = await host.audioInitSegmentFetchTask.taskComplete;
-			signal.throwIfAborted();
+			if (signal.aborted) return void 0;
 			const segment = await host.audioSegmentFetchTask.taskComplete;
-			signal.throwIfAborted();
-			if (!initSegment || !segment) return void 0;
+			if (signal.aborted) return void 0;
+			if (!initSegment || !segment) return;
 			const startTimeOffsetMs = audioRendition.startTimeOffsetMs;
 			const arrayBuffer = await new Blob([initSegment, segment]).arrayBuffer();
-			signal.throwIfAborted();
+			if (signal.aborted) return void 0;
 			return new BufferedSeekingInput(arrayBuffer, {
 				videoBufferSize: EFMedia.VIDEO_SAMPLE_BUFFER_SIZE,
 				audioBufferSize: EFMedia.AUDIO_SAMPLE_BUFFER_SIZE,

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

@@ -13,9 +13,7 @@ const makeAudioSeekTask = (host) => {
 			else console.error("audioSeekTask unknown error", error);
 		},
 		onComplete: (_value) => {},
-		task: async () => {
-			return void 0;
-		}
+		task: async () => {}
 	});
 };
 export { makeAudioSeekTask };

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

@@ -11,7 +11,7 @@ const makeAudioSegmentFetchTask = (host) => {
 			const mediaEngine = await getLatestMediaEngine(host, signal);
 			const segmentId = await host.audioSegmentIdTask.taskComplete;
 			const audioRendition = mediaEngine.getAudioRendition();
-			if (!audioRendition || segmentId === void 0) return void 0;
+			if (!audioRendition || segmentId === void 0) return;
 			return mediaEngine.fetchMediaSegment(segmentId, audioRendition, signal);
 		}
 	});

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

@@ -11,7 +11,7 @@ const makeAudioSegmentIdTask = (host) => {
 			const mediaEngine = await getLatestMediaEngine(host, signal);
 			signal.throwIfAborted();
 			const audioRendition = mediaEngine.getAudioRendition();
-			if (!audioRendition) return void 0;
+			if (!audioRendition) return;
 			return mediaEngine.computeSegmentId(targetSeekTimeMs, audioRendition);
 		}
 	});

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

@@ -2,7 +2,7 @@ import { EF_INTERACTIVE } from "../../../EF_INTERACTIVE.js";
 import { LRUCache } from "../../../utils/LRUCache.js";
 import { IgnorableError } from "../../EFMedia.js";
 import { Task } from "@lit/task";
-const DECAY_WEIGHT = .8;
+var DECAY_WEIGHT = .8;
 function makeAudioTimeDomainAnalysisTask(element) {
 	const cache = new LRUCache(1e3);
 	return new Task(element, {

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

@@ -1,53 +1,37 @@
-/**
-* Fetch audio segment data using MediaEngine
-* Pure function with explicit dependencies
-*/
-const fetchAudioSegmentData = async (segmentIds, mediaEngine, signal) => {
+var 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];
+		return [segmentId, await mediaEngine.fetchMediaSegment(segmentId, audioRendition, signal)];
 	});
 	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) => {
+var 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) return void 0;
-	if (!initSegment) return void 0;
+	if (!mediaEngine?.audioRendition) return;
+	if (!initSegment) return;
 	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 blob = createAudioSpanBlob(initSegment, 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,
+		startMs: Math.min(...segmentRanges.map((r) => r.startMs)),
+		endMs: Math.max(...segmentRanges.map((r) => r.endMs)),
 		blob
 	};
 };

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

@@ -1,6 +1,3 @@
-/**
-* Async version of computeSegmentRange for when computeSegmentId is async
-*/
 const computeSegmentRangeAsync = async (startTimeMs, endTimeMs, durationMs, rendition, computeSegmentId) => {
 	const segments = [];
 	const segmentDurationMs = rendition.segmentDurationMs || 1e3;
@@ -15,25 +12,14 @@ const computeSegmentRangeAsync = async (startTimeMs, endTimeMs, durationMs, rend
 	}
 	return segments.filter((id, index, arr) => arr.indexOf(id) === index);
 };
-/**
-* Compute buffer queue based on desired segments and what we've already requested
-* Pure function - determines what new segments should be prefetched
-*/
 const computeBufferQueue = (desiredSegments, requestedSegments) => {
 	return desiredSegments.filter((segmentId) => !requestedSegments.has(segmentId));
 };
-/**
-* Core media buffering orchestration logic - prefetch only, no data storage
-* Integrates with BaseMediaEngine's existing caching and request deduplication
-*/
 const manageMediaBuffer = async (seekTimeMs, config, currentState, durationMs, signal, deps) => {
 	if (!config.enableBuffering) return currentState;
 	const rendition = await deps.getRendition();
 	if (!rendition) return currentState;
-	const endTimeMs = seekTimeMs + config.bufferDurationMs;
-	const desiredSegments = await computeSegmentRangeAsync(seekTimeMs, endTimeMs, durationMs, rendition, deps.computeSegmentId);
-	const uncachedSegments = desiredSegments.filter((segmentId) => !deps.isSegmentCached(segmentId, rendition));
-	const newQueue = computeBufferQueue(uncachedSegments, currentState.requestedSegments);
+	const newQueue = computeBufferQueue((await computeSegmentRangeAsync(seekTimeMs, seekTimeMs + config.bufferDurationMs, durationMs, rendition, deps.computeSegmentId)).filter((segmentId) => !deps.isSegmentCached(segmentId, rendition)), currentState.requestedSegments);
 	const newRequestedSegments = new Set(currentState.requestedSegments);
 	const newActiveRequests = new Set(currentState.activeRequests);
 	const remainingQueue = [...newQueue];
@@ -60,12 +46,11 @@ const manageMediaBuffer = async (seekTimeMs, config, currentState, durationMs, s
 	};
 	const initialBatchSize = Math.min(config.maxParallelFetches, newQueue.length);
 	for (let i = 0; i < initialBatchSize; i++) startNextSegment();
-	const result = {
+	return {
 		currentSeekTimeMs: seekTimeMs,
 		requestedSegments: newRequestedSegments,
 		activeRequests: newActiveRequests,
 		requestQueue: remainingQueue
 	};
-	return result;
 };
 export { manageMediaBuffer };

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

@@ -1,50 +1,26 @@
 import { LRUCache } from "../../../utils/LRUCache.js";
-/**
-* Global cache for MediaBunny Input instances
-* Shared across all MediaEngine instances to prevent duplicate decoding
-* of the same segment data
-*/
 var GlobalInputCache = class {
 	constructor() {
 		this.cache = new LRUCache(50);
 	}
-	/**
-	* Generate standardized cache key for Input objects
-	* Format: "input:{src}:{segmentId}:{renditionId}"
-	*/
 	generateKey(src, segmentId, renditionId) {
 		return `input:${src}:${segmentId}:${renditionId || "default"}`;
 	}
-	/**
-	* Get cached Input object
-	*/
 	get(src, segmentId, renditionId) {
 		const key = this.generateKey(src, segmentId, renditionId);
 		return this.cache.get(key);
 	}
-	/**
-	* Cache Input object
-	*/
 	set(src, segmentId, input, renditionId) {
 		const key = this.generateKey(src, segmentId, renditionId);
 		this.cache.set(key, input);
 	}
-	/**
-	* Check if Input is cached
-	*/
 	has(src, segmentId, renditionId) {
 		const key = this.generateKey(src, segmentId, renditionId);
 		return this.cache.has(key);
 	}
-	/**
-	* Clear all cached Input objects
-	*/
 	clear() {
 		this.cache.clear();
 	}
-	/**
-	* Get cache statistics for debugging
-	*/
 	getStats() {
 		return {
 			size: this.cache.size,

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

@@ -1,27 +1,6 @@
-/**
-* 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);

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

@@ -1,16 +1,9 @@
 import { globalInputCache } from "./GlobalInputCache.js";
 import { ALL_FORMATS, BlobSource, CanvasSink, Input } from "mediabunny";
-/**
-* Shared thumbnail extraction logic for all MediaEngine implementations
-* Eliminates code duplication and provides consistent behavior
-*/
 var ThumbnailExtractor = class {
 	constructor(mediaEngine) {
 		this.mediaEngine = mediaEngine;
 	}
-	/**
-	* Extract thumbnails at multiple timestamps efficiently using segment batching
-	*/
 	async extractThumbnails(timestamps, rendition, durationMs) {
 		if (timestamps.length === 0) return [];
 		const validTimestamps = timestamps.filter((timeMs) => timeMs >= 0 && timeMs <= durationMs);
@@ -32,9 +25,6 @@ var ThumbnailExtractor = class {
 			return results.get(t) || null;
 		});
 	}
-	/**
-	* Group timestamps by segment ID for efficient batch processing
-	*/
 	groupTimestampsBySegment(timestamps, rendition) {
 		const segmentGroups = /* @__PURE__ */ new Map();
 		for (const timeMs of timestamps) try {
@@ -50,9 +40,6 @@ var ThumbnailExtractor = class {
 		}
 		return segmentGroups;
 	}
-	/**
-	* Extract thumbnails for a specific segment using CanvasSink
-	*/
 	async extractSegmentThumbnails(segmentId, timestamps, rendition) {
 		const results = /* @__PURE__ */ new Map();
 		try {
@@ -95,10 +82,6 @@ var ThumbnailExtractor = class {
 		}
 		return results;
 	}
-	/**
-	* Convert global timestamps to segment-relative timestamps for mediabunny
-	* This is where the main difference between JIT and Asset engines lies
-	*/
 	convertToSegmentRelativeTimestamps(globalTimestamps, segmentId, rendition) {
 		return this.mediaEngine.convertToSegmentRelativeTimestamps(globalTimestamps, segmentId, rendition);
 	}

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

@@ -9,10 +9,6 @@ const getLatestMediaEngine = async (host, signal) => {
 	if (!mediaEngine) throw new Error("Media engine is not available");
 	return mediaEngine;
 };
-/**
-* 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() !== "") {
@@ -25,15 +21,10 @@ const createMediaEngine = (host) => {
 	}
 	const lowerSrc = src.toLowerCase();
 	if (!lowerSrc.startsWith("http://") && !lowerSrc.startsWith("https://")) return AssetMediaEngine.fetch(host, urlGenerator, src);
-	const configuration = host.closest("ef-configuration");
-	if (configuration?.mediaEngine === "local") return AssetMediaEngine.fetch(host, urlGenerator, src);
+	if (host.closest("ef-configuration")?.mediaEngine === "local") return AssetMediaEngine.fetch(host, urlGenerator, src);
 	const url = urlGenerator.generateManifestUrl(src);
 	return JitMediaEngine.fetch(host, urlGenerator, url);
 };
-/**
-* Handle completion of media engine task - triggers necessary updates.
-* Extracted for testability.
-*/
 const handleMediaEngineComplete = (host) => {
 	host.requestUpdate("intrinsicDurationMs");
 	host.requestUpdate("ownCurrentTimeMs");

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

@@ -0,0 +1,29 @@
+import { BufferedSeekingInput } from '../BufferedSeekingInput';
+/**
+ * Cache for main video BufferedSeekingInput instances
+ * Main video segments are typically 2s long, so we can reuse the same input
+ * for multiple frames within that segment (e.g., 60 frames at 30fps)
+ */
+export declare class MainVideoInputCache {
+    private cache;
+    private maxCacheSize;
+    /**
+     * Create a cache key that uniquely identifies a segment
+     */
+    private getCacheKey;
+    /**
+     * Get or create BufferedSeekingInput for a main video segment
+     */
+    getOrCreateInput(src: string, segmentId: number, renditionId: string | undefined, createInputFn: () => Promise<BufferedSeekingInput | undefined>): Promise<BufferedSeekingInput | undefined>;
+    /**
+     * Clear the entire cache (called when video changes)
+     */
+    clear(): void;
+    /**
+     * Get cache statistics
+     */
+    getStats(): {
+        size: number;
+        cacheKeys: string[];
+    };
+}

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

@@ -0,0 +1,32 @@
+var MainVideoInputCache = class {
+	constructor() {
+		this.cache = /* @__PURE__ */ new Map();
+		this.maxCacheSize = 10;
+	}
+	getCacheKey(src, segmentId, renditionId) {
+		return `${src}:${renditionId || "default"}:${segmentId}`;
+	}
+	async getOrCreateInput(src, segmentId, renditionId, createInputFn) {
+		const cacheKey = this.getCacheKey(src, segmentId, renditionId);
+		const cached = this.cache.get(cacheKey);
+		if (cached) return cached;
+		const input = await createInputFn();
+		if (!input) return;
+		this.cache.set(cacheKey, input);
+		if (this.cache.size > this.maxCacheSize) {
+			const oldestKey = this.cache.keys().next().value;
+			if (oldestKey !== void 0) this.cache.delete(oldestKey);
+		}
+		return input;
+	}
+	clear() {
+		this.cache.clear();
+	}
+	getStats() {
+		return {
+			size: this.cache.size,
+			cacheKeys: Array.from(this.cache.keys())
+		};
+	}
+};
+export { MainVideoInputCache };

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

@@ -1,21 +1,13 @@
-/**
-* Cache for scrub BufferedSeekingInput instances
-* Since scrub segments are 30s long, we can reuse the same input for many seeks
-* within that time range, making scrub seeking very efficient
-*/
 var ScrubInputCache = class {
 	constructor() {
 		this.cache = /* @__PURE__ */ new Map();
 		this.maxCacheSize = 5;
 	}
-	/**
-	* Get or create BufferedSeekingInput for a scrub segment
-	*/
 	async getOrCreateInput(segmentId, createInputFn) {
 		const cached = this.cache.get(segmentId);
 		if (cached) return cached;
 		const input = await createInputFn();
-		if (!input) return void 0;
+		if (!input) return;
 		this.cache.set(segmentId, input);
 		if (this.cache.size > this.maxCacheSize) {
 			const oldestKey = this.cache.keys().next().value;
@@ -23,15 +15,9 @@ var ScrubInputCache = class {
 		}
 		return input;
 	}
-	/**
-	* Clear the entire cache (called when video changes)
-	*/
 	clear() {
 		this.cache.clear();
 	}
-	/**
-	* Get cache statistics
-	*/
 	getStats() {
 		return {
 			size: this.cache.size,

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

@@ -2,11 +2,6 @@ import { EF_INTERACTIVE } from "../../../EF_INTERACTIVE.js";
 import { EF_RENDERING } from "../../../EF_RENDERING.js";
 import { manageMediaBuffer } from "../shared/BufferUtils.js";
 import { Task } from "@lit/task";
-/**
-* Scrub video buffer task - aggressively preloads the ENTIRE scrub track
-* Unlike main video buffering, this loads the full duration with higher concurrency
-* for instant visual feedback during seeking
-*/
 const makeScrubVideoBufferTask = (host) => {
 	let currentState = {
 		currentSeekTimeMs: 0,
@@ -39,7 +34,7 @@ const makeScrubVideoBufferTask = (host) => {
 				} catch (error) {
 					console.warn("ScrubBuffer: Failed to cache scrub init segment:", error);
 				}
-				const newState = await manageMediaBuffer(0, {
+				return await manageMediaBuffer(0, {
 					bufferDurationMs: mediaEngine.durationMs,
 					maxParallelFetches: 10,
 					enableBuffering: true,
@@ -59,7 +54,6 @@ const makeScrubVideoBufferTask = (host) => {
 						console.warn(`ScrubBuffer: ${message}`, error);
 					}
 				});
-				return newState;
 			} catch (error) {
 				if (signal.aborted) return currentState;
 				console.warn("ScrubBuffer failed:", error);

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

@@ -8,19 +8,22 @@ const makeScrubVideoInputTask = (host) => {
 			console.error("scrubVideoInputTask error", error);
 		},
 		onComplete: (_value) => {},
-		task: async () => {
+		task: async (_, { signal }) => {
 			const initSegment = await host.scrubVideoInitSegmentFetchTask.taskComplete;
+			if (signal.aborted) return void 0;
 			const segment = await host.scrubVideoSegmentFetchTask.taskComplete;
+			if (signal.aborted) return void 0;
 			if (!initSegment || !segment) throw new Error("Scrub init segment or segment is not available");
 			const mediaEngine = await host.mediaEngineTask.taskComplete;
-			const scrubRendition = mediaEngine.getScrubVideoRendition();
-			const startTimeOffsetMs = scrubRendition?.startTimeOffsetMs;
-			const input = new BufferedSeekingInput(await new Blob([initSegment, segment]).arrayBuffer(), {
+			if (signal.aborted) return void 0;
+			const startTimeOffsetMs = mediaEngine.getScrubVideoRendition()?.startTimeOffsetMs;
+			const arrayBuffer = await new Blob([initSegment, segment]).arrayBuffer();
+			if (signal.aborted) return void 0;
+			return new BufferedSeekingInput(arrayBuffer, {
 				videoBufferSize: EFMedia.VIDEO_SAMPLE_BUFFER_SIZE,
 				audioBufferSize: EFMedia.AUDIO_SAMPLE_BUFFER_SIZE,
 				startTimeOffsetMs
 			});
-			return input;
 		}
 	});
 };