@editframe/elements 0.18.21-beta.0 → 0.18.23-beta.0

package/dist/elements/EFAudio.d.ts

@@ -8,20 +8,9 @@ export declare class EFAudio extends EFAudio_base {
     frameTask: Task<readonly [import('@lit/task').TaskStatus, import('@lit/task').TaskStatus, import('@lit/task').TaskStatus, import('@lit/task').TaskStatus], void>;
     /**
      * Legacy getter for fragment index task (maps to audioSegmentIdTask)
+     * Still used by EFCaptions
      */
     get fragmentIndexTask(): Task<readonly [import('../transcoding/types/index.js').MediaEngine | undefined, number], number | undefined>;
-    /**
-     * Legacy getter for media segments task (maps to audioSegmentFetchTask)
-     */
-    get mediaSegmentsTask(): Task<readonly [import('../transcoding/types/index.js').MediaEngine | undefined, number | undefined], ArrayBuffer>;
-    /**
-     * Legacy getter for seek task (maps to audioSeekTask)
-     */
-    get seekTask(): Task<readonly [number, import('./EFMedia/BufferedSeekingInput.js').BufferedSeekingInput | undefined], import('mediabunny').VideoSample | undefined>;
-    /**
-     * Legacy getter for audio asset task (maps to audioBufferTask)
-     */
-    get videoAssetTask(): Task<readonly [number], import('./EFMedia/audioTasks/makeAudioBufferTask.js').AudioBufferState>;
 }
 declare global {
     interface HTMLElementTagNameMap {

package/dist/elements/EFAudio.js

@@ -1,3 +1,4 @@
+import { EF_INTERACTIVE } from "../EF_INTERACTIVE.js";
 import { EFMedia } from "./EFMedia.js";
 import { TWMixin } from "../gui/TWMixin2.js";
 import { Task } from "@lit/task";
@@ -11,6 +12,7 @@ let EFAudio = class EFAudio$1 extends TWMixin(EFMedia) {
 		this._propertyHack = false;
 		this.audioElementRef = createRef();
 		this.frameTask = new Task(this, {
+			autoRun: EF_INTERACTIVE,
 			args: () => [
 				this.audioBufferTask.status,
 				this.audioSeekTask.status,
@@ -31,28 +33,11 @@ let EFAudio = class EFAudio$1 extends TWMixin(EFMedia) {
 	}
 	/**
 	* Legacy getter for fragment index task (maps to audioSegmentIdTask)
+	* Still used by EFCaptions
 	*/
 	get fragmentIndexTask() {
 		return this.audioSegmentIdTask;
 	}
-	/**
-	* Legacy getter for media segments task (maps to audioSegmentFetchTask)
-	*/
-	get mediaSegmentsTask() {
-		return this.audioSegmentFetchTask;
-	}
-	/**
-	* Legacy getter for seek task (maps to audioSeekTask)
-	*/
-	get seekTask() {
-		return this.audioSeekTask;
-	}
-	/**
-	* Legacy getter for audio asset task (maps to audioBufferTask)
-	*/
-	get videoAssetTask() {
-		return this.audioBufferTask;
-	}
 };
 _decorate([property({
 	type: Boolean,

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

@@ -40,5 +40,5 @@ export declare class AssetMediaEngine extends BaseMediaEngine implements MediaEn
      * Calculate audio segments for variable-duration segments using track fragment index
      */
     calculateAudioSegmentRange(fromMs: number, toMs: number, rendition: AudioRendition, _durationMs: number): SegmentTimeRange[];
-    computeSegmentId(desiredSeekTimeMs: number, rendition: MediaRendition): number;
+    computeSegmentId(seekTimeMs: number, rendition: MediaRendition): number;
 }

package/dist/elements/EFMedia/AssetMediaEngine.js

@@ -112,14 +112,14 @@ var AssetMediaEngine = class AssetMediaEngine extends BaseMediaEngine {
 		})}`);
 		return segmentRanges;
 	}
-	computeSegmentId(desiredSeekTimeMs, rendition) {
+	computeSegmentId(seekTimeMs, rendition) {
 		if (!rendition.trackId) throw new Error("Track ID is required for asset metadata");
 		const track = this.data[rendition.trackId];
 		if (!track) throw new Error("Track not found");
 		const { timescale, segments } = track;
 		const startTimeOffsetMs = "startTimeOffsetMs" in rendition && rendition.startTimeOffsetMs || 0;
-		const mediaTimeMs = roundToMilliseconds(desiredSeekTimeMs + startTimeOffsetMs);
-		const scaledSeekTime = convertToScaledTime(mediaTimeMs, timescale);
+		const offsetSeekTimeMs = roundToMilliseconds(seekTimeMs + startTimeOffsetMs);
+		const scaledSeekTime = convertToScaledTime(offsetSeekTimeMs, timescale);
 		for (let i = segments.length - 1; i >= 0; i--) {
 			const segment = segments[i];
 			const segmentEndTime = segment.cts + segment.duration;

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

@@ -1,4 +1,5 @@
-import { MediaSample } from '../SampleBuffer';
+import { AudioSampleSink, InputAudioTrack, InputTrack, InputVideoTrack, VideoSampleSink } from 'mediabunny';
+import { MediaSample, SampleBuffer } from '../SampleBuffer';
 interface BufferedSeekingInputOptions {
     videoBufferSize?: number;
     audioBufferSize?: number;
@@ -10,7 +11,10 @@ interface BufferedSeekingInputOptions {
 }
 export declare class NoSample extends RangeError {
 }
+export declare class ConcurrentSeekError extends RangeError {
+}
 export declare class BufferedSeekingInput {
+    #private;
     private input;
     private trackIterators;
     private trackBuffers;
@@ -28,14 +32,16 @@ export declare class BufferedSeekingInput {
     getBufferTimestamps(trackId: number): number[];
     clearBuffer(trackId: number): void;
     computeDuration(): Promise<number>;
-    getTrack(trackId: number): Promise<import('mediabunny').InputTrack>;
-    getAudioTrack(trackId: number): Promise<import('mediabunny').InputAudioTrack>;
-    getVideoTrack(trackId: number): Promise<import('mediabunny').InputVideoTrack>;
-    getFirstVideoTrack(): Promise<import('mediabunny').InputVideoTrack | undefined>;
-    getFirstAudioTrack(): Promise<import('mediabunny').InputAudioTrack | undefined>;
-    getTrackIterator(trackId: number): Promise<AsyncIterator<MediaSample, any, undefined>>;
-    private createIteratorSafe;
-    createTrackBuffer(trackId: number): Promise<void>;
+    getTrack(trackId: number): Promise<InputTrack>;
+    getAudioTrack(trackId: number): Promise<InputAudioTrack>;
+    getVideoTrack(trackId: number): Promise<InputVideoTrack>;
+    getFirstVideoTrack(): Promise<InputVideoTrack | undefined>;
+    getFirstAudioTrack(): Promise<InputAudioTrack | undefined>;
+    getTrackIterator(track: InputTrack): AsyncIterator<MediaSample, any, undefined>;
+    createTrackSampleSink(track: InputTrack): AudioSampleSink | VideoSampleSink;
+    createTrackIterator(track: InputTrack): AsyncGenerator<import('mediabunny').VideoSample, void, unknown> | AsyncGenerator<import('mediabunny').AudioSample, void, unknown>;
+    createTrackBuffer(track: InputTrack): SampleBuffer;
+    getTrackBuffer(track: InputTrack): SampleBuffer;
     seek(trackId: number, timeMs: number): Promise<MediaSample | undefined>;
     private resetIterator;
     private seekSafe;

package/dist/elements/EFMedia/BufferedSeekingInput.js

@@ -1,6 +1,6 @@
 import { roundToMilliseconds } from "./shared/PrecisionUtils.js";
 import { SampleBuffer } from "../SampleBuffer.js";
-import { AudioSampleSink, BufferSource, Input, MP4, VideoSampleSink } from "mediabunny";
+import { AudioSampleSink, BufferSource, Input, InputAudioTrack, InputVideoTrack, MP4, VideoSampleSink } from "mediabunny";
 const defaultOptions = {
 	videoBufferSize: 30,
 	audioBufferSize: 100,
@@ -70,48 +70,37 @@ var BufferedSeekingInput = class {
 		const tracks = await this.input.getAudioTracks();
 		return tracks[0];
 	}
-	async getTrackIterator(trackId) {
-		if (this.trackIterators.has(trackId)) return this.trackIterators.get(trackId);
-		const existingIteratorCreation = this.trackIteratorCreationPromises.get(trackId);
-		if (existingIteratorCreation) {
-			await existingIteratorCreation;
-			if (this.trackIterators.has(trackId)) return this.trackIterators.get(trackId);
-		}
-		const creationPromise = this.createIteratorSafe(trackId);
-		this.trackIteratorCreationPromises.set(trackId, creationPromise);
-		try {
-			const iterator = await creationPromise;
-			return iterator;
-		} finally {
-			this.trackIteratorCreationPromises.delete(trackId);
-		}
+	getTrackIterator(track) {
+		if (this.trackIterators.has(track.id)) return this.trackIterators.get(track.id);
+		const trackIterator = this.createTrackIterator(track);
+		this.trackIterators.set(track.id, trackIterator);
+		return trackIterator;
 	}
-	async createIteratorSafe(trackId) {
-		const track = await this.getTrack(trackId);
-		if (track.type === "audio") {
-			const track$1 = await this.getAudioTrack(trackId);
-			const sampleSink = new AudioSampleSink(track$1);
-			const iterator = sampleSink.samples();
-			this.trackIterators.set(trackId, iterator);
-			return iterator;
-		}
-		{
-			const track$1 = await this.getVideoTrack(trackId);
-			const sampleSink = new VideoSampleSink(track$1);
-			const iterator = sampleSink.samples();
-			this.trackIterators.set(trackId, iterator);
-			return iterator;
-		}
+	createTrackSampleSink(track) {
+		if (track instanceof InputAudioTrack) return new AudioSampleSink(track);
+		if (track instanceof InputVideoTrack) return new VideoSampleSink(track);
+		throw new Error(`Unsupported track type ${track.type}`);
 	}
-	async createTrackBuffer(trackId) {
-		const track = await this.getTrack(trackId);
+	createTrackIterator(track) {
+		const sampleSink = this.createTrackSampleSink(track);
+		return sampleSink.samples();
+	}
+	createTrackBuffer(track) {
 		if (track.type === "audio") {
-			const bufferSize = this.options.audioBufferSize;
-			this.trackBuffers.set(trackId, new SampleBuffer(bufferSize));
-		} else {
-			const bufferSize = this.options.videoBufferSize;
-			this.trackBuffers.set(trackId, new SampleBuffer(bufferSize));
+			const bufferSize$1 = this.options.audioBufferSize;
+			const sampleBuffer$1 = new SampleBuffer(bufferSize$1);
+			return sampleBuffer$1;
 		}
+		const bufferSize = this.options.videoBufferSize;
+		const sampleBuffer = new SampleBuffer(bufferSize);
+		return sampleBuffer;
+	}
+	getTrackBuffer(track) {
+		const maybeTrackBuffer = this.trackBuffers.get(track.id);
+		if (maybeTrackBuffer) return maybeTrackBuffer;
+		const trackBuffer = this.createTrackBuffer(track);
+		this.trackBuffers.set(track.id, trackBuffer);
+		return trackBuffer;
 	}
 	async seek(trackId, timeMs) {
 		const mediaTimeMs = timeMs + this.startTimeOffsetMs;
@@ -126,54 +115,63 @@ var BufferedSeekingInput = class {
 			this.trackSeekPromises.delete(trackId);
 		}
 	}
-	async resetIterator(trackId) {
-		const trackBuffer = this.trackBuffers.get(trackId);
+	async resetIterator(track) {
+		const trackBuffer = this.trackBuffers.get(track.id);
 		trackBuffer?.clear();
-		const ongoingIteratorCreation = this.trackIteratorCreationPromises.get(trackId);
+		const ongoingIteratorCreation = this.trackIteratorCreationPromises.get(track.id);
 		if (ongoingIteratorCreation) await ongoingIteratorCreation;
-		const iterator = this.trackIterators.get(trackId);
+		const iterator = this.trackIterators.get(track.id);
 		if (iterator) try {
 			await iterator.return?.();
 		} catch (_error) {}
-		this.trackIterators.delete(trackId);
+		this.trackIterators.delete(track.id);
 	}
+	#seekLock;
 	async seekSafe(trackId, timeMs) {
-		if (!this.trackBuffers.has(trackId)) await this.createTrackBuffer(trackId);
-		const trackBuffer = this.trackBuffers.get(trackId);
-		const track = await this.getTrack(trackId);
-		const firstTimestampMs = roundToMilliseconds(await track.getFirstTimestamp() * 1e3);
-		let roundedTimeMs = roundToMilliseconds(timeMs);
-		if (roundedTimeMs < firstTimestampMs) {
-			const bufferContents$1 = trackBuffer.getContents();
-			if (bufferContents$1.length > 0) {
-				timeMs = firstTimestampMs;
-				roundedTimeMs = roundToMilliseconds(timeMs);
+		if (this.#seekLock) await this.#seekLock.promise;
+		const seekLock = Promise.withResolvers();
+		this.#seekLock = seekLock;
+		try {
+			const track = await this.getTrack(trackId);
+			const trackBuffer = this.getTrackBuffer(track);
+			const roundedTimeMs = roundToMilliseconds(timeMs);
+			const firstTimestampMs = roundToMilliseconds(await track.getFirstTimestamp() * 1e3);
+			if (roundedTimeMs < firstTimestampMs) {
+				console.error("Seeking outside bounds of input", {
+					roundedTimeMs,
+					firstTimestampMs
+				});
+				throw new NoSample(`Seeking outside bounds of input ${roundedTimeMs} < ${firstTimestampMs}`);
 			}
+			const bufferContents = trackBuffer.getContents();
+			if (bufferContents.length > 0) {
+				const bufferStartMs = roundToMilliseconds(trackBuffer.firstTimestamp * 1e3);
+				if (roundedTimeMs < bufferStartMs) await this.resetIterator(track);
+			}
+			const alreadyInBuffer = trackBuffer.find(timeMs);
+			if (alreadyInBuffer) return alreadyInBuffer;
+			const iterator = this.getTrackIterator(track);
+			while (true) {
+				const { done, value: decodedSample } = await iterator.next();
+				if (decodedSample) trackBuffer.push(decodedSample);
+				const foundSample = trackBuffer.find(roundedTimeMs);
+				if (foundSample) return foundSample;
+				if (done) break;
+			}
+			const finalBufferContents = trackBuffer.getContents();
+			if (finalBufferContents.length > 0) {
+				const lastSample = finalBufferContents[finalBufferContents.length - 1];
+				const lastSampleEndMs = roundToMilliseconds(((lastSample?.timestamp || 0) + (lastSample?.duration || 0)) * 1e3);
+				const trackDurationMs = await track.computeDuration() * 1e3;
+				const isSeekingToTrackEnd = roundToMilliseconds(timeMs) === roundToMilliseconds(trackDurationMs);
+				const isAtEndOfTrack = roundToMilliseconds(timeMs) >= lastSampleEndMs;
+				if (isSeekingToTrackEnd && isAtEndOfTrack) return lastSample;
+			}
+			throw new NoSample(`Sample not found for time ${timeMs} in ${track.type} track ${trackId}`);
+		} finally {
+			this.#seekLock = void 0;
+			seekLock.resolve();
 		}
-		const bufferContents = trackBuffer.getContents();
-		if (bufferContents.length > 0) {
-			const bufferStartMs = roundToMilliseconds(trackBuffer.firstTimestamp * 1e3);
-			const lastSample = bufferContents[bufferContents.length - 1];
-			const bufferEndMs = lastSample ? roundToMilliseconds((lastSample.timestamp + (lastSample.duration || 0)) * 1e3) : bufferStartMs;
-			if (roundedTimeMs < bufferStartMs || roundedTimeMs > bufferEndMs) await this.resetIterator(trackId);
-		}
-		const alreadyInBuffer = trackBuffer.find(timeMs);
-		if (alreadyInBuffer) return alreadyInBuffer;
-		const iterator = await this.getTrackIterator(trackId);
-		while (true) {
-			const { done, value: decodedSample } = await iterator.next();
-			if (decodedSample) trackBuffer.push(decodedSample);
-			const foundSample = trackBuffer.find(timeMs);
-			if (foundSample) return foundSample;
-			if (done) break;
-		}
-		const finalBufferContents = trackBuffer.getContents();
-		if (finalBufferContents.length > 0) {
-			const lastSample = finalBufferContents[finalBufferContents.length - 1];
-			const lastSampleEndMs = roundToMilliseconds(((lastSample?.timestamp || 0) + (lastSample?.duration || 0)) * 1e3);
-			if (roundToMilliseconds(timeMs) >= lastSampleEndMs) return lastSample;
-		}
-		throw new NoSample(`Sample not found for time ${timeMs} in ${track.type} track ${trackId}`);
 	}
 };
 export { BufferedSeekingInput };

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

@@ -50,19 +50,24 @@ function makeAudioFrequencyAnalysisTask(element) {
 			element.fftGain,
 			element.shouldInterpolateFrequencies
 		],
-		task: async () => {
+		task: async (_, { signal }) => {
 			await element.audioBufferTask.taskComplete;
+			signal.throwIfAborted();
 			if (!element.audioBufferTask.value) return null;
 			if (element.currentSourceTimeMs < 0) return null;
 			const currentTimeMs = element.currentSourceTimeMs;
-			const analysisWindowMs = 5e3;
-			const fromMs = Math.max(0, currentTimeMs);
-			const maxToMs = fromMs + analysisWindowMs;
+			const frameIntervalMs = 1e3 / 30;
+			const earliestFrameMs = currentTimeMs - (element.fftDecay - 1) * frameIntervalMs;
+			const fromMs = Math.max(0, earliestFrameMs);
+			const maxToMs = currentTimeMs + frameIntervalMs;
 			const videoDurationMs = element.intrinsicDurationMs || 0;
 			const toMs = videoDurationMs > 0 ? Math.min(maxToMs, videoDurationMs) : maxToMs;
 			if (fromMs >= toMs) return null;
+			const preliminaryCacheKey = `${element.shouldInterpolateFrequencies}:${element.fftSize}:${element.fftDecay}:${element.fftGain}:${fromMs}:${currentTimeMs}`;
+			const cachedSmoothedData = cache.get(preliminaryCacheKey);
+			if (cachedSmoothedData) return cachedSmoothedData;
 			const { fetchAudioSpanningTime: fetchAudioSpan } = await import("../shared/AudioSpanUtils.js");
-			const audioSpan = await fetchAudioSpan(element, fromMs, toMs, new AbortController().signal);
+			const audioSpan = await fetchAudioSpan(element, fromMs, toMs, signal);
 			if (!audioSpan || !audioSpan.blob) {
 				console.warn("Frequency analysis skipped: no audio data available");
 				return null;
@@ -71,10 +76,7 @@ function makeAudioFrequencyAnalysisTask(element) {
 			const arrayBuffer = await audioSpan.blob.arrayBuffer();
 			const audioBuffer = await tempAudioContext.decodeAudioData(arrayBuffer);
 			const startOffsetMs = audioSpan.startMs;
-			const smoothedKey = `${element.shouldInterpolateFrequencies}:${element.fftSize}:${element.fftDecay}:${element.fftGain}:${startOffsetMs}:${currentTimeMs}`;
-			const cachedSmoothedData = cache.get(smoothedKey);
-			if (cachedSmoothedData) return cachedSmoothedData;
-			const framesData = await Promise.all(Array.from({ length: element.fftDecay }, async (_, i) => {
+			const framesData = await Promise.all(Array.from({ length: element.fftDecay }, async (_$1, i) => {
 				const frameOffset = i * (1e3 / 30);
 				const startTime = Math.max(0, (currentTimeMs - frameOffset - startOffsetMs) / 1e3);
 				const cacheKey = `${element.shouldInterpolateFrequencies}:${element.fftSize}:${element.fftGain}:${startOffsetMs}:${startTime}`;
@@ -133,7 +135,7 @@ function makeAudioFrequencyAnalysisTask(element) {
 			});
 			const slicedData = smoothedData.slice(0, Math.floor(smoothedData.length / 2));
 			const processedData = element.shouldInterpolateFrequencies ? processFFTData(slicedData) : slicedData;
-			cache.set(smoothedKey, processedData);
+			cache.set(preliminaryCacheKey, processedData);
 			return processedData;
 		}
 	});

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

@@ -13,24 +13,8 @@ const makeAudioSeekTask = (host) => {
 			else console.error("audioSeekTask unknown error", error);
 		},
 		onComplete: (_value) => {},
-		task: async ([targetSeekTimeMs], { signal }) => {
-			await host.audioSegmentIdTask.taskComplete;
-			signal.throwIfAborted();
-			await host.audioSegmentFetchTask.taskComplete;
-			signal.throwIfAborted();
-			await host.audioInitSegmentFetchTask.taskComplete;
-			signal.throwIfAborted();
-			const audioInput = await host.audioInputTask.taskComplete;
-			signal.throwIfAborted();
-			if (!audioInput) throw new Error("Audio input is not available");
-			const audioTrack = await audioInput.getFirstAudioTrack();
-			if (!audioTrack) throw new Error("Audio track is not available");
-			signal.throwIfAborted();
-			const sample = await audioInput.seek(audioTrack.id, targetSeekTimeMs);
-			signal.throwIfAborted();
-			if (sample === void 0 && signal.aborted) return void 0;
-			if (sample === void 0) throw new Error("Audio seek failed to find sample");
-			return sample;
+		task: async () => {
+			return void 0;
 		}
 	});
 };

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

@@ -17,19 +17,24 @@ function makeAudioTimeDomainAnalysisTask(element) {
 			element.fftGain,
 			element.shouldInterpolateFrequencies
 		],
-		task: async () => {
+		task: async (_, { signal }) => {
 			await element.audioBufferTask.taskComplete;
+			signal.throwIfAborted();
 			if (!element.audioBufferTask.value) return null;
 			if (element.currentSourceTimeMs < 0) return null;
 			const currentTimeMs = element.currentSourceTimeMs;
-			const analysisWindowMs = 5e3;
-			const fromMs = Math.max(0, currentTimeMs);
-			const maxToMs = fromMs + analysisWindowMs;
+			const frameIntervalMs = 1e3 / 30;
+			const earliestFrameMs = currentTimeMs - (element.fftDecay - 1) * frameIntervalMs;
+			const fromMs = Math.max(0, earliestFrameMs);
+			const maxToMs = currentTimeMs + frameIntervalMs;
 			const videoDurationMs = element.intrinsicDurationMs || 0;
 			const toMs = videoDurationMs > 0 ? Math.min(maxToMs, videoDurationMs) : maxToMs;
 			if (fromMs >= toMs) return null;
+			const preliminaryCacheKey = `${element.shouldInterpolateFrequencies}:${element.fftSize}:${element.fftDecay}:${element.fftGain}:${fromMs}:${currentTimeMs}`;
+			const cachedData = cache.get(preliminaryCacheKey);
+			if (cachedData) return cachedData;
 			const { fetchAudioSpanningTime: fetchAudioSpan } = await import("../shared/AudioSpanUtils.js");
-			const audioSpan = await fetchAudioSpan(element, fromMs, toMs, new AbortController().signal);
+			const audioSpan = await fetchAudioSpan(element, fromMs, toMs, signal);
 			if (!audioSpan || !audioSpan.blob) {
 				console.warn("Time domain analysis skipped: no audio data available");
 				return null;
@@ -38,10 +43,7 @@ function makeAudioTimeDomainAnalysisTask(element) {
 			const arrayBuffer = await audioSpan.blob.arrayBuffer();
 			const audioBuffer = await tempAudioContext.decodeAudioData(arrayBuffer);
 			const startOffsetMs = audioSpan.startMs;
-			const smoothedKey = `${element.shouldInterpolateFrequencies}:${element.fftSize}:${element.fftDecay}:${element.fftGain}:${startOffsetMs}:${currentTimeMs}`;
-			const cachedData = cache.get(smoothedKey);
-			if (cachedData) return cachedData;
-			const framesData = await Promise.all(Array.from({ length: element.fftDecay }, async (_, frameIndex) => {
+			const framesData = await Promise.all(Array.from({ length: element.fftDecay }, async (_$1, frameIndex) => {
 				const frameOffset = frameIndex * (1e3 / 30);
 				const startTime = Math.max(0, (currentTimeMs - frameOffset - startOffsetMs) / 1e3);
 				const cacheKey = `${element.shouldInterpolateFrequencies}:${element.fftSize}:${element.fftGain}:${startOffsetMs}:${startTime}`;
@@ -99,7 +101,7 @@ function makeAudioTimeDomainAnalysisTask(element) {
 				});
 				smoothedData[i] = Math.min(255, Math.round(weightedSum / weightSum));
 			}
-			cache.set(smoothedKey, smoothedData);
+			cache.set(preliminaryCacheKey, smoothedData);
 			return smoothedData;
 		}
 	});

package/dist/elements/EFTimegroup.d.ts

@@ -6,8 +6,6 @@ export declare class EFTimegroup extends EFTimegroup_base {
     #private;
     static styles: import('lit').CSSResult;
     _timeGroupContext: this;
-    private isFrameUpdateInProgress;
-    private queuedTimeUpdate;
     mode: "fit" | "fixed" | "sequence" | "contain";
     overlapMs: number;
     fit: "none" | "contain" | "cover";
@@ -27,8 +25,9 @@ export declare class EFTimegroup extends EFTimegroup_base {
     get intrinsicDurationMs(): number | undefined;
     get hasOwnDuration(): boolean;
     get durationMs(): number;
-    getPendingFrameTasks(): Promise<Task<readonly unknown[], unknown>[]>;
-    waitForFrameTasks(): Promise<void>;
+    getPendingFrameTasks(signal?: AbortSignal): Promise<Task<readonly unknown[], unknown>[]>;
+    waitForNestedUpdates(signal?: AbortSignal): Promise<void>;
+    waitForFrameTasks(signal?: AbortSignal): Promise<void>;
     /**
      * Wait for all media elements to load their initial segments.
      * Ideally we would only need the extracted index json data, but
@@ -60,6 +59,7 @@ export declare class EFTimegroup extends EFTimegroup_base {
     testPlayAudio(fromMs: number, toMs: number): Promise<void>;
     loadMd5Sums(): Promise<void>;
     frameTask: Task<readonly [number, number], void>;
+    seekTask: Task<readonly [number], void>;
 }
 declare global {
     interface HTMLElementTagNameMap {

package/dist/elements/EFTimegroup.js

@@ -25,17 +25,28 @@ let EFTimegroup = class EFTimegroup$1 extends EFTemporal(LitElement) {
 	constructor(..._args) {
 		super(..._args);
 		this._timeGroupContext = this;
-		this.isFrameUpdateInProgress = false;
-		this.queuedTimeUpdate = null;
 		this.mode = "contain";
 		this.overlapMs = 0;
 		this.fit = "none";
 		this.frameTask = new Task(this, {
 			autoRun: EF_INTERACTIVE,
 			args: () => [this.ownCurrentTimeMs, this.currentTimeMs],
-			task: async ([], { signal: _signal }) => {
-				let fullyUpdated = await this.updateComplete;
-				while (!fullyUpdated) fullyUpdated = await this.updateComplete;
+			task: async ([], { signal }) => {
+				if (this.isRootTimegroup) await this.waitForFrameTasks(signal);
+			}
+		});
+		this.seekTask = new Task(this, {
+			args: () => [this.#pendingSeekTime ?? this.#currentTime],
+			task: async ([targetTime], { signal }) => {
+				const newTime = Math.max(0, Math.min(targetTime, this.durationMs / 1e3));
+				this.#currentTime = newTime;
+				this.requestUpdate("currentTime");
+				await this.updateComplete;
+				signal.throwIfAborted();
+				const videoElements = this.querySelectorAll("ef-video");
+				for (const video of videoElements) if (video.videoSeekTask) video.videoSeekTask.run();
+				await this.frameTask.run();
+				this.#saveTimeToLocalStorage(newTime);
 			}
 		});
 	}
@@ -53,17 +64,23 @@ let EFTimegroup = class EFTimegroup$1 extends EFTemporal(LitElement) {
 	}
 	#currentTime = 0;
 	#resizeObserver;
+	#seekInProgress = false;
+	#pendingSeekTime;
 	set currentTime(time) {
-		const newTime = Math.max(0, Math.min(time, this.durationMs / 1e3));
-		if (this.isRootTimegroup && this.isFrameUpdateInProgress) {
-			this.queuedTimeUpdate = newTime;
+		if (this.#seekInProgress) {
+			this.#pendingSeekTime = time;
 			return;
 		}
-		if (this.isRootTimegroup) this.#executeTimeUpdate(newTime);
-		else {
-			this.#currentTime = newTime;
-			this.#saveTimeToLocalStorage(newTime);
-		}
+		this.#seekInProgress = true;
+		this.#pendingSeekTime = time;
+		this.seekTask.run().finally(() => {
+			this.#seekInProgress = false;
+			if (this.#pendingSeekTime !== void 0 && this.#pendingSeekTime !== time) {
+				const pendingTime = this.#pendingSeekTime;
+				this.#pendingSeekTime = void 0;
+				this.currentTime = pendingTime;
+			} else this.#pendingSeekTime = void 0;
+		});
 	}
 	get currentTime() {
 		return this.#currentTime;
@@ -81,26 +98,6 @@ let EFTimegroup = class EFTimegroup$1 extends EFTemporal(LitElement) {
 		return this.closest("ef-timegroup") === this;
 	}
 	/**
-	* Executes time update with frame locking for root timegroups
-	*/
-	async #executeTimeUpdate(time) {
-		this.isFrameUpdateInProgress = true;
-		this.#currentTime = time;
-		try {
-			this.#saveTimeToLocalStorage(time);
-			await this.waitForFrameTasks();
-		} catch (error) {
-			console.error("⚠️ [TIME_UPDATE_ERROR] Error during frame update:", error);
-		} finally {
-			this.isFrameUpdateInProgress = false;
-			if (this.queuedTimeUpdate !== null && this.queuedTimeUpdate !== time) {
-				const nextTime = this.queuedTimeUpdate;
-				this.queuedTimeUpdate = null;
-				setTimeout(() => this.#executeTimeUpdate(nextTime), 0);
-			}
-		}
-	}
-	/**
 	* Saves time to localStorage (extracted for reuse)
 	*/
 	#saveTimeToLocalStorage(time) {
@@ -175,21 +172,37 @@ let EFTimegroup = class EFTimegroup$1 extends EFTemporal(LitElement) {
 			default: throw new Error(`Invalid time mode: ${this.mode}`);
 		}
 	}
-	async getPendingFrameTasks() {
-		await this.updateComplete;
+	async getPendingFrameTasks(signal) {
+		await this.waitForNestedUpdates(signal);
+		signal?.throwIfAborted();
 		const temporals = deepGetElementsWithFrameTasks(this);
 		return temporals.map((temporal) => temporal.frameTask).filter((task) => task.status < TaskStatus.COMPLETE);
 	}
-	async waitForFrameTasks() {
+	async waitForNestedUpdates(signal) {
+		const limit = 10;
+		let steps = 0;
+		let isComplete = true;
+		while (true) {
+			steps++;
+			if (steps > limit) throw new Error("Reached update depth limit.");
+			isComplete = await this.updateComplete;
+			signal?.throwIfAborted();
+			if (isComplete) break;
+		}
+	}
+	async waitForFrameTasks(signal) {
 		const limit = 10;
 		let step = 0;
-		await this.updateComplete;
+		await this.waitForNestedUpdates(signal);
 		while (step < limit) {
 			step++;
-			let pendingTasks = await this.getPendingFrameTasks();
+			let pendingTasks = await this.getPendingFrameTasks(signal);
+			signal?.throwIfAborted();
 			await Promise.all(pendingTasks.map((task) => task.taskComplete));
+			signal?.throwIfAborted();
 			await this.updateComplete;
-			pendingTasks = await this.getPendingFrameTasks();
+			signal?.throwIfAborted();
+			pendingTasks = await this.getPendingFrameTasks(signal);
 			if (pendingTasks.length === 0) break;
 		}
 	}