@editframe/elements 0.20.3-beta.0 → 0.21.0-beta.0

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/MediaTaskUtils.d.ts

@@ -20,4 +20,4 @@ export type SegmentFetchTask = Task<readonly [MediaEngine | undefined, number |
 /**
  * Generic task type for input creation
  */
-export type InputTask = Task<readonly [ArrayBuffer, ArrayBuffer], BufferedSeekingInput>;
+export type InputTask = Task<readonly [ArrayBuffer, ArrayBuffer], BufferedSeekingInput | undefined>;

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/RenditionHelpers.d.ts

@@ -1,12 +1,4 @@
-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;
+import { AudioRendition, VideoRendition } from '../../../transcoding/types';
 /**
  * Calculate which segment contains a given timestamp
  * Returns 1-based segment ID, or undefined if segmentDurationMs is not available

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.d.ts

@@ -1,8 +1,7 @@
 import { Task } from '@lit/task';
-import { MediaEngine, VideoRendition } from '../../../transcoding/types';
+import { MediaEngine } 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.

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

@@ -9,15 +9,6 @@ const getLatestMediaEngine = async (host, signal) => {
 	if (!mediaEngine) throw new Error("Media engine is not available");
 	return mediaEngine;
 };
-const getVideoRendition = (mediaEngine) => {
-	const videoRendition = mediaEngine.videoRendition;
-	if (!videoRendition) throw new Error("No video track available in source");
-	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() !== "") {
@@ -30,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");
@@ -57,4 +43,4 @@ const makeMediaEngineTask = (host) => {
 		}
 	});
 };
-export { getLatestMediaEngine, getVideoRendition, makeMediaEngineTask };
+export { getLatestMediaEngine, makeMediaEngineTask };

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

@@ -1,11 +1,7 @@
+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,
@@ -14,7 +10,7 @@ const makeScrubVideoBufferTask = (host) => {
 		requestQueue: []
 	};
 	return new Task(host, {
-		autoRun: false,
+		autoRun: EF_INTERACTIVE,
 		args: () => [host.mediaEngineTask.value],
 		onError: (error) => {
 			console.error("scrubVideoBufferTask error", error);
@@ -38,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,
@@ -58,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/makeScrubVideoInitSegmentFetchTask.js

@@ -1,4 +1,3 @@
-import { EF_RENDERING } from "../../../EF_RENDERING.js";
 import { getLatestMediaEngine } from "../tasks/makeMediaEngineTask.js";
 import { Task } from "@lit/task";
 const makeScrubVideoInitSegmentFetchTask = (host) => {
@@ -9,7 +8,6 @@ const makeScrubVideoInitSegmentFetchTask = (host) => {
 		},
 		onComplete: (_value) => {},
 		task: async ([_mediaEngine], { signal }) => {
-			if (EF_RENDERING()) return /* @__PURE__ */ new ArrayBuffer(0);
 			const mediaEngine = await getLatestMediaEngine(host, signal);
 			const scrubRendition = mediaEngine.getScrubVideoRendition();
 			if (!scrubRendition) throw new Error("No scrub rendition available");

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

@@ -1,4 +1,3 @@
-import { EF_RENDERING } from "../../../EF_RENDERING.js";
 import { BufferedSeekingInput } from "../BufferedSeekingInput.js";
 import { EFMedia } from "../../EFMedia.js";
 import { Task } from "@lit/task";
@@ -9,20 +8,22 @@ const makeScrubVideoInputTask = (host) => {
 			console.error("scrubVideoInputTask error", error);
 		},
 		onComplete: (_value) => {},
-		task: async () => {
-			if (EF_RENDERING()) console.info("Scrub not available in rendering mode");
+		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;
 		}
 	});
 };

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

@@ -1,6 +1,6 @@
 import { ScrubInputCache } from "./ScrubInputCache.js";
 import { Task } from "@lit/task";
-const scrubInputCache = new ScrubInputCache();
+var scrubInputCache = new ScrubInputCache();
 const makeScrubVideoSeekTask = (host) => {
 	return new Task(host, {
 		args: () => [host.desiredSeekTimeMs],
@@ -11,22 +11,21 @@ const makeScrubVideoSeekTask = (host) => {
 		task: async ([desiredSeekTimeMs], { signal }) => {
 			signal.throwIfAborted();
 			const mediaEngine = host.mediaEngineTask.value;
-			if (!mediaEngine) return void 0;
+			if (!mediaEngine) return;
 			const scrubRendition = mediaEngine.getScrubVideoRendition();
-			if (!scrubRendition) return void 0;
+			if (!scrubRendition) return;
 			const scrubRenditionWithSrc = {
 				...scrubRendition,
 				src: mediaEngine.src
 			};
 			const segmentId = mediaEngine.computeSegmentId(desiredSeekTimeMs, scrubRenditionWithSrc);
-			if (segmentId === void 0) return void 0;
-			const isCached = mediaEngine.isSegmentCached(segmentId, scrubRenditionWithSrc);
-			if (!isCached) return void 0;
+			if (segmentId === void 0) return;
+			if (!mediaEngine.isSegmentCached(segmentId, scrubRenditionWithSrc)) return;
 			signal.throwIfAborted();
 			try {
 				const scrubInput = await scrubInputCache.getOrCreateInput(segmentId, async () => {
 					const [initSegment, mediaSegment] = await Promise.all([mediaEngine.fetchInitSegment(scrubRenditionWithSrc, signal), mediaEngine.fetchMediaSegment(segmentId, scrubRenditionWithSrc)]);
-					if (!initSegment || !mediaSegment || signal.aborted) return void 0;
+					if (!initSegment || !mediaSegment || signal.aborted) return;
 					const { BufferedSeekingInput } = await import("../BufferedSeekingInput.js");
 					const { EFMedia } = await import("../../EFMedia.js");
 					return new BufferedSeekingInput(await new Blob([initSegment, mediaSegment]).arrayBuffer(), {
@@ -35,16 +34,16 @@ const makeScrubVideoSeekTask = (host) => {
 						startTimeOffsetMs: scrubRendition.startTimeOffsetMs
 					});
 				});
-				if (!scrubInput) return void 0;
+				if (!scrubInput) return;
+				if (signal.aborted) return;
 				const videoTrack = await scrubInput.getFirstVideoTrack();
-				if (!videoTrack) return void 0;
-				signal.throwIfAborted();
-				const sample = await scrubInput.seek(videoTrack.id, desiredSeekTimeMs);
-				return sample;
+				if (!videoTrack) return;
+				if (signal.aborted) return;
+				return await scrubInput.seek(videoTrack.id, desiredSeekTimeMs);
 			} catch (error) {
 				if (signal.aborted) return void 0;
 				console.warn("Failed to get scrub video sample:", error);
-				return void 0;
+				return;
 			}
 		}
 	});

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

@@ -1,4 +1,3 @@
-import { EF_RENDERING } from "../../../EF_RENDERING.js";
 import { getLatestMediaEngine } from "../tasks/makeMediaEngineTask.js";
 import { Task } from "@lit/task";
 const makeScrubVideoSegmentFetchTask = (host) => {
@@ -9,7 +8,6 @@ const makeScrubVideoSegmentFetchTask = (host) => {
 		},
 		onComplete: (_value) => {},
 		task: async (_, { signal }) => {
-			if (EF_RENDERING()) return /* @__PURE__ */ new ArrayBuffer(0);
 			const mediaEngine = await getLatestMediaEngine(host, signal);
 			const segmentId = await host.scrubVideoSegmentIdTask.taskComplete;
 			if (segmentId === void 0) throw new Error("Scrub segment ID is not available for video");

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

@@ -1,4 +1,3 @@
-import { EF_RENDERING } from "../../../EF_RENDERING.js";
 import { getLatestMediaEngine } from "../tasks/makeMediaEngineTask.js";
 import { Task } from "@lit/task";
 const makeScrubVideoSegmentIdTask = (host) => {
@@ -9,11 +8,10 @@ const makeScrubVideoSegmentIdTask = (host) => {
 		},
 		onComplete: (_value) => {},
 		task: async ([, targetSeekTimeMs], { signal }) => {
-			if (EF_RENDERING()) return void 0;
 			const mediaEngine = await getLatestMediaEngine(host, signal);
 			signal.throwIfAborted();
 			const scrubRendition = mediaEngine.getScrubVideoRendition();
-			if (!scrubRendition) return void 0;
+			if (!scrubRendition) return;
 			return mediaEngine.computeSegmentId(targetSeekTimeMs, {
 				...scrubRendition,
 				src: mediaEngine.src