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

package/src/elements/EFMedia/shared/RenditionHelpers.browsertest.ts

@@ -4,12 +4,7 @@ import type {
   MediaEngine,
   VideoRendition,
 } from "../../../transcoding/types";
-import {
-  calculateSegmentRange,
-  computeSegmentId,
-  getAudioRendition,
-  getVideoRendition,
-} from "./RenditionHelpers";
+import { calculateSegmentRange, computeSegmentId } from "./RenditionHelpers";
 
 const test = baseTest.extend<{
   mockMediaEngine: MediaEngine;
@@ -36,6 +31,8 @@ const test = baseTest.extend<{
       src: "https://example.com/media.mp4",
       videoRendition: mockVideoRendition,
       audioRendition: mockAudioRendition,
+      getVideoRendition: () => mockVideoRendition,
+      getAudioRendition: () => mockAudioRendition,
       fetchMediaSegment: vi.fn(),
     } as unknown as MediaEngine;
     await use(mockMediaEngine);
@@ -60,30 +57,38 @@ const test = baseTest.extend<{
   },
 
   mockMediaEngineWithoutAudio: async ({}, use) => {
+    const videoRendition = {
+      trackId: 1,
+      src: "video-track.mp4",
+      segmentDurationMs: 1000,
+    } as VideoRendition;
+
     const mockMediaEngine = {
       durationMs: 10000,
       src: "https://example.com/media.mp4",
-      videoRendition: {
-        trackId: 1,
-        src: "video-track.mp4",
-        segmentDurationMs: 1000,
-      } as VideoRendition,
-      audioRendition: null,
+      videoRendition,
+      audioRendition: undefined,
+      getVideoRendition: () => videoRendition,
+      getAudioRendition: () => undefined,
       fetchMediaSegment: vi.fn(),
     } as unknown as MediaEngine;
     await use(mockMediaEngine);
   },
 
   mockMediaEngineWithoutVideo: async ({}, use) => {
+    const audioRendition = {
+      trackId: 2,
+      src: "audio-track.mp4",
+      segmentDurationMs: 1000,
+    } as AudioRendition;
+
     const mockMediaEngine = {
       durationMs: 10000,
       src: "https://example.com/media.mp4",
-      videoRendition: null,
-      audioRendition: {
-        trackId: 2,
-        src: "audio-track.mp4",
-        segmentDurationMs: 1000,
-      } as AudioRendition,
+      videoRendition: undefined,
+      audioRendition,
+      getVideoRendition: () => undefined,
+      getAudioRendition: () => audioRendition,
       fetchMediaSegment: vi.fn(),
     } as unknown as MediaEngine;
     await use(mockMediaEngine);
@@ -91,45 +96,39 @@ const test = baseTest.extend<{
 });
 
 describe("RenditionHelpers", () => {
-  describe("getAudioRendition", () => {
-    test("returns audio rendition when available", ({
-      mockMediaEngine,
+  describe("MediaEngine Rendition Access", () => {
+    test("mediaEngine.getAudioRendition() returns undefined for video-only assets", ({
+      mockMediaEngineWithoutAudio,
       expect,
     }) => {
-      const result = getAudioRendition(mockMediaEngine);
-      expect(result).toBe(mockMediaEngine.audioRendition);
-      expect(result.trackId).toBe(2);
-      expect(result.src).toBe("audio-track.mp4");
+      const result = mockMediaEngineWithoutAudio.getAudioRendition();
+      expect(result).toBeUndefined();
     });
 
-    test("throws error when audio rendition is not available", ({
-      mockMediaEngineWithoutAudio,
+    test("mediaEngine.getVideoRendition() returns undefined for audio-only assets", ({
+      mockMediaEngineWithoutVideo,
       expect,
     }) => {
-      expect(() => getAudioRendition(mockMediaEngineWithoutAudio)).toThrow(
-        "No audio track available in source",
-      );
+      const result = mockMediaEngineWithoutVideo.getVideoRendition();
+      expect(result).toBeUndefined();
     });
-  });
 
-  describe("getVideoRendition", () => {
-    test("returns video rendition when available", ({
+    test("mediaEngine.getAudioRendition() returns rendition when available", ({
       mockMediaEngine,
       expect,
     }) => {
-      const result = getVideoRendition(mockMediaEngine);
-      expect(result).toBe(mockMediaEngine.videoRendition);
-      expect(result.trackId).toBe(1);
-      expect(result.src).toBe("video-track.mp4");
+      const result = mockMediaEngine.getAudioRendition();
+      expect(result).toBeDefined();
+      expect(result?.trackId).toBe(2);
     });
 
-    test("throws error when video rendition is not available", ({
-      mockMediaEngineWithoutVideo,
+    test("mediaEngine.getVideoRendition() returns rendition when available", ({
+      mockMediaEngine,
       expect,
     }) => {
-      expect(() => getVideoRendition(mockMediaEngineWithoutVideo)).toThrow(
-        "No video track available in source",
-      );
+      const result = mockMediaEngine.getVideoRendition();
+      expect(result).toBeDefined();
+      expect(result?.trackId).toBe(1);
     });
   });
 

package/src/elements/EFMedia/shared/RenditionHelpers.ts

@@ -1,31 +1,8 @@
 import type {
   AudioRendition,
-  MediaEngine,
   VideoRendition,
 } from "../../../transcoding/types";
 
-/**
- * Get audio rendition from media engine, throwing if not available
- */
-export const getAudioRendition = (mediaEngine: MediaEngine): AudioRendition => {
-  const audioRendition = mediaEngine.audioRendition;
-  if (!audioRendition) {
-    throw new Error("No audio track available in source");
-  }
-  return audioRendition;
-};
-
-/**
- * Get video rendition from media engine, throwing if not available
- */
-export const getVideoRendition = (mediaEngine: MediaEngine): VideoRendition => {
-  const videoRendition = mediaEngine.videoRendition;
-  if (!videoRendition) {
-    throw new Error("No video track available in source");
-  }
-  return videoRendition;
-};
-
 /**
  * Calculate which segment contains a given timestamp
  * Returns 1-based segment ID, or undefined if segmentDurationMs is not available

package/src/elements/EFMedia/tasks/makeMediaEngineTask.ts

@@ -1,6 +1,6 @@
 import { Task } from "@lit/task";
 import { EF_INTERACTIVE } from "../../../EF_INTERACTIVE";
-import type { MediaEngine, VideoRendition } from "../../../transcoding/types";
+import type { MediaEngine } from "../../../transcoding/types";
 import type { EFMedia } from "../../EFMedia";
 import { AssetIdMediaEngine } from "../AssetIdMediaEngine";
 import { AssetMediaEngine } from "../AssetMediaEngine";
@@ -18,14 +18,6 @@ export const getLatestMediaEngine = async (
   return mediaEngine;
 };
 
-export const getVideoRendition = (mediaEngine: MediaEngine): VideoRendition => {
-  const videoRendition = mediaEngine.videoRendition;
-  if (!videoRendition) {
-    throw new Error("No video track available in source");
-  }
-  return videoRendition;
-};
-
 /**
  * Core logic for creating a MediaEngine with explicit dependencies.
  * Pure function that requires all dependencies to be provided.

package/src/elements/EFMedia/videoTasks/makeScrubVideoBufferTask.ts

@@ -1,4 +1,6 @@
 import { Task } from "@lit/task";
+
+import { EF_INTERACTIVE } from "../../../EF_INTERACTIVE.js";
 import { EF_RENDERING } from "../../../EF_RENDERING.js";
 import type { VideoRendition } from "../../../transcoding/types";
 import type { EFVideo } from "../../EFVideo";
@@ -19,8 +21,7 @@ export const makeScrubVideoBufferTask = (host: EFVideo) => {
   };
 
   return new Task(host, {
-    // Make lazy - only run when element becomes timeline-active
-    autoRun: false,
+    autoRun: EF_INTERACTIVE,
     args: () => [host.mediaEngineTask.value] as const,
     onError: (error) => {
       console.error("scrubVideoBufferTask error", error);

package/src/elements/EFMedia/videoTasks/makeScrubVideoInitSegmentFetchTask.ts

@@ -1,5 +1,4 @@
 import { Task } from "@lit/task";
-import { EF_RENDERING } from "../../../EF_RENDERING";
 import type { MediaEngine } from "../../../transcoding/types";
 import type { EFVideo } from "../../EFVideo";
 import { getLatestMediaEngine } from "../tasks/makeMediaEngineTask";
@@ -14,10 +13,6 @@ export const makeScrubVideoInitSegmentFetchTask = (
     },
     onComplete: (_value) => {},
     task: async ([_mediaEngine], { signal }) => {
-      if (EF_RENDERING()) {
-        return new ArrayBuffer(0);
-      }
-
       const mediaEngine = await getLatestMediaEngine(host, signal);
 
       // Get scrub rendition using the proper interface method

package/src/elements/EFMedia/videoTasks/makeScrubVideoInputTask.ts

@@ -1,5 +1,5 @@
 import { Task } from "@lit/task";
-import { EF_RENDERING } from "../../../EF_RENDERING";
+
 import { EFMedia } from "../../EFMedia";
 import type { EFVideo } from "../../EFVideo";
 import { BufferedSeekingInput } from "../BufferedSeekingInput";
@@ -20,10 +20,6 @@ export const makeScrubVideoInputTask = (host: EFVideo): InputTask => {
     },
     onComplete: (_value) => {},
     task: async () => {
-      if (EF_RENDERING()) {
-        console.info("Scrub not available in rendering mode");
-      }
-
       const initSegment =
         await host.scrubVideoInitSegmentFetchTask.taskComplete;
       const segment = await host.scrubVideoSegmentFetchTask.taskComplete;

package/src/elements/EFMedia/videoTasks/makeScrubVideoSegmentFetchTask.ts

@@ -1,5 +1,4 @@
 import { Task } from "@lit/task";
-import { EF_RENDERING } from "../../../EF_RENDERING";
 import type { MediaEngine } from "../../../transcoding/types";
 import type { EFVideo } from "../../EFVideo";
 import { getLatestMediaEngine } from "../tasks/makeMediaEngineTask";
@@ -18,10 +17,6 @@ export const makeScrubVideoSegmentFetchTask = (
     },
     onComplete: (_value) => {},
     task: async (_, { signal }) => {
-      if (EF_RENDERING()) {
-        return new ArrayBuffer(0);
-      }
-
       const mediaEngine = await getLatestMediaEngine(host, signal);
       const segmentId = await host.scrubVideoSegmentIdTask.taskComplete;
       if (segmentId === undefined) {

package/src/elements/EFMedia/videoTasks/makeScrubVideoSegmentIdTask.ts

@@ -1,5 +1,4 @@
 import { Task } from "@lit/task";
-import { EF_RENDERING } from "../../../EF_RENDERING";
 import type { MediaEngine } from "../../../transcoding/types";
 import type { EFVideo } from "../../EFVideo";
 import { getLatestMediaEngine } from "../tasks/makeMediaEngineTask";
@@ -14,10 +13,6 @@ export const makeScrubVideoSegmentIdTask = (
     },
     onComplete: (_value) => {},
     task: async ([, targetSeekTimeMs], { signal }) => {
-      if (EF_RENDERING()) {
-        return undefined;
-      }
-
       const mediaEngine = await getLatestMediaEngine(host, signal);
       signal.throwIfAborted(); // Abort if a new seek started
 

package/src/elements/EFMedia/videoTasks/makeUnifiedVideoSeekTask.ts

@@ -1,6 +1,5 @@
 import { Task } from "@lit/task";
 import type { VideoSample } from "mediabunny";
-import { EF_RENDERING } from "../../../EF_RENDERING";
 import type { VideoRendition } from "../../../transcoding/types";
 import type { EFVideo } from "../../EFVideo";
 import { getLatestMediaEngine } from "../tasks/makeMediaEngineTask";
@@ -25,16 +24,6 @@ export const makeUnifiedVideoSeekTask = (
       const mediaEngine = await getLatestMediaEngine(host, signal);
       if (!mediaEngine) return undefined;
 
-      // In rendering mode, skip all the scrub logic and go straight to main
-      if (EF_RENDERING()) {
-        return await getMainVideoSample(
-          host,
-          mediaEngine,
-          desiredSeekTimeMs,
-          signal,
-        );
-      }
-
       // FIRST: Check if main quality content is already cached
       const mainRendition = mediaEngine.videoRendition;
       if (mainRendition) {
@@ -186,20 +175,23 @@ async function getMainVideoSample(
 ): Promise<VideoSample | undefined> {
   try {
     // Use existing main video task chain
+    const videoRendition = mediaEngine.getVideoRendition();
+    if (!videoRendition) {
+      throw new Error(
+        "Video rendition unavailable after checking videoRendition exists",
+      );
+    }
+
     const segmentId = mediaEngine.computeSegmentId(
       desiredSeekTimeMs,
-      mediaEngine.getVideoRendition(),
+      videoRendition,
     );
     if (segmentId === undefined) return undefined;
 
     // Fetch main video segment
     const [initSegment, mediaSegment] = await Promise.all([
-      mediaEngine.fetchInitSegment(mediaEngine.getVideoRendition(), signal),
-      mediaEngine.fetchMediaSegment(
-        segmentId,
-        mediaEngine.getVideoRendition(),
-        signal,
-      ),
+      mediaEngine.fetchInitSegment(videoRendition, signal),
+      mediaEngine.fetchMediaSegment(segmentId, videoRendition, signal),
     ]);
 
     if (!initSegment || !mediaSegment) return undefined;
@@ -209,7 +201,6 @@ async function getMainVideoSample(
     const { BufferedSeekingInput } = await import("../BufferedSeekingInput.js");
     const { EFMedia } = await import("../../EFMedia.js");
 
-    const videoRendition = mediaEngine.videoRendition;
     const startTimeOffsetMs = videoRendition?.startTimeOffsetMs;
 
     const mainInput = new BufferedSeekingInput(

package/src/elements/EFMedia/videoTasks/makeVideoBufferTask.ts

@@ -9,10 +9,7 @@ import {
   type MediaBufferState,
   manageMediaBuffer,
 } from "../shared/BufferUtils";
-import {
-  getLatestMediaEngine,
-  getVideoRendition,
-} from "../tasks/makeMediaEngineTask";
+import { getLatestMediaEngine } from "../tasks/makeMediaEngineTask";
 
 /**
  * Configuration for video buffering - extends the generic interface
@@ -90,7 +87,7 @@ export const makeVideoBufferTask = (host: EFVideo): VideoBufferTask => {
           getRendition: async () => {
             // Get real video rendition from media engine
             const mediaEngine = await getLatestMediaEngine(host, signal);
-            return getVideoRendition(mediaEngine);
+            return mediaEngine.getVideoRendition();
           },
           logError: console.error,
         },

package/src/elements/EFMedia.ts

@@ -283,12 +283,13 @@ export class EFMedia extends EFTargetable(
   /**
    * Main integration method for EFTimegroup audio playback
    * Now powered by clean, testable utility functions
+   * Returns undefined if no audio rendition is available
    */
   async fetchAudioSpanningTime(
     fromMs: number,
     toMs: number,
     signal: AbortSignal = new AbortController().signal,
-  ): Promise<AudioSpan> {
+  ): Promise<AudioSpan | undefined> {
     return fetchAudioSpanningTime(this, fromMs, toMs, signal);
   }
 }

package/src/elements/EFThumbnailStrip.media-engine.browsertest.ts

@@ -132,7 +132,8 @@ describe("MediaEngine Thumbnail Extraction", () => {
       // Get segment duration to ensure timestamps are in same segment
       const videoRendition =
         mediaEngine.getScrubVideoRendition() || mediaEngine.getVideoRendition();
-      const segmentDurationMs = videoRendition.segmentDurationMs || 2000;
+      expect(videoRendition).toBeDefined();
+      const segmentDurationMs = videoRendition!.segmentDurationMs || 2000;
 
       // Pick timestamps within the first segment - avoid edge cases near boundaries
       const timestamps = [

package/src/elements/EFTimegroup.ts

@@ -602,7 +602,7 @@ export class EFTimegroup extends EFTemporal(LitElement) {
         }
 
         if (!audio) {
-          throw new Error("Failed to fetch audio");
+          return;
         }
 
         const bufferSource = audioContext.createBufferSource();

package/src/transcoding/types/index.ts

@@ -228,14 +228,16 @@ export interface MediaEngine {
   ) => number | undefined;
 
   /**
-   * Get the video rendition, or throws if no video rendition is available
+   * Get the video rendition if available, otherwise return undefined.
+   * Callers should handle undefined appropriately.
    */
-  getVideoRendition: () => VideoRendition;
+  getVideoRendition: () => VideoRendition | undefined;
 
   /**
-   * Get the audio rendition, or throws if no audio rendition is available
+   * Get the audio rendition if available, otherwise return undefined.
+   * Callers should handle undefined appropriately.
    */
-  getAudioRendition: () => AudioRendition;
+  getAudioRendition: () => AudioRendition | undefined;
 
   /**
    * Check if a segment is cached for a given rendition

package/src/utils/LRUCache.test.ts

@@ -244,7 +244,9 @@ describe("OrderedLRUCache", () => {
     expect(allItems.map((item) => item.key)).toEqual([100, 200, 300]); // 200±500 = [-300,700] contains all
   });
 
-  test("performance characteristics with large dataset", () => {
+  // This test is cute, but we can't perfectly controll wall time
+  // in CI, so it's flaky.
+  test.skip("performance characteristics with large dataset", () => {
     const cache = new OrderedLRUCache<number, string>(1000);
 
     // Insert many items