@editframe/elements 0.20.4-beta.0 → 0.21.0-beta.0

package/dist/DelayedLoadingState.js

@@ -6,9 +6,6 @@ var DelayedLoadingState = class {
 		this.loadingDelayMs = delayMs;
 		this.onStateChange = onStateChange;
 	}
-	/**
-	* Start a delayed loading operation
-	*/
 	startLoading(operationId, message, options = {}) {
 		const isBackground = options.background || false;
 		const existingOp = this.operations.get(operationId);
@@ -34,9 +31,6 @@ var DelayedLoadingState = class {
 			isBackground: false
 		});
 	}
-	/**
-	* Clear a loading operation
-	*/
 	clearLoading(operationId) {
 		const operation = this.operations.get(operationId);
 		if (!operation) return;
@@ -44,36 +38,21 @@ var DelayedLoadingState = class {
 		this.operations.delete(operationId);
 		this.updateLoadingState();
 	}
-	/**
-	* Clear all loading operations
-	*/
 	clearAllLoading() {
 		for (const operation of this.operations.values()) if (operation.timeout) clearTimeout(operation.timeout);
 		this.operations.clear();
 		this.updateLoadingState();
 	}
-	/**
-	* Get current loading state
-	*/
 	get isLoading() {
 		return this.isCurrentlyLoading;
 	}
-	/**
-	* Get current loading message
-	*/
 	get message() {
 		return this.currentMessage;
 	}
-	/**
-	* Check if any non-background operations are active
-	*/
 	hasActiveOperations() {
 		for (const operation of this.operations.values()) if (!operation.isBackground) return true;
 		return false;
 	}
-	/**
-	* Get the message for the most recent non-background operation
-	*/
 	getCurrentMessage() {
 		let latestTime = 0;
 		let latestMessage = "";
@@ -83,9 +62,6 @@ var DelayedLoadingState = class {
 		}
 		return latestMessage;
 	}
-	/**
-	* Trigger loading state (called by timeout)
-	*/
 	triggerLoadingState() {
 		if (this.hasActiveOperations() && !this.isCurrentlyLoading) {
 			this.isCurrentlyLoading = true;
@@ -93,9 +69,6 @@ var DelayedLoadingState = class {
 			this.onStateChange?.(true, this.currentMessage);
 		}
 	}
-	/**
-	* Update loading state based on current operations
-	*/
 	updateLoadingState() {
 		const shouldBeLoading = this.hasActiveOperations();
 		if (shouldBeLoading !== this.isCurrentlyLoading) {

package/dist/EF_FRAMEGEN.d.ts

@@ -1,12 +1,14 @@
 import { VideoRenderOptions } from '../../assets/src/index.ts';
+import { TraceContext } from './otel/tracingHelpers.js';
 interface Bridge {
-    onInitialize: (callback: (renderOptions: VideoRenderOptions) => void) => void;
+    onInitialize: (callback: (renderOptions: VideoRenderOptions, traceContext?: TraceContext, otelEndpoint?: string) => void) => void;
     initialized(): void;
-    onBeginFrame(callback: (frameNumber: number, isLast: boolean) => void): void;
-    onTriggerCanvas(callback: () => void): void;
+    onBeginFrame(callback: (frameNumber: number, isLast: boolean, traceContext?: TraceContext) => void): void;
+    onTriggerCanvas(callback: (traceContext?: TraceContext) => void): void;
     frameReady(frameNumber: number, audioSamples: ArrayBuffer): void;
     error(error: Error): void;
     syncLog(sequence: number, message: string, callback: () => void): void;
+    exportSpans?: (endpoint: string, payload: string) => void;
 }
 declare global {
     interface Window {

package/dist/EF_FRAMEGEN.js

@@ -1,4 +1,6 @@
+import { clearCurrentFrameSpan, enableTracing, extractParentContext, setCurrentFrameSpan, withSpan, withSpanAndContext } from "./otel/tracingHelpers.js";
 import { shallowGetTimegroups } from "./elements/EFTimegroup.js";
+import { setupBrowserTracing } from "./otel/setupBrowserTracing.js";
 var TriggerCanvas = class {
 	constructor() {
 		this.canvasInitialized = false;
@@ -91,17 +93,55 @@ var EFFramegen = class {
 	connectToBridge() {
 		const BRIDGE = this.BRIDGE;
 		if (!BRIDGE) throw new Error("No BRIDGE when attempting to connect to bridge");
-		BRIDGE.onInitialize(async (renderOptions) => {
-			await this.initialize(renderOptions).catch((error) => {
-				console.error("[EF_FRAMEGEN.connectToBridge] error initializing", error);
+		BRIDGE.onInitialize(async (renderOptions, traceContext, otelEndpoint) => {
+			if (renderOptions.enableTracing && otelEndpoint) {
+				enableTracing();
+				setupBrowserTracing({
+					otelEndpoint,
+					serviceName: "telecine-browser",
+					bridge: BRIDGE,
+					useBatching: true
+				});
+			}
+			const parentContext = extractParentContext(traceContext);
+			await withSpan("browser.initialize", {
+				width: renderOptions.encoderOptions.video.width,
+				height: renderOptions.encoderOptions.video.height,
+				fps: renderOptions.encoderOptions.video.framerate,
+				durationMs: renderOptions.encoderOptions.toMs - renderOptions.encoderOptions.fromMs
+			}, parentContext, async () => {
+				await this.initialize(renderOptions).catch((error) => {
+					console.error("[EF_FRAMEGEN.connectToBridge] error initializing", error);
+					throw error;
+				});
 			});
 			BRIDGE.initialized();
 		});
-		BRIDGE.onBeginFrame((frameNumber, isLast) => {
-			this.beginFrame(frameNumber, isLast);
+		BRIDGE.onBeginFrame((frameNumber, isLast, traceContext) => {
+			const parentContext = extractParentContext(traceContext);
+			withSpanAndContext("browser.frame.render", {
+				frameNumber,
+				isLast
+			}, parentContext, async (span, _spanContext) => {
+				setCurrentFrameSpan(span);
+				try {
+					await this.beginFrame(frameNumber, isLast);
+				} finally {
+					clearCurrentFrameSpan();
+				}
+			}).catch((error) => {
+				console.error("[EF_FRAMEGEN.beginFrame] error:", error);
+				clearCurrentFrameSpan();
+				throw error;
+			});
 		});
-		BRIDGE.onTriggerCanvas(() => {
-			this.triggerCanvas.trigger();
+		BRIDGE.onTriggerCanvas((traceContext) => {
+			const parentContext = extractParentContext(traceContext);
+			withSpan("browser.canvas.trigger", {}, parentContext, async () => {
+				this.triggerCanvas.trigger();
+			}).catch((error) => {
+				console.error("[EF_FRAMEGEN.triggerCanvas] error:", error);
+			});
 		});
 	}
 	get showFrameBox() {
@@ -113,8 +153,7 @@ var EFFramegen = class {
 		if (!workbench) throw new Error("No workbench found");
 		workbench.rendering = true;
 		workbench.playing = false;
-		const timegroups = shallowGetTimegroups(workbench);
-		const firstGroup = timegroups[0];
+		const firstGroup = shallowGetTimegroups(workbench)[0];
 		if (!firstGroup) throw new Error("No temporal elements found");
 		const startingTimeMs = renderOptions.encoderOptions.fromMs;
 		await firstGroup.waitForMediaDurations();
@@ -142,8 +181,7 @@ var EFFramegen = class {
 		const workbench = document.querySelector("ef-workbench");
 		if (!workbench) throw new Error("No workbench found");
 		workbench.rendering = true;
-		const timegroups = shallowGetTimegroups(workbench);
-		const firstGroup = timegroups[0];
+		const firstGroup = shallowGetTimegroups(workbench)[0];
 		if (!firstGroup) throw new Error("No temporal elements found");
 		const frameTime = this.renderOptions.encoderOptions.fromMs + frameNumber * this.frameDurationMs;
 		firstGroup.currentTimeMs = Number(Number(frameTime).toFixed(5));
@@ -183,3 +221,4 @@ var EFFramegen = class {
 	}
 };
 if (typeof window !== "undefined") window.EF_FRAMEGEN = new EFFramegen();
+export {};

package/dist/_virtual/_@oxc-project_runtime@0.93.0/helpers/decorate.js

@@ -0,0 +1,7 @@
+function __decorate(decorators, target, key, desc) {
+	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+	else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+	return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+export { __decorate };

package/dist/elements/ContextProxiesController.js

@@ -1,22 +1,4 @@
 import { ContextEvent } from "@lit/context";
-/**
-* A ReactiveController that proxies context requests to a target element.
-*
-* Usage:
-* ```typescript
-* @customElement('my-proxy')
-* class MyProxy extends LitElement {
-*   @state()
-*   targetElement: HTMLElement | null = null;
-*
-*   // @ts-expect-error controller is intentionally not referenced directly
-*   #contextProxyController = new ContextProxyController(this, {
-*     target: () => this.targetElement,
-*     contexts: [playingContext, loopContext, targetTimegroupContext]
-*   });
-* }
-* ```
-*/
 var ContextProxyController = class {
 	constructor(host, config) {
 		this.proxyMap = /* @__PURE__ */ new Map();
@@ -43,11 +25,9 @@ var ContextProxyController = class {
 	}
 	handleContextRequest(event) {
 		const contextEvent = event;
-		const targetGetter = this.proxyMap.get(contextEvent.context);
-		if (targetGetter) {
+		if (this.proxyMap.get(contextEvent.context)) {
 			contextEvent.stopPropagation();
-			const processed = this.processContextRequest(contextEvent);
-			if (!processed) this.pendingRequests.push(contextEvent);
+			if (!this.processContextRequest(contextEvent)) this.pendingRequests.push(contextEvent);
 		}
 	}
 	processContextRequest(contextEvent) {

package/dist/elements/EFAudio.js

@@ -1,12 +1,12 @@
 import { EF_INTERACTIVE } from "../EF_INTERACTIVE.js";
+import { __decorate } from "../_virtual/_@oxc-project_runtime@0.93.0/helpers/decorate.js";
 import { EFMedia } from "./EFMedia.js";
 import { TWMixin } from "../gui/TWMixin2.js";
 import { Task } from "@lit/task";
 import { html } from "lit";
 import { customElement, property } from "lit/decorators.js";
-import _decorate from "@oxc-project/runtime/helpers/decorate";
 import { createRef, ref } from "lit/directives/ref.js";
-let EFAudio = class EFAudio$1 extends TWMixin(EFMedia) {
+var EFAudio = class EFAudio$1 extends TWMixin(EFMedia) {
 	constructor(..._args) {
 		super(..._args);
 		this._propertyHack = false;
@@ -31,17 +31,13 @@ let EFAudio = class EFAudio$1 extends TWMixin(EFMedia) {
 	render() {
 		return html`<audio ${ref(this.audioElementRef)}></audio>`;
 	}
-	/**
-	* Legacy getter for fragment index task (maps to audioSegmentIdTask)
-	* Still used by EFCaptions
-	*/
 	get fragmentIndexTask() {
 		return this.audioSegmentIdTask;
 	}
 };
-_decorate([property({
+__decorate([property({
 	type: Boolean,
 	attribute: "dummy-property"
 })], EFAudio.prototype, "_propertyHack", void 0);
-EFAudio = _decorate([customElement("ef-audio")], EFAudio);
+EFAudio = __decorate([customElement("ef-audio")], EFAudio);
 export { EFAudio };

package/dist/elements/EFCaptions.js

@@ -1,4 +1,5 @@
 import { EF_INTERACTIVE } from "../EF_INTERACTIVE.js";
+import { __decorate } from "../_virtual/_@oxc-project_runtime@0.93.0/helpers/decorate.js";
 import { EFSourceMixin } from "./EFSourceMixin.js";
 import { EFTemporal, flushStartTimeMsCache } from "./EFTemporal.js";
 import { FetchMixin } from "./FetchMixin.js";
@@ -9,15 +10,14 @@ import { CrossUpdateController } from "./CrossUpdateController.js";
 import { Task, TaskStatus } from "@lit/task";
 import { LitElement, css, html } from "lit";
 import { customElement, property } from "lit/decorators.js";
-import _decorate from "@oxc-project/runtime/helpers/decorate";
-const stopWords = new Set([
+var stopWords = new Set([
 	"",
 	".",
 	"!",
 	"?",
 	","
 ]);
-let EFCaptionsActiveWord = class EFCaptionsActiveWord$1 extends EFTemporal(LitElement) {
+var EFCaptionsActiveWord = class EFCaptionsActiveWord$1 extends EFTemporal(LitElement) {
 	constructor(..._args) {
 		super(..._args);
 		this.wordStartMs = 0;
@@ -41,50 +41,45 @@ let EFCaptionsActiveWord = class EFCaptionsActiveWord$1 extends EFTemporal(LitEl
 	render() {
 		if (stopWords.has(this.wordText)) {
 			this.hidden = true;
-			return void 0;
+			return;
 		}
 		this.hidden = false;
-		const seed = this.wordIndex * 9007 % 233;
-		const seedValue = seed / 233;
+		const seedValue = this.wordIndex * 9007 % 233 / 233;
 		this.style.setProperty("--ef-word-seed", seedValue.toString());
 		return html` ${this.wordText.trim()} `;
 	}
 	get startTimeMs() {
-		const parentCaptions = this.closest("ef-captions");
-		const parentStartTime = parentCaptions?.startTimeMs || 0;
-		return parentStartTime + (this.wordStartMs || 0);
+		return (this.closest("ef-captions")?.startTimeMs || 0) + (this.wordStartMs || 0);
 	}
 	get endTimeMs() {
-		const parentCaptions = this.closest("ef-captions");
-		const parentStartTime = parentCaptions?.startTimeMs || 0;
-		return parentStartTime + (this.wordEndMs || 0);
+		return (this.closest("ef-captions")?.startTimeMs || 0) + (this.wordEndMs || 0);
 	}
 	get durationMs() {
 		return this.wordEndMs - this.wordStartMs;
 	}
 };
-_decorate([property({
+__decorate([property({
 	type: Number,
 	attribute: false
 })], EFCaptionsActiveWord.prototype, "wordStartMs", void 0);
-_decorate([property({
+__decorate([property({
 	type: Number,
 	attribute: false
 })], EFCaptionsActiveWord.prototype, "wordEndMs", void 0);
-_decorate([property({
+__decorate([property({
 	type: String,
 	attribute: false
 })], EFCaptionsActiveWord.prototype, "wordText", void 0);
-_decorate([property({
+__decorate([property({
 	type: Number,
 	attribute: false
 })], EFCaptionsActiveWord.prototype, "wordIndex", void 0);
-_decorate([property({
+__decorate([property({
 	type: Boolean,
 	reflect: true
 })], EFCaptionsActiveWord.prototype, "hidden", void 0);
-EFCaptionsActiveWord = _decorate([customElement("ef-captions-active-word")], EFCaptionsActiveWord);
-let EFCaptionsSegment = class EFCaptionsSegment$1 extends EFTemporal(LitElement) {
+EFCaptionsActiveWord = __decorate([customElement("ef-captions-active-word")], EFCaptionsActiveWord);
+var EFCaptionsSegment = class EFCaptionsSegment$1 extends EFTemporal(LitElement) {
 	constructor(..._args2) {
 		super(..._args2);
 		this.segmentStartMs = 0;
@@ -105,43 +100,39 @@ let EFCaptionsSegment = class EFCaptionsSegment$1 extends EFTemporal(LitElement)
 	render() {
 		if (stopWords.has(this.segmentText)) {
 			this.hidden = true;
-			return void 0;
+			return;
 		}
 		this.hidden = false;
 		return html`${this.segmentText}`;
 	}
 	get startTimeMs() {
-		const parentCaptions = this.closest("ef-captions");
-		const parentStartTime = parentCaptions?.startTimeMs || 0;
-		return parentStartTime + (this.segmentStartMs || 0);
+		return (this.closest("ef-captions")?.startTimeMs || 0) + (this.segmentStartMs || 0);
 	}
 	get endTimeMs() {
-		const parentCaptions = this.closest("ef-captions");
-		const parentStartTime = parentCaptions?.startTimeMs || 0;
-		return parentStartTime + (this.segmentEndMs || 0);
+		return (this.closest("ef-captions")?.startTimeMs || 0) + (this.segmentEndMs || 0);
 	}
 	get durationMs() {
 		return this.segmentEndMs - this.segmentStartMs;
 	}
 };
-_decorate([property({
+__decorate([property({
 	type: Number,
 	attribute: false
 })], EFCaptionsSegment.prototype, "segmentStartMs", void 0);
-_decorate([property({
+__decorate([property({
 	type: Number,
 	attribute: false
 })], EFCaptionsSegment.prototype, "segmentEndMs", void 0);
-_decorate([property({
+__decorate([property({
 	type: String,
 	attribute: false
 })], EFCaptionsSegment.prototype, "segmentText", void 0);
-_decorate([property({
+__decorate([property({
 	type: Boolean,
 	reflect: true
 })], EFCaptionsSegment.prototype, "hidden", void 0);
-EFCaptionsSegment = _decorate([customElement("ef-captions-segment")], EFCaptionsSegment);
-let EFCaptionsBeforeActiveWord = class EFCaptionsBeforeActiveWord$1 extends EFCaptionsSegment {
+EFCaptionsSegment = __decorate([customElement("ef-captions-segment")], EFCaptionsSegment);
+var EFCaptionsBeforeActiveWord = class EFCaptionsBeforeActiveWord$1 extends EFCaptionsSegment {
 	constructor(..._args3) {
 		super(..._args3);
 		this.hidden = false;
@@ -163,43 +154,39 @@ let EFCaptionsBeforeActiveWord = class EFCaptionsBeforeActiveWord$1 extends EFCa
 	render() {
 		if (stopWords.has(this.segmentText)) {
 			this.hidden = true;
-			return void 0;
+			return;
 		}
 		this.hidden = false;
 		return html` ${this.segmentText}`;
 	}
 	get startTimeMs() {
-		const parentCaptions = this.closest("ef-captions");
-		const parentStartTime = parentCaptions?.startTimeMs || 0;
-		return parentStartTime + (this.segmentStartMs || 0);
+		return (this.closest("ef-captions")?.startTimeMs || 0) + (this.segmentStartMs || 0);
 	}
 	get endTimeMs() {
-		const parentCaptions = this.closest("ef-captions");
-		const parentStartTime = parentCaptions?.startTimeMs || 0;
-		return parentStartTime + (this.segmentEndMs || 0);
+		return (this.closest("ef-captions")?.startTimeMs || 0) + (this.segmentEndMs || 0);
 	}
 	get durationMs() {
 		return this.segmentEndMs - this.segmentStartMs;
 	}
 };
-_decorate([property({
+__decorate([property({
 	type: Boolean,
 	reflect: true
 })], EFCaptionsBeforeActiveWord.prototype, "hidden", void 0);
-_decorate([property({
+__decorate([property({
 	type: String,
 	attribute: false
 })], EFCaptionsBeforeActiveWord.prototype, "segmentText", void 0);
-_decorate([property({
+__decorate([property({
 	type: Number,
 	attribute: false
 })], EFCaptionsBeforeActiveWord.prototype, "segmentStartMs", void 0);
-_decorate([property({
+__decorate([property({
 	type: Number,
 	attribute: false
 })], EFCaptionsBeforeActiveWord.prototype, "segmentEndMs", void 0);
-EFCaptionsBeforeActiveWord = _decorate([customElement("ef-captions-before-active-word")], EFCaptionsBeforeActiveWord);
-let EFCaptionsAfterActiveWord = class EFCaptionsAfterActiveWord$1 extends EFCaptionsSegment {
+EFCaptionsBeforeActiveWord = __decorate([customElement("ef-captions-before-active-word")], EFCaptionsBeforeActiveWord);
+var EFCaptionsAfterActiveWord = class EFCaptionsAfterActiveWord$1 extends EFCaptionsSegment {
 	constructor(..._args4) {
 		super(..._args4);
 		this.hidden = false;
@@ -221,43 +208,39 @@ let EFCaptionsAfterActiveWord = class EFCaptionsAfterActiveWord$1 extends EFCapt
 	render() {
 		if (stopWords.has(this.segmentText)) {
 			this.hidden = true;
-			return void 0;
+			return;
 		}
 		this.hidden = false;
 		return html`${this.segmentText} `;
 	}
 	get startTimeMs() {
-		const parentCaptions = this.closest("ef-captions");
-		const parentStartTime = parentCaptions?.startTimeMs || 0;
-		return parentStartTime + (this.segmentStartMs || 0);
+		return (this.closest("ef-captions")?.startTimeMs || 0) + (this.segmentStartMs || 0);
 	}
 	get endTimeMs() {
-		const parentCaptions = this.closest("ef-captions");
-		const parentStartTime = parentCaptions?.startTimeMs || 0;
-		return parentStartTime + (this.segmentEndMs || 0);
+		return (this.closest("ef-captions")?.startTimeMs || 0) + (this.segmentEndMs || 0);
 	}
 	get durationMs() {
 		return this.segmentEndMs - this.segmentStartMs;
 	}
 };
-_decorate([property({
+__decorate([property({
 	type: Boolean,
 	reflect: true
 })], EFCaptionsAfterActiveWord.prototype, "hidden", void 0);
-_decorate([property({
+__decorate([property({
 	type: String,
 	attribute: false
 })], EFCaptionsAfterActiveWord.prototype, "segmentText", void 0);
-_decorate([property({
+__decorate([property({
 	type: Number,
 	attribute: false
 })], EFCaptionsAfterActiveWord.prototype, "segmentStartMs", void 0);
-_decorate([property({
+__decorate([property({
 	type: Number,
 	attribute: false
 })], EFCaptionsAfterActiveWord.prototype, "segmentEndMs", void 0);
-EFCaptionsAfterActiveWord = _decorate([customElement("ef-captions-after-active-word")], EFCaptionsAfterActiveWord);
-let EFCaptions = class EFCaptions$1 extends EFSourceMixin(EFTemporal(FetchMixin(LitElement)), { assetType: "caption_files" }) {
+EFCaptionsAfterActiveWord = __decorate([customElement("ef-captions-after-active-word")], EFCaptionsAfterActiveWord);
+var EFCaptions = class EFCaptions$1 extends EFSourceMixin(EFTemporal(FetchMixin(LitElement)), { assetType: "caption_files" }) {
 	constructor(..._args5) {
 		super(..._args5);
 		this.displayMode = "segment";
@@ -277,11 +260,10 @@ let EFCaptions = class EFCaptions$1 extends EFSourceMixin(EFTemporal(FetchMixin(
 			task: async ([_target, fetch], { signal }) => {
 				if (!this.targetElement) return null;
 				const md5Path = `/@ef-asset/${this.targetElement.src ?? ""}`;
-				const response = await fetch(md5Path, {
+				return (await fetch(md5Path, {
 					method: "HEAD",
 					signal
-				});
-				return response.headers.get("etag") ?? void 0;
+				})).headers.get("etag") ?? void 0;
 			}
 		});
 		this.transcriptionDataTask = new Task(this, {
@@ -293,8 +275,7 @@ let EFCaptions = class EFCaptions$1 extends EFSourceMixin(EFTemporal(FetchMixin(
 			],
 			task: async ([transcriptionsPath, fetch, hasCustomData], { signal }) => {
 				if (hasCustomData || !transcriptionsPath) return null;
-				const response = await fetch(transcriptionsPath, { signal });
-				return response.json();
+				return (await fetch(transcriptionsPath, { signal })).json();
 			}
 		});
 		this.fragmentIndexTask = new Task(this, {
@@ -302,8 +283,7 @@ let EFCaptions = class EFCaptions$1 extends EFSourceMixin(EFTemporal(FetchMixin(
 			args: () => [this.transcriptionDataTask.value, this.ownCurrentTimeMs],
 			task: async ([transcription, ownCurrentTimeMs]) => {
 				if (!transcription) return null;
-				const fragmentIndex = Math.floor(ownCurrentTimeMs / transcription.work_slice_ms);
-				return fragmentIndex;
+				return Math.floor(ownCurrentTimeMs / transcription.work_slice_ms);
 			}
 		});
 		this.customCaptionsDataTask = new Task(this, {
@@ -326,8 +306,7 @@ let EFCaptions = class EFCaptions$1 extends EFSourceMixin(EFTemporal(FetchMixin(
 					}
 				}
 				if (captionsSrc) try {
-					const response = await fetch(captionsSrc, { signal });
-					return await response.json();
+					return await (await fetch(captionsSrc, { signal })).json();
 				} catch (error) {
 					console.error(`Failed to load captions from ${captionsSrc}:`, error);
 					return null;
@@ -345,8 +324,7 @@ let EFCaptions = class EFCaptions$1 extends EFSourceMixin(EFTemporal(FetchMixin(
 			task: async ([transcription, fragmentIndex, fetch], { signal }) => {
 				if (transcription === null || transcription === void 0 || fragmentIndex === null || fragmentIndex === void 0) return null;
 				const fragmentPath = this.transcriptionFragmentPath(transcription.id, fragmentIndex);
-				const response = await fetch(fragmentPath, { signal });
-				return response.json();
+				return (await fetch(fragmentPath, { signal })).json();
 			}
 		});
 		this.unifiedCaptionsDataTask = new Task(this, {
@@ -402,8 +380,7 @@ let EFCaptions = class EFCaptions$1 extends EFSourceMixin(EFTemporal(FetchMixin(
 	captionsPath() {
 		if (!this.targetElement) return null;
 		if (this.targetElement.assetId) return `${this.apiHost}/api/v1/caption_files/${this.targetElement.assetId}`;
-		const targetSrc = this.targetElement.src;
-		return `/@ef-captions/${targetSrc}`;
+		return `/@ef-captions/${this.targetElement.src}`;
 	}
 	transcriptionFragmentPath(transcriptionId, fragmentIndex) {
 		return `${this.apiHost}/api/v1/transcriptions/${transcriptionId}/fragments/${fragmentIndex}`;
@@ -430,8 +407,7 @@ let EFCaptions = class EFCaptions$1 extends EFSourceMixin(EFTemporal(FetchMixin(
 	updateTextContainers() {
 		const captionsData = this.unifiedCaptionsDataTask.value;
 		if (!captionsData) return;
-		const currentTimeMs = this.targetElement ? this.targetElement.currentSourceTimeMs : this.ownCurrentTimeMs;
-		const currentTimeSec = currentTimeMs / 1e3;
+		const currentTimeSec = (this.targetElement ? this.targetElement.currentSourceTimeMs : this.ownCurrentTimeMs) / 1e3;
 		const currentWord = captionsData.word_segments.find((word) => currentTimeSec >= word.start && currentTimeSec < word.end);
 		const currentSegment = captionsData.segments.find((segment) => currentTimeSec >= segment.start && currentTimeSec < segment.end);
 		for (const wordContainer of this.activeWordContainers) if (currentWord) {
@@ -476,8 +452,7 @@ let EFCaptions = class EFCaptions$1 extends EFSourceMixin(EFTemporal(FetchMixin(
 		} else if (currentSegment) {
 			const segmentWords = captionsData.word_segments.filter((word) => word.start >= currentSegment.start && word.end <= currentSegment.end);
 			const firstWord = segmentWords[0];
-			const isBeforeFirstWord = firstWord && currentTimeSec < firstWord.start;
-			if (isBeforeFirstWord) {
+			if (firstWord && currentTimeSec < firstWord.start) {
 				const allWords = segmentWords.map((w) => w.text.trim()).join(" ");
 				for (const container of this.beforeActiveWordContainers) {
 					container.segmentText = "";
@@ -533,7 +508,7 @@ let EFCaptions = class EFCaptions$1 extends EFSourceMixin(EFTemporal(FetchMixin(
 				captionsData = JSON.parse(scriptElement.textContent);
 			} catch {}
 		} else if (this.customCaptionsDataTask.value) captionsData = this.customCaptionsDataTask.value;
-		if (!captionsData) return void 0;
+		if (!captionsData) return;
 		if (captionsData.segments.length === 0 && captionsData.word_segments.length === 0) return 0;
 		const maxSegmentEnd = captionsData.segments.length > 0 ? Math.max(...captionsData.segments.map((s) => s.end)) : 0;
 		const maxWordEnd = captionsData.word_segments.length > 0 ? Math.max(...captionsData.word_segments.map((w) => w.end)) : 0;
@@ -543,35 +518,35 @@ let EFCaptions = class EFCaptions$1 extends EFSourceMixin(EFTemporal(FetchMixin(
 		return !!(this.captionsData || this.captionsScript || this.customCaptionsDataTask.value);
 	}
 };
-_decorate([property({
+__decorate([property({
 	type: String,
 	attribute: "display-mode",
 	reflect: true
 })], EFCaptions.prototype, "displayMode", void 0);
-_decorate([property({
+__decorate([property({
 	type: Number,
 	attribute: "context-words",
 	reflect: true
 })], EFCaptions.prototype, "contextWords", void 0);
-_decorate([property({
+__decorate([property({
 	type: String,
 	attribute: "target",
 	reflect: true
 })], EFCaptions.prototype, "targetSelector", void 0);
-_decorate([property({ attribute: "word-style" })], EFCaptions.prototype, "wordStyle", void 0);
-_decorate([property({
+__decorate([property({ attribute: "word-style" })], EFCaptions.prototype, "wordStyle", void 0);
+__decorate([property({
 	type: String,
 	attribute: "captions-src",
 	reflect: true
 })], EFCaptions.prototype, "captionsSrc", void 0);
-_decorate([property({
+__decorate([property({
 	type: Object,
 	attribute: false
 })], EFCaptions.prototype, "captionsData", void 0);
-_decorate([property({
+__decorate([property({
 	type: String,
 	attribute: "captions-script",
 	reflect: true
 })], EFCaptions.prototype, "captionsScript", void 0);
-EFCaptions = _decorate([customElement("ef-captions")], EFCaptions);
+EFCaptions = __decorate([customElement("ef-captions")], EFCaptions);
 export { EFCaptions, EFCaptionsActiveWord, EFCaptionsAfterActiveWord, EFCaptionsBeforeActiveWord, EFCaptionsSegment };