@editframe/elements 0.24.1-beta.0 → 0.25.0-beta.0

package/dist/elements/EFMedia/BaseMediaEngine.js

@@ -1,21 +1,38 @@
 import { withSpan } from "../../otel/tracingHelpers.js";
 import { RequestDeduplicator } from "../../transcoding/cache/RequestDeduplicator.js";
 import { SizeAwareLRUCache } from "../../utils/LRUCache.js";
+
+//#region src/elements/EFMedia/BaseMediaEngine.ts
 const mediaCache = new SizeAwareLRUCache(100 * 1024 * 1024);
 const globalRequestDeduplicator = new RequestDeduplicator();
 var BaseMediaEngine = class {
 	constructor(host) {
 		this.host = host;
 	}
+	/**
+	* Get video rendition if available. Returns undefined for audio-only assets.
+	* Callers should handle undefined gracefully.
+	*/
 	getVideoRendition() {
 		return this.videoRendition;
 	}
+	/**
+	* Get audio rendition if available. Returns undefined for video-only assets.
+	* Callers should handle undefined gracefully.
+	*/
 	getAudioRendition() {
 		return this.audioRendition;
 	}
+	/**
+	* Generate cache key for segment requests
+	*/
 	getSegmentCacheKey(segmentId, rendition) {
 		return `${rendition.src}-${rendition.id}-${segmentId}-${rendition.trackId}`;
 	}
+	/**
+	* Unified fetch method with caching and global deduplication
+	* All requests (media, manifest, init segments) go through this method
+	*/
 	async fetchWithCache(url, options) {
 		return withSpan("mediaEngine.fetchWithCache", {
 			url: url.length > 100 ? `${url.substring(0, 100)}...` : url,
@@ -74,6 +91,11 @@ var BaseMediaEngine = class {
 			return result;
 		});
 	}
+	/**
+	* Handles abort logic for a cached request without affecting the underlying fetch
+	* This allows multiple instances to share the same cached request while each
+	* manages their own abort behavior
+	*/
 	handleAbortForCachedRequest(promise, signal) {
 		if (signal.aborted) throw new DOMException("Aborted", "AbortError");
 		return Promise.race([promise, new Promise((_, reject) => {
@@ -113,22 +135,39 @@ var BaseMediaEngine = class {
 	async fetchMediaCacheWithHeaders(url, headers, signal) {
 		return this.fetchMediaWithHeaders(url, headers, signal);
 	}
+	/**
+	* Fetch media segment with built-in deduplication
+	* Now uses global deduplication for all requests
+	*/
 	async fetchMediaSegmentWithDeduplication(segmentId, rendition, _signal) {
 		const cacheKey = this.getSegmentCacheKey(segmentId, rendition);
 		return globalRequestDeduplicator.executeRequest(cacheKey, async () => {
 			return this.fetchMediaSegment(segmentId, rendition);
 		});
 	}
+	/**
+	* Check if a segment is currently being fetched
+	*/
 	isSegmentBeingFetched(segmentId, rendition) {
 		const cacheKey = this.getSegmentCacheKey(segmentId, rendition);
 		return globalRequestDeduplicator.isPending(cacheKey);
 	}
+	/**
+	* Get count of active segment requests (for debugging/monitoring)
+	*/
 	getActiveSegmentRequestCount() {
 		return globalRequestDeduplicator.getPendingCount();
 	}
+	/**
+	* Cancel all active segment requests (for cleanup)
+	*/
 	cancelAllSegmentRequests() {
 		globalRequestDeduplicator.clear();
 	}
+	/**
+	* Calculate audio segments needed for a time range
+	* Each media engine implements this based on their segment structure
+	*/
 	calculateAudioSegmentRange(fromMs, toMs, rendition, durationMs) {
 		if (fromMs >= toMs) return [];
 		const segments = [];
@@ -166,6 +205,10 @@ var BaseMediaEngine = class {
 		}
 		return segments;
 	}
+	/**
+	* Check if a segment is cached for a given rendition
+	* This needs to check the URL-based cache since that's where segments are actually stored
+	*/
 	isSegmentCached(segmentId, rendition) {
 		try {
 			const maybeJitEngine = this;
@@ -181,13 +224,23 @@ var BaseMediaEngine = class {
 			return false;
 		}
 	}
+	/**
+	* Get cached segment IDs from a list for a given rendition
+	*/
 	getCachedSegments(segmentIds, rendition) {
 		return new Set(segmentIds.filter((id) => this.isSegmentCached(id, rendition)));
 	}
+	/**
+	* Extract thumbnail canvases at multiple timestamps efficiently
+	* Default implementation provides helpful error information
+	*/
 	async extractThumbnails(timestamps) {
 		const engineName = this.constructor.name;
 		console.warn(`${engineName}: extractThumbnails not properly implemented. This MediaEngine type does not support thumbnail generation. Supported engines: JitMediaEngine. Requested ${timestamps.length} thumbnail${timestamps.length === 1 ? "" : "s"}.`);
 		return timestamps.map(() => null);
 	}
 };
+
+//#endregion
 export { BaseMediaEngine };
+//# sourceMappingURL=BaseMediaEngine.js.map

package/dist/elements/EFMedia/BaseMediaEngine.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BaseMediaEngine.js","names":["result","tEnd","segments: SegmentTimeRange[]"],"sources":["../../../src/elements/EFMedia/BaseMediaEngine.ts"],"sourcesContent":["import { withSpan } from \"../../otel/tracingHelpers.js\";\nimport { RequestDeduplicator } from \"../../transcoding/cache/RequestDeduplicator.js\";\nimport type {\n  AudioRendition,\n  SegmentTimeRange,\n  ThumbnailResult,\n  VideoRendition,\n} from \"../../transcoding/types\";\nimport { SizeAwareLRUCache } from \"../../utils/LRUCache.js\";\nimport type { EFMedia } from \"../EFMedia.js\";\nimport type { MediaRendition } from \"./shared/MediaTaskUtils.js\";\n\n// Global instances shared across all media engines\nexport const mediaCache = new SizeAwareLRUCache<string>(100 * 1024 * 1024); // 100MB cache limit\nexport const globalRequestDeduplicator = new RequestDeduplicator();\n\nexport abstract class BaseMediaEngine {\n  protected host: EFMedia;\n\n  constructor(host: EFMedia) {\n    this.host = host;\n  }\n\n  abstract get videoRendition(): VideoRendition | undefined;\n  abstract get audioRendition(): AudioRendition | undefined;\n\n  /**\n   * Get video rendition if available. Returns undefined for audio-only assets.\n   * Callers should handle undefined gracefully.\n   */\n  getVideoRendition(): VideoRendition | undefined {\n    return this.videoRendition;\n  }\n\n  /**\n   * Get audio rendition if available. Returns undefined for video-only assets.\n   * Callers should handle undefined gracefully.\n   */\n  getAudioRendition(): AudioRendition | undefined {\n    return this.audioRendition;\n  }\n\n  /**\n   * Generate cache key for segment requests\n   */\n  private getSegmentCacheKey(\n    segmentId: number,\n    rendition: { src: string; trackId: number | undefined; id?: string },\n  ): string {\n    return `${rendition.src}-${rendition.id}-${segmentId}-${rendition.trackId}`;\n  }\n\n  /**\n   * Unified fetch method with caching and global deduplication\n   * All requests (media, manifest, init segments) go through this method\n   */\n  protected async fetchWithCache(\n    url: string,\n    options: {\n      responseType: \"arrayBuffer\" | \"json\";\n      headers?: Record<string, string>;\n      signal?: AbortSignal;\n    },\n  ): Promise<any> {\n    return withSpan(\n      \"mediaEngine.fetchWithCache\",\n      {\n        url: url.length > 100 ? `${url.substring(0, 100)}...` : url,\n        responseType: options.responseType,\n        hasHeaders: !!options.headers,\n      },\n      undefined,\n      async (span) => {\n        const t0 = performance.now();\n        const { responseType, headers, signal } = options;\n\n        // Create cache key that includes URL and headers for proper isolation\n        // Note: We don't include signal in cache key as it would prevent proper deduplication\n        const cacheKey = headers ? `${url}:${JSON.stringify(headers)}` : url;\n\n        // Check cache first\n        const t1 = performance.now();\n        const cached = mediaCache.get(cacheKey);\n        const t2 = performance.now();\n        span.setAttribute(\"cacheLookupMs\", Math.round((t2 - t1) * 1000) / 1000);\n\n        if (cached) {\n          span.setAttribute(\"cacheHit\", true);\n          // If we have a cached promise, we need to handle the caller's abort signal\n          // without affecting the underlying request that other instances might be using\n          if (signal) {\n            const t3 = performance.now();\n            const result = await this.handleAbortForCachedRequest(\n              cached,\n              signal,\n            );\n            const t4 = performance.now();\n            span.setAttribute(\n              \"handleAbortMs\",\n              Math.round((t4 - t3) * 100) / 100,\n            );\n            span.setAttribute(\n              \"totalCacheHitMs\",\n              Math.round((t4 - t0) * 100) / 100,\n            );\n            return result;\n          }\n          span.setAttribute(\n            \"totalCacheHitMs\",\n            Math.round((t2 - t0) * 100) / 100,\n          );\n          return cached;\n        }\n\n        span.setAttribute(\"cacheHit\", false);\n\n        // Use global deduplicator to prevent concurrent requests for the same resource\n        // Note: We do NOT pass the signal to the deduplicator - each caller manages their own abort\n        const promise = globalRequestDeduplicator.executeRequest(\n          cacheKey,\n          async () => {\n            const fetchStart = performance.now();\n            try {\n              // Make the fetch request WITHOUT the signal - let each caller handle their own abort\n              // This prevents one instance's abort from affecting other instances using the shared cache\n              const response = await this.host.fetch(url, { headers });\n              const fetchEnd = performance.now();\n              span.setAttribute(\"fetchMs\", fetchEnd - fetchStart);\n\n              if (responseType === \"json\") {\n                return response.json();\n              }\n              const buffer = await response.arrayBuffer();\n              span.setAttribute(\"sizeBytes\", buffer.byteLength);\n              return buffer;\n            } catch (error) {\n              // If the request was aborted, don't cache the error\n              if (\n                error instanceof DOMException &&\n                error.name === \"AbortError\"\n              ) {\n                // Remove from cache so other requests can retry\n                mediaCache.delete(cacheKey);\n              }\n              throw error;\n            }\n          },\n        );\n\n        // Cache the promise (not the result) to handle concurrent requests\n        mediaCache.set(cacheKey, promise);\n\n        // Handle the case where the promise might be aborted\n        promise.catch((error) => {\n          // If the request was aborted, remove it from cache to prevent corrupted data\n          if (error instanceof DOMException && error.name === \"AbortError\") {\n            mediaCache.delete(cacheKey);\n          }\n        });\n\n        // If the caller has a signal, handle abort logic without affecting the underlying request\n        if (signal) {\n          const result = await this.handleAbortForCachedRequest(\n            promise,\n            signal,\n          );\n          const tEnd = performance.now();\n          span.setAttribute(\n            \"totalFetchMs\",\n            Math.round((tEnd - t0) * 100) / 100,\n          );\n          return result;\n        }\n\n        const result = await promise;\n        const tEnd = performance.now();\n        span.setAttribute(\"totalFetchMs\", Math.round((tEnd - t0) * 100) / 100);\n        return result;\n      },\n    );\n  }\n\n  /**\n   * Handles abort logic for a cached request without affecting the underlying fetch\n   * This allows multiple instances to share the same cached request while each\n   * manages their own abort behavior\n   */\n  private handleAbortForCachedRequest<T>(\n    promise: Promise<T>,\n    signal: AbortSignal,\n  ): Promise<T> {\n    // If signal is already aborted, reject immediately\n    if (signal.aborted) {\n      throw new DOMException(\"Aborted\", \"AbortError\");\n    }\n\n    // Return a promise that respects the caller's abort signal\n    // but doesn't affect the underlying cached request\n    return Promise.race([\n      promise,\n      new Promise<never>((_, reject) => {\n        signal.addEventListener(\"abort\", () => {\n          reject(new DOMException(\"Aborted\", \"AbortError\"));\n        });\n      }),\n    ]);\n  }\n\n  // Public wrapper methods that delegate to fetchWithCache\n  async fetchMedia(url: string, signal?: AbortSignal): Promise<ArrayBuffer> {\n    // Check abort signal immediately before any processing\n    if (signal?.aborted) {\n      throw new DOMException(\"Aborted\", \"AbortError\");\n    }\n    return this.fetchWithCache(url, { responseType: \"arrayBuffer\", signal });\n  }\n\n  async fetchManifest(url: string, signal?: AbortSignal): Promise<any> {\n    // Check abort signal immediately before any processing\n    if (signal?.aborted) {\n      throw new DOMException(\"Aborted\", \"AbortError\");\n    }\n    return this.fetchWithCache(url, { responseType: \"json\", signal });\n  }\n\n  async fetchMediaWithHeaders(\n    url: string,\n    headers: Record<string, string>,\n    signal?: AbortSignal,\n  ): Promise<ArrayBuffer> {\n    // Check abort signal immediately before any processing\n    if (signal?.aborted) {\n      throw new DOMException(\"Aborted\", \"AbortError\");\n    }\n    return this.fetchWithCache(url, {\n      responseType: \"arrayBuffer\",\n      headers,\n      signal,\n    });\n  }\n\n  // Legacy methods for backward compatibility\n  async fetchMediaCache(\n    url: string,\n    signal?: AbortSignal,\n  ): Promise<ArrayBuffer> {\n    return this.fetchMedia(url, signal);\n  }\n\n  async fetchManifestCache(url: string, signal?: AbortSignal): Promise<any> {\n    return this.fetchManifest(url, signal);\n  }\n\n  async fetchMediaCacheWithHeaders(\n    url: string,\n    headers: Record<string, string>,\n    signal?: AbortSignal,\n  ): Promise<ArrayBuffer> {\n    return this.fetchMediaWithHeaders(url, headers, signal);\n  }\n\n  /**\n   * Abstract method for actual segment fetching - implemented by subclasses\n   */\n  abstract fetchMediaSegment(\n    segmentId: number,\n    rendition: { trackId: number | undefined; src: string },\n  ): Promise<ArrayBuffer>;\n\n  abstract fetchInitSegment(\n    rendition: { trackId: number | undefined; src: string },\n    signal: AbortSignal,\n  ): Promise<ArrayBuffer>;\n\n  abstract computeSegmentId(\n    desiredSeekTimeMs: number,\n    rendition: MediaRendition,\n  ): number | undefined;\n\n  /**\n   * Fetch media segment with built-in deduplication\n   * Now uses global deduplication for all requests\n   */\n  async fetchMediaSegmentWithDeduplication(\n    segmentId: number,\n    rendition: { trackId: number | undefined; src: string },\n    _signal?: AbortSignal,\n  ): Promise<ArrayBuffer> {\n    const cacheKey = this.getSegmentCacheKey(segmentId, rendition);\n\n    return globalRequestDeduplicator.executeRequest(cacheKey, async () => {\n      return this.fetchMediaSegment(segmentId, rendition);\n    });\n  }\n\n  /**\n   * Check if a segment is currently being fetched\n   */\n  isSegmentBeingFetched(\n    segmentId: number,\n    rendition: { src: string; trackId: number | undefined },\n  ): boolean {\n    const cacheKey = this.getSegmentCacheKey(segmentId, rendition);\n    return globalRequestDeduplicator.isPending(cacheKey);\n  }\n\n  /**\n   * Get count of active segment requests (for debugging/monitoring)\n   */\n  getActiveSegmentRequestCount(): number {\n    return globalRequestDeduplicator.getPendingCount();\n  }\n\n  /**\n   * Cancel all active segment requests (for cleanup)\n   */\n  cancelAllSegmentRequests(): void {\n    globalRequestDeduplicator.clear();\n  }\n\n  /**\n   * Calculate audio segments needed for a time range\n   * Each media engine implements this based on their segment structure\n   */\n  calculateAudioSegmentRange(\n    fromMs: number,\n    toMs: number,\n    rendition: AudioRendition,\n    durationMs: number,\n  ): SegmentTimeRange[] {\n    // Default implementation for uniform segments (used by JitMediaEngine)\n    if (fromMs >= toMs) {\n      return [];\n    }\n\n    const segments: SegmentTimeRange[] = [];\n\n    // Use actual segment durations if available (more accurate)\n    if (\n      rendition.segmentDurationsMs &&\n      rendition.segmentDurationsMs.length > 0\n    ) {\n      let cumulativeTime = 0;\n\n      for (let i = 0; i < rendition.segmentDurationsMs.length; i++) {\n        const segmentDuration = rendition.segmentDurationsMs[i];\n        if (segmentDuration === undefined) {\n          continue; // Skip undefined segment durations\n        }\n        const segmentStartMs = cumulativeTime;\n        const segmentEndMs = Math.min(\n          cumulativeTime + segmentDuration,\n          durationMs,\n        );\n\n        // Don't include segments that start at or beyond the file duration\n        if (segmentStartMs >= durationMs) {\n          break;\n        }\n\n        // Only include segments that overlap with requested time range\n        if (segmentStartMs < toMs && segmentEndMs > fromMs) {\n          segments.push({\n            segmentId: i + 1, // Convert to 1-based\n            startMs: segmentStartMs,\n            endMs: segmentEndMs,\n          });\n        }\n\n        cumulativeTime += segmentDuration;\n\n        // If we've reached or exceeded file duration, stop\n        if (cumulativeTime >= durationMs) {\n          break;\n        }\n      }\n\n      return segments;\n    }\n\n    // Fall back to fixed duration calculation for backward compatibility\n    const segmentDurationMs = rendition.segmentDurationMs || 1000;\n    const startSegmentIndex = Math.floor(fromMs / segmentDurationMs);\n    const endSegmentIndex = Math.floor(toMs / segmentDurationMs);\n\n    for (let i = startSegmentIndex; i <= endSegmentIndex; i++) {\n      const segmentId = i + 1; // Convert to 1-based\n      const segmentStartMs = i * segmentDurationMs;\n      const segmentEndMs = Math.min((i + 1) * segmentDurationMs, durationMs);\n\n      // Don't include segments that start at or beyond the file duration\n      if (segmentStartMs >= durationMs) {\n        break;\n      }\n\n      // Only include segments that overlap with requested time range\n      if (segmentStartMs < toMs && segmentEndMs > fromMs) {\n        segments.push({\n          segmentId,\n          startMs: segmentStartMs,\n          endMs: segmentEndMs,\n        });\n      }\n    }\n\n    return segments;\n  }\n\n  /**\n   * Check if a segment is cached for a given rendition\n   * This needs to check the URL-based cache since that's where segments are actually stored\n   */\n  isSegmentCached(\n    segmentId: number,\n    rendition: AudioRendition | VideoRendition,\n  ): boolean {\n    try {\n      // Check if this is a JIT engine by looking for urlGenerator property\n      const maybeJitEngine = this as any;\n      if (\n        maybeJitEngine.urlGenerator &&\n        typeof maybeJitEngine.urlGenerator.generateSegmentUrl === \"function\"\n      ) {\n        // This is a JIT engine - generate the URL and check URL-based cache\n        if (!rendition.id) {\n          return false;\n        }\n\n        const segmentUrl = maybeJitEngine.urlGenerator.generateSegmentUrl(\n          segmentId,\n          rendition.id,\n          maybeJitEngine,\n        );\n        const urlIsCached = mediaCache.has(segmentUrl);\n\n        return urlIsCached;\n      }\n      // For other engine types, fall back to the old segment-based key approach\n      const cacheKey = `${rendition.src}-${rendition.id || \"default\"}-${segmentId}-${rendition.trackId}`;\n      const isCached = mediaCache.has(cacheKey);\n      return isCached;\n    } catch (error) {\n      console.warn(\n        `🎬 BaseMediaEngine: Error checking if segment ${segmentId} is cached:`,\n        error,\n      );\n      return false;\n    }\n  }\n\n  /**\n   * Get cached segment IDs from a list for a given rendition\n   */\n  getCachedSegments(\n    segmentIds: number[],\n    rendition: AudioRendition | VideoRendition,\n  ): Set<number> {\n    return new Set(\n      segmentIds.filter((id) => this.isSegmentCached(id, rendition)),\n    );\n  }\n\n  /**\n   * Extract thumbnail canvases at multiple timestamps efficiently\n   * Default implementation provides helpful error information\n   */\n  async extractThumbnails(\n    timestamps: number[],\n  ): Promise<(ThumbnailResult | null)[]> {\n    const engineName = this.constructor.name;\n    console.warn(\n      `${engineName}: extractThumbnails not properly implemented. ` +\n        \"This MediaEngine type does not support thumbnail generation. \" +\n        \"Supported engines: JitMediaEngine. \" +\n        `Requested ${timestamps.length} thumbnail${timestamps.length === 1 ? \"\" : \"s\"}.`,\n    );\n    return timestamps.map(() => null);\n  }\n\n  abstract convertToSegmentRelativeTimestamps(\n    globalTimestamps: number[],\n    segmentId: number,\n    rendition: VideoRendition,\n  ): number[];\n}\n"],"mappings":"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"}

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

@@ -1,49 +1,50 @@
-import { AudioSampleSink, InputAudioTrack, InputTrack, InputVideoTrack, VideoSampleSink } from 'mediabunny';
-import { MediaSample, SampleBuffer } from '../SampleBuffer';
+import { MediaSample, SampleBuffer } from "../SampleBuffer.js";
+import * as mediabunny3 from "mediabunny";
+import { AudioSampleSink, InputAudioTrack, InputTrack, InputVideoTrack, VideoSampleSink } from "mediabunny";
+
+//#region src/elements/EFMedia/BufferedSeekingInput.d.ts
 interface BufferedSeekingInputOptions {
-    videoBufferSize?: number;
-    audioBufferSize?: number;
-    /**
-     * Timeline offset in milliseconds to map user timeline to media timeline.
-     * Applied during seeking to handle media that doesn't start at 0ms.
-     */
-    startTimeOffsetMs?: number;
+  videoBufferSize?: number;
+  audioBufferSize?: number;
+  /**
+   * Timeline offset in milliseconds to map user timeline to media timeline.
+   * Applied during seeking to handle media that doesn't start at 0ms.
+   */
+  startTimeOffsetMs?: number;
 }
-export declare class NoSample extends RangeError {
+declare class BufferedSeekingInput {
+  #private;
+  private input;
+  private trackIterators;
+  private trackBuffers;
+  private options;
+  private trackIteratorCreationPromises;
+  private trackSeekPromises;
+  /**
+   * Timeline offset in milliseconds to map user timeline to media timeline.
+   * Applied during seeking to handle media that doesn't start at 0ms.
+   */
+  private readonly startTimeOffsetMs;
+  constructor(arrayBuffer: ArrayBuffer, options?: BufferedSeekingInputOptions);
+  getBufferSize(trackId: number): number;
+  getBufferContents(trackId: number): readonly MediaSample[];
+  getBufferTimestamps(trackId: number): number[];
+  clearBuffer(trackId: number): void;
+  computeDuration(): Promise<number>;
+  getTrack(trackId: number): Promise<InputTrack>;
+  getAudioTrack(trackId: number): Promise<InputAudioTrack>;
+  getVideoTrack(trackId: number): Promise<InputVideoTrack>;
+  getFirstVideoTrack(): Promise<InputVideoTrack | undefined>;
+  getFirstAudioTrack(): Promise<InputAudioTrack | undefined>;
+  getTrackIterator(track: InputTrack): AsyncIterator<MediaSample, any, any>;
+  createTrackSampleSink(track: InputTrack): AudioSampleSink | VideoSampleSink;
+  createTrackIterator(track: InputTrack): AsyncGenerator<mediabunny3.VideoSample, void, unknown> | AsyncGenerator<mediabunny3.AudioSample, void, unknown>;
+  createTrackBuffer(track: InputTrack): SampleBuffer;
+  getTrackBuffer(track: InputTrack): SampleBuffer;
+  seek(trackId: number, timeMs: number): Promise<MediaSample | undefined>;
+  private resetIterator;
+  private seekSafe;
 }
-export declare class ConcurrentSeekError extends RangeError {
-}
-export declare class BufferedSeekingInput {
-    #private;
-    private input;
-    private trackIterators;
-    private trackBuffers;
-    private options;
-    private trackIteratorCreationPromises;
-    private trackSeekPromises;
-    /**
-     * Timeline offset in milliseconds to map user timeline to media timeline.
-     * Applied during seeking to handle media that doesn't start at 0ms.
-     */
-    private readonly startTimeOffsetMs;
-    constructor(arrayBuffer: ArrayBuffer, options?: BufferedSeekingInputOptions);
-    getBufferSize(trackId: number): number;
-    getBufferContents(trackId: number): readonly MediaSample[];
-    getBufferTimestamps(trackId: number): number[];
-    clearBuffer(trackId: number): void;
-    computeDuration(): Promise<number>;
-    getTrack(trackId: number): Promise<InputTrack>;
-    getAudioTrack(trackId: number): Promise<InputAudioTrack>;
-    getVideoTrack(trackId: number): Promise<InputVideoTrack>;
-    getFirstVideoTrack(): Promise<InputVideoTrack | undefined>;
-    getFirstAudioTrack(): Promise<InputAudioTrack | undefined>;
-    getTrackIterator(track: InputTrack): AsyncIterator<MediaSample, any, any>;
-    createTrackSampleSink(track: InputTrack): AudioSampleSink | VideoSampleSink;
-    createTrackIterator(track: InputTrack): AsyncGenerator<import('mediabunny').VideoSample, void, unknown> | AsyncGenerator<import('mediabunny').AudioSample, void, unknown>;
-    createTrackBuffer(track: InputTrack): SampleBuffer;
-    getTrackBuffer(track: InputTrack): SampleBuffer;
-    seek(trackId: number, timeMs: number): Promise<MediaSample | undefined>;
-    private resetIterator;
-    private seekSafe;
-}
-export {};
+//#endregion
+export { BufferedSeekingInput };
+//# sourceMappingURL=BufferedSeekingInput.d.ts.map

package/dist/elements/EFMedia/BufferedSeekingInput.js

@@ -2,7 +2,9 @@ import { withSpan } from "../../otel/tracingHelpers.js";
 import { roundToMilliseconds } from "./shared/PrecisionUtils.js";
 import { SampleBuffer } from "../SampleBuffer.js";
 import { AudioSampleSink, BufferSource, Input, InputAudioTrack, InputVideoTrack, MP4, VideoSampleSink } from "mediabunny";
-var defaultOptions = {
+
+//#region src/elements/EFMedia/BufferedSeekingInput.ts
+const defaultOptions = {
 	videoBufferSize: 30,
 	audioBufferSize: 100,
 	startTimeOffsetMs: 0
@@ -230,4 +232,7 @@ var BufferedSeekingInput = class {
 		});
 	}
 };
+
+//#endregion
 export { BufferedSeekingInput };
+//# sourceMappingURL=BufferedSeekingInput.js.map

package/dist/elements/EFMedia/BufferedSeekingInput.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BufferedSeekingInput.js","names":["defaultOptions: BufferedSeekingInputOptions","track","bufferSize","#seekLock","contents"],"sources":["../../../src/elements/EFMedia/BufferedSeekingInput.ts"],"sourcesContent":["import {\n  AudioSampleSink,\n  BufferSource,\n  Input,\n  InputAudioTrack,\n  type InputTrack,\n  InputVideoTrack,\n  MP4,\n  VideoSampleSink,\n} from \"mediabunny\";\nimport { withSpan } from \"../../otel/tracingHelpers.js\";\nimport { type MediaSample, SampleBuffer } from \"../SampleBuffer\";\nimport { roundToMilliseconds } from \"./shared/PrecisionUtils\";\n\ninterface BufferedSeekingInputOptions {\n  videoBufferSize?: number;\n  audioBufferSize?: number;\n  /**\n   * Timeline offset in milliseconds to map user timeline to media timeline.\n   * Applied during seeking to handle media that doesn't start at 0ms.\n   */\n  startTimeOffsetMs?: number;\n}\n\nconst defaultOptions: BufferedSeekingInputOptions = {\n  videoBufferSize: 30,\n  audioBufferSize: 100,\n  startTimeOffsetMs: 0,\n};\n\nexport class NoSample extends RangeError {}\n\nexport class ConcurrentSeekError extends RangeError {}\n\nexport class BufferedSeekingInput {\n  private input: Input;\n  private trackIterators: Map<number, AsyncIterator<MediaSample>> = new Map();\n  private trackBuffers: Map<number, SampleBuffer> = new Map();\n  private options: BufferedSeekingInputOptions;\n  // Separate locks for different operation types to prevent unnecessary blocking\n  private trackIteratorCreationPromises: Map<number, Promise<any>> = new Map();\n  private trackSeekPromises: Map<number, Promise<any>> = new Map();\n\n  /**\n   * Timeline offset in milliseconds to map user timeline to media timeline.\n   * Applied during seeking to handle media that doesn't start at 0ms.\n   */\n  private readonly startTimeOffsetMs: number;\n\n  constructor(arrayBuffer: ArrayBuffer, options?: BufferedSeekingInputOptions) {\n    const bufferSource = new BufferSource(arrayBuffer);\n    const input = new Input({\n      source: bufferSource,\n      formats: [MP4],\n    });\n    this.input = input;\n    this.options = { ...defaultOptions, ...options };\n    this.startTimeOffsetMs = this.options.startTimeOffsetMs ?? 0;\n  }\n\n  // Buffer inspection API for testing\n  getBufferSize(trackId: number): number {\n    const buffer = this.trackBuffers.get(trackId);\n    return buffer ? buffer.length : 0;\n  }\n\n  getBufferContents(trackId: number): readonly MediaSample[] {\n    const buffer = this.trackBuffers.get(trackId);\n    return buffer ? Object.freeze([...buffer.getContents()]) : [];\n  }\n\n  getBufferTimestamps(trackId: number): number[] {\n    const contents = this.getBufferContents(trackId);\n    return contents.map((sample) => sample.timestamp || 0);\n  }\n\n  clearBuffer(trackId: number): void {\n    const buffer = this.trackBuffers.get(trackId);\n    if (buffer) {\n      buffer.clear();\n    }\n  }\n\n  computeDuration() {\n    return this.input.computeDuration();\n  }\n\n  async getTrack(trackId: number) {\n    const tracks = await this.input.getTracks();\n    const track = tracks.find((track) => track.id === trackId);\n    if (!track) {\n      throw new Error(`Track ${trackId} not found`);\n    }\n    return track;\n  }\n\n  async getAudioTrack(trackId: number) {\n    const tracks = await this.input.getAudioTracks();\n    const track = tracks.find(\n      (track) => track.id === trackId && track.type === \"audio\",\n    );\n    if (!track) {\n      throw new Error(`Track ${trackId} not found`);\n    }\n    return track;\n  }\n\n  async getVideoTrack(trackId: number) {\n    const tracks = await this.input.getVideoTracks();\n    const track = tracks.find(\n      (track) => track.id === trackId && track.type === \"video\",\n    );\n    if (!track) {\n      throw new Error(`Track ${trackId} not found`);\n    }\n    return track;\n  }\n\n  async getFirstVideoTrack() {\n    const tracks = await this.input.getVideoTracks();\n    return tracks[0];\n  }\n\n  async getFirstAudioTrack() {\n    const tracks = await this.input.getAudioTracks();\n    return tracks[0];\n  }\n\n  getTrackIterator(track: InputTrack) {\n    if (this.trackIterators.has(track.id)) {\n      // biome-ignore lint/style/noNonNullAssertion: we know the map has the key\n      return this.trackIterators.get(track.id)!;\n    }\n\n    const trackIterator = this.createTrackIterator(track);\n\n    this.trackIterators.set(track.id, trackIterator);\n\n    return trackIterator;\n  }\n\n  createTrackSampleSink(track: InputTrack) {\n    if (track instanceof InputAudioTrack) {\n      return new AudioSampleSink(track);\n    }\n    if (track instanceof InputVideoTrack) {\n      return new VideoSampleSink(track);\n    }\n    throw new Error(`Unsupported track type ${track.type}`);\n  }\n\n  createTrackIterator(track: InputTrack) {\n    const sampleSink = this.createTrackSampleSink(track);\n    return sampleSink.samples();\n  }\n\n  createTrackBuffer(track: InputTrack) {\n    if (track.type === \"audio\") {\n      const bufferSize = this.options.audioBufferSize;\n      const sampleBuffer = new SampleBuffer(bufferSize);\n      return sampleBuffer;\n    }\n    const bufferSize = this.options.videoBufferSize;\n    const sampleBuffer = new SampleBuffer(bufferSize);\n    return sampleBuffer;\n  }\n\n  getTrackBuffer(track: InputTrack) {\n    const maybeTrackBuffer = this.trackBuffers.get(track.id);\n\n    if (maybeTrackBuffer) {\n      return maybeTrackBuffer;\n    }\n\n    const trackBuffer = this.createTrackBuffer(track);\n    this.trackBuffers.set(track.id, trackBuffer);\n    return trackBuffer;\n  }\n\n  async seek(trackId: number, timeMs: number) {\n    return withSpan(\n      \"bufferedInput.seek\",\n      {\n        trackId,\n        timeMs,\n        startTimeOffsetMs: this.startTimeOffsetMs,\n      },\n      undefined,\n      async (span) => {\n        // Apply timeline offset to map user timeline to media timeline\n        const mediaTimeMs = timeMs + this.startTimeOffsetMs;\n\n        // Round using consistent precision handling\n        const roundedMediaTimeMs = roundToMilliseconds(mediaTimeMs);\n        span.setAttribute(\"roundedMediaTimeMs\", roundedMediaTimeMs);\n\n        // Serialize seek operations per track (but don't block iterator creation)\n        const existingSeek = this.trackSeekPromises.get(trackId);\n        if (existingSeek) {\n          span.setAttribute(\"waitedForExistingSeek\", true);\n          await existingSeek;\n        }\n\n        const seekPromise = this.seekSafe(trackId, roundedMediaTimeMs);\n        this.trackSeekPromises.set(trackId, seekPromise);\n\n        try {\n          return await seekPromise;\n        } finally {\n          this.trackSeekPromises.delete(trackId);\n        }\n      },\n    );\n  }\n\n  private async resetIterator(track: InputTrack) {\n    const trackBuffer = this.trackBuffers.get(track.id);\n    trackBuffer?.clear();\n    // Clean up iterator safely - wait for any ongoing iterator creation\n    const ongoingIteratorCreation = this.trackIteratorCreationPromises.get(\n      track.id,\n    );\n    if (ongoingIteratorCreation) {\n      await ongoingIteratorCreation;\n    }\n\n    const iterator = this.trackIterators.get(track.id);\n    if (iterator) {\n      try {\n        await iterator.return?.();\n      } catch (_error) {\n        // Iterator cleanup failed, continue anyway\n      }\n    }\n    this.trackIterators.delete(track.id);\n  }\n\n  #seekLock?: PromiseWithResolvers<void>;\n\n  private async seekSafe(trackId: number, timeMs: number) {\n    return withSpan(\n      \"bufferedInput.seekSafe\",\n      {\n        trackId,\n        timeMs,\n      },\n      undefined,\n      async (span) => {\n        if (this.#seekLock) {\n          span.setAttribute(\"waitedForSeekLock\", true);\n          await this.#seekLock.promise;\n        }\n        const seekLock = Promise.withResolvers<void>();\n        this.#seekLock = seekLock;\n\n        try {\n          const track = await this.getTrack(trackId);\n          span.setAttribute(\"trackType\", track.type);\n\n          const trackBuffer = this.getTrackBuffer(track);\n\n          const roundedTimeMs = roundToMilliseconds(timeMs);\n          const firstTimestampMs = roundToMilliseconds(\n            (await track.getFirstTimestamp()) * 1000,\n          );\n          span.setAttribute(\"firstTimestampMs\", firstTimestampMs);\n\n          if (roundedTimeMs < firstTimestampMs) {\n            console.error(\"Seeking outside bounds of input\", {\n              roundedTimeMs,\n              firstTimestampMs,\n            });\n            throw new NoSample(\n              `Seeking outside bounds of input ${roundedTimeMs} < ${firstTimestampMs}`,\n            );\n          }\n\n          // Check if we need to reset iterator for seeks outside current buffer range\n          const bufferContents = trackBuffer.getContents();\n          span.setAttribute(\"bufferContentsLength\", bufferContents.length);\n\n          if (bufferContents.length > 0) {\n            const bufferStartMs = roundToMilliseconds(\n              trackBuffer.firstTimestamp * 1000,\n            );\n            span.setAttribute(\"bufferStartMs\", bufferStartMs);\n\n            if (roundedTimeMs < bufferStartMs) {\n              span.setAttribute(\"resetIterator\", true);\n              await this.resetIterator(track);\n            }\n          }\n\n          const alreadyInBuffer = trackBuffer.find(timeMs);\n          if (alreadyInBuffer) {\n            span.setAttribute(\"foundInBuffer\", true);\n            span.setAttribute(\"bufferSize\", trackBuffer.length);\n            const contents = trackBuffer.getContents();\n            if (contents.length > 0) {\n              span.setAttribute(\n                \"bufferTimestamps\",\n                contents\n                  .map((s) => Math.round((s.timestamp || 0) * 1000))\n                  .slice(0, 10)\n                  .join(\",\"),\n              );\n            }\n            return alreadyInBuffer;\n          }\n\n          // Buffer miss - record buffer state\n          span.setAttribute(\"foundInBuffer\", false);\n          span.setAttribute(\"bufferSize\", trackBuffer.length);\n          span.setAttribute(\"requestedTimeMs\", Math.round(timeMs));\n\n          const contents = trackBuffer.getContents();\n          if (contents.length > 0) {\n            const firstSample = contents[0];\n            const lastSample = contents[contents.length - 1];\n            if (firstSample && lastSample) {\n              const bufferStartMs = Math.round(\n                (firstSample.timestamp || 0) * 1000,\n              );\n              const bufferEndMs = Math.round(\n                ((lastSample.timestamp || 0) + (lastSample.duration || 0)) *\n                  1000,\n              );\n              span.setAttribute(\"bufferStartMs\", bufferStartMs);\n              span.setAttribute(\"bufferEndMs\", bufferEndMs);\n              span.setAttribute(\n                \"bufferRangeMs\",\n                `${bufferStartMs}-${bufferEndMs}`,\n              );\n            }\n          }\n\n          const iterator = this.getTrackIterator(track);\n          let iterationCount = 0;\n          const decodeStart = performance.now();\n\n          while (true) {\n            iterationCount++;\n            const iterStart = performance.now();\n            const { done, value: decodedSample } = await iterator.next();\n            const iterEnd = performance.now();\n\n            // Record individual iteration timing for first 5 iterations\n            if (iterationCount <= 5) {\n              span.setAttribute(\n                `iter${iterationCount}Ms`,\n                Math.round((iterEnd - iterStart) * 100) / 100,\n              );\n            }\n\n            if (decodedSample) {\n              trackBuffer.push(decodedSample);\n              if (iterationCount <= 5) {\n                span.setAttribute(\n                  `iter${iterationCount}Timestamp`,\n                  Math.round((decodedSample.timestamp || 0) * 1000),\n                );\n              }\n            }\n\n            const foundSample = trackBuffer.find(roundedTimeMs);\n            if (foundSample) {\n              const decodeEnd = performance.now();\n              span.setAttribute(\"iterationCount\", iterationCount);\n              span.setAttribute(\n                \"decodeMs\",\n                Math.round((decodeEnd - decodeStart) * 100) / 100,\n              );\n              span.setAttribute(\n                \"avgIterMs\",\n                Math.round(((decodeEnd - decodeStart) / iterationCount) * 100) /\n                  100,\n              );\n              span.setAttribute(\"foundSample\", true);\n              span.setAttribute(\n                \"foundTimestamp\",\n                Math.round((foundSample.timestamp || 0) * 1000),\n              );\n              return foundSample;\n            }\n            if (done) {\n              break;\n            }\n          }\n\n          span.setAttribute(\"iterationCount\", iterationCount);\n          span.setAttribute(\"reachedEnd\", true);\n\n          // Check if we're seeking to the exact end of the track (legitimate use case)\n          const finalBufferContents = trackBuffer.getContents();\n          if (finalBufferContents.length > 0) {\n            const lastSample =\n              finalBufferContents[finalBufferContents.length - 1];\n            const lastSampleEndMs = roundToMilliseconds(\n              ((lastSample?.timestamp || 0) + (lastSample?.duration || 0)) *\n                1000,\n            );\n\n            // Only return last sample if seeking to exactly the track duration\n            // (end of video) AND we have the final segment loaded\n            const trackDurationMs = (await track.computeDuration()) * 1000;\n            const isSeekingToTrackEnd =\n              roundToMilliseconds(timeMs) ===\n              roundToMilliseconds(trackDurationMs);\n            const isAtEndOfTrack =\n              roundToMilliseconds(timeMs) >= lastSampleEndMs;\n\n            if (isSeekingToTrackEnd && isAtEndOfTrack) {\n              span.setAttribute(\"returnedLastSample\", true);\n              return lastSample;\n            }\n          }\n\n          // For all other cases (seeking within track but outside buffer range), throw error\n          // The caller should ensure the correct segment is loaded before seeking\n          throw new NoSample(\n            `Sample not found for time ${timeMs} in ${track.type} track ${trackId}`,\n          );\n        } finally {\n          this.#seekLock = undefined;\n          seekLock.resolve();\n        }\n      },\n    );\n  }\n}\n"],"mappings":"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"}

package/dist/elements/EFMedia/JitMediaEngine.js

@@ -1,5 +1,7 @@
 import { BaseMediaEngine } from "./BaseMediaEngine.js";
 import { ThumbnailExtractor } from "./shared/ThumbnailExtractor.js";
+
+//#region src/elements/EFMedia/JitMediaEngine.ts
 var JitMediaEngine = class JitMediaEngine extends BaseMediaEngine {
 	static async fetch(host, urlGenerator, url) {
 		const engine = new JitMediaEngine(host, urlGenerator);
@@ -88,6 +90,10 @@ 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,
@@ -96,6 +102,9 @@ 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 {
@@ -116,4 +125,7 @@ var JitMediaEngine = class JitMediaEngine extends BaseMediaEngine {
 		return globalTimestamps.map((timestamp) => timestamp / 1e3);
 	}
 };
+
+//#endregion
 export { JitMediaEngine };
+//# sourceMappingURL=JitMediaEngine.js.map

package/dist/elements/EFMedia/JitMediaEngine.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"JitMediaEngine.js","names":["rendition: VideoRendition"],"sources":["../../../src/elements/EFMedia/JitMediaEngine.ts"],"sourcesContent":["import type {\n  AudioRendition,\n  MediaEngine,\n  RenditionId,\n  ThumbnailResult,\n  VideoRendition,\n} from \"../../transcoding/types\";\nimport type { ManifestResponse } from \"../../transcoding/types/index.js\";\nimport type { UrlGenerator } from \"../../transcoding/utils/UrlGenerator\";\nimport type { EFMedia } from \"../EFMedia.js\";\nimport { BaseMediaEngine } from \"./BaseMediaEngine\";\nimport { ThumbnailExtractor } from \"./shared/ThumbnailExtractor.js\";\n\nexport class JitMediaEngine extends BaseMediaEngine implements MediaEngine {\n  private urlGenerator: UrlGenerator;\n  private data: ManifestResponse = {} as ManifestResponse;\n  private thumbnailExtractor: ThumbnailExtractor;\n\n  static async fetch(host: EFMedia, urlGenerator: UrlGenerator, url: string) {\n    const engine = new JitMediaEngine(host, urlGenerator);\n    const data = await engine.fetchManifest(url);\n    engine.data = data;\n    return engine;\n  }\n\n  constructor(host: EFMedia, urlGenerator: UrlGenerator) {\n    super(host);\n    this.urlGenerator = urlGenerator;\n    this.thumbnailExtractor = new ThumbnailExtractor(this);\n  }\n\n  get durationMs() {\n    return this.data.durationMs;\n  }\n\n  get src() {\n    return this.data.sourceUrl;\n  }\n\n  get audioRendition(): AudioRendition | undefined {\n    if (!this.data.audioRenditions || this.data.audioRenditions.length === 0) {\n      return undefined;\n    }\n\n    const rendition = this.data.audioRenditions[0];\n    if (!rendition) return undefined;\n\n    return {\n      id: rendition.id as RenditionId,\n      trackId: undefined,\n      src: this.data.sourceUrl,\n      segmentDurationMs: rendition.segmentDurationMs,\n      segmentDurationsMs: rendition.segmentDurationsMs,\n    };\n  }\n\n  get videoRendition(): VideoRendition | undefined {\n    if (!this.data.videoRenditions || this.data.videoRenditions.length === 0) {\n      return undefined;\n    }\n\n    const rendition = this.data.videoRenditions[0];\n    if (!rendition) return undefined;\n\n    return {\n      id: rendition.id as RenditionId,\n      trackId: undefined,\n      src: this.data.sourceUrl,\n      segmentDurationMs: rendition.segmentDurationMs,\n      segmentDurationsMs: rendition.segmentDurationsMs,\n    };\n  }\n\n  get templates() {\n    return this.data.endpoints;\n  }\n\n  async fetchInitSegment(\n    rendition: { id?: RenditionId; trackId: number | undefined; src: string },\n    signal: AbortSignal,\n  ) {\n    if (!rendition.id) {\n      throw new Error(\"Rendition ID is required for JIT metadata\");\n    }\n    const url = this.urlGenerator.generateSegmentUrl(\n      \"init\",\n      rendition.id,\n      this,\n    );\n\n    // Use unified fetch method\n    return this.fetchMedia(url, signal);\n  }\n\n  async fetchMediaSegment(\n    segmentId: number,\n    rendition: { id?: RenditionId; trackId: number | undefined; src: string },\n  ) {\n    if (!rendition.id) {\n      throw new Error(\"Rendition ID is required for JIT metadata\");\n    }\n    const url = this.urlGenerator.generateSegmentUrl(\n      segmentId,\n      rendition.id,\n      this,\n    );\n    return this.fetchMedia(url);\n  }\n\n  computeSegmentId(\n    desiredSeekTimeMs: number,\n    rendition: VideoRendition | AudioRendition,\n  ) {\n    // Don't request segments beyond the actual file duration\n    // Note: seeking to exactly durationMs should be allowed (it's the last moment of the file)\n    if (desiredSeekTimeMs > this.durationMs) {\n      return undefined;\n    }\n\n    // Use actual segment durations if available (more accurate)\n    if (\n      rendition.segmentDurationsMs &&\n      rendition.segmentDurationsMs.length > 0\n    ) {\n      let cumulativeTime = 0;\n\n      for (let i = 0; i < rendition.segmentDurationsMs.length; i++) {\n        const segmentDuration = rendition.segmentDurationsMs[i];\n        if (segmentDuration === undefined) {\n          throw new Error(\"Segment duration is required for JIT metadata\");\n        }\n        const segmentStartMs = cumulativeTime;\n        const segmentEndMs = cumulativeTime + segmentDuration;\n\n        // Check if the desired seek time falls within this segment\n        // Special case: for the last segment, include the exact end time\n        const isLastSegment = i === rendition.segmentDurationsMs.length - 1;\n        const includesEndTime =\n          isLastSegment && desiredSeekTimeMs === this.durationMs;\n\n        if (\n          desiredSeekTimeMs >= segmentStartMs &&\n          (desiredSeekTimeMs < segmentEndMs || includesEndTime)\n        ) {\n          return i + 1; // Convert 0-based to 1-based segment ID\n        }\n\n        cumulativeTime += segmentDuration;\n\n        // If we've reached or exceeded file duration, stop\n        if (cumulativeTime >= this.durationMs) {\n          break;\n        }\n      }\n\n      // If we didn't find a segment, return undefined\n      return undefined;\n    }\n\n    // Fall back to fixed duration calculation for backward compatibility\n    if (!rendition.segmentDurationMs) {\n      throw new Error(\"Segment duration is required for JIT metadata\");\n    }\n\n    const segmentIndex = Math.floor(\n      desiredSeekTimeMs / rendition.segmentDurationMs,\n    );\n\n    // Calculate the actual segment start time\n    const segmentStartMs = segmentIndex * rendition.segmentDurationMs;\n\n    // If this segment would start at or beyond file duration, it doesn't exist\n    if (segmentStartMs >= this.durationMs) {\n      return undefined;\n    }\n\n    return segmentIndex + 1; // Convert 0-based to 1-based\n  }\n\n  getScrubVideoRendition(): VideoRendition | undefined {\n    if (!this.data.videoRenditions) return undefined;\n\n    const scrubManifestRendition = this.data.videoRenditions.find(\n      (r) => r.id === \"scrub\",\n    );\n\n    if (!scrubManifestRendition) return this.videoRendition; // Fallback to main\n\n    return {\n      id: scrubManifestRendition.id as any,\n      trackId: undefined,\n      src: this.src,\n      segmentDurationMs: scrubManifestRendition.segmentDurationMs,\n      segmentDurationsMs: scrubManifestRendition.segmentDurationsMs,\n    };\n  }\n\n  /**\n   * Get preferred buffer configuration for JIT transcoding\n   * Uses higher buffering since transcoding introduces latency\n   */\n  getBufferConfig() {\n    return {\n      // Buffer more aggressively for JIT transcoding to smooth over latency\n      videoBufferDurationMs: 8000,\n      audioBufferDurationMs: 8000,\n      maxVideoBufferFetches: 3,\n      maxAudioBufferFetches: 3,\n    };\n  }\n\n  /**\n   * Extract thumbnail canvases using same rendition priority as video playback for frame alignment\n   */\n  async extractThumbnails(\n    timestamps: number[],\n  ): Promise<(ThumbnailResult | null)[]> {\n    // Use same rendition priority as video: try main rendition first for frame alignment\n    let rendition: VideoRendition;\n    try {\n      const mainRendition = this.getVideoRendition();\n      if (mainRendition) {\n        rendition = mainRendition;\n      } else {\n        const scrubRendition = this.getScrubVideoRendition();\n        if (scrubRendition) {\n          rendition = scrubRendition;\n        } else {\n          throw new Error(\"No video rendition available\");\n        }\n      }\n    } catch (error) {\n      console.warn(\n        \"JitMediaEngine: No video rendition available for thumbnails\",\n        error,\n      );\n      return timestamps.map(() => null);\n    }\n\n    // Use shared thumbnail extraction logic\n    return this.thumbnailExtractor.extractThumbnails(\n      timestamps,\n      rendition,\n      this.durationMs,\n    );\n  }\n\n  convertToSegmentRelativeTimestamps(\n    globalTimestamps: number[],\n    _segmentId: number,\n    _rendition: VideoRendition,\n  ): number[] {\n    return globalTimestamps.map((timestamp) => timestamp / 1000);\n  }\n}\n"],"mappings":"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"}

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

@@ -1,16 +1,12 @@
-import { Task } from '@lit/task';
-import { EFMedia } from '../../EFMedia';
-import { MediaBufferConfig, MediaBufferState } from '../shared/BufferUtils';
-/**
- * Configuration for audio buffering - extends the generic interface
- */
-export interface AudioBufferConfig extends MediaBufferConfig {
-}
+import { MediaBufferState } from "../shared/BufferUtils.js";
+import { Task } from "@lit/task";
+
+//#region src/elements/EFMedia/audioTasks/makeAudioBufferTask.d.ts
+
 /**
  * State of the audio buffer - uses the generic interface
  */
-export interface AudioBufferState extends MediaBufferState {
-}
-type AudioBufferTask = Task<readonly [number], AudioBufferState>;
-export declare const makeAudioBufferTask: (host: EFMedia) => AudioBufferTask;
-export {};
+interface AudioBufferState extends MediaBufferState {}
+//#endregion
+export { AudioBufferState };
+//# sourceMappingURL=makeAudioBufferTask.d.ts.map

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

@@ -3,6 +3,8 @@ import { EF_RENDERING } from "../../../EF_RENDERING.js";
 import { manageMediaBuffer } from "../shared/BufferUtils.js";
 import { getLatestMediaEngine } from "../tasks/makeMediaEngineTask.js";
 import { Task } from "@lit/task";
+
+//#region src/elements/EFMedia/audioTasks/makeAudioBufferTask.ts
 const makeAudioBufferTask = (host) => {
 	let currentState = {
 		currentSeekTimeMs: 0,
@@ -50,4 +52,7 @@ const makeAudioBufferTask = (host) => {
 		}
 	});
 };
+
+//#endregion
 export { makeAudioBufferTask };
+//# sourceMappingURL=makeAudioBufferTask.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"makeAudioBufferTask.js","names":["currentState: AudioBufferState","mediaEngine"],"sources":["../../../../src/elements/EFMedia/audioTasks/makeAudioBufferTask.ts"],"sourcesContent":["import { Task } from \"@lit/task\";\n\nimport { EF_INTERACTIVE } from \"../../../EF_INTERACTIVE\";\nimport { EF_RENDERING } from \"../../../EF_RENDERING\";\nimport type { AudioRendition } from \"../../../transcoding/types\";\nimport type { EFMedia } from \"../../EFMedia\";\nimport {\n  type MediaBufferConfig,\n  type MediaBufferState,\n  manageMediaBuffer,\n} from \"../shared/BufferUtils\";\nimport { getLatestMediaEngine } from \"../tasks/makeMediaEngineTask\";\n\n/**\n * Configuration for audio buffering - extends the generic interface\n */\nexport interface AudioBufferConfig extends MediaBufferConfig {}\n\n/**\n * State of the audio buffer - uses the generic interface\n */\nexport interface AudioBufferState extends MediaBufferState {}\n\ntype AudioBufferTask = Task<readonly [number], AudioBufferState>;\nexport const makeAudioBufferTask = (host: EFMedia): AudioBufferTask => {\n  let currentState: AudioBufferState = {\n    currentSeekTimeMs: 0,\n    requestedSegments: new Set(),\n    activeRequests: new Set(),\n    requestQueue: [],\n  };\n\n  return new Task(host, {\n    autoRun: EF_INTERACTIVE, // Make lazy - only run when element becomes timeline-active\n    args: () => [host.desiredSeekTimeMs] as const,\n    onError: (error) => {\n      console.error(\"audioBufferTask error\", error);\n    },\n    onComplete: (value) => {\n      currentState = value;\n    },\n    task: async ([seekTimeMs], { signal }) => {\n      // Skip buffering entirely in rendering mode\n      if (EF_RENDERING()) {\n        return currentState; // Return existing state without any buffering activity\n      }\n\n      // Get media engine to potentially override buffer configuration\n      const mediaEngine = await getLatestMediaEngine(host, signal);\n\n      // Return existing state if no audio rendition available\n      if (!mediaEngine.audioRendition) {\n        return currentState;\n      }\n\n      // Use media engine's buffer config, falling back to host properties\n      const engineConfig = mediaEngine.getBufferConfig();\n      const bufferDurationMs = engineConfig.audioBufferDurationMs;\n      const maxParallelFetches = engineConfig.maxAudioBufferFetches;\n\n      const currentConfig: AudioBufferConfig = {\n        bufferDurationMs,\n        maxParallelFetches,\n        enableBuffering: host.enableAudioBuffering,\n      };\n\n      return manageMediaBuffer<AudioRendition>(\n        seekTimeMs,\n        currentConfig,\n        currentState,\n        (host as any).intrinsicDurationMs || 10000,\n        signal,\n        {\n          computeSegmentId: async (timeMs, rendition) => {\n            // Use media engine's computeSegmentId\n            const mediaEngine = await getLatestMediaEngine(host, signal);\n            return mediaEngine.computeSegmentId(timeMs, rendition);\n          },\n          prefetchSegment: async (segmentId, rendition) => {\n            // Trigger prefetch through BaseMediaEngine - let it handle caching\n            const mediaEngine = await getLatestMediaEngine(host, signal);\n            await mediaEngine.fetchMediaSegment(segmentId, rendition);\n            // Don't return data - just ensure it's cached in BaseMediaEngine\n          },\n          isSegmentCached: (segmentId, rendition) => {\n            // Check if segment is already cached in BaseMediaEngine\n            const mediaEngine = host.mediaEngineTask.value;\n            if (!mediaEngine) return false;\n\n            return mediaEngine.isSegmentCached(segmentId, rendition);\n          },\n          getRendition: async () => {\n            const mediaEngine = await getLatestMediaEngine(host, signal);\n            const audioRendition = mediaEngine.audioRendition;\n            if (!audioRendition) {\n              throw new Error(\"Audio rendition not available\");\n            }\n            return audioRendition;\n          },\n          logError: console.error,\n        },\n      );\n    },\n  });\n};\n"],"mappings":";;;;;;;AAwBA,MAAa,uBAAuB,SAAmC;CACrE,IAAIA,eAAiC;EACnC,mBAAmB;EACnB,mCAAmB,IAAI,KAAK;EAC5B,gCAAgB,IAAI,KAAK;EACzB,cAAc,EAAE;EACjB;AAED,QAAO,IAAI,KAAK,MAAM;EACpB,SAAS;EACT,YAAY,CAAC,KAAK,kBAAkB;EACpC,UAAU,UAAU;AAClB,WAAQ,MAAM,yBAAyB,MAAM;;EAE/C,aAAa,UAAU;AACrB,kBAAe;;EAEjB,MAAM,OAAO,CAAC,aAAa,EAAE,aAAa;AAExC,OAAI,cAAc,CAChB,QAAO;GAIT,MAAM,cAAc,MAAM,qBAAqB,MAAM,OAAO;AAG5D,OAAI,CAAC,YAAY,eACf,QAAO;GAIT,MAAM,eAAe,YAAY,iBAAiB;AAUlD,UAAO,kBACL,YAPuC;IACvC,kBAJuB,aAAa;IAKpC,oBAJyB,aAAa;IAKtC,iBAAiB,KAAK;IACvB,EAKC,cACC,KAAa,uBAAuB,KACrC,QACA;IACE,kBAAkB,OAAO,QAAQ,cAAc;AAG7C,aADoB,MAAM,qBAAqB,MAAM,OAAO,EACzC,iBAAiB,QAAQ,UAAU;;IAExD,iBAAiB,OAAO,WAAW,cAAc;AAG/C,YADoB,MAAM,qBAAqB,MAAM,OAAO,EAC1C,kBAAkB,WAAW,UAAU;;IAG3D,kBAAkB,WAAW,cAAc;KAEzC,MAAMC,gBAAc,KAAK,gBAAgB;AACzC,SAAI,CAACA,cAAa,QAAO;AAEzB,YAAOA,cAAY,gBAAgB,WAAW,UAAU;;IAE1D,cAAc,YAAY;KAExB,MAAM,kBADc,MAAM,qBAAqB,MAAM,OAAO,EACzB;AACnC,SAAI,CAAC,eACH,OAAM,IAAI,MAAM,gCAAgC;AAElD,YAAO;;IAET,UAAU,QAAQ;IACnB,CACF;;EAEJ,CAAC"}

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

@@ -1,7 +1,9 @@
 import { EF_INTERACTIVE } from "../../../EF_INTERACTIVE.js";
 import { LRUCache } from "../../../utils/LRUCache.js";
 import { Task } from "@lit/task";
-var DECAY_WEIGHT = .8;
+
+//#region src/elements/EFMedia/audioTasks/makeAudioFrequencyAnalysisTask.ts
+const DECAY_WEIGHT = .8;
 function processFFTData(fftData, zeroThresholdPercent = .1) {
 	const totalBins = fftData.length;
 	const zeroThresholdCount = Math.floor(totalBins * zeroThresholdPercent);
@@ -135,4 +137,7 @@ function makeAudioFrequencyAnalysisTask(element) {
 		}
 	});
 }
+
+//#endregion
 export { makeAudioFrequencyAnalysisTask };
+//# sourceMappingURL=makeAudioFrequencyAnalysisTask.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"makeAudioFrequencyAnalysisTask.js","names":["audioContext: OfflineAudioContext"],"sources":["../../../../src/elements/EFMedia/audioTasks/makeAudioFrequencyAnalysisTask.ts"],"sourcesContent":["import { Task } from \"@lit/task\";\nimport { EF_INTERACTIVE } from \"../../../EF_INTERACTIVE.js\";\nimport { LRUCache } from \"../../../utils/LRUCache.js\";\nimport type { EFMedia } from \"../../EFMedia.js\";\n\n// DECAY_WEIGHT constant - same as original\nconst DECAY_WEIGHT = 0.8;\n\nfunction processFFTData(\n  fftData: Uint8Array,\n  zeroThresholdPercent = 0.1,\n): Uint8Array {\n  // Step 1: Determine the threshold for zeros\n  const totalBins = fftData.length;\n  const zeroThresholdCount = Math.floor(totalBins * zeroThresholdPercent);\n\n  // Step 2: Interrogate the FFT output to find the cutoff point\n  let zeroCount = 0;\n  let cutoffIndex = totalBins; // Default to the end of the array\n\n  for (let i = totalBins - 1; i >= 0; i--) {\n    if (fftData[i] ?? 0 < 10) {\n      zeroCount++;\n    } else {\n      // If we encounter a non-zero value, we can stop\n      if (zeroCount >= zeroThresholdCount) {\n        cutoffIndex = i + 1; // Include this index\n        break;\n      }\n    }\n  }\n\n  if (cutoffIndex < zeroThresholdCount) {\n    return fftData;\n  }\n\n  // Step 3: Resample the \"good\" portion of the data\n  const goodData = fftData.slice(0, cutoffIndex);\n  const resampledData = interpolateData(goodData, fftData.length);\n\n  // Step 4: Attenuate the top 10% of interpolated samples\n  const attenuationStartIndex = Math.floor(totalBins * 0.9);\n  for (let i = attenuationStartIndex; i < totalBins; i++) {\n    // Calculate attenuation factor that goes from 1 to 0 over the top 10%\n    const attenuationProgress =\n      (i - attenuationStartIndex) / (totalBins - attenuationStartIndex) + 0.2;\n    const attenuationFactor = Math.max(0, 1 - attenuationProgress);\n    resampledData[i] = Math.floor((resampledData[i] ?? 0) * attenuationFactor);\n  }\n\n  return resampledData;\n}\n\nfunction interpolateData(data: Uint8Array, targetSize: number): Uint8Array {\n  const resampled = new Uint8Array(targetSize);\n  const dataLength = data.length;\n\n  for (let i = 0; i < targetSize; i++) {\n    // Calculate the corresponding index in the original data\n    const ratio = (i / (targetSize - 1)) * (dataLength - 1);\n    const index = Math.floor(ratio);\n    const fraction = ratio - index;\n\n    // Handle edge cases\n    if (index >= dataLength - 1) {\n      resampled[i] = data[dataLength - 1] ?? 0; // Last value\n    } else {\n      // Linear interpolation\n      resampled[i] = Math.round(\n        (data[index] ?? 0) * (1 - fraction) + (data[index + 1] ?? 0) * fraction,\n      );\n    }\n  }\n\n  return resampled;\n}\n\nexport function makeAudioFrequencyAnalysisTask(element: EFMedia) {\n  // Internal cache for this task instance (same as original #frequencyDataCache)\n  const cache = new LRUCache<string, Uint8Array>(100);\n\n  return new Task(element, {\n    autoRun: EF_INTERACTIVE,\n    onError: (error) => {\n      console.error(\"frequencyDataTask error\", error);\n    },\n    args: () =>\n      [\n        element.currentSourceTimeMs,\n        element.fftSize,\n        element.fftDecay,\n        element.fftGain,\n        element.shouldInterpolateFrequencies,\n      ] as const,\n    task: async (_, { signal }) => {\n      if (element.currentSourceTimeMs < 0) return null;\n\n      const currentTimeMs = element.currentSourceTimeMs;\n\n      // Calculate exact audio window needed based on fftDecay and frame timing\n      const frameIntervalMs = 1000 / 30; // 33.33ms per frame\n\n      // Need audio from earliest frame to current frame\n      const earliestFrameMs =\n        currentTimeMs - (element.fftDecay - 1) * frameIntervalMs;\n      const fromMs = Math.max(0, earliestFrameMs);\n      const maxToMs = currentTimeMs + frameIntervalMs; // Include current frame\n      const videoDurationMs = element.intrinsicDurationMs || 0;\n      const toMs =\n        videoDurationMs > 0 ? Math.min(maxToMs, videoDurationMs) : maxToMs;\n\n      // If the clamping results in an invalid range (seeking beyond the end), skip analysis silently\n      if (fromMs >= toMs) {\n        return null;\n      }\n\n      // Check cache early - before expensive audio fetching\n      // Use a preliminary cache key that doesn't depend on actual startOffsetMs from audio span\n      const preliminaryCacheKey = `${element.shouldInterpolateFrequencies}:${element.fftSize}:${element.fftDecay}:${element.fftGain}:${fromMs}:${currentTimeMs}`;\n      const cachedSmoothedData = cache.get(preliminaryCacheKey);\n      if (cachedSmoothedData) {\n        return cachedSmoothedData;\n      }\n\n      const { fetchAudioSpanningTime: fetchAudioSpan } = await import(\n        \"../shared/AudioSpanUtils.ts\"\n      );\n      const audioSpan = await fetchAudioSpan(element, fromMs, toMs, signal);\n\n      if (!audioSpan || !audioSpan.blob) {\n        console.warn(\"Frequency analysis skipped: no audio data available\");\n        return null;\n      }\n\n      // Decode the real audio data\n      const tempAudioContext = new OfflineAudioContext(2, 48000, 48000);\n      const arrayBuffer = await audioSpan.blob.arrayBuffer();\n      const audioBuffer = await tempAudioContext.decodeAudioData(arrayBuffer);\n\n      // Use actual startOffset from audioSpan (relative to requested time)\n      const startOffsetMs = audioSpan.startMs;\n\n      const framesData = await Promise.all(\n        Array.from({ length: element.fftDecay }, async (_, i) => {\n          const frameOffset = i * (1000 / 30);\n          const startTime = Math.max(\n            0,\n            (currentTimeMs - frameOffset - startOffsetMs) / 1000,\n          );\n\n          // Cache key for this specific frame\n          const cacheKey = `${element.shouldInterpolateFrequencies}:${element.fftSize}:${element.fftGain}:${startOffsetMs}:${startTime}`;\n\n          // Check cache for this specific frame\n          const cachedFrame = cache.get(cacheKey);\n          if (cachedFrame) {\n            return cachedFrame;\n          }\n\n          // Running 48000 * (1 / 30) = 1600 broke something terrible, it came out as 0,\n          // I'm assuming weird floating point nonsense to do with running on rosetta\n          const SIZE = 48000 / 30;\n          let audioContext: OfflineAudioContext;\n          try {\n            audioContext = new OfflineAudioContext(2, SIZE, 48000);\n          } catch (error) {\n            throw new Error(\n              `[EFMedia.frequencyDataTask] Failed to create OfflineAudioContext(2, ${SIZE}, 48000) for frame ${i} at time ${startTime}s: ${error instanceof Error ? error.message : String(error)}. This is for audio frequency analysis.`,\n            );\n          }\n          const analyser = audioContext.createAnalyser();\n          analyser.fftSize = element.fftSize;\n          analyser.minDecibels = -90;\n          analyser.maxDecibels = -10;\n\n          const gainNode = audioContext.createGain();\n          gainNode.gain.value = element.fftGain;\n\n          const filter = audioContext.createBiquadFilter();\n          filter.type = \"bandpass\";\n          filter.frequency.value = 15000;\n          filter.Q.value = 0.05;\n\n          const audioBufferSource = audioContext.createBufferSource();\n          audioBufferSource.buffer = audioBuffer;\n\n          audioBufferSource.connect(filter);\n          filter.connect(gainNode);\n          gainNode.connect(analyser);\n          analyser.connect(audioContext.destination);\n\n          audioBufferSource.start(0, startTime, 1 / 30);\n\n          try {\n            await audioContext.startRendering();\n            const frameData = new Uint8Array(element.fftSize / 2);\n            analyser.getByteFrequencyData(frameData);\n\n            // Cache this frame's analysis\n            cache.set(cacheKey, frameData);\n            return frameData;\n          } finally {\n            audioBufferSource.disconnect();\n            analyser.disconnect();\n          }\n        }),\n      );\n\n      const frameLength = framesData[0]?.length ?? 0;\n\n      // Combine frames with decay\n      const smoothedData = new Uint8Array(frameLength);\n      for (let i = 0; i < frameLength; i++) {\n        let weightedSum = 0;\n        let weightSum = 0;\n\n        framesData.forEach((frame: Uint8Array, frameIndex: number) => {\n          const decayWeight = DECAY_WEIGHT ** frameIndex;\n          weightedSum += (frame[i] ?? 0) * decayWeight;\n          weightSum += decayWeight;\n        });\n\n        smoothedData[i] = Math.min(255, Math.round(weightedSum / weightSum));\n      }\n\n      // Apply frequency weights using instance FREQ_WEIGHTS\n      smoothedData.forEach((value, i) => {\n        const freqWeight = element.FREQ_WEIGHTS[i] ?? 0;\n        smoothedData[i] = Math.min(255, Math.round(value * freqWeight));\n      });\n\n      // Only return the lower half of the frequency data\n      // The top half is zeroed out, which makes for aesthetically unpleasing waveforms\n      const slicedData = smoothedData.slice(\n        0,\n        Math.floor(smoothedData.length / 2),\n      );\n      const processedData = element.shouldInterpolateFrequencies\n        ? processFFTData(slicedData)\n        : slicedData;\n      // Cache with the preliminary key so future requests can skip audio fetching\n      cache.set(preliminaryCacheKey, processedData);\n      return processedData;\n    },\n  });\n}\n"],"mappings":"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"}

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

@@ -1,5 +1,7 @@
 import { getLatestMediaEngine } from "../tasks/makeMediaEngineTask.js";
 import { Task } from "@lit/task";
+
+//#region src/elements/EFMedia/audioTasks/makeAudioInitSegmentFetchTask.ts
 const makeAudioInitSegmentFetchTask = (host) => {
 	return new Task(host, {
 		args: () => [host.mediaEngineTask.value],
@@ -15,4 +17,7 @@ const makeAudioInitSegmentFetchTask = (host) => {
 		}
 	});
 };
+
+//#endregion
 export { makeAudioInitSegmentFetchTask };
+//# sourceMappingURL=makeAudioInitSegmentFetchTask.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"makeAudioInitSegmentFetchTask.js","names":[],"sources":["../../../../src/elements/EFMedia/audioTasks/makeAudioInitSegmentFetchTask.ts"],"sourcesContent":["import { Task } from \"@lit/task\";\nimport type { MediaEngine } from \"../../../transcoding/types\";\nimport type { EFMedia } from \"../../EFMedia\";\nimport { getLatestMediaEngine } from \"../tasks/makeMediaEngineTask\";\n\nexport const makeAudioInitSegmentFetchTask = (\n  host: EFMedia,\n): Task<readonly [MediaEngine | undefined], ArrayBuffer | undefined> => {\n  return new Task(host, {\n    args: () => [host.mediaEngineTask.value] as const,\n    onError: (error) => {\n      console.error(\"audioInitSegmentFetchTask error\", error);\n    },\n    onComplete: (_value) => {},\n    task: async ([_mediaEngine], { signal }) => {\n      const mediaEngine = await getLatestMediaEngine(host, signal);\n      const audioRendition = mediaEngine.getAudioRendition();\n\n      // Return undefined if no audio rendition available (video-only asset)\n      if (!audioRendition) {\n        return undefined;\n      }\n\n      return mediaEngine.fetchInitSegment(audioRendition, signal);\n    },\n  });\n};\n"],"mappings":";;;;AAKA,MAAa,iCACX,SACsE;AACtE,QAAO,IAAI,KAAK,MAAM;EACpB,YAAY,CAAC,KAAK,gBAAgB,MAAM;EACxC,UAAU,UAAU;AAClB,WAAQ,MAAM,mCAAmC,MAAM;;EAEzD,aAAa,WAAW;EACxB,MAAM,OAAO,CAAC,eAAe,EAAE,aAAa;GAC1C,MAAM,cAAc,MAAM,qBAAqB,MAAM,OAAO;GAC5D,MAAM,iBAAiB,YAAY,mBAAmB;AAGtD,OAAI,CAAC,eACH;AAGF,UAAO,YAAY,iBAAiB,gBAAgB,OAAO;;EAE9D,CAAC"}

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

@@ -1,6 +1,8 @@
 import { BufferedSeekingInput } from "../BufferedSeekingInput.js";
 import { EFMedia } from "../../EFMedia.js";
 import { Task } from "@lit/task";
+
+//#region src/elements/EFMedia/audioTasks/makeAudioInputTask.ts
 const makeAudioInputTask = (host) => {
 	return new Task(host, {
 		args: () => [host.audioInitSegmentFetchTask.value, host.audioSegmentFetchTask.value],
@@ -29,4 +31,7 @@ const makeAudioInputTask = (host) => {
 		}
 	});
 };
+
+//#endregion
 export { makeAudioInputTask };
+//# sourceMappingURL=makeAudioInputTask.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"makeAudioInputTask.js","names":[],"sources":["../../../../src/elements/EFMedia/audioTasks/makeAudioInputTask.ts"],"sourcesContent":["import { Task } from \"@lit/task\";\nimport { EFMedia } from \"../../EFMedia\";\nimport { BufferedSeekingInput } from \"../BufferedSeekingInput\";\nimport type { InputTask } from \"../shared/MediaTaskUtils\";\n\nexport const makeAudioInputTask = (host: EFMedia): InputTask => {\n  return new Task<\n    readonly [ArrayBuffer | undefined, ArrayBuffer | undefined],\n    BufferedSeekingInput | undefined\n  >(host, {\n    args: () =>\n      [\n        host.audioInitSegmentFetchTask.value,\n        host.audioSegmentFetchTask.value,\n      ] as const,\n    onError: (error) => {\n      console.error(\"audioInputTask error\", error);\n    },\n    onComplete: (_value) => {},\n    task: async (_, { signal }) => {\n      const mediaEngine = await host.mediaEngineTask.taskComplete;\n      if (signal.aborted) return undefined;\n\n      const audioRendition = mediaEngine?.audioRendition;\n\n      // Return undefined if no audio rendition available (video-only asset)\n      if (!audioRendition) {\n        return undefined;\n      }\n\n      const initSegment = await host.audioInitSegmentFetchTask.taskComplete;\n      if (signal.aborted) return undefined;\n\n      const segment = await host.audioSegmentFetchTask.taskComplete;\n      if (signal.aborted) return undefined;\n\n      if (!initSegment || !segment) {\n        return undefined;\n      }\n\n      const startTimeOffsetMs = audioRendition.startTimeOffsetMs;\n\n      const arrayBuffer = await new Blob([initSegment, segment]).arrayBuffer();\n      if (signal.aborted) return undefined;\n\n      return new BufferedSeekingInput(arrayBuffer, {\n        videoBufferSize: EFMedia.VIDEO_SAMPLE_BUFFER_SIZE,\n        audioBufferSize: EFMedia.AUDIO_SAMPLE_BUFFER_SIZE,\n        startTimeOffsetMs,\n      });\n    },\n  });\n};\n"],"mappings":";;;;;AAKA,MAAa,sBAAsB,SAA6B;AAC9D,QAAO,IAAI,KAGT,MAAM;EACN,YACE,CACE,KAAK,0BAA0B,OAC/B,KAAK,sBAAsB,MAC5B;EACH,UAAU,UAAU;AAClB,WAAQ,MAAM,wBAAwB,MAAM;;EAE9C,aAAa,WAAW;EACxB,MAAM,OAAO,GAAG,EAAE,aAAa;GAC7B,MAAM,cAAc,MAAM,KAAK,gBAAgB;AAC/C,OAAI,OAAO,QAAS,QAAO;GAE3B,MAAM,iBAAiB,aAAa;AAGpC,OAAI,CAAC,eACH;GAGF,MAAM,cAAc,MAAM,KAAK,0BAA0B;AACzD,OAAI,OAAO,QAAS,QAAO;GAE3B,MAAM,UAAU,MAAM,KAAK,sBAAsB;AACjD,OAAI,OAAO,QAAS,QAAO;AAE3B,OAAI,CAAC,eAAe,CAAC,QACnB;GAGF,MAAM,oBAAoB,eAAe;GAEzC,MAAM,cAAc,MAAM,IAAI,KAAK,CAAC,aAAa,QAAQ,CAAC,CAAC,aAAa;AACxE,OAAI,OAAO,QAAS,QAAO;AAE3B,UAAO,IAAI,qBAAqB,aAAa;IAC3C,iBAAiB,QAAQ;IACzB,iBAAiB,QAAQ;IACzB;IACD,CAAC;;EAEL,CAAC"}

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

@@ -1,5 +1,7 @@
 import { IgnorableError } from "../../EFMedia.js";
 import { Task } from "@lit/task";
+
+//#region src/elements/EFMedia/audioTasks/makeAudioSeekTask.ts
 const makeAudioSeekTask = (host) => {
 	return new Task(host, {
 		args: () => [host.desiredSeekTimeMs, host.audioInputTask.value],
@@ -16,4 +18,7 @@ const makeAudioSeekTask = (host) => {
 		task: async () => {}
 	});
 };
+
+//#endregion
 export { makeAudioSeekTask };
+//# sourceMappingURL=makeAudioSeekTask.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"makeAudioSeekTask.js","names":[],"sources":["../../../../src/elements/EFMedia/audioTasks/makeAudioSeekTask.ts"],"sourcesContent":["import { Task } from \"@lit/task\";\nimport type { VideoSample } from \"mediabunny\";\nimport { type EFMedia, IgnorableError } from \"../../EFMedia\";\nimport type { BufferedSeekingInput } from \"../BufferedSeekingInput\";\n\ntype AudioSeekTask = Task<\n  readonly [number, BufferedSeekingInput | undefined],\n  VideoSample | undefined\n>;\nexport const makeAudioSeekTask = (host: EFMedia): AudioSeekTask => {\n  return new Task(host, {\n    args: () => [host.desiredSeekTimeMs, host.audioInputTask.value] as const,\n    onError: (error) => {\n      if (error instanceof IgnorableError) {\n        console.info(\"audioSeekTask aborted\");\n        return;\n      }\n      if (error instanceof DOMException) {\n        console.error(\n          `audioSeekTask error: ${error.message} ${error.name} ${error.code}`,\n        );\n      } else if (error instanceof Error) {\n        console.error(`audioSeekTask error ${error.name}: ${error.message}`);\n      } else {\n        console.error(\"audioSeekTask unknown error\", error);\n      }\n    },\n    onComplete: (_value) => {},\n    task: async (): Promise<VideoSample | undefined> => {\n      return undefined;\n      // TODO: validate that the audio seek task is not actually used to render any audio\n      // CRITICAL FIX: Use the targetSeekTimeMs from args, not host.desiredSeekTimeMs\n      // This ensures we use the same seek time that the segment loading tasks used\n\n      // await host.audioSegmentIdTask.taskComplete;\n      // signal.throwIfAborted(); // Abort if a new seek started\n      // await host.audioSegmentFetchTask.taskComplete;\n      // signal.throwIfAborted(); // Abort if a new seek started\n      // await host.audioInitSegmentFetchTask.taskComplete;\n      // signal.throwIfAborted(); // Abort if a new seek started\n\n      // const audioInput = await host.audioInputTask.taskComplete;\n      // signal.throwIfAborted(); // Abort if a new seek started\n      // if (!audioInput) {\n      //   throw new Error(\"Audio input is not available\");\n      // }\n      // const audioTrack = await audioInput.getFirstAudioTrack();\n      // if (!audioTrack) {\n      //   throw new Error(\"Audio track is not available\");\n      // }\n      // signal.throwIfAborted(); // Abort if a new seek started\n\n      // const sample = (await audioInput.seek(\n      //   audioTrack.id,\n      //   targetSeekTimeMs, // Use the captured value, not host.desiredSeekTimeMs\n      // )) as unknown as VideoSample | undefined;\n      // signal.throwIfAborted(); // Abort if a new seek started\n\n      // // If seek returned undefined, it was aborted - don't throw\n      // if (sample === undefined && signal.aborted) {\n      //   return undefined;\n      // }\n\n      // // If we got undefined but weren't aborted, that's an actual error\n      // if (sample === undefined) {\n      //   throw new Error(\"Audio seek failed to find sample\");\n      // }\n\n      // return sample;\n    },\n  });\n};\n"],"mappings":";;;;AASA,MAAa,qBAAqB,SAAiC;AACjE,QAAO,IAAI,KAAK,MAAM;EACpB,YAAY,CAAC,KAAK,mBAAmB,KAAK,eAAe,MAAM;EAC/D,UAAU,UAAU;AAClB,OAAI,iBAAiB,gBAAgB;AACnC,YAAQ,KAAK,wBAAwB;AACrC;;AAEF,OAAI,iBAAiB,aACnB,SAAQ,MACN,wBAAwB,MAAM,QAAQ,GAAG,MAAM,KAAK,GAAG,MAAM,OAC9D;YACQ,iBAAiB,MAC1B,SAAQ,MAAM,uBAAuB,MAAM,KAAK,IAAI,MAAM,UAAU;OAEpE,SAAQ,MAAM,+BAA+B,MAAM;;EAGvD,aAAa,WAAW;EACxB,MAAM,YAA8C;EA0CrD,CAAC"}

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

@@ -1,5 +1,7 @@
 import { getLatestMediaEngine } from "../tasks/makeMediaEngineTask.js";
 import { Task } from "@lit/task";
+
+//#region src/elements/EFMedia/audioTasks/makeAudioSegmentFetchTask.ts
 const makeAudioSegmentFetchTask = (host) => {
 	return new Task(host, {
 		args: () => [host.mediaEngineTask.value, host.audioSegmentIdTask.value],
@@ -16,4 +18,7 @@ const makeAudioSegmentFetchTask = (host) => {
 		}
 	});
 };
+
+//#endregion
 export { makeAudioSegmentFetchTask };
+//# sourceMappingURL=makeAudioSegmentFetchTask.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"makeAudioSegmentFetchTask.js","names":[],"sources":["../../../../src/elements/EFMedia/audioTasks/makeAudioSegmentFetchTask.ts"],"sourcesContent":["import { Task } from \"@lit/task\";\nimport type { MediaEngine } from \"../../../transcoding/types\";\nimport type { EFMedia } from \"../../EFMedia\";\nimport { getLatestMediaEngine } from \"../tasks/makeMediaEngineTask\";\n\nexport const makeAudioSegmentFetchTask = (\n  host: EFMedia,\n): Task<\n  readonly [MediaEngine | undefined, number | undefined],\n  ArrayBuffer | undefined\n> => {\n  return new Task(host, {\n    args: () =>\n      [host.mediaEngineTask.value, host.audioSegmentIdTask.value] as const,\n    onError: (error) => {\n      console.error(\"audioSegmentFetchTask error\", error);\n    },\n    onComplete: (_value) => {},\n    task: async (_, { signal }) => {\n      const mediaEngine = await getLatestMediaEngine(host, signal);\n      const segmentId = await host.audioSegmentIdTask.taskComplete;\n      const audioRendition = mediaEngine.getAudioRendition();\n\n      // Return undefined if no audio rendition or segment ID available (video-only asset)\n      if (!audioRendition || segmentId === undefined) {\n        return undefined;\n      }\n\n      return mediaEngine.fetchMediaSegment(segmentId, audioRendition, signal);\n    },\n  });\n};\n"],"mappings":";;;;AAKA,MAAa,6BACX,SAIG;AACH,QAAO,IAAI,KAAK,MAAM;EACpB,YACE,CAAC,KAAK,gBAAgB,OAAO,KAAK,mBAAmB,MAAM;EAC7D,UAAU,UAAU;AAClB,WAAQ,MAAM,+BAA+B,MAAM;;EAErD,aAAa,WAAW;EACxB,MAAM,OAAO,GAAG,EAAE,aAAa;GAC7B,MAAM,cAAc,MAAM,qBAAqB,MAAM,OAAO;GAC5D,MAAM,YAAY,MAAM,KAAK,mBAAmB;GAChD,MAAM,iBAAiB,YAAY,mBAAmB;AAGtD,OAAI,CAAC,kBAAkB,cAAc,OACnC;AAGF,UAAO,YAAY,kBAAkB,WAAW,gBAAgB,OAAO;;EAE1E,CAAC"}