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

package/dist/elements/EFMedia.js

@@ -1,621 +1,81 @@
-import { EF_INTERACTIVE } from "../EF_INTERACTIVE.js";
-import { JitTranscodingClient } from "../JitTranscodingClient.js";
+import { UrlGenerator } from "../transcoding/utils/UrlGenerator.js";
+import { makeMediaEngineTask } from "./EFMedia/tasks/makeMediaEngineTask.js";
+import { makeAudioBufferTask } from "./EFMedia/audioTasks/makeAudioBufferTask.js";
+import { makeAudioFrequencyAnalysisTask } from "./EFMedia/audioTasks/makeAudioFrequencyAnalysisTask.js";
+import { makeAudioInitSegmentFetchTask } from "./EFMedia/audioTasks/makeAudioInitSegmentFetchTask.js";
+import { makeAudioInputTask } from "./EFMedia/audioTasks/makeAudioInputTask.js";
+import { makeAudioSeekTask } from "./EFMedia/audioTasks/makeAudioSeekTask.js";
+import { makeAudioSegmentFetchTask } from "./EFMedia/audioTasks/makeAudioSegmentFetchTask.js";
+import { makeAudioSegmentIdTask } from "./EFMedia/audioTasks/makeAudioSegmentIdTask.js";
+import { makeAudioTimeDomainAnalysisTask } from "./EFMedia/audioTasks/makeAudioTimeDomainAnalysisTask.js";
+import { AudioElementFactory } from "./EFMedia/services/AudioElementFactory.js";
+import { MediaSourceService } from "./EFMedia/services/MediaSourceService.js";
 import { EFSourceMixin } from "./EFSourceMixin.js";
 import { EFTemporal } from "./EFTemporal.js";
 import { FetchMixin } from "./FetchMixin.js";
 import { EFTargetable } from "./TargetController.js";
 import { updateAnimations } from "./updateAnimations.js";
-import { Task } from "@lit/task";
-import debug from "debug";
 import { LitElement, css } from "lit";
 import { property, state } from "lit/decorators.js";
 import _decorate from "@oxc-project/runtime/helpers/decorate";
-import { VideoAsset } from "@editframe/assets/EncodedAsset.js";
-import { MP4File } from "@editframe/assets/MP4File.js";
-import { deepArrayEquals } from "@lit/task/deep-equals.js";
-const log = debug("ef:elements:EFMedia");
 const freqWeightsCache = /* @__PURE__ */ new Map();
-var LRUCache = class {
-	constructor(maxSize) {
-		this.cache = /* @__PURE__ */ new Map();
-		this.maxSize = maxSize;
-	}
-	get(key) {
-		const value = this.cache.get(key);
-		if (value) {
-			this.cache.delete(key);
-			this.cache.set(key, value);
-		}
-		return value;
-	}
-	set(key, value) {
-		if (this.cache.has(key)) this.cache.delete(key);
-		else if (this.cache.size >= this.maxSize) {
-			const firstKey = this.cache.keys().next().value;
-			if (firstKey) this.cache.delete(firstKey);
-		}
-		this.cache.set(key, value);
-	}
-};
+var IgnorableError = class extends Error {};
 const deepGetMediaElements = (element, medias = []) => {
 	for (const child of Array.from(element.children)) if (child instanceof EFMedia) medias.push(child);
 	else deepGetMediaElements(child, medias);
 	return medias;
 };
-var EFMedia = class EFMedia extends EFTargetable(EFSourceMixin(EFTemporal(FetchMixin(LitElement)), { assetType: "isobmff_files" })) {
+var EFMedia = class extends EFTargetable(EFSourceMixin(EFTemporal(FetchMixin(LitElement)), { assetType: "isobmff_files" })) {
 	constructor(..._args) {
 		super(..._args);
-		this.currentTimeMs = 0;
-		this._mode = "auto";
-		this.prefetchSegments = 3;
-		this.cacheSize = 20;
-		this.enablePrefetch = true;
-		this.jitLoadingState = "idle";
-		this.jitErrorMessage = null;
-		this.jitCacheStats = null;
-		this.jitClientTask = new Task(this, {
-			autoRun: EF_INTERACTIVE,
+		this.mediaSourceService = new MediaSourceService({
 			onError: (error) => {
-				console.error("jitClientTask error", error);
-			},
-			args: () => [
-				this.apiHost,
-				this.cacheSize,
-				this.enablePrefetch,
-				this.prefetchSegments
-			],
-			task: ([apiHost, cacheSize, enablePrefetch, prefetchSegments]) => {
-				const baseUrl = apiHost && apiHost !== "https://editframe.dev" ? apiHost : "http://localhost:3000";
-				return new JitTranscodingClient({
-					baseUrl,
-					segmentCacheSize: cacheSize,
-					enableNetworkAdaptation: enablePrefetch,
-					enablePrefetch,
-					prefetchSegments
-				});
-			}
-		});
-		this.jitMetadataLoader = new Task(this, {
-			autoRun: EF_INTERACTIVE,
-			onError: (error) => {
-				console.error("jitMetadataLoader error", error);
-			},
-			args: () => [this.src, this.jitClientTask.value],
-			task: async ([src, _jitClient], { signal: _signal }) => {
-				if (this.effectiveMode !== "jit-transcode") return null;
-				await this.jitClientTask.taskComplete;
-				const jitClient = this.jitClientTask.value;
-				if (!src || !jitClient) return null;
-				try {
-					this.jitLoadingState = "metadata";
-					this.jitErrorMessage = null;
-					const metadata = await jitClient.loadVideoMetadata(src);
-					this.jitLoadingState = "idle";
-					return metadata;
-				} catch (error) {
-					this.jitLoadingState = "error";
-					this.jitErrorMessage = error instanceof Error ? error.message : "Failed to load video metadata";
-					log("Failed to load JIT metadata:", error);
-					return null;
-				}
+				console.error("🎵 [EFMedia] MediaSourceService error:", error);
 			},
-			onComplete: () => {
-				if (this.jitLoadingState === "metadata") this.jitLoadingState = "idle";
-				this.requestUpdate("intrinsicDurationMs");
-				this.requestUpdate("ownCurrentTimeMs");
-				this.rootTimegroup?.requestUpdate("ownCurrentTimeMs");
-				this.rootTimegroup?.requestUpdate("durationMs");
-			}
-		});
-		this.audioBufferTask = new Task(this, {
-			autoRun: EF_INTERACTIVE,
-			onError: (error) => {
-				console.error("audioBufferTask error", error);
-			},
-			args: () => [this.mediaSegmentsTask.value, this.seekTask.value],
-			task: async ([files, segments], { signal: _signal }) => {
-				if (!files || !segments) return;
-				if (!this.defaultAudioTrackId) return;
-				const segment = segments[this.defaultAudioTrackId];
-				if (!segment) return;
-				const audioFile = files[this.defaultAudioTrackId];
-				if (!audioFile) return;
-				return {
-					buffer: await this.#audioContext.decodeAudioData(await audioFile.arrayBuffer()),
-					startOffsetMs: segment.segment.cts / segment.track.timescale * 1e3
-				};
-			}
-		});
-		this.byteTimeDomainTask = new Task(this, {
-			autoRun: EF_INTERACTIVE,
-			onError: (error) => {
-				console.error("byteTimeDomainTask error", error);
-			},
-			args: () => [
-				this.audioBufferTask.status,
-				this.currentSourceTimeMs,
-				this.fftSize,
-				this.fftDecay,
-				this.fftGain,
-				this.shouldInterpolateFrequencies
-			],
-			task: async () => {
-				await this.audioBufferTask.taskComplete;
-				if (!this.audioBufferTask.value) return null;
-				if (this.currentSourceTimeMs < 0) return null;
-				const currentTimeMs = this.currentSourceTimeMs;
-				const startOffsetMs = this.audioBufferTask.value.startOffsetMs;
-				const audioBuffer = this.audioBufferTask.value.buffer;
-				const smoothedKey = `${this.shouldInterpolateFrequencies}:${this.fftSize}:${this.fftDecay}:${this.fftGain}:${startOffsetMs}:${currentTimeMs}`;
-				const cachedData = this.#byteTimeDomainCache.get(smoothedKey);
-				if (cachedData) return cachedData;
-				const framesData = await Promise.all(Array.from({ length: this.fftDecay }, async (_, frameIndex) => {
-					const frameOffset = frameIndex * (1e3 / 30);
-					const startTime = Math.max(0, (currentTimeMs - frameOffset - startOffsetMs) / 1e3);
-					const cacheKey = `${this.shouldInterpolateFrequencies}:${this.fftSize}:${this.fftGain}:${startOffsetMs}:${startTime}`;
-					const cachedFrame = this.#byteTimeDomainCache.get(cacheKey);
-					if (cachedFrame) return cachedFrame;
-					let audioContext;
-					try {
-						audioContext = new OfflineAudioContext(2, 48e3 * (1 / 30), 48e3);
-					} catch (error) {
-						throw new Error(`[EFMedia.byteTimeDomainTask] Failed to create OfflineAudioContext(2, ${48e3 * (1 / 30)}, 48000) for frame ${frameIndex} at time ${startTime}s: ${error instanceof Error ? error.message : String(error)}. This is for audio time domain analysis.`);
-					}
-					const source = audioContext.createBufferSource();
-					source.buffer = audioBuffer;
-					const analyser = audioContext.createAnalyser();
-					analyser.fftSize = this.fftSize;
-					analyser.minDecibels = -90;
-					analyser.maxDecibels = -20;
-					const gainNode = audioContext.createGain();
-					gainNode.gain.value = this.fftGain;
-					source.connect(gainNode);
-					gainNode.connect(analyser);
-					analyser.connect(audioContext.destination);
-					source.start(0, startTime, 1 / 30);
-					const dataLength = analyser.fftSize / 2;
-					try {
-						await audioContext.startRendering();
-						const frameData = new Uint8Array(dataLength);
-						analyser.getByteTimeDomainData(frameData);
-						const points = new Uint8Array(dataLength);
-						for (let i = 0; i < dataLength; i++) {
-							const pointSamples = frameData.slice(i * (frameData.length / dataLength), (i + 1) * (frameData.length / dataLength));
-							const rms = Math.sqrt(pointSamples.reduce((sum, sample) => {
-								const normalized = (sample - 128) / 128;
-								return sum + normalized * normalized;
-							}, 0) / pointSamples.length);
-							const avgSign = Math.sign(pointSamples.reduce((sum, sample) => sum + (sample - 128), 0));
-							points[i] = Math.min(255, Math.round(128 + avgSign * rms * 128));
-						}
-						this.#byteTimeDomainCache.set(cacheKey, points);
-						return points;
-					} finally {
-						source.disconnect();
-						analyser.disconnect();
-					}
-				}));
-				const frameLength = framesData[0]?.length ?? 0;
-				const smoothedData = new Uint8Array(frameLength);
-				for (let i = 0; i < frameLength; i++) {
-					let weightedSum = 0;
-					let weightSum = 0;
-					framesData.forEach((frame, frameIndex) => {
-						const decayWeight = EFMedia.DECAY_WEIGHT ** frameIndex;
-						weightedSum += (frame[i] ?? 0) * decayWeight;
-						weightSum += decayWeight;
-					});
-					smoothedData[i] = Math.min(255, Math.round(weightedSum / weightSum));
-				}
-				this.#byteTimeDomainCache.set(smoothedKey, smoothedData);
-				return smoothedData;
-			}
-		});
-		this.frequencyDataTask = new Task(this, {
-			autoRun: EF_INTERACTIVE,
-			onError: (error) => {
-				console.error("frequencyDataTask error", error);
-			},
-			args: () => [
-				this.audioBufferTask.status,
-				this.currentSourceTimeMs,
-				this.fftSize,
-				this.fftDecay,
-				this.fftGain,
-				this.shouldInterpolateFrequencies
-			],
-			task: async () => {
-				await this.audioBufferTask.taskComplete;
-				if (!this.audioBufferTask.value) return null;
-				if (this.currentSourceTimeMs < 0) return null;
-				const currentTimeMs = this.currentSourceTimeMs;
-				const startOffsetMs = this.audioBufferTask.value.startOffsetMs;
-				const audioBuffer = this.audioBufferTask.value.buffer;
-				const smoothedKey = `${this.shouldInterpolateFrequencies}:${this.fftSize}:${this.fftDecay}:${this.fftGain}:${startOffsetMs}:${currentTimeMs}`;
-				const cachedSmoothedData = this.#frequencyDataCache.get(smoothedKey);
-				if (cachedSmoothedData) return cachedSmoothedData;
-				const framesData = await Promise.all(Array.from({ length: this.fftDecay }, async (_, i) => {
-					const frameOffset = i * (1e3 / 30);
-					const startTime = Math.max(0, (currentTimeMs - frameOffset - startOffsetMs) / 1e3);
-					const cacheKey = `${this.shouldInterpolateFrequencies}:${this.fftSize}:${this.fftGain}:${startOffsetMs}:${startTime}`;
-					const cachedFrame = this.#frequencyDataCache.get(cacheKey);
-					if (cachedFrame) return cachedFrame;
-					const SIZE = 48e3 / 30;
-					let audioContext;
-					try {
-						audioContext = new OfflineAudioContext(2, SIZE, 48e3);
-					} catch (error) {
-						throw new Error(`[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.`);
-					}
-					const analyser = audioContext.createAnalyser();
-					analyser.fftSize = this.fftSize;
-					analyser.minDecibels = -90;
-					analyser.maxDecibels = -10;
-					const gainNode = audioContext.createGain();
-					gainNode.gain.value = this.fftGain;
-					const filter = audioContext.createBiquadFilter();
-					filter.type = "bandpass";
-					filter.frequency.value = 15e3;
-					filter.Q.value = .05;
-					const audioBufferSource = audioContext.createBufferSource();
-					audioBufferSource.buffer = audioBuffer;
-					audioBufferSource.connect(filter);
-					filter.connect(gainNode);
-					gainNode.connect(analyser);
-					analyser.connect(audioContext.destination);
-					audioBufferSource.start(0, startTime, 1 / 30);
-					try {
-						await audioContext.startRendering();
-						const frameData = new Uint8Array(this.fftSize / 2);
-						analyser.getByteFrequencyData(frameData);
-						this.#frequencyDataCache.set(cacheKey, frameData);
-						return frameData;
-					} finally {
-						audioBufferSource.disconnect();
-						analyser.disconnect();
-					}
-				}));
-				const frameLength = framesData[0]?.length ?? 0;
-				const smoothedData = new Uint8Array(frameLength);
-				for (let i = 0; i < frameLength; i++) {
-					let weightedSum = 0;
-					let weightSum = 0;
-					framesData.forEach((frame, frameIndex) => {
-						const decayWeight = EFMedia.DECAY_WEIGHT ** frameIndex;
-						weightedSum += (frame[i] ?? 0) * decayWeight;
-						weightSum += decayWeight;
-					});
-					smoothedData[i] = Math.min(255, Math.round(weightedSum / weightSum));
-				}
-				smoothedData.forEach((value, i) => {
-					const freqWeight = this.FREQ_WEIGHTS[i] ?? 0;
-					smoothedData[i] = Math.min(255, Math.round(value * freqWeight));
-				});
-				const slicedData = smoothedData.slice(0, Math.floor(smoothedData.length / 2));
-				const processedData = this.shouldInterpolateFrequencies ? processFFTData(slicedData) : slicedData;
-				this.#frequencyDataCache.set(smoothedKey, processedData);
-				return processedData;
-			}
-		});
-		this.videoAssetTask = new Task(this, {
-			autoRun: EF_INTERACTIVE,
-			onError: (error) => {
-				console.error("videoAssetTask error", error);
-			},
-			args: () => [this.effectiveMode, this.mediaSegmentsTask.value],
-			task: async ([mode, files], { signal: _signal }) => {
-				if (!files) return;
-				const fragmentIndex = this.fragmentIndexTask.value;
-				const computedVideoTrackId = Object.values(fragmentIndex ?? {}).find((track) => track.type === "video")?.track;
-				if (computedVideoTrackId === void 0) return;
-				const videoFile = files[computedVideoTrackId];
-				if (!videoFile) return;
-				const existingAsset = this.videoAssetTask.value;
-				if (existingAsset) {
-					for (const frame of existingAsset?.decodedFrames || []) frame.close();
-					const maybeDecoder = existingAsset?.videoDecoder;
-					if (maybeDecoder?.state !== "closed") maybeDecoder.close();
-				}
-				if (mode === "jit-transcode") return await VideoAsset.createFromCompleteMP4(`jit-segment-${computedVideoTrackId}`, videoFile);
-				return await VideoAsset.createFromReadableStream("video.mp4", videoFile.stream(), videoFile);
-			}
-		});
-		this._desiredSeekTimeMs = -1;
-		this.assetIndexLoader = new Task(this, {
-			autoRun: EF_INTERACTIVE,
-			onError: (error) => {
-				console.error("assetIndexLoader error", error);
-			},
-			args: () => [this.effectiveMode === "asset" ? this.fragmentIndexPath() : null, this.fetch],
-			task: async ([path, fetch], { signal }) => {
-				if (!path) return null;
-				try {
-					const response = await fetch(path, { signal });
-					return await response.json();
-				} catch (error) {
-					console.error("Failed to load asset fragment index", error);
-					return null;
-				}
-			},
-			onComplete: () => {
-				this.requestUpdate("intrinsicDurationMs");
-				this.requestUpdate("ownCurrentTimeMs");
-				this.rootTimegroup?.requestUpdate("ownCurrentTimeMs");
-				this.rootTimegroup?.requestUpdate("durationMs");
-			}
-		});
-		this.assetSegmentKeysTask = new Task(this, {
-			autoRun: EF_INTERACTIVE,
-			onError: (error) => {
-				console.error("assetSegmentKeysTask error", error);
-			},
-			args: () => [this.effectiveMode === "asset" ? this.assetIndexLoader.value : null, this.desiredSeekTimeMs],
-			task: async ([fragmentIndex, seekMs]) => {
-				if (this.effectiveMode === "asset") {
-					await this.assetIndexLoader.taskComplete;
-					fragmentIndex = this.assetIndexLoader.value;
-				}
-				if (!fragmentIndex || seekMs == null) return null;
-				return this.calculateAssetSegmentKeys(fragmentIndex, seekMs);
-			}
-		});
-		this.assetInitSegmentsTask = new Task(this, {
-			autoRun: EF_INTERACTIVE,
-			onError: (error) => {
-				console.error("assetInitSegmentsTask error", error);
-			},
-			args: () => [this.effectiveMode === "asset" ? this.assetIndexLoader.value : null, this.fetch],
-			task: async ([fragmentIndex, fetch], { signal }) => {
-				if (this.effectiveMode === "asset") {
-					await this.assetIndexLoader.taskComplete;
-					fragmentIndex = this.assetIndexLoader.value;
-				}
-				if (!fragmentIndex) return null;
-				return await Promise.all(Object.entries(fragmentIndex).map(async ([trackId, track]) => {
-					const start = track.initSegment.offset;
-					const end = track.initSegment.offset + track.initSegment.size;
-					const response = await fetch(this.fragmentTrackPath(trackId), {
-						signal,
-						headers: { Range: `bytes=${start}-${end - 1}` }
-					});
-					const buffer = await response.arrayBuffer();
-					buffer.fileStart = 0;
-					const mp4File = new MP4File();
-					mp4File.appendBuffer(buffer, true);
-					mp4File.flush();
-					await mp4File.readyPromise;
-					return {
-						trackId,
-						buffer,
-						mp4File
-					};
-				}));
-			}
-		});
-		this.assetSegmentLoader = new Task(this, {
-			autoRun: EF_INTERACTIVE,
-			onError: (error) => {
-				console.error("assetSegmentLoader error", error);
-			},
-			argsEqual: deepArrayEquals,
-			args: () => [
-				this.assetIndexLoader.value,
-				this.assetSegmentKeysTask.value,
-				this.assetInitSegmentsTask.value,
-				this.fetch
-			],
-			task: async ([fragmentIndex, segmentKeys, initSegments, fetch], { signal }) => {
-				if (this.effectiveMode === "asset") {
-					await this.assetIndexLoader.taskComplete;
-					fragmentIndex = this.assetIndexLoader.value;
-					await this.assetSegmentKeysTask.taskComplete;
-					segmentKeys = this.assetSegmentKeysTask.value;
-					await this.assetInitSegmentsTask.taskComplete;
-					initSegments = this.assetInitSegmentsTask.value;
-				}
-				if (!fragmentIndex || !segmentKeys || !initSegments) return null;
-				const seekMs = this.desiredSeekTimeMs;
-				if (seekMs == null) return null;
-				const files = {};
-				const seekResult = this.calculateAssetSeekResult(fragmentIndex, initSegments, seekMs);
-				if (!seekResult) return null;
-				for (const [trackId, { segment, track, nextSegment }] of Object.entries(seekResult)) {
-					const start = segment.offset;
-					const end = segment.offset + segment.size;
-					const response = await fetch(this.fragmentTrackPath(trackId), {
-						signal,
-						headers: { Range: `bytes=${start}-${end - 1}` }
-					});
-					if (nextSegment) {
-						const nextStart = nextSegment.offset;
-						const nextEnd = nextSegment.offset + nextSegment.size;
-						fetch(this.fragmentTrackPath(trackId), {
-							signal,
-							headers: { Range: `bytes=${nextStart}-${nextEnd - 1}` }
-						}).catch(() => {});
-					}
-					const initSegment = initSegments.find((seg) => seg.trackId === String(track.id));
-					if (!initSegment) continue;
-					const mediaBuffer = await response.arrayBuffer();
-					files[trackId] = new File([initSegment.buffer, mediaBuffer], "video.mp4", { type: "video/mp4" });
-				}
-				return files;
-			}
-		});
-		this.jitSegmentKeysTask = new Task(this, {
-			autoRun: EF_INTERACTIVE,
-			onError: (error) => {
-				console.error("jitSegmentKeysTask error", error);
-			},
-			args: () => [this.effectiveMode === "jit-transcode" ? this.jitMetadataLoader.value : null, this.desiredSeekTimeMs],
-			task: ([metadata, seekMs]) => {
-				if (!metadata || seekMs == null) return null;
-				return this.calculateJitSegmentKeys(metadata, seekMs);
-			}
-		});
-		this.jitSegmentLoader = new Task(this, {
-			autoRun: EF_INTERACTIVE,
-			onError: (error) => {
-				console.error("jitSegmentLoader error", error);
-			},
-			argsEqual: deepArrayEquals,
-			args: () => [
-				this.src,
-				this.jitSegmentKeysTask.value,
-				this.jitMetadataLoader.value
-			],
-			task: async ([src, segmentKeys, metadata], { signal: _signal }) => {
-				await this.jitSegmentKeysTask.taskComplete;
-				await this.jitMetadataLoader.taskComplete;
-				if (!src || !segmentKeys || !metadata || !this.jitClientTask.value) return null;
-				const seekMs = this.desiredSeekTimeMs;
-				if (seekMs == null) return null;
-				try {
-					this.jitLoadingState = "segments";
-					this.jitErrorMessage = null;
-					const files = {};
-					const quality = await this.jitClientTask.value.getAdaptiveQuality();
-					const fragmentIndex = this.synthesizeFragmentIndex(metadata);
-					const seekResult = this.calculateJitSeekResult(fragmentIndex, seekMs);
-					for (const [trackId, { segment, track, nextSegment }] of Object.entries(seekResult)) {
-						const startTimeMs = segment.dts / track.timescale * 1e3;
-						const segmentBuffer = await this.jitClientTask.value.fetchSegment(src, startTimeMs, quality);
-						files[trackId] = new File([segmentBuffer], "segment.mp4", { type: "video/mp4" });
-						if (nextSegment && this.enablePrefetch) {
-							const nextStartTimeMs = nextSegment.dts / track.timescale * 1e3;
-							this.jitClientTask.value.fetchSegment(src, nextStartTimeMs, quality).catch(() => {});
-						}
-					}
-					this.jitCacheStats = this.jitClientTask.value.getCacheStats();
-					this.jitLoadingState = "idle";
-					return files;
-				} catch (error) {
-					this.jitLoadingState = "error";
-					this.jitErrorMessage = error instanceof Error ? error.message : "Failed to load video segments";
-					throw error;
-				}
-			}
-		});
-		this.fragmentIndexTask = new Task(this, {
-			autoRun: EF_INTERACTIVE,
-			onError: (error) => {
-				console.error("fragmentIndexTask error", error);
-			},
-			args: () => [this.assetIndexLoader.value, this.jitMetadataLoader.value],
-			task: async ([assetIndex, jitMetadata]) => {
-				await this.assetIndexLoader.taskComplete;
-				await this.jitMetadataLoader.taskComplete;
-				if (assetIndex) return assetIndex;
-				if (jitMetadata) return this.synthesizeFragmentIndex(jitMetadata);
-				return null;
-			}
-		});
-		this.mediaSegmentsTask = new Task(this, {
-			autoRun: EF_INTERACTIVE,
-			onError: (error) => {
-				console.error("mediaSegmentsTask error", error);
-			},
-			args: () => [this.assetSegmentLoader.value, this.jitSegmentLoader.value],
-			task: async ([_assetFiles, _jitFiles], { signal }) => {
-				log("🔍 SIGNAL: mediaSegmentsTask starting", { signalAborted: signal.aborted });
-				await this.assetSegmentLoader.taskComplete;
-				if (signal.aborted) {
-					log("🔍 SIGNAL: mediaSegmentsTask aborted after assetSegmentLoader.taskComplete");
-					return null;
-				}
-				await this.jitSegmentLoader.taskComplete;
-				if (signal.aborted) {
-					log("🔍 SIGNAL: mediaSegmentsTask aborted after jitSegmentLoader.taskComplete");
-					return null;
-				}
-				const assetFiles = this.assetSegmentLoader.value;
-				const jitFiles = this.jitSegmentLoader.value;
-				log("🔍 SIGNAL: mediaSegmentsTask using fresh values", {
-					hasAssetFiles: !!assetFiles,
-					hasJitFiles: !!jitFiles,
-					signalAborted: signal.aborted
-				});
-				const result = assetFiles || jitFiles || null;
-				log("🔍 SIGNAL: mediaSegmentsTask resolved", {
-					hasResult: !!result,
-					signalAborted: signal.aborted
-				});
-				return result;
-			}
-		});
-		this.seekTask = new Task(this, {
-			autoRun: EF_INTERACTIVE,
-			onError: (error) => {
-				console.error("seekTask error", error);
-			},
-			args: () => [
-				this.fragmentIndexTask.value,
-				this.mediaSegmentsTask.value,
-				this.desiredSeekTimeMs
-			],
-			task: async ([_fragmentIndex, _files, seekMs], { signal }) => {
-				log("🔍 SIGNAL: seekTask starting", {
-					seekMs,
-					signalAborted: signal.aborted
-				});
-				await this.fragmentIndexTask.taskComplete;
-				if (signal.aborted) {
-					log("🔍 SIGNAL: seekTask aborted after fragmentIndexTask.taskComplete");
-					return null;
-				}
-				await this.mediaSegmentsTask.taskComplete;
-				if (signal.aborted) {
-					log("🔍 SIGNAL: seekTask aborted after mediaSegmentsTask.taskComplete");
-					return null;
-				}
-				const fragmentIndex = this.fragmentIndexTask.value;
-				const files = this.mediaSegmentsTask.value;
-				log("🔍 SIGNAL: seekTask using fresh values", {
-					hasFragmentIndex: !!fragmentIndex,
-					hasFiles: !!files,
-					seekMs,
-					signalAborted: signal.aborted
-				});
-				const typedFragmentIndex = fragmentIndex;
-				if (!typedFragmentIndex || !files) {
-					log("🔍 SIGNAL: seekTask calculation aborted - missing required data");
-					return null;
-				}
-				const result = {};
-				for (const index of Object.values(typedFragmentIndex)) {
-					const track = this.createTrackInfo(index);
-					log("trace: processing track", {
-						trackId: index.track,
-						type: index.type
-					});
-					const segment = index.segments.toReversed().find((segment$1) => {
-						const segmentStartMs = segment$1.dts / track.timescale * 1e3;
-						return segmentStartMs <= seekMs;
-					});
-					const nextSegment = index.segments.find((segment$1) => {
-						const segmentStartMs = segment$1.dts / track.timescale * 1e3;
-						return segmentStartMs > seekMs;
-					});
-					if (segment) {
-						result[index.track] = {
-							segment,
-							track,
-							nextSegment
-						};
-						log("trace: found segment for track", {
-							trackId: index.track,
-							segmentDts: segment.dts,
-							hasNextSegment: !!nextSegment
-						});
-					}
-				}
-				log("🔍 SIGNAL: seekTask calculation complete", {
-					trackCount: Object.keys(result).length,
-					signalAborted: signal.aborted
-				});
-				return result;
-			}
+			onReady: () => {}
 		});
+		this.audioElementFactory = new AudioElementFactory();
+		this.currentTimeMs = 0;
+		this.audioBufferDurationMs = 3e4;
+		this.maxAudioBufferFetches = 2;
+		this.enableAudioBuffering = true;
+		this.mute = false;
+		this.fftSize = 128;
+		this.fftDecay = 8;
+		this.fftGain = 3;
+		this.interpolateFrequencies = false;
+		this.mediaEngineTask = makeMediaEngineTask(this);
+		this.audioSegmentIdTask = makeAudioSegmentIdTask(this);
+		this.audioInitSegmentFetchTask = makeAudioInitSegmentFetchTask(this);
+		this.audioSegmentFetchTask = makeAudioSegmentFetchTask(this);
+		this.audioInputTask = makeAudioInputTask(this);
+		this.audioSeekTask = makeAudioSeekTask(this);
+		this.audioBufferTask = makeAudioBufferTask(this);
+		this.byteTimeDomainTask = makeAudioTimeDomainAnalysisTask(this);
+		this.frequencyDataTask = makeAudioFrequencyAnalysisTask(this);
+		this.assetId = null;
+		this._desiredSeekTimeMs = 0;
+	}
+	static {
+		this.VIDEO_SAMPLE_BUFFER_SIZE = 30;
+	}
+	static {
+		this.AUDIO_SAMPLE_BUFFER_SIZE = 120;
+	}
+	static get observedAttributes() {
+		const parentAttributes = super.observedAttributes || [];
+		return [
+			...parentAttributes,
+			"mute",
+			"fft-size",
+			"fft-decay",
+			"fft-gain",
+			"interpolate-frequencies",
+			"asset-id",
+			"audio-buffer-duration",
+			"max-audio-buffer-fetches",
+			"enable-audio-buffering"
+		];
 	}
 	static {
 		this.styles = [css`
@@ -626,307 +86,6 @@ var EFMedia = class EFMedia extends EFTargetable(EFSourceMixin(EFTemporal(FetchM
       }
     `];
 	}
-	/**
-	* Get the mode, prioritizing attribute values over property values
-	*/
-	get mode() {
-		const attr = this.getAttribute("mode");
-		return attr || this._mode || "auto";
-	}
-	set mode(value) {
-		const oldValue = this.mode;
-		this._mode = value;
-		this.setAttribute("mode", value);
-		this.requestUpdate("mode", oldValue);
-	}
-	connectedCallback() {
-		super.connectedCallback();
-		const modeAttr = this.getAttribute("mode");
-		if (modeAttr && modeAttr !== this._mode) {
-			this._mode = modeAttr;
-			this.requestUpdate("mode");
-		}
-		const prefetchSegmentsAttr = this.getAttribute("prefetch-segments");
-		if (prefetchSegmentsAttr !== null) this.prefetchSegments = Number.parseInt(prefetchSegmentsAttr, 10) || 3;
-		const cacheSizeAttr = this.getAttribute("cache-size");
-		if (cacheSizeAttr !== null) this.cacheSize = Number.parseInt(cacheSizeAttr, 10) || 20;
-		const enablePrefetchAttr = this.getAttribute("enable-prefetch");
-		if (enablePrefetchAttr !== null) this.enablePrefetch = enablePrefetchAttr === "true";
-	}
-	/**
-	* Detected loading mode based on URL patterns and manual override
-	*/
-	get effectiveMode() {
-		const actualMode = this.mode;
-		if (actualMode === "asset" || actualMode === "jit-transcode") return actualMode;
-		if (this.assetId) return "asset";
-		if (!this.src) return "asset";
-		if (JitTranscodingClient.isJitTranscodeEligible(this.src)) return "jit-transcode";
-		return "asset";
-	}
-	#assetId = null;
-	/**
-	* The unique identifier for the media asset.
-	* This property can be set programmatically or via the "asset-id" attribute.
-	* @domAttribute "asset-id"
-	*/
-	set assetId(value) {
-		this.#assetId = value;
-	}
-	get assetId() {
-		return this.#assetId || this.getAttribute("asset-id");
-	}
-	fragmentIndexPath() {
-		if (this.assetId) return `${this.apiHost}/api/v1/isobmff_files/${this.assetId}/index`;
-		const src = this.src ?? "";
-		if (!src) return "/@ef-track-fragment-index/no-src-available";
-		const normalizedSrc = src.startsWith("/") ? src.slice(1) : src;
-		if (normalizedSrc.startsWith("@ef-")) return `/@ef-track-fragment-index/${normalizedSrc}`;
-		return `/@ef-track-fragment-index/${normalizedSrc}`;
-	}
-	fragmentTrackPath(trackId) {
-		if (this.assetId) return `${this.apiHost}/api/v1/isobmff_tracks/${this.assetId}/${trackId}`;
-		const src = this.src ?? "";
-		if (!src) return `/@ef-track/no-src-available?trackId=${trackId}`;
-		const normalizedSrc = src.startsWith("/") ? src.slice(1) : src;
-		if (normalizedSrc.startsWith("@ef-")) return `/@ef-track/${normalizedSrc}?trackId=${trackId}`;
-		return `/@ef-track/${normalizedSrc}?trackId=${trackId}`;
-	}
-	get mediaDurationTask() {
-		return this.fragmentIndexTask;
-	}
-	get defaultVideoTrackId() {
-		const fragmentIndex = this.fragmentIndexTask.value;
-		return Object.values(fragmentIndex ?? {}).find((track) => track.type === "video")?.track;
-	}
-	get defaultAudioTrackId() {
-		const fragmentIndex = this.fragmentIndexTask.value;
-		return Object.values(fragmentIndex ?? {}).find((track) => track.type === "audio")?.track;
-	}
-	get intrinsicDurationMs() {
-		const fragmentIndex = this.fragmentIndexTask.value;
-		if (!fragmentIndex) return 0;
-		const durations = Object.values(fragmentIndex).map((track) => track.duration / track.timescale * 1e3);
-		if (durations.length === 0) return 0;
-		return Math.max(...durations);
-	}
-	#audioContext = (() => {
-		try {
-			return new OfflineAudioContext(2, 48e3 / 30, 48e3);
-		} catch (error) {
-			throw new Error(`[EFMedia.audioBufferTask] Failed to create OfflineAudioContext(2, ${48e3 / 30}, 48000): ${error instanceof Error ? error.message : String(error)}. This is the class field audioContext for audio buffer task processing.`);
-		}
-	})();
-	async fetchAudioSpanningTime(fromMs, toMs) {
-		toMs = Math.min(toMs, this.durationMs);
-		if (this.sourceInMs) fromMs -= this.startTimeMs - (this.trimStartMs ?? 0) - (this.sourceInMs ?? 0);
-		if (this.sourceOutMs) toMs -= this.startTimeMs - (this.trimStartMs ?? 0) - (this.sourceOutMs ?? 0);
-		fromMs -= this.startTimeMs - (this.trimStartMs ?? 0);
-		toMs -= this.startTimeMs - (this.trimStartMs ?? 0);
-		await this.fragmentIndexTask.taskComplete;
-		const fragmentIndex = this.fragmentIndexTask.value;
-		const audioTrackId = this.defaultAudioTrackId;
-		if (!audioTrackId) return void 0;
-		const audioTrackIndex = fragmentIndex?.[audioTrackId];
-		if (!audioTrackIndex) return void 0;
-		if (this.effectiveMode === "jit-transcode" && this.src) {
-			const jitClient = this.jitClientTask.value;
-			if (!jitClient) return void 0;
-			try {
-				const segmentDuration = 2e3;
-				const startSegmentIndex = Math.floor(fromMs / segmentDuration);
-				const maxSegmentIndex = Math.floor(this.durationMs / segmentDuration) - 1;
-				const endSegmentIndex = Math.min(Math.floor(toMs / segmentDuration), maxSegmentIndex);
-				const quality = await jitClient.getAdaptiveQuality();
-				const segmentPromises = [];
-				for (let i = startSegmentIndex; i <= endSegmentIndex; i++) {
-					const segmentStartMs = i * segmentDuration;
-					const segmentEndMs = (i + 1) * segmentDuration;
-					segmentPromises.push(jitClient.fetchSegment(this.src, segmentStartMs, quality).then((buffer) => ({
-						buffer,
-						startMs: segmentStartMs,
-						endMs: segmentEndMs
-					})));
-				}
-				const segments = await Promise.all(segmentPromises);
-				const audioBuffers = [];
-				for (const segment of segments) try {
-					let tempContext;
-					try {
-						tempContext = new OfflineAudioContext(2, 48e3, 48e3);
-					} catch (error) {
-						throw new Error(`[EFMedia.fetchAudioSpanningTime JIT] Failed to create temp OfflineAudioContext(2, 48000, 48000) for segment ${segment.startMs}-${segment.endMs}ms: ${error instanceof Error ? error.message : String(error)}. This is for decoding audio from JIT video segments.`);
-					}
-					const clonedBuffer = segment.buffer.slice(0);
-					const audioBuffer = await tempContext.decodeAudioData(clonedBuffer);
-					audioBuffers.push({
-						buffer: audioBuffer,
-						startMs: segment.startMs,
-						endMs: segment.endMs
-					});
-				} catch (error) {
-					log(`Failed to decode audio from segment ${segment.startMs}-${segment.endMs}ms:`, error);
-					throw error;
-				}
-				if (audioBuffers.length === 0) return void 0;
-				const firstAudioBuffer = audioBuffers[0];
-				const lastAudioBuffer = audioBuffers[audioBuffers.length - 1];
-				if (!firstAudioBuffer || !lastAudioBuffer) return void 0;
-				const sampleRate = firstAudioBuffer.buffer.sampleRate;
-				const numberOfChannels = firstAudioBuffer.buffer.numberOfChannels;
-				const actualStartMs = Math.max(fromMs, firstAudioBuffer.startMs);
-				const actualEndMs = Math.min(toMs, lastAudioBuffer.endMs);
-				const totalDurationMs = actualEndMs - actualStartMs;
-				const totalSamples = Math.floor(totalDurationMs / 1e3 * sampleRate);
-				if (totalSamples <= 0) return void 0;
-				let finalContext;
-				try {
-					finalContext = new OfflineAudioContext(numberOfChannels, totalSamples, sampleRate);
-				} catch (error) {
-					throw new Error(`[EFMedia.fetchAudioSpanningTime final] Failed to create final OfflineAudioContext(${numberOfChannels}, ${totalSamples}, ${sampleRate}) for time range ${actualStartMs}-${actualEndMs}ms: ${error instanceof Error ? error.message : String(error)}. This is for creating the final concatenated audio buffer.`);
-				}
-				const finalBuffer = finalContext.createBuffer(numberOfChannels, totalSamples, sampleRate);
-				let outputOffset = 0;
-				for (const { buffer: audioBuffer, startMs: segmentStartMs, endMs: segmentEndMs } of audioBuffers) {
-					const segmentNeedStart = Math.max(actualStartMs, segmentStartMs);
-					const segmentNeedEnd = Math.min(actualEndMs, segmentEndMs);
-					if (segmentNeedStart >= segmentNeedEnd) continue;
-					const segmentStartSample = Math.floor((segmentNeedStart - segmentStartMs) / 1e3 * sampleRate);
-					const segmentDurationSamples = Math.floor((segmentNeedEnd - segmentNeedStart) / 1e3 * sampleRate);
-					const actualSamples = Math.min(segmentDurationSamples, audioBuffer.length - segmentStartSample, totalSamples - outputOffset);
-					if (actualSamples <= 0) continue;
-					for (let channel = 0; channel < numberOfChannels; channel++) {
-						const sourceData = audioBuffer.getChannelData(channel);
-						const targetData = finalBuffer.getChannelData(channel);
-						for (let i = 0; i < actualSamples; i++) {
-							const sourceIndex = segmentStartSample + i;
-							const targetIndex = outputOffset + i;
-							if (sourceIndex < sourceData.length && targetIndex < targetData.length) {
-								const sample = sourceData[sourceIndex];
-								if (sample !== void 0) targetData[targetIndex] = sample;
-							}
-						}
-					}
-					outputOffset += actualSamples;
-				}
-				const wavBlob = this.encodeWAVBuffer(finalBuffer);
-				const result = {
-					blob: wavBlob,
-					startMs: actualStartMs - (this.trimStartMs ?? 0),
-					endMs: actualEndMs - (this.trimEndMs ?? 0)
-				};
-				return result;
-			} catch (error) {
-				log("Failed to extract and concatenate audio from JIT video segments:", error);
-				return void 0;
-			}
-		}
-		const start = audioTrackIndex.initSegment.offset;
-		const end = audioTrackIndex.initSegment.offset + audioTrackIndex.initSegment.size;
-		const audioInitFragmentRequest = this.fetch(this.fragmentTrackPath(String(audioTrackId)), { headers: { Range: `bytes=${start}-${end - 1}` } });
-		const fragments = Object.values(audioTrackIndex.segments).filter((segment) => {
-			const segmentStartsBeforeEnd = segment.dts <= toMs * audioTrackIndex.timescale / 1e3;
-			const segmentEndsAfterStart = segment.dts + segment.duration >= fromMs * audioTrackIndex.timescale / 1e3;
-			return segmentStartsBeforeEnd && segmentEndsAfterStart;
-		});
-		const firstFragment = fragments[0];
-		if (!firstFragment) return void 0;
-		const lastFragment = fragments[fragments.length - 1];
-		if (!lastFragment) return void 0;
-		const fragmentStart = firstFragment.offset;
-		const fragmentEnd = lastFragment.offset + lastFragment.size;
-		const audioFragmentRequest = this.fetch(this.fragmentTrackPath(String(audioTrackId)), { headers: { Range: `bytes=${fragmentStart}-${fragmentEnd - 1}` } });
-		const initResponse = await audioInitFragmentRequest;
-		const dataResponse = await audioFragmentRequest;
-		const initBuffer = await initResponse.arrayBuffer();
-		const dataBuffer = await dataResponse.arrayBuffer();
-		const audioBlob = new Blob([initBuffer, dataBuffer], { type: "audio/mp4" });
-		return {
-			blob: audioBlob,
-			startMs: firstFragment.dts / audioTrackIndex.timescale * 1e3 - (this.trimStartMs ?? 0),
-			endMs: lastFragment.dts / audioTrackIndex.timescale * 1e3 + lastFragment.duration / audioTrackIndex.timescale * 1e3 - (this.trimEndMs ?? 0)
-		};
-	}
-	/**
-	* Encode an AudioBuffer to a WAV blob
-	*/
-	encodeWAVBuffer(audioBuffer) {
-		const numberOfChannels = audioBuffer.numberOfChannels;
-		const sampleRate = audioBuffer.sampleRate;
-		const length = audioBuffer.length;
-		const bytesPerSample = 2;
-		const blockAlign = numberOfChannels * bytesPerSample;
-		const byteRate = sampleRate * blockAlign;
-		const dataSize = length * blockAlign;
-		const fileSize = 36 + dataSize;
-		const buffer = new ArrayBuffer(44 + dataSize);
-		const view = new DataView(buffer);
-		let offset = 0;
-		view.setUint32(offset, 1380533830, false);
-		offset += 4;
-		view.setUint32(offset, fileSize, true);
-		offset += 4;
-		view.setUint32(offset, 1463899717, false);
-		offset += 4;
-		view.setUint32(offset, 1718449184, false);
-		offset += 4;
-		view.setUint32(offset, 16, true);
-		offset += 4;
-		view.setUint16(offset, 1, true);
-		offset += 2;
-		view.setUint16(offset, numberOfChannels, true);
-		offset += 2;
-		view.setUint32(offset, sampleRate, true);
-		offset += 4;
-		view.setUint32(offset, byteRate, true);
-		offset += 4;
-		view.setUint16(offset, blockAlign, true);
-		offset += 2;
-		view.setUint16(offset, 16, true);
-		offset += 2;
-		view.setUint32(offset, 1684108385, false);
-		offset += 4;
-		view.setUint32(offset, dataSize, true);
-		offset += 4;
-		for (let i = 0; i < length; i++) for (let channel = 0; channel < numberOfChannels; channel++) {
-			const sample = audioBuffer.getChannelData(channel)[i] || 0;
-			const pcmSample = Math.max(-32768, Math.min(32767, Math.floor(sample * 32767)));
-			view.setInt16(offset, pcmSample, true);
-			offset += 2;
-		}
-		return new Blob([buffer], { type: "audio/wav" });
-	}
-	set fftSize(value) {
-		const oldValue = this.fftSize;
-		this.setAttribute("fft-size", String(value));
-		this.requestUpdate("fft-size", oldValue);
-	}
-	set fftDecay(value) {
-		const oldValue = this.fftDecay;
-		this.setAttribute("fft-decay", String(value));
-		this.requestUpdate("fft-decay", oldValue);
-	}
-	get fftSize() {
-		return Number.parseInt(this.getAttribute("fft-size") ?? "128", 10);
-	}
-	get fftDecay() {
-		return Number.parseInt(this.getAttribute("fft-decay") ?? "8", 10);
-	}
-	set interpolateFrequencies(value) {
-		const oldValue = this.interpolateFrequencies;
-		this.setAttribute("interpolate-frequencies", String(value));
-		this.requestUpdate("interpolate-frequencies", oldValue);
-	}
-	get interpolateFrequencies() {
-		return this.getAttribute("interpolate-frequencies") !== "false";
-	}
-	get shouldInterpolateFrequencies() {
-		if (this.hasAttribute("interpolate-frequencies")) return this.getAttribute("interpolate-frequencies") !== "false";
-		return false;
-	}
-	static {
-		this.DECAY_WEIGHT = .7;
-	}
 	get FREQ_WEIGHTS() {
 		if (freqWeightsCache.has(this.fftSize)) return freqWeightsCache.get(this.fftSize);
 		const weights = new Float32Array(this.fftSize / 2).map((_, i) => {
@@ -942,175 +101,14 @@ var EFMedia = class EFMedia extends EFTargetable(EFSourceMixin(EFTemporal(FetchM
 		freqWeightsCache.set(this.fftSize, weights);
 		return weights;
 	}
-	#byteTimeDomainCache = new LRUCache(100);
-	#frequencyDataCache = new LRUCache(100);
-	set fftGain(value) {
-		const oldValue = this.fftGain;
-		this.setAttribute("fft-gain", String(value));
-		this.requestUpdate("fft-gain", oldValue);
-	}
-	get fftGain() {
-		return Number.parseFloat(this.getAttribute("fft-gain") ?? "3.0");
-	}
-	synthesizeFragmentIndex(jitMetadata) {
-		const segmentDuration = jitMetadata.segmentDuration || 2e3;
-		const numSegments = Math.ceil(jitMetadata.durationMs / segmentDuration);
-		const fragmentIndex = {};
-		const videoStream = jitMetadata.streams.find((s) => s.type === "video");
-		if (videoStream) {
-			const segments = [];
-			for (let i = 0; i < numSegments; i++) {
-				const startMs = i * segmentDuration;
-				const endMs = Math.min(startMs + segmentDuration, jitMetadata.durationMs);
-				segments.push({
-					dts: Math.floor(startMs * 90),
-					cts: Math.floor(startMs * 90),
-					duration: Math.floor((endMs - startMs) * 90),
-					offset: 0,
-					size: 0
-				});
-			}
-			fragmentIndex[videoStream.index] = {
-				track: videoStream.index,
-				type: "video",
-				timescale: 9e4,
-				duration: Math.floor(jitMetadata.durationMs * 90),
-				width: videoStream.width || 1920,
-				height: videoStream.height || 1080,
-				sample_count: numSegments * 50,
-				codec: videoStream.codecName || "h264",
-				segments,
-				initSegment: {
-					offset: 0,
-					size: 0
-				}
-			};
-		}
-		const audioStream = jitMetadata.streams.find((s) => s.type === "audio");
-		if (audioStream) {
-			const segments = [];
-			const audioTimescale = audioStream.sampleRate || 48e3;
-			for (let i = 0; i < numSegments; i++) {
-				const startMs = i * segmentDuration;
-				const endMs = Math.min(startMs + segmentDuration, jitMetadata.durationMs);
-				segments.push({
-					dts: Math.floor(startMs * audioTimescale / 1e3),
-					cts: Math.floor(startMs * audioTimescale / 1e3),
-					duration: Math.floor((endMs - startMs) * audioTimescale / 1e3),
-					offset: 0,
-					size: 0
-				});
-			}
-			fragmentIndex[audioStream.index] = {
-				track: audioStream.index,
-				type: "audio",
-				timescale: audioTimescale,
-				duration: Math.floor(jitMetadata.durationMs * audioTimescale / 1e3),
-				channel_count: audioStream.channels || 2,
-				sample_rate: audioStream.sampleRate || 48e3,
-				sample_size: 16,
-				sample_count: Math.floor(jitMetadata.durationMs * (audioStream.sampleRate || 48e3) / 1e3),
-				codec: audioStream.codecName || "aac",
-				segments,
-				initSegment: {
-					offset: 0,
-					size: 0
-				}
-			};
-		}
-		return fragmentIndex;
-	}
-	calculateAssetSegmentKeys(fragmentIndex, seekMs) {
-		const segmentKeys = {};
-		for (const [trackId, index] of Object.entries(fragmentIndex)) {
-			const segment = index.segments.toReversed().find((segment$1) => {
-				const segmentStartMs = segment$1.dts / index.timescale * 1e3;
-				return segmentStartMs <= seekMs;
-			});
-			if (segment) {
-				const startTimeMs = segment.dts / index.timescale * 1e3;
-				segmentKeys[trackId] = {
-					startTimeMs,
-					trackId
-				};
-			}
-		}
-		return segmentKeys;
-	}
-	calculateJitSegmentKeys(metadata, seekMs) {
-		const segmentKeys = {};
-		const segmentDuration = metadata.segmentDuration || 2e3;
-		for (const stream of metadata.streams) {
-			const segmentIndex = Math.floor(seekMs / segmentDuration);
-			const startTimeMs = segmentIndex * segmentDuration;
-			segmentKeys[stream.index] = {
-				startTimeMs,
-				trackId: String(stream.index)
-			};
-		}
-		return segmentKeys;
-	}
-	calculateAssetSeekResult(fragmentIndex, initSegments, seekMs) {
-		const result = {};
-		for (const index of Object.values(fragmentIndex)) {
-			const initTrack = initSegments.find((segment$1) => segment$1.trackId === String(index.track))?.mp4File.getInfo().tracks[0];
-			if (!initTrack) continue;
-			const segment = index.segments.toReversed().find((segment$1) => {
-				const segmentStartMs = segment$1.dts / initTrack.timescale * 1e3;
-				return segmentStartMs <= seekMs;
-			});
-			const nextSegment = index.segments.find((segment$1) => {
-				return segment$1.dts / initTrack.timescale * 1e3 > seekMs;
-			});
-			if (segment) result[index.track] = {
-				segment,
-				track: initTrack,
-				nextSegment
-			};
-		}
-		return result;
+	get shouldInterpolateFrequencies() {
+		return this.interpolateFrequencies;
 	}
-	calculateJitSeekResult(fragmentIndex, seekMs) {
-		const result = {};
-		for (const index of Object.values(fragmentIndex)) {
-			const track = this.createTrackInfo(index);
-			const segment = index.segments.toReversed().find((segment$1) => {
-				const segmentStartMs = segment$1.dts / track.timescale * 1e3;
-				return segmentStartMs <= seekMs;
-			});
-			const nextSegment = index.segments.find((segment$1) => {
-				return segment$1.dts / track.timescale * 1e3 > seekMs;
-			});
-			if (segment) result[index.track] = {
-				segment,
-				track,
-				nextSegment
-			};
-		}
-		return result;
+	get urlGenerator() {
+		return new UrlGenerator(() => this.apiHost ?? "");
 	}
-	createTrackInfo(index) {
-		return {
-			id: index.track,
-			name: index.type,
-			type: index.type,
-			timescale: index.timescale,
-			duration: index.duration,
-			bitrate: index.type === "video" ? 1e6 : 128e3,
-			created: /* @__PURE__ */ new Date(),
-			modified: /* @__PURE__ */ new Date(),
-			movie_duration: index.duration,
-			movie_timescale: index.timescale,
-			layer: 0,
-			alternate_group: 0,
-			volume: index.type === "audio" ? 1 : 0,
-			track_width: index.type === "video" ? index.width || 0 : 0,
-			track_height: index.type === "video" ? index.height || 0 : 0,
-			samples_duration: index.duration,
-			codec: index.codec || "unknown",
-			language: "und",
-			nb_samples: index.sample_count || 0
-		};
+	get intrinsicDurationMs() {
+		return this.mediaEngineTask.value?.durationMs ?? 0;
 	}
 	updated(changedProperties) {
 		super.updated(changedProperties);
@@ -1129,60 +127,92 @@ var EFMedia = class EFMedia extends EFTargetable(EFSourceMixin(EFTemporal(FetchM
 	async executeSeek(seekToMs) {
 		this.desiredSeekTimeMs = seekToMs;
 	}
+	/**
+	* Main integration method for EFTimegroup audio playback
+	* Now powered by clean, testable utility functions
+	*/
+	async fetchAudioSpanningTime(fromMs, toMs, signal = new AbortController().signal) {
+		await this.mediaSourceService.initialize();
+		const { fetchAudioSpanningTime: fetchAudioSpan } = await import("./EFMedia/shared/AudioSpanUtils.js");
+		return fetchAudioSpan(this, fromMs, toMs, signal);
+	}
+	/**
+	* Get the HTML audio element for ContextMixin integration
+	*/
+	get audioElement() {
+		return this.mediaSourceService.getAudioElement();
+	}
+	/**
+	* Check if an audio segment is cached in the unified buffer system
+	* Now uses the same caching approach as video for consistency
+	*/
+	getCachedAudioSegment(segmentId) {
+		return this.audioBufferTask.value?.cachedSegments.has(segmentId) ?? false;
+	}
+	/**
+	* Get cached audio segments from the unified buffer system
+	* Now uses the same caching approach as video for consistency
+	*/
+	getCachedAudioSegments(segmentIds) {
+		const bufferState = this.audioBufferTask.value;
+		if (!bufferState) return /* @__PURE__ */ new Set();
+		return new Set(segmentIds.filter((id) => bufferState.cachedSegments.has(id)));
+	}
+	/**
+	* Get MediaElementAudioSourceNode for ContextMixin integration
+	* Uses AudioElementFactory for proper caching and lifecycle management
+	*/
+	async getMediaElementSource(audioContext) {
+		return this.audioElementFactory.createMediaElementSource(audioContext, this.mediaSourceService);
+	}
+	disconnectedCallback() {
+		super.disconnectedCallback?.();
+		this.mediaSourceService.cleanup();
+		this.audioElementFactory.clearCache();
+	}
 };
 _decorate([property({ type: Number })], EFMedia.prototype, "currentTimeMs", void 0);
 _decorate([property({
 	type: Number,
-	attribute: "prefetch-segments"
-})], EFMedia.prototype, "prefetchSegments", void 0);
+	attribute: "audio-buffer-duration"
+})], EFMedia.prototype, "audioBufferDurationMs", void 0);
+_decorate([property({
+	type: Number,
+	attribute: "max-audio-buffer-fetches"
+})], EFMedia.prototype, "maxAudioBufferFetches", void 0);
+_decorate([property({
+	type: Boolean,
+	attribute: "enable-audio-buffering"
+})], EFMedia.prototype, "enableAudioBuffering", void 0);
+_decorate([property({
+	type: Boolean,
+	attribute: "mute",
+	reflect: true
+})], EFMedia.prototype, "mute", void 0);
+_decorate([property({
+	type: Number,
+	attribute: "fft-size",
+	reflect: true
+})], EFMedia.prototype, "fftSize", void 0);
 _decorate([property({
 	type: Number,
-	attribute: "cache-size"
-})], EFMedia.prototype, "cacheSize", void 0);
+	attribute: "fft-decay",
+	reflect: true
+})], EFMedia.prototype, "fftDecay", void 0);
+_decorate([property({
+	type: Number,
+	attribute: "fft-gain",
+	reflect: true
+})], EFMedia.prototype, "fftGain", void 0);
 _decorate([property({
 	type: Boolean,
-	attribute: "enable-prefetch"
-})], EFMedia.prototype, "enablePrefetch", void 0);
-_decorate([state()], EFMedia.prototype, "jitLoadingState", void 0);
-_decorate([state()], EFMedia.prototype, "jitErrorMessage", void 0);
-_decorate([state()], EFMedia.prototype, "jitCacheStats", void 0);
+	attribute: "interpolate-frequencies",
+	reflect: true
+})], EFMedia.prototype, "interpolateFrequencies", void 0);
 _decorate([property({
 	type: String,
 	attribute: "asset-id",
 	reflect: true
-})], EFMedia.prototype, "assetId", null);
+})], EFMedia.prototype, "assetId", void 0);
 _decorate([state()], EFMedia.prototype, "_desiredSeekTimeMs", void 0);
-function processFFTData(fftData, zeroThresholdPercent = .1) {
-	const totalBins = fftData.length;
-	const zeroThresholdCount = Math.floor(totalBins * zeroThresholdPercent);
-	let zeroCount = 0;
-	let cutoffIndex = totalBins;
-	for (let i = totalBins - 1; i >= 0; i--) if (fftData[i] ?? true) zeroCount++;
-	else if (zeroCount >= zeroThresholdCount) {
-		cutoffIndex = i + 1;
-		break;
-	}
-	if (cutoffIndex < zeroThresholdCount) return fftData;
-	const goodData = fftData.slice(0, cutoffIndex);
-	const resampledData = interpolateData(goodData, fftData.length);
-	const attenuationStartIndex = Math.floor(totalBins * .9);
-	for (let i = attenuationStartIndex; i < totalBins; i++) {
-		const attenuationProgress = (i - attenuationStartIndex) / (totalBins - attenuationStartIndex) + .2;
-		const attenuationFactor = Math.max(0, 1 - attenuationProgress);
-		resampledData[i] = Math.floor((resampledData[i] ?? 0) * attenuationFactor);
-	}
-	return resampledData;
-}
-function interpolateData(data, targetSize) {
-	const resampled = new Uint8Array(targetSize);
-	const dataLength = data.length;
-	for (let i = 0; i < targetSize; i++) {
-		const ratio = i / (targetSize - 1) * (dataLength - 1);
-		const index = Math.floor(ratio);
-		const fraction = ratio - index;
-		if (index >= dataLength - 1) resampled[i] = data[dataLength - 1] ?? 0;
-		else resampled[i] = Math.round((data[index] ?? 0) * (1 - fraction) + (data[index + 1] ?? 0) * fraction);
-	}
-	return resampled;
-}
-export { EFMedia, deepGetMediaElements };
+export { EFMedia, IgnorableError, deepGetMediaElements };