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

package/README.md

@@ -0,0 +1,30 @@
+# Tasks: Hierarchical Async Task System for lit-html
+
+## Relevant Files
+
+- `src/task-system/types.ts` - Complete TypeScript interfaces and types for the task system 
+- `src/task-system/Task.ts` - Core Task class with lifecycle management, hierarchy, and event handling
+- `src/task-system/Task.test.ts` - Comprehensive unit tests for Task class
+- `src/task-system/TaskManager.ts` - Core task orchestration with dependency tracking, resolution, and priority scheduling
+- `src/task-system/TaskManager.test.ts` - Comprehensive unit tests for TaskManager with dependency scenarios
+- `src/task-system/TaskRegistry.ts` - Global registry with automatic cleanup, memory management, and monitoring
+- `src/task-system/TaskRegistry.test.ts` - Comprehensive unit tests for TaskRegistry covering all cleanup scenarios
+- `src/task-system/index.ts` - Public API exports with convenience functions for common task patterns
+- `src/integrations/lit-html-task-mixin.ts` - Lit-html component integration mixin
+- `src/integrations/lit-html-task-mixin.test.ts` - Unit tests for lit-html integration
+- `src/utils/task-debug.ts` - Developer debugging utilities and task graph visualization
+- `src/utils/task-debug.test.ts` - Unit tests for debugging utilities
+
+### Notes
+
+- Unit tests should be placed alongside the code files they are testing
+- Use `npx tsx` to execute TypeScript files for testing
+- The system should be domain-agnostic and reusable across different use cases
+
+## Tasks
+
+- [x] 1.0 Design and implement core task abstraction and lifecycle management
+- [x] 2.0 Build hierarchical dependency tracking and resolution system  
+- [x] 3.0 Create task registry and cleanup mechanisms
+- [ ] 4.0 Implement lit-html component integration layer
+- [ ] 5.0 Add debugging and observability features 

package/dist/DecoderResetFrequency.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/DecoderResetRecovery.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/DelayedLoadingState.d.ts

@@ -0,0 +1,48 @@
+interface LoadingOptions {
+    background?: boolean;
+}
+export declare class DelayedLoadingState {
+    private operations;
+    private loadingDelayMs;
+    private isCurrentlyLoading;
+    private currentMessage;
+    private onStateChange?;
+    constructor(delayMs?: number, onStateChange?: (isLoading: boolean, message: string) => void);
+    /**
+     * Start a delayed loading operation
+     */
+    startLoading(operationId: string, message: string, options?: LoadingOptions): void;
+    /**
+     * Clear a loading operation
+     */
+    clearLoading(operationId: string): void;
+    /**
+     * Clear all loading operations
+     */
+    clearAllLoading(): void;
+    /**
+     * Get current loading state
+     */
+    get isLoading(): boolean;
+    /**
+     * Get current loading message
+     */
+    get message(): string;
+    /**
+     * Check if any non-background operations are active
+     */
+    private hasActiveOperations;
+    /**
+     * Get the message for the most recent non-background operation
+     */
+    private getCurrentMessage;
+    /**
+     * Trigger loading state (called by timeout)
+     */
+    private triggerLoadingState;
+    /**
+     * Update loading state based on current operations
+     */
+    private updateLoadingState;
+}
+export {};

package/dist/DelayedLoadingState.integration.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/DelayedLoadingState.js

@@ -0,0 +1,113 @@
+var DelayedLoadingState = class {
+	constructor(delayMs = 250, onStateChange) {
+		this.operations = /* @__PURE__ */ new Map();
+		this.isCurrentlyLoading = false;
+		this.currentMessage = "";
+		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);
+		if (existingOp?.timeout) clearTimeout(existingOp.timeout);
+		if (isBackground) {
+			this.operations.set(operationId, {
+				id: operationId,
+				message,
+				startTime: Date.now(),
+				isBackground: true
+			});
+			return;
+		}
+		const timeout = setTimeout(() => {
+			const operation = this.operations.get(operationId);
+			if (operation && !operation.isBackground) this.triggerLoadingState();
+		}, this.loadingDelayMs);
+		this.operations.set(operationId, {
+			id: operationId,
+			message,
+			startTime: Date.now(),
+			timeout,
+			isBackground: false
+		});
+	}
+	/**
+	* Clear a loading operation
+	*/
+	clearLoading(operationId) {
+		const operation = this.operations.get(operationId);
+		if (!operation) return;
+		if (operation.timeout) clearTimeout(operation.timeout);
+		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 = "";
+		for (const operation of this.operations.values()) if (!operation.isBackground && operation.startTime > latestTime) {
+			latestTime = operation.startTime;
+			latestMessage = operation.message;
+		}
+		return latestMessage;
+	}
+	/**
+	* Trigger loading state (called by timeout)
+	*/
+	triggerLoadingState() {
+		if (this.hasActiveOperations() && !this.isCurrentlyLoading) {
+			this.isCurrentlyLoading = true;
+			this.currentMessage = this.getCurrentMessage();
+			this.onStateChange?.(true, this.currentMessage);
+		}
+	}
+	/**
+	* Update loading state based on current operations
+	*/
+	updateLoadingState() {
+		const shouldBeLoading = this.hasActiveOperations();
+		if (shouldBeLoading !== this.isCurrentlyLoading) {
+			this.isCurrentlyLoading = shouldBeLoading;
+			if (shouldBeLoading) {
+				this.currentMessage = this.getCurrentMessage();
+				this.onStateChange?.(true, this.currentMessage);
+			} else {
+				this.currentMessage = "";
+				this.onStateChange?.(false, "");
+			}
+		}
+	}
+};
+export { DelayedLoadingState };

package/dist/DelayedLoadingState.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/EF_FRAMEGEN.d.ts

@@ -6,6 +6,7 @@ interface Bridge {
     onTriggerCanvas(callback: () => void): void;
     frameReady(frameNumber: number, audioSamples: ArrayBuffer): void;
     error(error: Error): void;
+    syncLog(sequence: number, message: string, callback: () => void): void;
 }
 declare global {
     interface Window {
@@ -27,15 +28,23 @@ declare class TriggerCanvas {
 export declare class EFFramegen {
     time: number;
     frameDurationMs: number;
-    initialBusyTasks: Promise<unknown[]>;
     audioBufferPromise?: Promise<AudioBuffer>;
     renderOptions?: VideoRenderOptions;
     frameBox: HTMLDivElement;
     BRIDGE: typeof window.FRAMEGEN_BRIDGE;
     triggerCanvas: TriggerCanvas;
+    verificationCanvas?: HTMLCanvasElement;
+    verificationCtx?: CanvasRenderingContext2D;
+    private logSequence;
+    frameTasksInProgress: boolean;
+    currentFrameNumber: number;
     trace(...args: any[]): void;
+    syncLog(...args: any[]): Promise<void>;
+    private initializeVerificationCanvas;
+    private drawVerificationStrip;
     constructor();
     connectToBridge(): void;
+    get showFrameBox(): boolean;
     initialize(renderOptions: VideoRenderOptions): Promise<void>;
     beginFrame(frameNumber: number, isLast: boolean): Promise<string | ArrayBuffer | null | undefined>;
 }

package/dist/EF_FRAMEGEN.js

@@ -1,182 +1,202 @@
-import { TaskStatus } from "@lit/task";
-import { deepGetElementsWithFrameTasks } from "./elements/EFTemporal.js";
 import { shallowGetTimegroups } from "./elements/EFTimegroup.js";
-class TriggerCanvas {
-  constructor() {
-    this.canvasInitialized = false;
-    this.canvas = document.createElement("canvas");
-    const ctx = this.canvas.getContext("2d", { willReadFrequently: true });
-    if (!ctx) throw new Error("Canvas 2d context not ready");
-    this.ctx = ctx;
-    this.ctx.fillStyle = "transparent";
-  }
-  initialize() {
-    if (this.canvasInitialized) return;
-    this.canvasInitialized = true;
-    this.canvas.width = 1;
-    this.canvas.height = 1;
-    Object.assign(this.canvas.style, {
-      position: "fixed",
-      top: "0px",
-      left: "0px",
-      width: "100%",
-      height: "100%",
-      zIndex: "100000"
-    });
-    document.body.appendChild(this.canvas);
-  }
-  trigger() {
-    this.ctx.clearRect(0, 0, this.canvas.width, this.canvas.height);
-  }
-}
-class EFFramegen {
-  constructor() {
-    this.time = 0;
-    this.frameDurationMs = 0;
-    this.initialBusyTasks = Promise.resolve([]);
-    this.frameBox = document.createElement("div");
-    this.triggerCanvas = new TriggerCanvas();
-    this.BRIDGE = window.FRAMEGEN_BRIDGE;
-    if (this.BRIDGE) {
-      console.log("trace: BRIDGE.constructor (connecting to bridge)");
-      this.connectToBridge();
-    }
-  }
-  trace(...args) {
-    console.trace("[EF_FRAMEGEN]", ...args);
-  }
-  connectToBridge() {
-    const BRIDGE = this.BRIDGE;
-    if (!BRIDGE) {
-      throw new Error("No BRIDGE when attempting to connect to bridge");
-    }
-    console.log("trace: BRIDGE.connectToBridge");
-    BRIDGE.onInitialize(async (renderOptions) => {
-      console.log("trace: BRIDGE.onInitialize", renderOptions);
-      await this.initialize(renderOptions);
-      BRIDGE.initialized();
-    });
-    BRIDGE.onBeginFrame((frameNumber, isLast) => {
-      console.log("trace: BRIDGE.onBeginFrame", frameNumber, isLast);
-      this.beginFrame(frameNumber, isLast);
-    });
-  }
-  async initialize(renderOptions) {
-    this.renderOptions = renderOptions;
-    const workbench = document.querySelector("ef-workbench");
-    if (!workbench) {
-      throw new Error("No workbench found");
-    }
-    workbench.rendering = true;
-    const timegroups = shallowGetTimegroups(workbench);
-    const temporals = deepGetElementsWithFrameTasks(workbench);
-    const firstGroup = timegroups[0];
-    if (!firstGroup) {
-      throw new Error("No temporal elements found");
-    }
-    firstGroup.currentTimeMs = renderOptions.encoderOptions.fromMs;
-    this.frameDurationMs = 1e3 / renderOptions.encoderOptions.video.framerate;
-    this.initialBusyTasks = Promise.all(
-      temporals.filter((temporal) => temporal.frameTask.status < TaskStatus.COMPLETE).map((temporal) => temporal.frameTask).map((task) => task.taskComplete)
-    );
-    this.time = 0;
-    if (renderOptions.showFrameBox) {
-      Object.assign(this.frameBox.style, {
-        width: "200px",
-        height: "100px",
-        font: "30px Arial",
-        backgroundColor: "white",
-        position: "absolute",
-        top: "0px",
-        left: "0px",
-        zIndex: "100000"
-      });
-      document.body.prepend(this.frameBox);
-    }
-    this.audioBufferPromise = firstGroup.renderAudio(
-      renderOptions.encoderOptions.alignedFromUs / 1e3,
-      renderOptions.encoderOptions.alignedToUs / 1e3
-    );
-    console.log("trace: Initialized");
-  }
-  async beginFrame(frameNumber, isLast) {
-    if (this.renderOptions === void 0) {
-      throw new Error("No renderOptions");
-    }
-    if (this.renderOptions.showFrameBox) {
-      this.frameBox.innerHTML = `
-        <div>Frame #${frameNumber}</div>
-        <div>${this.time.toFixed(4)}</div>
+var TriggerCanvas = class {
+	constructor() {
+		this.canvasInitialized = false;
+		this.canvas = document.createElement("canvas");
+		const ctx = this.canvas.getContext("2d", { willReadFrequently: true });
+		if (!ctx) throw new Error("Canvas 2d context not ready");
+		this.ctx = ctx;
+		this.ctx.fillStyle = "transparent";
+	}
+	initialize() {
+		if (this.canvasInitialized) return;
+		this.canvasInitialized = true;
+		this.canvas.width = 1;
+		this.canvas.height = 1;
+		Object.assign(this.canvas.style, {
+			position: "fixed",
+			top: "0px",
+			left: "0px",
+			width: "100%",
+			height: "100%",
+			zIndex: "100000"
+		});
+		document.body.appendChild(this.canvas);
+	}
+	trigger() {
+		this.ctx.clearRect(0, 0, this.canvas.width, this.canvas.height);
+	}
+};
+var EFFramegen = class {
+	trace(...args) {
+		console.trace("[EF_FRAMEGEN]", ...args);
+	}
+	async syncLog(...args) {
+		if (!this.BRIDGE) {
+			console.log("[EF_FRAMEGEN]", ...args);
+			return;
+		}
+		const sequence = ++this.logSequence;
+		const message = args.map((arg) => typeof arg === "object" ? JSON.stringify(arg) : String(arg)).join(" ");
+		return new Promise((resolve) => {
+			this.BRIDGE.syncLog(sequence, message, () => {
+				resolve();
+			});
+		});
+	}
+	initializeVerificationCanvas() {
+		if (this.verificationCanvas) return;
+		this.verificationCanvas = document.createElement("canvas");
+		const ctx = this.verificationCanvas.getContext("2d");
+		if (!ctx) throw new Error("Verification canvas 2d context not ready");
+		this.verificationCtx = ctx;
+		const workbench = document.querySelector("ef-workbench");
+		if (workbench) {
+			this.verificationCanvas.width = workbench.clientWidth;
+			this.verificationCanvas.height = 1;
+			Object.assign(this.verificationCanvas.style, {
+				position: "fixed",
+				left: "0px",
+				bottom: "0px",
+				width: `${workbench.clientWidth}px`,
+				height: "1px",
+				zIndex: "99999"
+			});
+			document.body.appendChild(this.verificationCanvas);
+		}
+	}
+	drawVerificationStrip(frameNumber) {
+		this.initializeVerificationCanvas();
+		if (!this.verificationCanvas || !this.verificationCtx) return;
+		const width = this.verificationCanvas.width;
+		const height = this.verificationCanvas.height;
+		this.verificationCtx.clearRect(0, 0, width, height);
+		const red = Math.floor(frameNumber / (256 * 256)) % 256;
+		const green = Math.floor(frameNumber / 256) % 256;
+		const blue = frameNumber % 256;
+		this.verificationCtx.fillStyle = `rgb(${red}, ${green}, ${blue})`;
+		this.verificationCtx.fillRect(0, 0, width, height);
+	}
+	constructor() {
+		this.time = 0;
+		this.frameDurationMs = 0;
+		this.frameBox = document.createElement("div");
+		this.triggerCanvas = new TriggerCanvas();
+		this.logSequence = 0;
+		this.frameTasksInProgress = false;
+		this.currentFrameNumber = 0;
+		this.BRIDGE = window.FRAMEGEN_BRIDGE;
+		if (this.BRIDGE) this.connectToBridge();
+	}
+	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);
+			BRIDGE.initialized();
+		});
+		BRIDGE.onBeginFrame((frameNumber, isLast) => {
+			this.beginFrame(frameNumber, isLast);
+		});
+		BRIDGE.onTriggerCanvas(() => {
+			this.triggerCanvas.trigger();
+		});
+	}
+	get showFrameBox() {
+		return true;
+	}
+	async initialize(renderOptions) {
+		this.renderOptions = renderOptions;
+		const alignedFromMs = renderOptions.encoderOptions.alignedFromUs / 1e3;
+		const alignedToMs = renderOptions.encoderOptions.alignedToUs / 1e3;
+		const alignedDurationMs = alignedToMs - alignedFromMs;
+		await this.syncLog("[EF_FRAMEGEN.initialize] Aligned boundary parameters:", {
+			alignedFromUs: renderOptions.encoderOptions.alignedFromUs,
+			alignedToUs: renderOptions.encoderOptions.alignedToUs,
+			alignedFromMs: alignedFromMs.toFixed(3),
+			alignedToMs: alignedToMs.toFixed(3),
+			alignedDurationMs: alignedDurationMs.toFixed(3),
+			sequenceNumber: renderOptions.encoderOptions.sequenceNumber,
+			originalFromMs: renderOptions.encoderOptions.fromMs,
+			originalToMs: renderOptions.encoderOptions.toMs,
+			originalDurationMs: (renderOptions.encoderOptions.toMs - renderOptions.encoderOptions.fromMs).toFixed(3)
+		});
+		const workbench = document.querySelector("ef-workbench");
+		if (!workbench) throw new Error("No workbench found");
+		workbench.rendering = true;
+		workbench.playing = false;
+		const timegroups = shallowGetTimegroups(workbench);
+		const firstGroup = timegroups[0];
+		if (!firstGroup) throw new Error("No temporal elements found");
+		const startingTimeMs = renderOptions.encoderOptions.fromMs;
+		await firstGroup.waitForMediaDurations();
+		await firstGroup.waitForFrameTasks();
+		this.frameDurationMs = 1e3 / renderOptions.encoderOptions.video.framerate;
+		this.time = startingTimeMs;
+		if (this.showFrameBox) {
+			Object.assign(this.frameBox.style, {
+				width: "200px",
+				height: "100px",
+				font: "10px Arial",
+				backgroundColor: "white",
+				position: "absolute",
+				top: "0px",
+				right: "0px",
+				zIndex: "100000"
+			});
+			document.body.prepend(this.frameBox);
+		}
+		this.triggerCanvas.initialize();
+		await this.syncLog("[EF_FRAMEGEN.initialize] About to call renderAudio with:", {
+			fromMs: alignedFromMs.toFixed(3),
+			toMs: alignedToMs.toFixed(3),
+			durationMs: alignedDurationMs.toFixed(3)
+		});
+		this.audioBufferPromise = firstGroup.renderAudio(renderOptions.encoderOptions.alignedFromUs / 1e3, renderOptions.encoderOptions.alignedToUs / 1e3);
+	}
+	async beginFrame(frameNumber, isLast) {
+		if (this.renderOptions === void 0) throw new Error("No renderOptions");
+		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];
+		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));
+		await firstGroup.waitForFrameTasks();
+		if (this.showFrameBox) this.frameBox.innerHTML = `
+        <div>🖼️   Frame: ${frameNumber}</div>
+        <div>🕛 Segment: ${this.time.toFixed(4)}</div>
+        <div>🕛   Frame: ${firstGroup.currentTimeMs.toFixed(4)}</div>
+        <div>  from-to: ${this.renderOptions.encoderOptions.fromMs.toFixed(4)} - ${this.renderOptions.encoderOptions.toMs.toFixed(4)}</div>
       `;
-    }
-    const workbench = document.querySelector("ef-workbench");
-    if (!workbench) {
-      throw new Error("No workbench found");
-    }
-    workbench.rendering = true;
-    const timegroups = shallowGetTimegroups(workbench);
-    const temporals = deepGetElementsWithFrameTasks(workbench);
-    const firstGroup = timegroups[0];
-    if (!firstGroup) {
-      throw new Error("No temporal elements found");
-    }
-    this.time = this.renderOptions.encoderOptions.fromMs + frameNumber * this.frameDurationMs;
-    firstGroup.currentTimeMs = this.time;
-    await this.initialBusyTasks;
-    await new Promise(queueMicrotask);
-    const now = performance.now();
-    await Promise.all(
-      temporals.filter((temporal) => temporal.frameTask.status < TaskStatus.COMPLETE).map((temporal) => {
-        return temporal.frameTask;
-      }).map((task) => task.taskComplete)
-    );
-    console.log(
-      `trace: frame:${frameNumber} All tasks complete ${performance.now() - now}ms`
-    );
-    this.triggerCanvas.trigger();
-    if (isLast && this.audioBufferPromise) {
-      const renderedAudio = await this.audioBufferPromise;
-      const channelCount = renderedAudio.numberOfChannels;
-      const interleavedSamples = new Float32Array(
-        channelCount * renderedAudio.length
-      );
-      for (let i = 0; i < renderedAudio.length; i++) {
-        for (let j = 0; j < channelCount; j++) {
-          interleavedSamples.set(
-            renderedAudio.getChannelData(j).slice(i, i + 1),
-            i * channelCount + j
-          );
-        }
-      }
-      if (this.BRIDGE) {
-        this.BRIDGE.frameReady(frameNumber, interleavedSamples.buffer);
-      } else {
-        const fileReader = new FileReader();
-        fileReader.readAsDataURL(new Blob([interleavedSamples.buffer]));
-        await new Promise((resolve, reject) => {
-          fileReader.onload = resolve;
-          fileReader.onerror = reject;
-        });
-        return fileReader.result;
-      }
-    } else {
-      if (this.BRIDGE) {
-        this.BRIDGE.frameReady(frameNumber, new ArrayBuffer(0));
-      } else {
-        const fileReader = new FileReader();
-        fileReader.readAsDataURL(new Blob([]));
-        await new Promise((resolve, reject) => {
-          fileReader.onload = resolve;
-          fileReader.onerror = reject;
-        });
-        return fileReader.result;
-      }
-    }
-  }
-}
-if (typeof window !== "undefined") {
-  window.EF_FRAMEGEN = new EFFramegen();
-}
-export {
-  EFFramegen
+		this.drawVerificationStrip(frameNumber);
+		if (isLast && this.audioBufferPromise) {
+			const renderedAudio = await this.audioBufferPromise;
+			const channelCount = renderedAudio.numberOfChannels;
+			const interleavedSamples = new Float32Array(channelCount * renderedAudio.length);
+			for (let i = 0; i < renderedAudio.length; i++) for (let j = 0; j < channelCount; j++) interleavedSamples.set(renderedAudio.getChannelData(j).slice(i, i + 1), i * channelCount + j);
+			if (this.BRIDGE) this.BRIDGE.frameReady(frameNumber, interleavedSamples.buffer);
+			else {
+				const fileReader = new FileReader();
+				fileReader.readAsDataURL(new Blob([interleavedSamples.buffer]));
+				await new Promise((resolve, reject) => {
+					fileReader.onload = resolve;
+					fileReader.onerror = reject;
+				});
+				return fileReader.result;
+			}
+		} else if (this.BRIDGE) this.BRIDGE.frameReady(frameNumber, /* @__PURE__ */ new ArrayBuffer(0));
+		else {
+			const fileReader = new FileReader();
+			fileReader.readAsDataURL(new Blob([]));
+			await new Promise((resolve, reject) => {
+				fileReader.onload = resolve;
+				fileReader.onerror = reject;
+			});
+			return fileReader.result;
+		}
+	}
 };
+if (typeof window !== "undefined") window.EF_FRAMEGEN = new EFFramegen();

package/dist/EF_INTERACTIVE.js

@@ -1,7 +1,3 @@
 let EF_INTERACTIVE = false;
-if (typeof window !== "undefined") {
-  EF_INTERACTIVE = !window.location?.search.includes("EF_NONINTERACTIVE");
-}
-export {
-  EF_INTERACTIVE
-};
+if (typeof window !== "undefined") EF_INTERACTIVE = !window.location?.search.includes("EF_NONINTERACTIVE");
+export { EF_INTERACTIVE };

package/dist/EF_RENDERING.js

@@ -1,4 +1,2 @@
 const EF_RENDERING = () => typeof window !== "undefined" && "FRAMEGEN_BRIDGE" in window;
-export {
-  EF_RENDERING
-};
+export { EF_RENDERING };

package/dist/JitTranscodingClient.browsertest.d.ts

@@ -0,0 +1 @@
+export {};