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

package/dist/elements/EFMedia.js

@@ -1,697 +1,1188 @@
-import { Task } from "@lit/task";
-import { deepArrayEquals } from "@lit/task/deep-equals.js";
-import debug from "debug";
-import { css, LitElement } from "lit";
-import { property, state } from "lit/decorators.js";
-import { VideoAsset } from "@editframe/assets/EncodedAsset.js";
-import { MP4File } from "@editframe/assets/MP4File.js";
 import { EF_INTERACTIVE } from "../EF_INTERACTIVE.js";
+import { JitTranscodingClient } from "../JitTranscodingClient.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";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __decorateClass = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
-  for (var i = decorators.length - 1, decorator; i >= 0; i--)
-    if (decorator = decorators[i])
-      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
-  if (kind && result) __defProp(target, key, result);
-  return result;
-};
+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();
-class LRUCache {
-  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 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);
+	}
+};
 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;
+	for (const child of Array.from(element.children)) if (child instanceof EFMedia) medias.push(child);
+	else deepGetMediaElements(child, medias);
+	return medias;
 };
-const _EFMedia = class _EFMedia2 extends EFTargetable(
-  EFSourceMixin(EFTemporal(FetchMixin(LitElement)), {
-    assetType: "isobmff_files"
-  })
-) {
-  constructor() {
-    super(...arguments);
-    this.currentTimeMs = 0;
-    this.#assetId = null;
-    this.trackFragmentIndexLoader = new Task(this, {
-      args: () => [this.fragmentIndexPath(), this.fetch],
-      task: async ([fragmentIndexPath, fetch], { signal }) => {
-        try {
-          const response = await fetch(fragmentIndexPath, { signal });
-          return await response.json();
-        } catch (error) {
-          log("Failed to load track fragment index", error);
-          return void 0;
-        }
-      },
-      onComplete: () => {
-        this.requestUpdate("intrinsicDurationMs");
-        this.requestUpdate("ownCurrentTimeMs");
-        this.rootTimegroup?.requestUpdate("ownCurrentTimeMs");
-        this.rootTimegroup?.requestUpdate("durationMs");
-      }
-    });
-    this.initSegmentsLoader = new Task(this, {
-      autoRun: EF_INTERACTIVE,
-      args: () => [this.trackFragmentIndexLoader.value, this.src, this.fetch],
-      task: async ([fragmentIndex, _src, fetch], { signal }) => {
-        if (!fragmentIndex) {
-          return;
-        }
-        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.seekTask = new Task(this, {
-      autoRun: EF_INTERACTIVE,
-      args: () => [
-        this.desiredSeekTimeMs,
-        this.trackFragmentIndexLoader.value,
-        this.initSegmentsLoader.value
-      ],
-      task: async ([seekToMs, fragmentIndex, initSegments], { signal: _signal }) => {
-        if (fragmentIndex === void 0) {
-          return;
-        }
-        if (initSegments === void 0) {
-          return;
-        }
-        const result = {};
-        for (const index of Object.values(fragmentIndex)) {
-          const track = initSegments.find((segment2) => segment2.trackId === String(index.track))?.mp4File.getInfo().tracks[0];
-          if (!track) {
-            throw new Error("Could not finding matching track");
-          }
-          const segment = index.segments.toReversed().find((segment2) => {
-            return segment2.dts / track.timescale * 1e3 <= seekToMs;
-          });
-          const nextSegment = index.segments.find((segment2) => {
-            return segment2.dts / track.timescale * 1e3 > seekToMs;
-          });
-          if (!segment) {
-            return;
-          }
-          result[index.track] = { segment, track, nextSegment };
-        }
-        return result;
-      }
-    });
-    this.fetchSeekTask = new Task(this, {
-      autoRun: EF_INTERACTIVE,
-      argsEqual: deepArrayEquals,
-      args: () => [this.initSegmentsLoader.value, this.seekTask.value, this.fetch],
-      task: async ([initSegments, seekResult, fetch], { signal }) => {
-        if (!initSegments) {
-          return;
-        }
-        if (!seekResult) {
-          return;
-        }
-        const files = {};
-        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}` }
-            }).then(() => {
-              log("Prefetched next segment");
-            }).catch((error) => {
-              log("Failed to prefetch next segment", error);
-            });
-          }
-          const initSegment = Object.values(initSegments).find(
-            (initSegment2) => initSegment2.trackId === String(track.id)
-          );
-          if (!initSegment) {
-            throw new Error("Could not find matching init segment");
-          }
-          const initBuffer = initSegment.buffer;
-          const mediaBuffer = await response.arrayBuffer();
-          files[trackId] = new File([initBuffer, mediaBuffer], "video.mp4", {
-            type: "video/mp4"
-          });
-        }
-        return files;
-      }
-    });
-    this.videoAssetTask = new Task(this, {
-      autoRun: EF_INTERACTIVE,
-      args: () => [this.fetchSeekTask.value],
-      task: async ([files], { signal: _signal }) => {
-        if (!files) {
-          return;
-        }
-        if (!this.defaultVideoTrackId) {
-          return;
-        }
-        const videoFile = files[this.defaultVideoTrackId];
-        if (!videoFile) {
-          return;
-        }
-        for (const frame of this.videoAssetTask.value?.decodedFrames || []) {
-          frame.close();
-        }
-        this.videoAssetTask.value?.videoDecoder?.close();
-        return await VideoAsset.createFromReadableStream(
-          "video.mp4",
-          videoFile.stream(),
-          videoFile
-        );
-      }
-    });
-    this.desiredSeekTimeMs = 0;
-    this.#audioContext = new OfflineAudioContext(2, 48e3 / 30, 48e3);
-    this.audioBufferTask = new Task(this, {
-      autoRun: EF_INTERACTIVE,
-      args: () => [this.fetchSeekTask.value, this.seekTask.value],
-      task: async ([files, segments], { signal: _signal }) => {
-        if (!files) {
-          return;
-        }
-        if (!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.#byteTimeDomainCache = new LRUCache(100);
-    this.byteTimeDomainTask = new Task(this, {
-      autoRun: EF_INTERACTIVE,
-      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;
-            const audioContext = new OfflineAudioContext(
-              2,
-              48e3 * (1 / 30),
-              48e3
-            );
-            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 = _EFMedia2.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.#frequencyDataCache = new LRUCache(100);
-    this.frequencyDataTask = new Task(this, {
-      autoRun: EF_INTERACTIVE,
-      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 audioContext = new OfflineAudioContext(
-              2,
-              48e3 * (1 / 30),
-              48e3
-            );
-            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 = 0.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 = _EFMedia2.DECAY_WEIGHT ** frameIndex;
-            weightedSum += frame[i] * decayWeight;
-            weightSum += decayWeight;
-          });
-          smoothedData[i] = Math.min(255, Math.round(weightedSum / weightSum));
-        }
-        smoothedData.forEach((value, i) => {
-          const freqWeight = this.FREQ_WEIGHTS[i];
-          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;
-      }
-    });
-  }
-  static {
-    this.styles = [
-      css`
+var EFMedia = class EFMedia 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,
+			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;
+				}
+			},
+			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;
+			}
+		});
+	}
+	static {
+		this.styles = [css`
       :host {
         display: block;
         position: relative;
         overflow: hidden;
       }
-    `
-    ];
-  }
-  #assetId;
-  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`;
-    }
-    return `/@ef-track-fragment-index/${this.src ?? ""}`;
-  }
-  fragmentTrackPath(trackId) {
-    if (this.assetId) {
-      return `${this.apiHost}/api/v1/isobmff_tracks/${this.assetId}/${trackId}`;
-    }
-    return `/@ef-track/${this.src ?? ""}?trackId=${trackId}`;
-  }
-  get defaultVideoTrackId() {
-    return Object.values(this.trackFragmentIndexLoader.value ?? {}).find(
-      (track) => track.type === "video"
-    )?.track;
-  }
-  get defaultAudioTrackId() {
-    return Object.values(this.trackFragmentIndexLoader.value ?? {}).find(
-      (track) => track.type === "audio"
-    )?.track;
-  }
-  async executeSeek(seekToMs) {
-    this.desiredSeekTimeMs = seekToMs;
-  }
-  updated(changedProperties) {
-    if (changedProperties.has("ownCurrentTimeMs")) {
-      this.executeSeek(this.currentSourceTimeMs);
-    }
-    if (changedProperties.has("currentTime") || changedProperties.has("ownCurrentTimeMs")) {
-      updateAnimations(this);
-    }
-  }
-  get hasOwnDuration() {
-    return true;
-  }
-  get intrinsicDurationMs() {
-    if (!this.trackFragmentIndexLoader.value) {
-      return 0;
-    }
-    const durations = Object.values(this.trackFragmentIndexLoader.value).map(
-      (track) => {
-        return track.duration / track.timescale * 1e3;
-      }
-    );
-    if (durations.length === 0) {
-      return 0;
-    }
-    return Math.max(...durations);
-  }
-  #audioContext;
-  async fetchAudioSpanningTime(fromMs, toMs) {
-    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.trackFragmentIndexLoader.taskComplete;
-    const audioTrackId = this.defaultAudioTrackId;
-    if (!audioTrackId) {
-      log("No audio track found");
-      return;
-    }
-    const audioTrackIndex = this.trackFragmentIndexLoader.value?.[audioTrackId];
-    if (!audioTrackIndex) {
-      log("No audio track found");
-      return;
-    }
-    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) {
-      log("No audio fragments found");
-      return;
-    }
-    const lastFragment = fragments[fragments.length - 1];
-    if (!lastFragment) {
-      log("No audio fragments found");
-      return;
-    }
-    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)
-    };
-  }
-  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 = 0.7;
-  }
-  // Update FREQ_WEIGHTS to use the instance fftSize instead of a static value
-  get FREQ_WEIGHTS() {
-    if (freqWeightsCache.has(this.fftSize)) {
-      return freqWeightsCache.get(this.fftSize);
-    }
-    const weights = new Float32Array(this.fftSize / 2).map((_, i) => {
-      const frequency = i * 48e3 / this.fftSize;
-      if (frequency < 60) return 0.3;
-      if (frequency < 250) return 0.4;
-      if (frequency < 500) return 0.6;
-      if (frequency < 2e3) return 0.8;
-      if (frequency < 4e3) return 1.2;
-      if (frequency < 8e3) return 1.6;
-      return 2;
-    });
-    freqWeightsCache.set(this.fftSize, weights);
-    return weights;
-  }
-  #byteTimeDomainCache;
-  #frequencyDataCache;
-  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");
-  }
+    `];
+	}
+	/**
+	* 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) => {
+			const frequency = i * 48e3 / this.fftSize;
+			if (frequency < 60) return .3;
+			if (frequency < 250) return .4;
+			if (frequency < 500) return .6;
+			if (frequency < 2e3) return .8;
+			if (frequency < 4e3) return 1.2;
+			if (frequency < 8e3) return 1.6;
+			return 2;
+		});
+		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;
+	}
+	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;
+	}
+	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
+		};
+	}
+	updated(changedProperties) {
+		super.updated(changedProperties);
+		if (changedProperties.has("ownCurrentTimeMs")) this.executeSeek(this.currentSourceTimeMs);
+		if (changedProperties.has("currentTime") || changedProperties.has("ownCurrentTimeMs")) updateAnimations(this);
+	}
+	get hasOwnDuration() {
+		return true;
+	}
+	get desiredSeekTimeMs() {
+		return this._desiredSeekTimeMs;
+	}
+	set desiredSeekTimeMs(value) {
+		if (this._desiredSeekTimeMs !== value) this._desiredSeekTimeMs = value;
+	}
+	async executeSeek(seekToMs) {
+		this.desiredSeekTimeMs = seekToMs;
+	}
 };
-__decorateClass([
-  property({ type: Number })
-], _EFMedia.prototype, "currentTimeMs", 2);
-__decorateClass([
-  property({ type: String, attribute: "asset-id", reflect: true })
-], _EFMedia.prototype, "assetId", 1);
-__decorateClass([
-  state()
-], _EFMedia.prototype, "desiredSeekTimeMs", 2);
-let EFMedia = _EFMedia;
-function processFFTData(fftData, zeroThresholdPercent = 0.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] < 10) {
-      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 * 0.9);
-  for (let i = attenuationStartIndex; i < totalBins; i++) {
-    const attenuationProgress = (i - attenuationStartIndex) / (totalBins - attenuationStartIndex) + 0.2;
-    const attenuationFactor = Math.max(0, 1 - attenuationProgress);
-    resampledData[i] = Math.floor(resampledData[i] * attenuationFactor);
-  }
-  return resampledData;
+_decorate([property({ type: Number })], EFMedia.prototype, "currentTimeMs", void 0);
+_decorate([property({
+	type: Number,
+	attribute: "prefetch-segments"
+})], EFMedia.prototype, "prefetchSegments", void 0);
+_decorate([property({
+	type: Number,
+	attribute: "cache-size"
+})], EFMedia.prototype, "cacheSize", 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);
+_decorate([property({
+	type: String,
+	attribute: "asset-id",
+	reflect: true
+})], EFMedia.prototype, "assetId", null);
+_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];
-    } else {
-      resampled[i] = Math.round(
-        // biome-ignore lint/style/noNonNullAssertion: Manual bounds check
-        data[index] * (1 - fraction) + data[index + 1] * fraction
-      );
-    }
-  }
-  return resampled;
+	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, deepGetMediaElements };