@editframe/elements 0.18.27-beta.0 → 0.19.4-beta.0

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

@@ -42,4 +42,14 @@ export declare class AssetMediaEngine extends BaseMediaEngine implements MediaEn
     calculateAudioSegmentRange(fromMs: number, toMs: number, rendition: AudioRendition, _durationMs: number): SegmentTimeRange[];
     computeSegmentId(seekTimeMs: number, rendition: MediaRendition): number;
     getScrubVideoRendition(): VideoRendition | undefined;
+    /**
+     * Get preferred buffer configuration for this media engine
+     * AssetMediaEngine uses lower buffering since segments are already optimized
+     */
+    getBufferConfig(): {
+        videoBufferDurationMs: number;
+        audioBufferDurationMs: number;
+        maxVideoBufferFetches: number;
+        maxAudioBufferFetches: number;
+    };
 }

package/dist/elements/EFMedia/AssetMediaEngine.js

@@ -143,7 +143,19 @@ var AssetMediaEngine = class AssetMediaEngine extends BaseMediaEngine {
 		return nearestSegmentIndex;
 	}
 	getScrubVideoRendition() {
-		return this.videoRendition;
+		return void 0;
+	}
+	/**
+	* Get preferred buffer configuration for this media engine
+	* AssetMediaEngine uses lower buffering since segments are already optimized
+	*/
+	getBufferConfig() {
+		return {
+			videoBufferDurationMs: 2e3,
+			audioBufferDurationMs: 2e3,
+			maxVideoBufferFetches: 1,
+			maxAudioBufferFetches: 1
+		};
 	}
 };
 export { AssetMediaEngine };

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

@@ -27,4 +27,14 @@ export declare class JitMediaEngine extends BaseMediaEngine implements MediaEngi
     }): Promise<ArrayBuffer>;
     computeSegmentId(desiredSeekTimeMs: number, rendition: VideoRendition | AudioRendition): number | undefined;
     getScrubVideoRendition(): VideoRendition | undefined;
+    /**
+     * Get preferred buffer configuration for JIT transcoding
+     * Uses higher buffering since transcoding introduces latency
+     */
+    getBufferConfig(): {
+        videoBufferDurationMs: number;
+        audioBufferDurationMs: number;
+        maxVideoBufferFetches: number;
+        maxAudioBufferFetches: number;
+    };
 }

package/dist/elements/EFMedia/JitMediaEngine.js

@@ -89,5 +89,17 @@ var JitMediaEngine = class JitMediaEngine extends BaseMediaEngine {
 			segmentDurationsMs: scrubManifestRendition.segmentDurationsMs
 		};
 	}
+	/**
+	* Get preferred buffer configuration for JIT transcoding
+	* Uses higher buffering since transcoding introduces latency
+	*/
+	getBufferConfig() {
+		return {
+			videoBufferDurationMs: 8e3,
+			audioBufferDurationMs: 8e3,
+			maxVideoBufferFetches: 3,
+			maxAudioBufferFetches: 3
+		};
+	}
 };
 export { JitMediaEngine };

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

@@ -11,7 +11,7 @@ const makeAudioBufferTask = (host) => {
 		requestQueue: []
 	};
 	return new Task(host, {
-		autoRun: EF_INTERACTIVE && !EF_RENDERING(),
+		autoRun: EF_INTERACTIVE,
 		args: () => [host.desiredSeekTimeMs],
 		onError: (error) => {
 			console.error("audioBufferTask error", error);
@@ -21,28 +21,32 @@ const makeAudioBufferTask = (host) => {
 		},
 		task: async ([seekTimeMs], { signal }) => {
 			if (EF_RENDERING()) return currentState;
+			const mediaEngine = await getLatestMediaEngine(host, signal);
+			const engineConfig = mediaEngine.getBufferConfig();
+			const bufferDurationMs = engineConfig.audioBufferDurationMs;
+			const maxParallelFetches = engineConfig.maxAudioBufferFetches;
 			const currentConfig = {
-				bufferDurationMs: host.audioBufferDurationMs,
-				maxParallelFetches: host.maxAudioBufferFetches,
+				bufferDurationMs,
+				maxParallelFetches,
 				enableBuffering: host.enableAudioBuffering
 			};
 			return manageMediaBuffer(seekTimeMs, currentConfig, currentState, host.intrinsicDurationMs || 1e4, signal, {
 				computeSegmentId: async (timeMs, rendition) => {
-					const mediaEngine = await getLatestMediaEngine(host, signal);
-					return mediaEngine.computeSegmentId(timeMs, rendition);
+					const mediaEngine$1 = await getLatestMediaEngine(host, signal);
+					return mediaEngine$1.computeSegmentId(timeMs, rendition);
 				},
 				prefetchSegment: async (segmentId, rendition) => {
-					const mediaEngine = await getLatestMediaEngine(host, signal);
-					await mediaEngine.fetchMediaSegment(segmentId, rendition);
+					const mediaEngine$1 = await getLatestMediaEngine(host, signal);
+					await mediaEngine$1.fetchMediaSegment(segmentId, rendition);
 				},
 				isSegmentCached: (segmentId, rendition) => {
-					const mediaEngine = host.mediaEngineTask.value;
-					if (!mediaEngine) return false;
-					return mediaEngine.isSegmentCached(segmentId, rendition);
+					const mediaEngine$1 = host.mediaEngineTask.value;
+					if (!mediaEngine$1) return false;
+					return mediaEngine$1.isSegmentCached(segmentId, rendition);
 				},
 				getRendition: async () => {
-					const mediaEngine = await getLatestMediaEngine(host, signal);
-					const audioRendition = mediaEngine.audioRendition;
+					const mediaEngine$1 = await getLatestMediaEngine(host, signal);
+					const audioRendition = mediaEngine$1.audioRendition;
 					if (!audioRendition) throw new Error("Audio rendition not available");
 					return audioRendition;
 				},

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

@@ -1,3 +1,3 @@
 import { Task } from '@lit/task';
 import { EFMedia } from '../../EFMedia.js';
-export declare function makeAudioFrequencyAnalysisTask(element: EFMedia): Task<readonly [import('@lit/task').TaskStatus, number, number, number, number, boolean], Uint8Array | null>;
+export declare function makeAudioFrequencyAnalysisTask(element: EFMedia): Task<readonly [number, number, number, number, boolean], Uint8Array | null>;

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

@@ -43,7 +43,6 @@ function makeAudioFrequencyAnalysisTask(element) {
 			console.error("frequencyDataTask error", error);
 		},
 		args: () => [
-			element.audioBufferTask.status,
 			element.currentSourceTimeMs,
 			element.fftSize,
 			element.fftDecay,
@@ -51,9 +50,6 @@ function makeAudioFrequencyAnalysisTask(element) {
 			element.shouldInterpolateFrequencies
 		],
 		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 frameIntervalMs = 1e3 / 30;

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

@@ -1,3 +1,3 @@
 import { Task } from '@lit/task';
 import { EFMedia } from '../../EFMedia.js';
-export declare function makeAudioTimeDomainAnalysisTask(element: EFMedia): Task<readonly [import('@lit/task').TaskStatus, number, number, number, number, boolean], Uint8Array | null>;
+export declare function makeAudioTimeDomainAnalysisTask(element: EFMedia): Task<readonly [number, number, number, number, boolean], Uint8Array | null>;

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

@@ -10,7 +10,6 @@ function makeAudioTimeDomainAnalysisTask(element) {
 			console.error("byteTimeDomainTask error", error);
 		},
 		args: () => [
-			element.audioBufferTask.status,
 			element.currentSourceTimeMs,
 			element.fftSize,
 			element.fftDecay,
@@ -18,9 +17,6 @@ function makeAudioTimeDomainAnalysisTask(element) {
 			element.shouldInterpolateFrequencies
 		],
 		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 frameIntervalMs = 1e3 / 30;

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

@@ -14,7 +14,7 @@ const makeScrubVideoBufferTask = (host) => {
 		requestQueue: []
 	};
 	return new Task(host, {
-		autoRun: !EF_RENDERING(),
+		autoRun: false,
 		args: () => [host.mediaEngineTask.value],
 		onError: (error) => {
 			console.error("scrubVideoBufferTask error", error);

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

@@ -4,13 +4,13 @@ import { Task } from "@lit/task";
 const scrubInputCache = new ScrubInputCache();
 const makeUnifiedVideoSeekTask = (host) => {
 	return new Task(host, {
+		autoRun: false,
 		args: () => [host.desiredSeekTimeMs],
 		onError: (error) => {
 			console.error("unifiedVideoSeekTask error", error);
 		},
 		onComplete: (_value) => {},
 		task: async ([desiredSeekTimeMs], { signal }) => {
-			signal.throwIfAborted();
 			const mediaEngine = await getLatestMediaEngine(host, signal);
 			if (!mediaEngine) return void 0;
 			const mainRendition = mediaEngine.videoRendition;
@@ -33,7 +33,8 @@ const makeUnifiedVideoSeekTask = (host) => {
 async function tryGetScrubSample(mediaEngine, desiredSeekTimeMs, signal) {
 	try {
 		let scrubRendition;
-		if ("data" in mediaEngine && mediaEngine.data?.videoRenditions) scrubRendition = mediaEngine.data.videoRenditions.find((r) => r.id === "scrub");
+		if (typeof mediaEngine.getScrubVideoRendition === "function") scrubRendition = mediaEngine.getScrubVideoRendition();
+		else if ("data" in mediaEngine && mediaEngine.data?.videoRenditions) scrubRendition = mediaEngine.data.videoRenditions.find((r) => r.id === "scrub");
 		if (!scrubRendition) return void 0;
 		const scrubRenditionWithSrc = {
 			...scrubRendition,

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

@@ -11,7 +11,7 @@ const makeVideoBufferTask = (host) => {
 		requestQueue: []
 	};
 	return new Task(host, {
-		autoRun: EF_INTERACTIVE && !EF_RENDERING(),
+		autoRun: EF_INTERACTIVE,
 		args: () => [host.desiredSeekTimeMs],
 		onError: (error) => {
 			console.error("videoBufferTask error", error);
@@ -21,28 +21,32 @@ const makeVideoBufferTask = (host) => {
 		},
 		task: async ([seekTimeMs], { signal }) => {
 			if (EF_RENDERING()) return currentState;
+			const mediaEngine = await getLatestMediaEngine(host, signal);
+			const engineConfig = mediaEngine.getBufferConfig();
+			const bufferDurationMs = engineConfig.videoBufferDurationMs;
+			const maxParallelFetches = engineConfig.maxVideoBufferFetches;
 			const currentConfig = {
-				bufferDurationMs: host.videoBufferDurationMs,
-				maxParallelFetches: host.maxVideoBufferFetches,
+				bufferDurationMs,
+				maxParallelFetches,
 				enableBuffering: host.enableVideoBuffering
 			};
 			return manageMediaBuffer(seekTimeMs, currentConfig, currentState, host.intrinsicDurationMs || 1e4, signal, {
 				computeSegmentId: async (timeMs, rendition) => {
-					const mediaEngine = await getLatestMediaEngine(host, signal);
-					return mediaEngine.computeSegmentId(timeMs, rendition);
+					const mediaEngine$1 = await getLatestMediaEngine(host, signal);
+					return mediaEngine$1.computeSegmentId(timeMs, rendition);
 				},
 				prefetchSegment: async (segmentId, rendition) => {
-					const mediaEngine = await getLatestMediaEngine(host, signal);
-					await mediaEngine.fetchMediaSegment(segmentId, rendition);
+					const mediaEngine$1 = await getLatestMediaEngine(host, signal);
+					await mediaEngine$1.fetchMediaSegment(segmentId, rendition);
 				},
 				isSegmentCached: (segmentId, rendition) => {
-					const mediaEngine = host.mediaEngineTask.value;
-					if (!mediaEngine) return false;
-					return mediaEngine.isSegmentCached(segmentId, rendition);
+					const mediaEngine$1 = host.mediaEngineTask.value;
+					if (!mediaEngine$1) return false;
+					return mediaEngine$1.isSegmentCached(segmentId, rendition);
 				},
 				getRendition: async () => {
-					const mediaEngine = await getLatestMediaEngine(host, signal);
-					return getVideoRendition(mediaEngine);
+					const mediaEngine$1 = await getLatestMediaEngine(host, signal);
+					return getVideoRendition(mediaEngine$1);
 				},
 				logError: console.error
 			});

package/dist/elements/EFMedia.d.ts

@@ -13,7 +13,6 @@ export declare class EFMedia extends EFMedia_base {
     static readonly AUDIO_SAMPLE_BUFFER_SIZE = 120;
     static get observedAttributes(): string[];
     static styles: import('lit').CSSResult[];
-    currentTimeMs: number;
     /**
      * Duration in milliseconds for audio buffering ahead of current time
      * @domAttribute "audio-buffer-duration"
@@ -64,8 +63,8 @@ export declare class EFMedia extends EFMedia_base {
     audioInputTask: import('./EFMedia/shared/MediaTaskUtils.ts').InputTask;
     audioSeekTask: import('@lit/task').Task<readonly [number, import('./EFMedia/BufferedSeekingInput.ts').BufferedSeekingInput | undefined], import('mediabunny').VideoSample | undefined>;
     audioBufferTask: import('@lit/task').Task<readonly [number], import('./EFMedia/audioTasks/makeAudioBufferTask.ts').AudioBufferState>;
-    byteTimeDomainTask: import('@lit/task').Task<readonly [import('@lit/task').TaskStatus, number, number, number, number, boolean], Uint8Array | null>;
-    frequencyDataTask: import('@lit/task').Task<readonly [import('@lit/task').TaskStatus, number, number, number, number, boolean], Uint8Array | null>;
+    byteTimeDomainTask: import('@lit/task').Task<readonly [number, number, number, number, boolean], Uint8Array | null>;
+    frequencyDataTask: import('@lit/task').Task<readonly [number, number, number, number, boolean], Uint8Array | null>;
     /**
      * The unique identifier for the media asset.
      * This property can be set programmatically or via the "asset-id" attribute.

package/dist/elements/EFMedia.js

@@ -13,7 +13,6 @@ import { EFSourceMixin } from "./EFSourceMixin.js";
 import { EFTemporal } from "./EFTemporal.js";
 import { FetchMixin } from "./FetchMixin.js";
 import { EFTargetable } from "./TargetController.js";
-import { updateAnimations } from "./updateAnimations.js";
 import { LitElement, css } from "lit";
 import { property, state } from "lit/decorators.js";
 import _decorate from "@oxc-project/runtime/helpers/decorate";
@@ -27,7 +26,6 @@ const deepGetMediaElements = (element, medias = []) => {
 var EFMedia = class extends EFTargetable(EFSourceMixin(EFTemporal(FetchMixin(LitElement)), { assetType: "isobmff_files" })) {
 	constructor(..._args) {
 		super(..._args);
-		this.currentTimeMs = 0;
 		this.audioBufferDurationMs = 1e4;
 		this.maxAudioBufferFetches = 2;
 		this.enableAudioBuffering = true;
@@ -107,7 +105,6 @@ var EFMedia = class extends EFTargetable(EFSourceMixin(EFTemporal(FetchMixin(Lit
 		const newCurrentSourceTimeMs = this.currentSourceTimeMs;
 		if (newCurrentSourceTimeMs !== this.desiredSeekTimeMs) this.executeSeek(newCurrentSourceTimeMs);
 		if (changedProperties.has("ownCurrentTimeMs")) this.executeSeek(this.currentSourceTimeMs);
-		if (changedProperties.has("currentTime") || changedProperties.has("ownCurrentTimeMs")) updateAnimations(this);
 	}
 	get hasOwnDuration() {
 		return true;
@@ -129,7 +126,6 @@ var EFMedia = class extends EFTargetable(EFSourceMixin(EFTemporal(FetchMixin(Lit
 		return fetchAudioSpanningTime(this, fromMs, toMs, signal);
 	}
 };
-_decorate([property({ type: Number })], EFMedia.prototype, "currentTimeMs", void 0);
 _decorate([property({
 	type: Number,
 	attribute: "audio-buffer-duration"

package/dist/elements/EFTemporal.d.ts

@@ -131,6 +131,12 @@ export declare class TemporalMixinInterface {
      * played.
      */
     get ownCurrentTimeMs(): number;
+    /**
+     * Element's current time for progress calculation.
+     * For timegroups: their timeline currentTimeMs
+     * For other temporal elements: their ownCurrentTimeMs
+     */
+    get currentTimeMs(): number;
     /**
      * The current time of the element in milliseconds, adjusted for trimming.
      *
@@ -181,12 +187,9 @@ export declare class TemporalMixinInterface {
     frameTask: Task<readonly unknown[], unknown>;
 }
 export declare const isEFTemporal: (obj: any) => obj is TemporalMixinInterface;
-export declare const deepGetTemporalElements: (element: Element, temporals?: TemporalMixinInterface[]) => TemporalMixinInterface[];
-export declare const deepGetElementsWithFrameTasks: (element: Element, elements?: Array<HTMLElement & {
-    frameTask: Task;
-}>) => (HTMLElement & {
-    frameTask: Task;
-})[];
+export declare const deepGetTemporalElements: (element: Element, temporals?: Array<TemporalMixinInterface & HTMLElement>) => (TemporalMixinInterface & HTMLElement)[];
+export declare const deepGetElementsWithFrameTasks: (element: Element, elements?: Array<TemporalMixinInterface & HTMLElement>) => (TemporalMixinInterface & HTMLElement)[];
+export declare const resetTemporalCache: () => void;
 export declare const shallowGetTemporalElements: (element: Element, temporals?: TemporalMixinInterface[]) => TemporalMixinInterface[];
 export declare class OwnCurrentTimeController implements ReactiveController {
     private host;

package/dist/elements/EFTemporal.js

@@ -7,6 +7,13 @@ import _decorate from "@oxc-project/runtime/helpers/decorate";
 const timegroupContext = createContext(Symbol("timeGroupContext"));
 const isEFTemporal = (obj) => obj[EF_TEMPORAL];
 const EF_TEMPORAL = Symbol("EF_TEMPORAL");
+const deepGetTemporalElements = (element, temporals = []) => {
+	for (const child of element.children) {
+		if (isEFTemporal(child)) temporals.push(child);
+		deepGetTemporalElements(child, temporals);
+	}
+	return temporals;
+};
 const deepGetElementsWithFrameTasks = (element, elements = []) => {
 	for (const child of element.children) {
 		if ("frameTask" in child && child.frameTask instanceof Task) elements.push(child);
@@ -219,6 +226,13 @@ const EFTemporal = (superClass) => {
 			return 0;
 		}
 		/**
+		* Element's current time for progress calculation.
+		* Non-timegroup temporal elements use their local time (ownCurrentTimeMs)
+		*/
+		get currentTimeMs() {
+			return this.ownCurrentTimeMs;
+		}
+		/**
 		* Used to calculate the internal currentTimeMs of the element. This is useful
 		* for mapping to internal media time codes for audio/video elements.
 		*/
@@ -226,17 +240,6 @@ const EFTemporal = (superClass) => {
 			const leadingTrimMs = this.sourceInMs || this.trimStartMs || 0;
 			return this.ownCurrentTimeMs + leadingTrimMs;
 		}
-		updated(changedProperties) {
-			super.updated(changedProperties);
-			if (changedProperties.has("currentTime") || changedProperties.has("ownCurrentTimeMs")) {
-				const timelineTimeMs = (this.rootTimegroup ?? this).ownCurrentTimeMs;
-				if (this.startTimeMs > timelineTimeMs || this.endTimeMs < timelineTimeMs) {
-					this.style.display = "none";
-					return;
-				}
-				this.style.display = "";
-			}
-		}
 	}
 	_decorate([consume({
 		context: timegroupContext,
@@ -281,4 +284,4 @@ const EFTemporal = (superClass) => {
 	Object.defineProperty(TemporalMixinClass.prototype, EF_TEMPORAL, { value: true });
 	return TemporalMixinClass;
 };
-export { EFTemporal, deepGetElementsWithFrameTasks, flushStartTimeMsCache, isEFTemporal, shallowGetTemporalElements, timegroupContext };
+export { EFTemporal, deepGetElementsWithFrameTasks, deepGetTemporalElements, flushStartTimeMsCache, isEFTemporal, resetTemporalCache, shallowGetTemporalElements, timegroupContext };

package/dist/elements/EFTimegroup.browsertest.d.ts

@@ -1,7 +1,29 @@
 import { LitElement } from 'lit';
+import { Task } from '@lit/task';
+import { MediaEngine } from '../transcoding/types/index.js';
+import { EFMedia } from './EFMedia.js';
 declare const TestContext_base: (new (...args: any[]) => import('../gui/ContextMixin.js').ContextMixinInterface) & typeof LitElement;
 declare class TestContext extends TestContext_base {
 }
+declare class TimegroupTestMedia extends EFMedia {
+    mediaEngineTaskCount: number;
+    mediaEngineTask: Task<readonly ["source", null], MediaEngine>;
+}
+declare const TestFrameTaskA_base: (new (...args: any[]) => import('./EFTemporal.js').TemporalMixinInterface) & typeof LitElement;
+declare class TestFrameTaskA extends TestFrameTaskA_base {
+    frameTaskCount: number;
+    frameTask: Task<never[], void>;
+}
+declare const TestFrameTaskB_base: (new (...args: any[]) => import('./EFTemporal.js').TemporalMixinInterface) & typeof LitElement;
+declare class TestFrameTaskB extends TestFrameTaskB_base {
+    frameTaskCount: number;
+    frameTask: Task<never[], void>;
+}
+declare const TestFrameTaskC_base: (new (...args: any[]) => import('./EFTemporal.js').TemporalMixinInterface) & typeof LitElement;
+declare class TestFrameTaskC extends TestFrameTaskC_base {
+    frameTaskCount: number;
+    frameTask: Task<never[], void>;
+}
 declare const TestTemporal_base: (new (...args: any[]) => import('./EFTemporal.js').TemporalMixinInterface) & typeof LitElement;
 declare class TestTemporal extends TestTemporal_base {
     get hasOwnDuration(): boolean;
@@ -10,6 +32,10 @@ declare global {
     interface HTMLElementTagNameMap {
         "test-temporal": TestTemporal;
         "test-context": TestContext;
+        "timegroup-test-media": TimegroupTestMedia;
+        "test-frame-task-a": TestFrameTaskA;
+        "test-frame-task-b": TestFrameTaskB;
+        "test-frame-task-c": TestFrameTaskC;
     }
 }
 export {};

package/dist/elements/EFTimegroup.d.ts

@@ -1,24 +1,29 @@
 import { Task } from '@lit/task';
-import { LitElement, PropertyValueMap } from 'lit';
+import { LitElement } from 'lit';
+export declare const flushSequenceDurationCache: () => void;
 export declare const shallowGetTimegroups: (element: Element, groups?: EFTimegroup[]) => EFTimegroup[];
 declare const EFTimegroup_base: (new (...args: any[]) => import('./EFTemporal.js').TemporalMixinInterface) & typeof LitElement;
 export declare class EFTimegroup extends EFTimegroup_base {
     #private;
     static styles: import('lit').CSSResult;
     _timeGroupContext: this;
-    mode: "fit" | "fixed" | "sequence" | "contain";
-    overlapMs: number;
+    set mode(value: "fit" | "fixed" | "sequence" | "contain");
+    get mode(): "fit" | "fixed" | "sequence" | "contain";
+    private _mode;
+    set overlapMs(value: number);
+    get overlapMs(): number;
+    private _overlapMs;
     fit: "none" | "contain" | "cover";
     set currentTime(time: number);
     get currentTime(): number;
-    get currentTimeMs(): number;
     set currentTimeMs(ms: number);
+    get currentTimeMs(): number;
     /**
      * Determines if this is a root timegroup (no parent timegroups)
      */
     get isRootTimegroup(): boolean;
     render(): import('lit-html').TemplateResult<1>;
-    maybeLoadTimeFromLocalStorage(): number;
+    maybeLoadTimeFromLocalStorage(): number | undefined;
     connectedCallback(): void;
     disconnectedCallback(): void;
     get storageKey(): string;
@@ -27,17 +32,10 @@ export declare class EFTimegroup extends EFTimegroup_base {
     get durationMs(): number;
     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
-     * that caused issues with constructing audio data. We had negative durations
-     * in calculations and it was not clear why.
-     */
+    waitForFrameTasks(): Promise<void>;
+    mediaDurationsPromise: Promise<void> | undefined;
     waitForMediaDurations(): Promise<void>;
     get childTemporals(): import('./EFTemporal.js').TemporalMixinInterface[];
-    protected updated(changedProperties: PropertyValueMap<any> | Map<PropertyKey, unknown>): void;
-    private updateAnimations;
     get contextProvider(): import('../gui/ContextMixin.js').ContextMixinInterface | null;
     /**
      * Returns true if the timegroup should be wrapped with a workbench.
@@ -59,7 +57,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>;
+    seekTask: Task<readonly [number | undefined], number | undefined>;
 }
 declare global {
     interface HTMLElementTagNameMap {