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

package/src/elements/EFVideo.browsertest.ts

@@ -681,7 +681,9 @@ describe("EFVideo", () => {
   describe("AssetMediaEngine", () => {
     test("seeks to 8074ms", async ({ barsNtone, barsNtoneTimegroup }) => {
       // Wait for any initial loading to complete
-      await waitForTaskIgnoringAborts(barsNtone.videoSeekTask.taskComplete);
+      await waitForTaskIgnoringAborts(
+        barsNtone.unifiedVideoSeekTask.taskComplete,
+      );
       await waitForTaskIgnoringAborts(barsNtone.audioSeekTask.taskComplete);
 
       // Use timegroup for seeking to ensure audio and video are synchronized
@@ -690,28 +692,36 @@ describe("EFVideo", () => {
 
       // Wait for the new seek tasks to complete (ignoring any aborts from previous operations)
       await waitForTaskIgnoringAborts(barsNtone.audioSeekTask.taskComplete);
-      await waitForTaskIgnoringAborts(barsNtone.videoSeekTask.taskComplete);
+      await waitForTaskIgnoringAborts(
+        barsNtone.unifiedVideoSeekTask.taskComplete,
+      );
     });
 
     test("seeks to beginning of video (0ms)", async ({
       barsNtone,
       barsNtoneTimegroup,
     }) => {
-      await waitForTaskIgnoringAborts(barsNtone.videoSeekTask.taskComplete);
+      await waitForTaskIgnoringAborts(
+        barsNtone.unifiedVideoSeekTask.taskComplete,
+      );
       await waitForTaskIgnoringAborts(barsNtone.audioSeekTask.taskComplete);
       barsNtoneTimegroup.currentTimeMs = 0;
       await barsNtone.updateComplete;
 
       // Wait for the new seek tasks to complete
       await waitForTaskIgnoringAborts(barsNtone.audioSeekTask.taskComplete);
-      await waitForTaskIgnoringAborts(barsNtone.videoSeekTask.taskComplete);
+      await waitForTaskIgnoringAborts(
+        barsNtone.unifiedVideoSeekTask.taskComplete,
+      );
     });
 
     test("seeks to exact segment boundary at 2066ms", async ({
       barsNtone,
       barsNtoneTimegroup,
     }) => {
-      await waitForTaskIgnoringAborts(barsNtone.videoSeekTask.taskComplete);
+      await waitForTaskIgnoringAborts(
+        barsNtone.unifiedVideoSeekTask.taskComplete,
+      );
       await waitForTaskIgnoringAborts(barsNtone.audioSeekTask.taskComplete);
       // This is approximately where segment 0 ends and segment 1 begins
       barsNtoneTimegroup.currentTimeMs = 2066;
@@ -719,14 +729,18 @@ describe("EFVideo", () => {
 
       // Wait for the new seek tasks to complete
       await waitForTaskIgnoringAborts(barsNtone.audioSeekTask.taskComplete);
-      await waitForTaskIgnoringAborts(barsNtone.videoSeekTask.taskComplete);
+      await waitForTaskIgnoringAborts(
+        barsNtone.unifiedVideoSeekTask.taskComplete,
+      );
     });
 
     test("seeks to exact segment boundary at 4033ms", async ({
       barsNtone,
       barsNtoneTimegroup,
     }) => {
-      await waitForTaskIgnoringAborts(barsNtone.videoSeekTask.taskComplete);
+      await waitForTaskIgnoringAborts(
+        barsNtone.unifiedVideoSeekTask.taskComplete,
+      );
       await waitForTaskIgnoringAborts(barsNtone.audioSeekTask.taskComplete);
       // This is approximately where segment 1 ends and segment 2 begins
       barsNtoneTimegroup.currentTimeMs = 4033;
@@ -734,79 +748,103 @@ describe("EFVideo", () => {
 
       // Wait for the new seek tasks to complete
       await waitForTaskIgnoringAborts(barsNtone.audioSeekTask.taskComplete);
-      await waitForTaskIgnoringAborts(barsNtone.videoSeekTask.taskComplete);
+      await waitForTaskIgnoringAborts(
+        barsNtone.unifiedVideoSeekTask.taskComplete,
+      );
     });
 
     test("seeks to exact segment boundary at 6066ms", async ({
       barsNtone,
       barsNtoneTimegroup,
     }) => {
-      await waitForTaskIgnoringAborts(barsNtone.videoSeekTask.taskComplete);
+      await waitForTaskIgnoringAborts(
+        barsNtone.unifiedVideoSeekTask.taskComplete,
+      );
       await waitForTaskIgnoringAborts(barsNtone.audioSeekTask.taskComplete);
       // Reset to 0 first to ensure clean state
       barsNtoneTimegroup.currentTimeMs = 0;
       await barsNtone.updateComplete;
       // Wait for both audio and video to complete the reset
       await waitForTaskIgnoringAborts(barsNtone.audioSeekTask.taskComplete);
-      await waitForTaskIgnoringAborts(barsNtone.videoSeekTask.taskComplete);
+      await waitForTaskIgnoringAborts(
+        barsNtone.unifiedVideoSeekTask.taskComplete,
+      );
 
       // Updated: Use time safely within segment boundaries (6000ms instead of 6066ms)
       // The actual boundary is at 6066.67ms, so 6000ms should be in segment 2
       barsNtoneTimegroup.currentTimeMs = 6000;
       await barsNtone.updateComplete;
       await waitForTaskIgnoringAborts(barsNtone.audioSeekTask.taskComplete);
-      await waitForTaskIgnoringAborts(barsNtone.videoSeekTask.taskComplete);
+      await waitForTaskIgnoringAborts(
+        barsNtone.unifiedVideoSeekTask.taskComplete,
+      );
     });
 
     test("seeks to exact segment boundary at 8033ms", async ({
       barsNtone,
       barsNtoneTimegroup,
     }) => {
-      await waitForTaskIgnoringAborts(barsNtone.videoSeekTask.taskComplete);
+      await waitForTaskIgnoringAborts(
+        barsNtone.unifiedVideoSeekTask.taskComplete,
+      );
       await waitForTaskIgnoringAborts(barsNtone.audioSeekTask.taskComplete);
       // This is approximately where segment 2 ends and segment 3 begins
       barsNtoneTimegroup.currentTimeMs = 8033;
       await barsNtone.updateComplete;
       await waitForTaskIgnoringAborts(barsNtone.audioSeekTask.taskComplete);
-      await waitForTaskIgnoringAborts(barsNtone.videoSeekTask.taskComplete);
+      await waitForTaskIgnoringAborts(
+        barsNtone.unifiedVideoSeekTask.taskComplete,
+      );
     });
 
     test("seeks to near end of video at 9900ms", async ({
       barsNtone,
       barsNtoneTimegroup,
     }) => {
-      await waitForTaskIgnoringAborts(barsNtone.videoSeekTask.taskComplete);
+      await waitForTaskIgnoringAborts(
+        barsNtone.unifiedVideoSeekTask.taskComplete,
+      );
       await waitForTaskIgnoringAborts(barsNtone.audioSeekTask.taskComplete);
       // Seek to near the end of the video
       barsNtoneTimegroup.currentTimeMs = 9900;
       await barsNtone.updateComplete;
       await waitForTaskIgnoringAborts(barsNtone.audioSeekTask.taskComplete);
-      await waitForTaskIgnoringAborts(barsNtone.videoSeekTask.taskComplete);
+      await waitForTaskIgnoringAborts(
+        barsNtone.unifiedVideoSeekTask.taskComplete,
+      );
     });
 
     test("seeks backwards from 8000ms to 2000ms", async ({
       barsNtone,
       barsNtoneTimegroup,
     }) => {
-      await waitForTaskIgnoringAborts(barsNtone.videoSeekTask.taskComplete);
+      await waitForTaskIgnoringAborts(
+        barsNtone.unifiedVideoSeekTask.taskComplete,
+      );
       await waitForTaskIgnoringAborts(barsNtone.audioSeekTask.taskComplete);
       // First seek forward
       barsNtoneTimegroup.currentTimeMs = 8000;
       await barsNtone.updateComplete;
-      await waitForTaskIgnoringAborts(barsNtone.videoSeekTask.taskComplete);
+      await waitForTaskIgnoringAborts(
+        barsNtone.unifiedVideoSeekTask.taskComplete,
+      );
 
       // Then seek backward
       barsNtoneTimegroup.currentTimeMs = 2000;
       await barsNtone.updateComplete;
       await waitForTaskIgnoringAborts(barsNtone.audioSeekTask.taskComplete);
-      await waitForTaskIgnoringAborts(barsNtone.videoSeekTask.taskComplete);
+      await waitForTaskIgnoringAborts(
+        barsNtone.unifiedVideoSeekTask.taskComplete,
+      );
     });
 
     test("seeks to multiple points across segments", async ({
       barsNtone,
       barsNtoneTimegroup,
     }) => {
-      await waitForTaskIgnoringAborts(barsNtone.videoSeekTask.taskComplete);
+      await waitForTaskIgnoringAborts(
+        barsNtone.unifiedVideoSeekTask.taskComplete,
+      );
       await waitForTaskIgnoringAborts(barsNtone.audioSeekTask.taskComplete);
 
       // Use seek points that are within the actual media duration
@@ -817,7 +855,9 @@ describe("EFVideo", () => {
         barsNtoneTimegroup.currentTimeMs = seekPoint;
         await barsNtone.updateComplete;
         await waitForTaskIgnoringAborts(barsNtone.audioSeekTask.taskComplete);
-        await waitForTaskIgnoringAborts(barsNtone.videoSeekTask.taskComplete);
+        await waitForTaskIgnoringAborts(
+          barsNtone.unifiedVideoSeekTask.taskComplete,
+        );
       }
     });
 
@@ -825,33 +865,43 @@ describe("EFVideo", () => {
       barsNtone,
       barsNtoneTimegroup,
     }) => {
-      await waitForTaskIgnoringAborts(barsNtone.videoSeekTask.taskComplete);
+      await waitForTaskIgnoringAborts(
+        barsNtone.unifiedVideoSeekTask.taskComplete,
+      );
       await waitForTaskIgnoringAborts(barsNtone.audioSeekTask.taskComplete);
       // Use a safe seek time within the media duration
       barsNtoneTimegroup.currentTimeMs = 8030;
       await barsNtone.updateComplete;
       await waitForTaskIgnoringAborts(barsNtone.audioSeekTask.taskComplete);
-      await waitForTaskIgnoringAborts(barsNtone.videoSeekTask.taskComplete);
+      await waitForTaskIgnoringAborts(
+        barsNtone.unifiedVideoSeekTask.taskComplete,
+      );
     });
 
     test("seeks just after segment boundary at 8070ms", async ({
       barsNtone,
       barsNtoneTimegroup,
     }) => {
-      await waitForTaskIgnoringAborts(barsNtone.videoSeekTask.taskComplete);
+      await waitForTaskIgnoringAborts(
+        barsNtone.unifiedVideoSeekTask.taskComplete,
+      );
       await waitForTaskIgnoringAborts(barsNtone.audioSeekTask.taskComplete);
       // Use a safe seek time within the media duration
       barsNtoneTimegroup.currentTimeMs = 8070;
       await barsNtone.updateComplete;
       await waitForTaskIgnoringAborts(barsNtone.audioSeekTask.taskComplete);
-      await waitForTaskIgnoringAborts(barsNtone.videoSeekTask.taskComplete);
+      await waitForTaskIgnoringAborts(
+        barsNtone.unifiedVideoSeekTask.taskComplete,
+      );
     });
 
     test("handles rapid scrubbing between segments", async ({
       barsNtone,
       barsNtoneTimegroup,
     }) => {
-      await waitForTaskIgnoringAborts(barsNtone.videoSeekTask.taskComplete);
+      await waitForTaskIgnoringAborts(
+        barsNtone.unifiedVideoSeekTask.taskComplete,
+      );
       await waitForTaskIgnoringAborts(barsNtone.audioSeekTask.taskComplete);
 
       // Simulate rapid scrubbing back and forth across segments
@@ -875,7 +925,9 @@ describe("EFVideo", () => {
 
       // Final seek operations should complete without errors
       await waitForTaskIgnoringAborts(barsNtone.audioSeekTask.taskComplete);
-      await waitForTaskIgnoringAborts(barsNtone.videoSeekTask.taskComplete);
+      await waitForTaskIgnoringAborts(
+        barsNtone.unifiedVideoSeekTask.taskComplete,
+      );
     });
 
     test("handles concurrent seeks to different segments", async ({
@@ -883,7 +935,9 @@ describe("EFVideo", () => {
       barsNtone,
       barsNtoneTimegroup,
     }) => {
-      await waitForTaskIgnoringAborts(barsNtone.videoSeekTask.taskComplete);
+      await waitForTaskIgnoringAborts(
+        barsNtone.unifiedVideoSeekTask.taskComplete,
+      );
       await waitForTaskIgnoringAborts(barsNtone.audioSeekTask.taskComplete);
 
       // Start multiple seeks without waiting for completion
@@ -895,7 +949,7 @@ describe("EFVideo", () => {
       seekPromises.push(
         Promise.allSettled([
           barsNtone.audioSeekTask.taskComplete,
-          barsNtone.videoSeekTask.taskComplete,
+          barsNtone.unifiedVideoSeekTask.taskComplete,
         ]),
       );
 
@@ -905,7 +959,7 @@ describe("EFVideo", () => {
       seekPromises.push(
         Promise.allSettled([
           barsNtone.audioSeekTask.taskComplete,
-          barsNtone.videoSeekTask.taskComplete,
+          barsNtone.unifiedVideoSeekTask.taskComplete,
         ]),
       );
 
@@ -915,7 +969,7 @@ describe("EFVideo", () => {
       seekPromises.push(
         Promise.allSettled([
           barsNtone.audioSeekTask.taskComplete,
-          barsNtone.videoSeekTask.taskComplete,
+          barsNtone.unifiedVideoSeekTask.taskComplete,
         ]),
       );
 
@@ -932,7 +986,9 @@ describe("EFVideo", () => {
       barsNtone,
       barsNtoneTimegroup,
     }) => {
-      await waitForTaskIgnoringAborts(barsNtone.videoSeekTask.taskComplete);
+      await waitForTaskIgnoringAborts(
+        barsNtone.unifiedVideoSeekTask.taskComplete,
+      );
       await waitForTaskIgnoringAborts(barsNtone.audioSeekTask.taskComplete);
 
       // Try to reproduce the exact error scenario
@@ -947,7 +1003,9 @@ describe("EFVideo", () => {
 
       // The system should recover and eventually succeed
       await waitForTaskIgnoringAborts(barsNtone.audioSeekTask.taskComplete);
-      await waitForTaskIgnoringAborts(barsNtone.videoSeekTask.taskComplete);
+      await waitForTaskIgnoringAborts(
+        barsNtone.unifiedVideoSeekTask.taskComplete,
+      );
     });
 
     test("seeks to 7975ms", async ({
@@ -958,7 +1016,6 @@ describe("EFVideo", () => {
       await barsNtoneTimegroup.frameTask.taskComplete;
       barsNtoneTimegroup.currentTimeMs = 7975;
       await barsNtoneTimegroup.waitForNestedUpdates();
-      await barsNtone.videoSegmentIdTask.run();
       console.log(
         "barsNtoneTimegroup.currentTime",
         barsNtoneTimegroup.currentTime,
@@ -970,11 +1027,13 @@ describe("EFVideo", () => {
       );
       console.log("barsNtone.desiredSeekTimeMs", barsNtone.desiredSeekTimeMs);
       console.log(
-        "barsNtone.videoSegmentId",
-        barsNtone.videoSegmentIdTask.value,
+        "barsNtone.unifiedVideoSeekResult",
+        barsNtone.unifiedVideoSeekTask.value,
       );
       await barsNtoneTimegroup.frameTask.taskComplete;
-      expect(barsNtone.videoSeekTask.value?.timestamp).toBeCloseTo(8.033);
+      expect(barsNtone.unifiedVideoSeekTask.value?.timestamp).toBeCloseTo(
+        8.033,
+      );
     });
 
     test("seeks to 8041.667ms in video track 1", async ({
@@ -985,14 +1044,16 @@ describe("EFVideo", () => {
       await barsNtoneTimegroup.frameTask.taskComplete;
       barsNtoneTimegroup.currentTimeMs = 8041.667;
       await barsNtoneTimegroup.seekTask.taskComplete;
-      expect(barsNtone.videoSeekTask.value?.timestamp).toBe(8.1);
+      expect(barsNtone.unifiedVideoSeekTask.value?.timestamp).toBe(8.1);
     });
 
     test("seeks to 10000ms near end of file", async ({
       barsNtone,
       barsNtoneTimegroup,
     }) => {
-      await waitForTaskIgnoringAborts(barsNtone.videoSeekTask.taskComplete);
+      await waitForTaskIgnoringAborts(
+        barsNtone.unifiedVideoSeekTask.taskComplete,
+      );
       await waitForTaskIgnoringAborts(barsNtone.audioSeekTask.taskComplete);
 
       // Use a safe seek time within the media duration
@@ -1001,7 +1062,9 @@ describe("EFVideo", () => {
       await barsNtone.updateComplete;
 
       // Should not throw "Sample not found" errors
-      await waitForTaskIgnoringAborts(barsNtone.videoSeekTask.taskComplete);
+      await waitForTaskIgnoringAborts(
+        barsNtone.unifiedVideoSeekTask.taskComplete,
+      );
       await waitForTaskIgnoringAborts(barsNtone.audioSeekTask.taskComplete);
     });
   });
@@ -1012,64 +1075,82 @@ describe("EFVideo", () => {
       headMoov480p,
       expect,
     }) => {
-      await waitForTaskIgnoringAborts(headMoov480p.videoSeekTask.taskComplete);
+      await waitForTaskIgnoringAborts(
+        headMoov480p.unifiedVideoSeekTask.taskComplete,
+      );
       await waitForTaskIgnoringAborts(headMoov480p.audioSeekTask.taskComplete);
 
       timegroup.currentTimeMs = 0;
       await timegroup.seekTask.taskComplete;
 
-      expect(headMoov480p.videoSeekTask.value?.timestamp).toBe(0);
+      expect(headMoov480p.unifiedVideoSeekTask.value?.timestamp).toBe(0);
     });
 
     test("seeks to 1000ms", async ({ timegroup, headMoov480p, expect }) => {
-      await waitForTaskIgnoringAborts(headMoov480p.videoSeekTask.taskComplete);
+      await waitForTaskIgnoringAborts(
+        headMoov480p.unifiedVideoSeekTask.taskComplete,
+      );
       await waitForTaskIgnoringAborts(headMoov480p.audioSeekTask.taskComplete);
 
       timegroup.currentTimeMs = 1000;
       await timegroup.seekTask.taskComplete;
 
-      expect(headMoov480p.videoSeekTask.value?.timestamp).toBe(1);
+      expect(headMoov480p.unifiedVideoSeekTask.value?.timestamp).toBe(1);
     });
 
     test("seeks to 3000ms", async ({ timegroup, headMoov480p, expect }) => {
-      await waitForTaskIgnoringAborts(headMoov480p.videoSeekTask.taskComplete);
+      await waitForTaskIgnoringAborts(
+        headMoov480p.unifiedVideoSeekTask.taskComplete,
+      );
       await waitForTaskIgnoringAborts(headMoov480p.audioSeekTask.taskComplete);
 
       timegroup.currentTimeMs = 3000;
       await timegroup.seekTask.taskComplete;
 
-      expect(headMoov480p.videoSeekTask.value?.timestamp).toBe(3);
+      expect(headMoov480p.unifiedVideoSeekTask.value?.timestamp).toBe(3);
     });
 
     test("seeks to 5000ms", async ({ timegroup, headMoov480p, expect }) => {
-      await waitForTaskIgnoringAborts(headMoov480p.videoSeekTask.taskComplete);
+      await waitForTaskIgnoringAborts(
+        headMoov480p.unifiedVideoSeekTask.taskComplete,
+      );
       await waitForTaskIgnoringAborts(headMoov480p.audioSeekTask.taskComplete);
 
       timegroup.currentTimeMs = 5000;
       await timegroup.seekTask.taskComplete;
 
-      expect(headMoov480p.videoSeekTask.value?.timestamp).toBe(5);
+      expect(headMoov480p.unifiedVideoSeekTask.value?.timestamp).toBe(5);
     });
 
     test("seeks to 7500ms", async ({ timegroup, headMoov480p, expect }) => {
-      await waitForTaskIgnoringAborts(headMoov480p.videoSeekTask.taskComplete);
+      await waitForTaskIgnoringAborts(
+        headMoov480p.unifiedVideoSeekTask.taskComplete,
+      );
       await waitForTaskIgnoringAborts(headMoov480p.audioSeekTask.taskComplete);
 
       timegroup.currentTimeMs = 7500;
       await timegroup.seekTask.taskComplete;
 
       // JIT transcoding returns actual video frame timestamps, not idealized segment boundaries
-      expect(headMoov480p.videoSeekTask.value?.timestamp).toBeCloseTo(7.5, 1);
+      expect(headMoov480p.unifiedVideoSeekTask.value?.timestamp).toBeCloseTo(
+        7.5,
+        1,
+      );
     });
 
     test("seeks to 8500ms", async ({ timegroup, headMoov480p, expect }) => {
-      await waitForTaskIgnoringAborts(headMoov480p.videoSeekTask.taskComplete);
+      await waitForTaskIgnoringAborts(
+        headMoov480p.unifiedVideoSeekTask.taskComplete,
+      );
       await waitForTaskIgnoringAborts(headMoov480p.audioSeekTask.taskComplete);
 
       timegroup.currentTimeMs = 8500;
       await timegroup.seekTask.taskComplete;
 
-      expect(headMoov480p.videoSeekTask.value?.timestamp).toBeCloseTo(8.5, 1);
+      expect(headMoov480p.unifiedVideoSeekTask.value?.timestamp).toBeCloseTo(
+        8.5,
+        1,
+      );
     });
 
     test("seeks to near end at 9000ms", async ({
@@ -1077,13 +1158,15 @@ describe("EFVideo", () => {
       headMoov480p,
       expect,
     }) => {
-      await waitForTaskIgnoringAborts(headMoov480p.videoSeekTask.taskComplete);
+      await waitForTaskIgnoringAborts(
+        headMoov480p.unifiedVideoSeekTask.taskComplete,
+      );
       await waitForTaskIgnoringAborts(headMoov480p.audioSeekTask.taskComplete);
 
       timegroup.currentTimeMs = 9000;
       await timegroup.seekTask.taskComplete;
 
-      expect(headMoov480p.videoSeekTask.value?.timestamp).toBe(9);
+      expect(headMoov480p.unifiedVideoSeekTask.value?.timestamp).toBe(9);
     });
 
     test("seeks backward from 7000ms to 2000ms", async ({
@@ -1091,20 +1174,32 @@ describe("EFVideo", () => {
       headMoov480p,
       expect,
     }) => {
-      await waitForTaskIgnoringAborts(headMoov480p.videoSeekTask.taskComplete);
+      await waitForTaskIgnoringAborts(
+        headMoov480p.unifiedVideoSeekTask.taskComplete,
+      );
       await waitForTaskIgnoringAborts(headMoov480p.audioSeekTask.taskComplete);
 
       // First seek forward
       timegroup.currentTimeMs = 7000;
       await timegroup.seekTask.taskComplete;
-      await waitForTaskIgnoringAborts(headMoov480p.videoSeekTask.taskComplete);
-      expect(headMoov480p.videoSeekTask.value?.timestamp).toBeCloseTo(7, 1);
+      await waitForTaskIgnoringAborts(
+        headMoov480p.unifiedVideoSeekTask.taskComplete,
+      );
+      expect(headMoov480p.unifiedVideoSeekTask.value?.timestamp).toBeCloseTo(
+        7,
+        1,
+      );
 
       // Then seek backward
       timegroup.currentTimeMs = 2000;
       await timegroup.seekTask.taskComplete;
-      await waitForTaskIgnoringAborts(headMoov480p.videoSeekTask.taskComplete);
-      expect(headMoov480p.videoSeekTask.value?.timestamp).toBeCloseTo(2, 1);
+      await waitForTaskIgnoringAborts(
+        headMoov480p.unifiedVideoSeekTask.taskComplete,
+      );
+      expect(headMoov480p.unifiedVideoSeekTask.value?.timestamp).toBeCloseTo(
+        2,
+        1,
+      );
     });
 
     test("seeks to multiple points in sequence", async ({
@@ -1112,7 +1207,9 @@ describe("EFVideo", () => {
       headMoov480p,
       expect,
     }) => {
-      await waitForTaskIgnoringAborts(headMoov480p.videoSeekTask.taskComplete);
+      await waitForTaskIgnoringAborts(
+        headMoov480p.unifiedVideoSeekTask.taskComplete,
+      );
       await waitForTaskIgnoringAborts(headMoov480p.audioSeekTask.taskComplete);
 
       const seekPoints = [1000, 3000, 5000, 2000, 6000, 0];
@@ -1122,9 +1219,9 @@ describe("EFVideo", () => {
         timegroup.currentTimeMs = seekPoints[i]!;
         await timegroup.seekTask.taskComplete;
         await waitForTaskIgnoringAborts(
-          headMoov480p.videoSeekTask.taskComplete,
+          headMoov480p.unifiedVideoSeekTask.taskComplete,
         );
-        expect(headMoov480p.videoSeekTask.value?.timestamp).toBeCloseTo(
+        expect(headMoov480p.unifiedVideoSeekTask.value?.timestamp).toBeCloseTo(
           expectedTimestamps[i]!,
           1,
         );
@@ -1136,7 +1233,9 @@ describe("EFVideo", () => {
       headMoov480p,
       expect,
     }) => {
-      await waitForTaskIgnoringAborts(headMoov480p.videoSeekTask.taskComplete);
+      await waitForTaskIgnoringAborts(
+        headMoov480p.unifiedVideoSeekTask.taskComplete,
+      );
       await waitForTaskIgnoringAborts(headMoov480p.audioSeekTask.taskComplete);
 
       const fractionalTimes = [1234.567, 3456.789, 5678.901];
@@ -1146,9 +1245,9 @@ describe("EFVideo", () => {
         timegroup.currentTimeMs = fractionalTimes[i]!;
         await timegroup.seekTask.taskComplete;
         await waitForTaskIgnoringAborts(
-          headMoov480p.videoSeekTask.taskComplete,
+          headMoov480p.unifiedVideoSeekTask.taskComplete,
         );
-        expect(headMoov480p.videoSeekTask.value?.timestamp).toBeCloseTo(
+        expect(headMoov480p.unifiedVideoSeekTask.value?.timestamp).toBeCloseTo(
           expectedTimestamps[i]!,
           1,
         ); // Reduced precision for JIT
@@ -1161,18 +1260,33 @@ describe("EFVideo", () => {
       expect,
     }) => {
       await timegroup.seekTask.taskComplete;
-      await waitForTaskIgnoringAborts(headMoov480p.videoSeekTask.taskComplete);
-      expect(headMoov480p.videoSeekTask.value?.timestamp).toBeCloseTo(0, 1);
+      await waitForTaskIgnoringAborts(
+        headMoov480p.unifiedVideoSeekTask.taskComplete,
+      );
+      expect(headMoov480p.unifiedVideoSeekTask.value?.timestamp).toBeCloseTo(
+        0,
+        1,
+      );
 
       timegroup.currentTimeMs = 1000;
       await timegroup.seekTask.taskComplete;
-      await waitForTaskIgnoringAborts(headMoov480p.videoSeekTask.taskComplete);
-      expect(headMoov480p.videoSeekTask.value?.timestamp).toBeCloseTo(1, 1);
+      await waitForTaskIgnoringAborts(
+        headMoov480p.unifiedVideoSeekTask.taskComplete,
+      );
+      expect(headMoov480p.unifiedVideoSeekTask.value?.timestamp).toBeCloseTo(
+        1,
+        1,
+      );
 
       timegroup.currentTimeMs = 4000;
       await timegroup.seekTask.taskComplete;
-      await waitForTaskIgnoringAborts(headMoov480p.videoSeekTask.taskComplete);
-      expect(headMoov480p.videoSeekTask.value?.timestamp).toBeCloseTo(4, 1);
+      await waitForTaskIgnoringAborts(
+        headMoov480p.unifiedVideoSeekTask.taskComplete,
+      );
+      expect(headMoov480p.unifiedVideoSeekTask.value?.timestamp).toBeCloseTo(
+        4,
+        1,
+      );
     });
 
     test("rapid succession seeks cause intermediate seeks to be skipped", async ({
@@ -1183,7 +1297,7 @@ describe("EFVideo", () => {
       await timegroup.waitForMediaDurations();
       timegroup.currentTimeMs = 1000;
       await timegroup.seekTask.taskComplete;
-      expect(headMoov480p.videoSeekTask.value?.timestamp).toBe(1);
+      expect(headMoov480p.unifiedVideoSeekTask.value?.timestamp).toBe(1);
 
       // // Track frameTask executions using a spy on the run method
       // const runSpy = vi.spyOn(timegroup.frameTask, 'run');
@@ -1199,7 +1313,7 @@ describe("EFVideo", () => {
       // timegroup.currentTimeMs = 8000;
 
       // await timegroup.seekTask.taskComplete;
-      // expect(headMoov480p.videoSeekTask.value?.timestamp).toBe(8);
+      // expect(headMoov480p.unifiedVideoSeekTask.value?.timestamp).toBe(8);
       // expect(runSpy).toHaveBeenCalledTimes(3);
     });
   });
@@ -1216,9 +1330,9 @@ describe("EFVideo", () => {
       const video2 = videos[1]!;
 
       // Wait for initial loading
-      await waitForTaskIgnoringAborts(video1.videoSeekTask.taskComplete);
+      await waitForTaskIgnoringAborts(video1.unifiedVideoSeekTask.taskComplete);
       await waitForTaskIgnoringAborts(video1.audioSeekTask.taskComplete);
-      await waitForTaskIgnoringAborts(video2.videoSeekTask.taskComplete);
+      await waitForTaskIgnoringAborts(video2.unifiedVideoSeekTask.taskComplete);
       await waitForTaskIgnoringAborts(video2.audioSeekTask.taskComplete);
 
       // Get the duration of the first video to know where the second video starts
@@ -1241,7 +1355,9 @@ describe("EFVideo", () => {
       const timegroup = headMoov480p.closest("ef-timegroup") as EFTimegroup;
 
       // Wait for initial loading to complete
-      await waitForTaskIgnoringAborts(headMoov480p.videoSeekTask.taskComplete);
+      await waitForTaskIgnoringAborts(
+        headMoov480p.unifiedVideoSeekTask.taskComplete,
+      );
       await waitForTaskIgnoringAborts(headMoov480p.audioSeekTask.taskComplete);
 
       // The fix: JitMediaEngine.computeSegmentId should handle seeking to exact duration
@@ -1260,7 +1376,7 @@ describe("EFVideo", () => {
 
         // This should now work without throwing "Segment ID is not available"
         await waitForTaskIgnoringAborts(
-          headMoov480p.videoSeekTask.taskComplete,
+          headMoov480p.unifiedVideoSeekTask.taskComplete,
         );
         await waitForTaskIgnoringAborts(
           headMoov480p.audioSeekTask.taskComplete,
@@ -1275,7 +1391,9 @@ describe("EFVideo", () => {
       const timegroup = headMoov480p.closest("ef-timegroup") as EFTimegroup;
 
       // Wait for initial loading to complete
-      await waitForTaskIgnoringAborts(headMoov480p.videoSeekTask.taskComplete);
+      await waitForTaskIgnoringAborts(
+        headMoov480p.unifiedVideoSeekTask.taskComplete,
+      );
       await waitForTaskIgnoringAborts(headMoov480p.audioSeekTask.taskComplete);
 
       console.log("🧪 TESTING: Audio analysis out-of-bounds time range fix");
@@ -1298,7 +1416,9 @@ describe("EFVideo", () => {
       // Let the audio analysis tasks run - they should now handle this gracefully
 
       // The basic seek should complete without errors
-      await waitForTaskIgnoringAborts(headMoov480p.videoSeekTask.taskComplete);
+      await waitForTaskIgnoringAborts(
+        headMoov480p.unifiedVideoSeekTask.taskComplete,
+      );
 
       // Audio tasks may still throw their own errors, but not the "No segments found" error
       // We don't explicitly test the audio analysis tasks here since they might legitimately
@@ -1314,7 +1434,9 @@ describe("EFVideo", () => {
       const timegroup = headMoov480p.closest("ef-timegroup") as EFTimegroup;
 
       // Wait for initial loading to complete
-      await waitForTaskIgnoringAborts(headMoov480p.videoSeekTask.taskComplete);
+      await waitForTaskIgnoringAborts(
+        headMoov480p.unifiedVideoSeekTask.taskComplete,
+      );
       await waitForTaskIgnoringAborts(headMoov480p.audioSeekTask.taskComplete);
 
       console.log("🧪 TESTING: Rapid seeking race condition fix");
@@ -1337,7 +1459,9 @@ describe("EFVideo", () => {
       }
 
       // The fix should prevent errors - both video and audio tasks should complete
-      await waitForTaskIgnoringAborts(headMoov480p.videoSeekTask.taskComplete);
+      await waitForTaskIgnoringAborts(
+        headMoov480p.unifiedVideoSeekTask.taskComplete,
+      );
 
       // Audio tasks should also complete without throwing, though they may log warnings
       await waitForTaskIgnoringAborts(headMoov480p.audioSeekTask.taskComplete);